Index: .hgignore
===================================================================
--- .hgignore	(revision 944)
+++ .hgignore	(revision 514)
@@ -23,15 +23,9 @@
 lemon/stamp-h2
 doc/Doxyfile
-doc/references.dox
-cmake/version.cmake
+cmake/cmake.version
 .dirstamp
 .libs/*
 .deps/*
 demo/*.eps
-m4/libtool.m4
-m4/ltoptions.m4
-m4/ltsugar.m4
-m4/ltversion.m4
-m4/lt~obsolete.m4
 
 syntax: regexp
@@ -42,9 +36,8 @@
 ^autom4te.cache/.*
 ^build-aux/.*
-^.*objs.*/.*
+^objs.*/.*
 ^test/[a-z_]*$
-^tools/[a-z-_]*$
 ^demo/.*_demo$
-^.*build.*/.*
+^build/.*
 ^doc/gen-images/.*
 CMakeFiles
Index: gtags
===================================================================
--- .hgtags	(revision 1006)
+++ 	(revision )
@@ -1,2 +1,0 @@
-3ed8f7c8bed8f51aecdc8395aa11af2f1fa12d9f r1.2
-ffc2d2559fc916e90c3f000582a2d4761d229d44 r1.2.1
Index: CMakeLists.txt
===================================================================
--- CMakeLists.txt	(revision 791)
+++ CMakeLists.txt	(revision 540)
@@ -1,74 +1,36 @@
 CMAKE_MINIMUM_REQUIRED(VERSION 2.6)
 
-SET(PROJECT_NAME "LEMON")
+IF(EXISTS ${CMAKE_SOURCE_DIR}/cmake/version.cmake)
+  INCLUDE(${CMAKE_SOURCE_DIR}/cmake/version.cmake)
+ELSE(EXISTS ${CMAKE_SOURCE_DIR}/cmake/version.cmake)
+  SET(PROJECT_NAME "LEMON")
+  SET(PROJECT_VERSION "hg-tip" CACHE STRING "LEMON version string.")
+ENDIF(EXISTS ${CMAKE_SOURCE_DIR}/cmake/version.cmake)
+
 PROJECT(${PROJECT_NAME})
 
-IF(EXISTS ${PROJECT_SOURCE_DIR}/cmake/version.cmake)
-  INCLUDE(${PROJECT_SOURCE_DIR}/cmake/version.cmake)
-ELSEIF(DEFINED ENV{LEMON_VERSION})
-  SET(LEMON_VERSION $ENV{LEMON_VERSION} CACHE STRING "LEMON version string.")
-ELSE()
-  EXECUTE_PROCESS(
-    COMMAND hg id -i
-    WORKING_DIRECTORY ${PROJECT_SOURCE_DIR}
-    OUTPUT_VARIABLE HG_REVISION
-    ERROR_QUIET
-    OUTPUT_STRIP_TRAILING_WHITESPACE
-  )
-  IF(HG_REVISION STREQUAL "")
-    SET(HG_REVISION "hg-tip")
-  ENDIF()
-  SET(LEMON_VERSION ${HG_REVISION} CACHE STRING "LEMON version string.")
-ENDIF()
+SET(CMAKE_MODULE_PATH ${CMAKE_SOURCE_DIR}/cmake)
 
-SET(PROJECT_VERSION ${LEMON_VERSION})
+INCLUDE(FindDoxygen)
+INCLUDE(FindGhostscript)
 
-SET(CMAKE_MODULE_PATH ${PROJECT_SOURCE_DIR}/cmake)
-
-FIND_PACKAGE(Doxygen)
-FIND_PACKAGE(Ghostscript)
-FIND_PACKAGE(GLPK 4.33)
-FIND_PACKAGE(CPLEX)
-FIND_PACKAGE(COIN)
+ADD_DEFINITIONS(-DHAVE_CONFIG_H)
 
 INCLUDE(CheckTypeSize)
-CHECK_TYPE_SIZE("long long" LONG_LONG)
-SET(LEMON_HAVE_LONG_LONG ${HAVE_LONG_LONG})
-
-INCLUDE(FindPythonInterp)
+CHECK_TYPE_SIZE("long long" LEMON_LONG_LONG)
 
 ENABLE_TESTING()
 
 ADD_SUBDIRECTORY(lemon)
-IF(${CMAKE_SOURCE_DIR} STREQUAL ${PROJECT_SOURCE_DIR})
-  ADD_SUBDIRECTORY(demo)
-  ADD_SUBDIRECTORY(tools)
-  ADD_SUBDIRECTORY(doc)
-  ADD_SUBDIRECTORY(test)
-ENDIF()
+ADD_SUBDIRECTORY(demo)
+ADD_SUBDIRECTORY(doc)
+ADD_SUBDIRECTORY(test)
 
-CONFIGURE_FILE(
-  ${PROJECT_SOURCE_DIR}/cmake/LEMONConfig.cmake.in
-  ${PROJECT_BINARY_DIR}/cmake/LEMONConfig.cmake
-  @ONLY
-)
-IF(UNIX)
-  INSTALL(
-    FILES ${PROJECT_BINARY_DIR}/cmake/LEMONConfig.cmake
-    DESTINATION share/lemon/cmake
-  )
-ELSEIF(WIN32)
-  INSTALL(
-    FILES ${PROJECT_BINARY_DIR}/cmake/LEMONConfig.cmake
-    DESTINATION cmake
-  )
-ENDIF()
-
-IF(${CMAKE_SOURCE_DIR} STREQUAL ${PROJECT_SOURCE_DIR} AND WIN32)
+IF(WIN32)
   SET(CPACK_PACKAGE_NAME ${PROJECT_NAME})
   SET(CPACK_PACKAGE_VENDOR "EGRES")
   SET(CPACK_PACKAGE_DESCRIPTION_SUMMARY
-    "LEMON - Library for Efficient Modeling and Optimization in Networks")
-  SET(CPACK_RESOURCE_FILE_LICENSE "${PROJECT_SOURCE_DIR}/LICENSE")
+    "LEMON - Library of Efficient Models and Optimization in Networks")
+  SET(CPACK_RESOURCE_FILE_LICENSE "${CMAKE_SOURCE_DIR}/LICENSE")
 
   SET(CPACK_PACKAGE_VERSION ${PROJECT_VERSION})
@@ -79,9 +41,8 @@
     "${PROJECT_NAME} ${PROJECT_VERSION}")
 
-  SET(CPACK_COMPONENTS_ALL headers library html_documentation bin)
+  SET(CPACK_COMPONENTS_ALL headers library html_documentation)
 
   SET(CPACK_COMPONENT_HEADERS_DISPLAY_NAME "C++ headers")
   SET(CPACK_COMPONENT_LIBRARY_DISPLAY_NAME "Dynamic-link library")
-  SET(CPACK_COMPONENT_BIN_DISPLAY_NAME "Command line utilities")
   SET(CPACK_COMPONENT_HTML_DOCUMENTATION_DISPLAY_NAME "HTML documentation")
 
@@ -90,6 +51,4 @@
   SET(CPACK_COMPONENT_LIBRARY_DESCRIPTION
     "DLL and import library")
-  SET(CPACK_COMPONENT_BIN_DESCRIPTION
-    "Command line utilities")
   SET(CPACK_COMPONENT_HTML_DOCUMENTATION_DESCRIPTION
     "Doxygen generated documentation")
@@ -113,7 +72,7 @@
 
   SET(CPACK_GENERATOR "NSIS")
-  SET(CPACK_NSIS_MUI_ICON "${PROJECT_SOURCE_DIR}/cmake/nsis/lemon.ico")
-  SET(CPACK_NSIS_MUI_UNIICON "${PROJECT_SOURCE_DIR}/cmake/nsis/uninstall.ico")
-  #SET(CPACK_PACKAGE_ICON "${PROJECT_SOURCE_DIR}/cmake/nsis\\\\installer.bmp")
+  SET(CPACK_NSIS_MUI_ICON "${CMAKE_SOURCE_DIR}/cmake/nsis/lemon.ico")
+  SET(CPACK_NSIS_MUI_UNIICON "${CMAKE_SOURCE_DIR}/cmake/nsis/uninstall.ico")
+  #SET(CPACK_PACKAGE_ICON "${CMAKE_SOURCE_DIR}/cmake/nsis\\\\installer.bmp")
   SET(CPACK_NSIS_INSTALLED_ICON_NAME "bin\\\\lemon.ico")
   SET(CPACK_NSIS_DISPLAY_NAME "${CPACK_PACKAGE_INSTALL_DIRECTORY} ${PROJECT_NAME}")
@@ -130,3 +89,3 @@
 
   INCLUDE(CPack)
-ENDIF()
+ENDIF(WIN32)
Index: INSTALL
===================================================================
--- INSTALL	(revision 890)
+++ INSTALL	(revision 526)
@@ -28,6 +28,6 @@
 
       This command compiles the non-template part of LEMON into libemon.a
-      file. It also compiles the programs in the tools subdirectory by
-      default.
+      file. It also compiles the programs in the tools and demo subdirectories
+      when enabled.
 
    4. `make check'
@@ -75,4 +75,12 @@
 
   Set the installation prefix to PREFIX. By default it is /usr/local.
+
+--enable-demo
+
+   Build the examples in the demo subdirectory.
+
+--disable-demo
+
+   Do not build the examples in the demo subdirectory (default).
 
 --enable-tools
@@ -151,47 +159,2 @@
 
    Disable SoPlex support.
-
---with-coin[=PREFIX]
-
-   Enable support for COIN-OR solvers (CLP and CBC). You should
-   specify the prefix too. (by default, COIN-OR tools install
-   themselves to the source code directory). This command enables the
-   solvers that are actually found.
-
---with-coin-includedir=DIR
-
-   The directory where the COIN-OR header files are located. This is
-   only useful when the COIN-OR headers and libraries are not under
-   the same prefix (which is unlikely).
-
---with-coin-libdir=DIR
-
-   The directory where the COIN-OR libraries are located. This is only
-   useful when the COIN-OR headers and libraries are not under the
-   same prefix (which is unlikely).
-
---without-coin
-
-   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 959)
+++ LICENSE	(revision 530)
@@ -2,5 +2,5 @@
 copyright/license.
 
-Copyright (C) 2003-2010 Egervary Jeno Kombinatorikus Optimalizalasi
+Copyright (C) 2003-2008 Egervary Jeno Kombinatorikus Optimalizalasi
 Kutatocsoport (Egervary Combinatorial Optimization Research Group,
 EGRES).
Index: Makefile.am
===================================================================
--- Makefile.am	(revision 840)
+++ Makefile.am	(revision 503)
@@ -1,5 +1,3 @@
 ACLOCAL_AMFLAGS = -I m4
-
-AM_CXXFLAGS = $(WARNINGCXXFLAGS)
 
 AM_CPPFLAGS = -I$(top_srcdir) -I$(top_builddir)
@@ -12,11 +10,6 @@
 	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 \
@@ -44,11 +37,6 @@
 include test/Makefile.am
 include doc/Makefile.am
+include demo/Makefile.am
 include tools/Makefile.am
-include scripts/Makefile.am
-
-DIST_SUBDIRS = demo
-
-demo:
-	$(MAKE) $(AM_MAKEFLAGS) -C demo
 
 MRPROPERFILES = \
@@ -78,3 +66,3 @@
 	bzip2 --best -c > $(PACKAGE)-$(VERSION).tar.bz2
 
-.PHONY: demo mrproper dist-bz2 distcheck-bz2
+.PHONY: mrproper dist-bz2 distcheck-bz2
Index: NEWS
===================================================================
--- NEWS	(revision 1005)
+++ NEWS	(revision 534)
@@ -1,181 +1,2 @@
-2010-10-21 Version 1.2.1 released
-
-        Bugfix release.
-
-        #366: Fix Pred[Matrix]MapPath::empty()
-        #371: Bug fix in (di)graphCopy()
-              The target graph is cleared before adding nodes and arcs/edges.
-
-        #364: Add missing UndirectedTags
-        #368: Fix the usage of std::numeric_limits<>::min() in Network Simplex
-        #372: Fix a critical bug in preflow
-
-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
-
-        This is the second stable release of the 1.x series. It
-        features a better coverage of the tools available in the 0.x
-        series, a thoroughly reworked LP/MIP interface plus various
-        improvements in the existing tools.
-
-        * Much improved M$ Windows support
-          * Various improvements in the CMAKE build system
-          * Compilation warnings are fixed/suppressed
-        * Support IBM xlC compiler
-        * New algorithms
-          * Connectivity related algorithms (#61)
-          * Euler walks (#65)
-          * Preflow push-relabel max. flow algorithm (#176)
-          * Circulation algorithm (push-relabel based) (#175)
-          * Suurballe algorithm (#47)
-          * Gomory-Hu algorithm (#66)
-          * Hao-Orlin algorithm (#58)
-          * Edmond's maximum cardinality and weighted matching algorithms
-            in general graphs (#48,#265)
-          * Minimum cost arborescence/branching (#60)
-          * Network Simplex min. cost flow algorithm (#234)
-        * New data structures
-          * Full graph structure (#57)
-          * Grid graph structure (#57)
-          * Hypercube graph structure (#57)
-          * Graph adaptors (#67)
-          * ArcSet and EdgeSet classes (#67)
-          * Elevator class (#174)
-        * Other new tools
-          * LP/MIP interface (#44)
-            * Support for GLPK, CPLEX, Soplex, COIN-OR CLP and CBC
-          * Reader for the Nauty file format (#55)
-          * DIMACS readers (#167)
-          * Radix sort algorithms (#72)
-          * RangeIdMap and CrossRefMap (#160)
-        * New command line tools
-          * DIMACS to LGF converter (#182)
-          * lgf-gen - a graph generator (#45)
-          * DIMACS solver utility (#226)
-        * Other code improvements
-          * Lognormal distribution added to Random (#102)
-          * Better (i.e. O(1) time) item counting in SmartGraph (#3)
-          * The standard maps of graphs are guaranteed to be
-            reference maps (#190)
-        * Miscellaneous
-          * Various doc improvements
-          * Improved 0.x -> 1.x converter script
-
-        * Several bugfixes (compared to release 1.0):
-          #170: Bugfix SmartDigraph::split()
-          #171: Bugfix in SmartGraph::restoreSnapshot()
-          #172: Extended test cases for graphs and digraphs
-          #173: Bugfix in Random
-                * operator()s always return a double now
-                * the faulty real<Num>(Num) and real<Num>(Num,Num)
-                  have been removed
-          #187: Remove DijkstraWidestPathOperationTraits
-          #61:  Bugfix in DfsVisit
-          #193: Bugfix in GraphReader::skipSection()
-          #195: Bugfix in ConEdgeIt()
-          #197: Bugfix in heap unionfind
-                * This bug affects Edmond's general matching algorithms
-          #207: Fix 'make install' without 'make html' using CMAKE
-          #208: Suppress or fix VS2008 compilation warnings
-          ----: Update the LEMON icon
-          ----: Enable the component-based installer
-                (in installers made by CPACK)
-          ----: Set the proper version for CMAKE in the tarballs
-                (made by autotools)
-          ----: Minor clarification in the LICENSE file
-          ----: 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
-          #230: Build systems check the availability of 'long long' type
-          #229: Default implementation of Tolerance<> is used for integer types
-          #211,#212: Various fixes for compiling on AIX
-          ----: Improvements in CMAKE config
-                - docs is installed in share/doc/
-                - detects newer versions of Ghostscript
-          #239: Fix missing 'inline' specifier in time_measure.h
-          #274,#280: Install lemon/config.h
-          #275: Prefix macro names with LEMON_ in lemon/config.h
-          ----: Small script for making the release tarballs added
-          ----: Minor improvement in unify-sources.sh (a76f55d7d397)
-
 2009-03-27 LEMON joins to the COIN-OR initiative
 
@@ -187,50 +8,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 921)
+++ README	(revision 318)
@@ -1,5 +1,5 @@
-=====================================================================
-LEMON - a Library for Efficient Modeling and Optimization in Networks
-=====================================================================
+==================================================================
+LEMON - a Library of Efficient Models and Optimization in Networks
+==================================================================
 
 LEMON is an open source library written in C++. It provides
@@ -17,8 +17,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: ake/FindCOIN.cmake
===================================================================
--- cmake/FindCOIN.cmake	(revision 681)
+++ 	(revision )
@@ -1,88 +1,0 @@
-SET(COIN_ROOT_DIR "" CACHE PATH "COIN root directory")
-
-FIND_PATH(COIN_INCLUDE_DIR coin/CoinUtilsConfig.h
-  HINTS ${COIN_ROOT_DIR}/include
-)
-FIND_LIBRARY(COIN_CBC_LIBRARY
-  NAMES Cbc libCbc
-  HINTS ${COIN_ROOT_DIR}/lib
-)
-FIND_LIBRARY(COIN_CBC_SOLVER_LIBRARY
-  NAMES CbcSolver libCbcSolver
-  HINTS ${COIN_ROOT_DIR}/lib
-)
-FIND_LIBRARY(COIN_CGL_LIBRARY
-  NAMES Cgl libCgl
-  HINTS ${COIN_ROOT_DIR}/lib
-)
-FIND_LIBRARY(COIN_CLP_LIBRARY
-  NAMES Clp libClp
-  HINTS ${COIN_ROOT_DIR}/lib
-)
-FIND_LIBRARY(COIN_COIN_UTILS_LIBRARY
-  NAMES CoinUtils libCoinUtils
-  HINTS ${COIN_ROOT_DIR}/lib
-)
-FIND_LIBRARY(COIN_OSI_LIBRARY
-  NAMES Osi libOsi
-  HINTS ${COIN_ROOT_DIR}/lib
-)
-FIND_LIBRARY(COIN_OSI_CBC_LIBRARY
-  NAMES OsiCbc libOsiCbc
-  HINTS ${COIN_ROOT_DIR}/lib
-)
-FIND_LIBRARY(COIN_OSI_CLP_LIBRARY
-  NAMES OsiClp libOsiClp
-  HINTS ${COIN_ROOT_DIR}/lib
-)
-FIND_LIBRARY(COIN_OSI_VOL_LIBRARY
-  NAMES OsiVol libOsiVol
-  HINTS ${COIN_ROOT_DIR}/lib
-)
-FIND_LIBRARY(COIN_VOL_LIBRARY
-  NAMES Vol libVol
-  HINTS ${COIN_ROOT_DIR}/lib
-)
-
-INCLUDE(FindPackageHandleStandardArgs)
-FIND_PACKAGE_HANDLE_STANDARD_ARGS(COIN DEFAULT_MSG
-  COIN_INCLUDE_DIR
-  COIN_CBC_LIBRARY
-  COIN_CBC_SOLVER_LIBRARY
-  COIN_CGL_LIBRARY
-  COIN_CLP_LIBRARY
-  COIN_COIN_UTILS_LIBRARY
-  COIN_OSI_LIBRARY
-  COIN_OSI_CBC_LIBRARY
-  COIN_OSI_CLP_LIBRARY
-  COIN_OSI_VOL_LIBRARY
-  COIN_VOL_LIBRARY
-)
-
-IF(COIN_FOUND)
-  SET(COIN_INCLUDE_DIRS ${COIN_INCLUDE_DIR})
-  SET(COIN_LIBRARIES "${COIN_CBC_LIBRARY};${COIN_CBC_SOLVER_LIBRARY};${COIN_CGL_LIBRARY};${COIN_CLP_LIBRARY};${COIN_COIN_UTILS_LIBRARY};${COIN_OSI_LIBRARY};${COIN_OSI_CBC_LIBRARY};${COIN_OSI_CLP_LIBRARY};${COIN_OSI_VOL_LIBRARY};${COIN_VOL_LIBRARY}")
-  SET(COIN_CLP_LIBRARIES "${COIN_CLP_LIBRARY};${COIN_COIN_UTILS_LIBRARY}")
-  SET(COIN_CBC_LIBRARIES ${COIN_LIBRARIES})
-ENDIF(COIN_FOUND)
-
-MARK_AS_ADVANCED(
-  COIN_INCLUDE_DIR
-  COIN_CBC_LIBRARY
-  COIN_CBC_SOLVER_LIBRARY
-  COIN_CGL_LIBRARY
-  COIN_CLP_LIBRARY
-  COIN_COIN_UTILS_LIBRARY
-  COIN_OSI_LIBRARY
-  COIN_OSI_CBC_LIBRARY
-  COIN_OSI_CLP_LIBRARY
-  COIN_OSI_VOL_LIBRARY
-  COIN_VOL_LIBRARY
-)
-
-IF(COIN_FOUND)
-  SET(LEMON_HAVE_LP TRUE)
-  SET(LEMON_HAVE_MIP TRUE)
-  SET(LEMON_HAVE_CLP TRUE)
-  SET(LEMON_HAVE_CBC TRUE)
-ENDIF(COIN_FOUND)
Index: ake/FindCPLEX.cmake
===================================================================
--- cmake/FindCPLEX.cmake	(revision 683)
+++ 	(revision )
@@ -1,38 +1,0 @@
-SET(CPLEX_ROOT_DIR "" CACHE PATH "CPLEX root directory")
-
-FIND_PATH(CPLEX_INCLUDE_DIR
-  ilcplex/cplex.h
-  PATHS "C:/ILOG/CPLEX91/include"
-  PATHS "/opt/ilog/cplex91/include"
-  HINTS ${CPLEX_ROOT_DIR}/include
-)
-FIND_LIBRARY(CPLEX_LIBRARY
-  cplex91
-  PATHS "C:/ILOG/CPLEX91/lib/msvc7/stat_mda"
-  PATHS "/opt/ilog/cplex91/bin"
-  HINTS ${CPLEX_ROOT_DIR}/bin
-)
-
-INCLUDE(FindPackageHandleStandardArgs)
-FIND_PACKAGE_HANDLE_STANDARD_ARGS(CPLEX DEFAULT_MSG CPLEX_LIBRARY CPLEX_INCLUDE_DIR)
-
-FIND_PATH(CPLEX_BIN_DIR
-  cplex91.dll
-  PATHS "C:/ILOG/CPLEX91/bin/x86_win32"
-)
-
-IF(CPLEX_FOUND)
-  SET(CPLEX_INCLUDE_DIRS ${CPLEX_INCLUDE_DIR})
-  SET(CPLEX_LIBRARIES ${CPLEX_LIBRARY})
-  IF(CMAKE_SYSTEM_NAME STREQUAL "Linux")
-    SET(CPLEX_LIBRARIES "${CPLEX_LIBRARIES};m;pthread")
-  ENDIF(CMAKE_SYSTEM_NAME STREQUAL "Linux")
-ENDIF(CPLEX_FOUND)
-
-MARK_AS_ADVANCED(CPLEX_LIBRARY CPLEX_INCLUDE_DIR CPLEX_BIN_DIR)
-
-IF(CPLEX_FOUND)
-  SET(LEMON_HAVE_LP TRUE)
-  SET(LEMON_HAVE_MIP TRUE)
-  SET(LEMON_HAVE_CPLEX TRUE)
-ENDIF(CPLEX_FOUND)
Index: ake/FindGLPK.cmake
===================================================================
--- cmake/FindGLPK.cmake	(revision 685)
+++ 	(revision )
@@ -1,61 +1,0 @@
-SET(GLPK_ROOT_DIR "" CACHE PATH "GLPK root directory")
-
-SET(GLPK_REGKEY "[HKEY_LOCAL_MACHINE\\SOFTWARE\\GnuWin32\\Glpk;InstallPath]")
-GET_FILENAME_COMPONENT(GLPK_ROOT_PATH ${GLPK_REGKEY} ABSOLUTE)
-
-FIND_PATH(GLPK_INCLUDE_DIR
-  glpk.h
-  PATHS ${GLPK_REGKEY}/include
-  HINTS ${GLPK_ROOT_DIR}/include
-)
-FIND_LIBRARY(GLPK_LIBRARY
-  glpk
-  PATHS ${GLPK_REGKEY}/lib
-  HINTS ${GLPK_ROOT_DIR}/lib
-)
-
-IF(GLPK_INCLUDE_DIR AND GLPK_LIBRARY)
-  FILE(READ ${GLPK_INCLUDE_DIR}/glpk.h GLPK_GLPK_H)
-
-  STRING(REGEX MATCH "define[ ]+GLP_MAJOR_VERSION[ ]+[0-9]+" GLPK_MAJOR_VERSION_LINE "${GLPK_GLPK_H}")
-  STRING(REGEX REPLACE "define[ ]+GLP_MAJOR_VERSION[ ]+([0-9]+)" "\\1" GLPK_VERSION_MAJOR "${GLPK_MAJOR_VERSION_LINE}")
-
-  STRING(REGEX MATCH "define[ ]+GLP_MINOR_VERSION[ ]+[0-9]+" GLPK_MINOR_VERSION_LINE "${GLPK_GLPK_H}")
-  STRING(REGEX REPLACE "define[ ]+GLP_MINOR_VERSION[ ]+([0-9]+)" "\\1" GLPK_VERSION_MINOR "${GLPK_MINOR_VERSION_LINE}")
-
-  SET(GLPK_VERSION_STRING "${GLPK_VERSION_MAJOR}.${GLPK_VERSION_MINOR}")
-
-  IF(GLPK_FIND_VERSION)
-    IF(GLPK_FIND_VERSION_COUNT GREATER 2)
-      MESSAGE(SEND_ERROR "unexpected version string")
-    ENDIF(GLPK_FIND_VERSION_COUNT GREATER 2)
-
-    MATH(EXPR GLPK_REQUESTED_VERSION "${GLPK_FIND_VERSION_MAJOR}*100 + ${GLPK_FIND_VERSION_MINOR}")
-    MATH(EXPR GLPK_FOUND_VERSION "${GLPK_VERSION_MAJOR}*100 + ${GLPK_VERSION_MINOR}")
-
-    IF(GLPK_FOUND_VERSION LESS GLPK_REQUESTED_VERSION)
-      SET(GLPK_PROPER_VERSION_FOUND FALSE)
-    ELSE(GLPK_FOUND_VERSION LESS GLPK_REQUESTED_VERSION)
-      SET(GLPK_PROPER_VERSION_FOUND TRUE)
-    ENDIF(GLPK_FOUND_VERSION LESS GLPK_REQUESTED_VERSION)
-  ELSE(GLPK_FIND_VERSION)
-    SET(GLPK_PROPER_VERSION_FOUND TRUE)
-  ENDIF(GLPK_FIND_VERSION)
-ENDIF(GLPK_INCLUDE_DIR AND GLPK_LIBRARY)
-
-INCLUDE(FindPackageHandleStandardArgs)
-FIND_PACKAGE_HANDLE_STANDARD_ARGS(GLPK DEFAULT_MSG GLPK_LIBRARY GLPK_INCLUDE_DIR GLPK_PROPER_VERSION_FOUND)
-
-IF(GLPK_FOUND)
-  SET(GLPK_INCLUDE_DIRS ${GLPK_INCLUDE_DIR})
-  SET(GLPK_LIBRARIES ${GLPK_LIBRARY})
-  SET(GLPK_BIN_DIR ${GLPK_ROOT_PATH}/bin)
-ENDIF(GLPK_FOUND)
-
-MARK_AS_ADVANCED(GLPK_LIBRARY GLPK_INCLUDE_DIR GLPK_BIN_DIR)
-
-IF(GLPK_FOUND)
-  SET(LEMON_HAVE_LP TRUE)
-  SET(LEMON_HAVE_MIP TRUE)
-  SET(LEMON_HAVE_GLPK TRUE)
-ENDIF(GLPK_FOUND)
Index: ake/LEMONConfig.cmake.in
===================================================================
--- cmake/LEMONConfig.cmake.in	(revision 722)
+++ 	(revision )
@@ -1,13 +1,0 @@
-SET(LEMON_INCLUDE_DIR "@CMAKE_INSTALL_PREFIX@/include" CACHE PATH "LEMON include directory")
-SET(LEMON_INCLUDE_DIRS "${LEMON_INCLUDE_DIR}")
-
-IF(UNIX)
-  SET(LEMON_LIB_NAME "libemon.a")
-ELSEIF(WIN32)
-  SET(LEMON_LIB_NAME "lemon.lib")
-ENDIF(UNIX)
-
-SET(LEMON_LIBRARY "@CMAKE_INSTALL_PREFIX@/lib/${LEMON_LIB_NAME}" CACHE FILEPATH "LEMON library")
-SET(LEMON_LIBRARIES "${LEMON_LIBRARY}")
-
-MARK_AS_ADVANCED(LEMON_LIBRARY LEMON_INCLUDE_DIR)
Index: cmake/version.cmake.in
===================================================================
--- cmake/version.cmake.in	(revision 725)
+++ cmake/version.cmake.in	(revision 503)
@@ -1,1 +1,2 @@
-SET(LEMON_VERSION "@PACKAGE_VERSION@" CACHE STRING "LEMON version string.")
+SET(PROJECT_NAME "@PACKAGE_NAME@")
+SET(PROJECT_VERSION "@PACKAGE_VERSION@" CACHE STRING "LEMON version string.")
Index: configure.ac
===================================================================
--- configure.ac	(revision 840)
+++ configure.ac	(revision 540)
@@ -3,15 +3,12 @@
 dnl Version information.
 m4_define([lemon_version_number],
-          [m4_normalize(esyscmd([echo ${LEMON_VERSION}]))])
+	[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_hg_revision], [m4_normalize(esyscmd([hg id -i]))])
 m4_define([lemon_version], [ifelse(lemon_version_number(),
-                           [],
-                           [ifelse(lemon_hg_revision(),
-                           [],
-                           [hg-tip],
-                           [lemon_hg_path().lemon_hg_revision()])],
-                           [lemon_version_number()])])
+			   [],
+			   [lemon_hg_path().lemon_hg_revision()],
+			   [lemon_version_number()])])
 
 AC_PREREQ([2.59])
@@ -23,5 +20,5 @@
 AC_CONFIG_HEADERS([config.h lemon/config.h])
 
-AC_DEFINE([LEMON_VERSION], [lemon_version()], [The version string])
+lx_cmdline_cxxflags_set=${CXXFLAGS+set}
 
 dnl Do compilation tests using the C++ compiler.
@@ -42,5 +39,4 @@
 
 AC_CHECK_PROG([doxygen_found],[doxygen],[yes],[no])
-AC_CHECK_PROG([python_found],[python],[yes],[no])
 AC_CHECK_PROG([gs_found],[gs],[yes],[no])
 
@@ -57,17 +53,25 @@
 
 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"
+if test x"$lx_cmdline_cxxflags_set" != x"set" -a "$GXX" = yes -a "$ICC" = no; then
+  CXXFLAGS="$CXXFLAGS -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 -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
+#LX_CHECK_GLPK
+#LX_CHECK_CPLEX
+#LX_CHECK_SOPLEX
 
-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 demo programs.
+AC_ARG_ENABLE([demo],
+AS_HELP_STRING([--enable-demo], [build the demo programs])
+AS_HELP_STRING([--disable-demo], [do not build the demo programs @<:@default@:>@]),
+              [], [enable_demo=no])
+AC_MSG_CHECKING([whether to build the demo programs])
+if test x"$enable_demo" != x"no"; then
+  AC_MSG_RESULT([yes])
+else
+  AC_MSG_RESULT([no])
+fi
+AM_CONDITIONAL([WANT_DEMO], [test x"$enable_demo" != x"no"])
 
 dnl Disable/enable building the binary tools.
@@ -83,19 +87,4 @@
 fi
 AM_CONDITIONAL([WANT_TOOLS], [test x"$enable_tools" != x"no"])
-
-dnl Support for running test cases using valgrind.
-use_valgrind=no
-AC_ARG_ENABLE([valgrind],
-AS_HELP_STRING([--enable-valgrind], [use valgrind when running tests]),
-              [use_valgrind=yes])
-
-if [[ "$use_valgrind" = "yes" ]]; then
-  AC_CHECK_PROG(HAVE_VALGRIND, valgrind, yes, no)
-
-  if [[ "$HAVE_VALGRIND" = "no" ]]; then
-    AC_MSG_ERROR([Valgrind not found in PATH.])
-  fi
-fi
-AM_CONDITIONAL(USE_VALGRIND, [test "$use_valgrind" = "yes"])
 
 dnl Checks for header files.
@@ -119,5 +108,4 @@
 AC_CONFIG_FILES([
 Makefile
-demo/Makefile
 cmake/version.cmake
 doc/Doxyfile
@@ -133,16 +121,14 @@
 echo
 echo C++ compiler.................. : $CXX
-echo C++ compiles flags............ : $WARNINGCXXFLAGS $CXXFLAGS
+echo C++ compiles flags............ : $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 GLPK support.................. : $lx_glpk_found
+#echo CPLEX support................. : $lx_cplex_found
+#echo SOPLEX support................ : $lx_soplex_found
+#echo
+echo Build demo programs........... : $enable_demo
 echo Build additional tools........ : $enable_tools
-echo Use valgrind for tests........ : $use_valgrind
 echo
 echo The packace will be installed in
Index: demo/CMakeLists.txt
===================================================================
--- demo/CMakeLists.txt	(revision 726)
+++ demo/CMakeLists.txt	(revision 539)
@@ -1,19 +1,16 @@
 INCLUDE_DIRECTORIES(
-  ${PROJECT_SOURCE_DIR}
+  ${CMAKE_SOURCE_DIR}
   ${PROJECT_BINARY_DIR}
 )
 
-LINK_DIRECTORIES(
-  ${PROJECT_BINARY_DIR}/lemon
-)
+LINK_DIRECTORIES(${CMAKE_BINARY_DIR}/lemon)
 
 SET(DEMOS
   arg_parser_demo
   graph_to_eps_demo
-  lgf_demo
-)
+  lgf_demo)
 
 FOREACH(DEMO_NAME ${DEMOS})
   ADD_EXECUTABLE(${DEMO_NAME} ${DEMO_NAME}.cc)
   TARGET_LINK_LIBRARIES(${DEMO_NAME} lemon)
-ENDFOREACH()
+ENDFOREACH(DEMO_NAME)
Index: demo/Makefile.am
===================================================================
--- demo/Makefile.am	(revision 611)
+++ demo/Makefile.am	(revision 164)
@@ -1,17 +1,16 @@
-AM_CXXFLAGS = $(WARNINGCXXFLAGS)
+EXTRA_DIST += \
+	demo/CMakeLists.txt \
+	demo/digraph.lgf
 
-AM_CPPFLAGS = -I$(top_srcdir) -I$(top_builddir)
-LDADD = $(top_builddir)/lemon/libemon.la
+if WANT_DEMO
 
-EXTRA_DIST = \
-	CMakeLists.txt \
-	digraph.lgf
+noinst_PROGRAMS += \
+	demo/arg_parser_demo \
+	demo/graph_to_eps_demo \
+	demo/lgf_demo
 
-noinst_PROGRAMS = \
-	arg_parser_demo \
-	graph_to_eps_demo \
-	lgf_demo
+endif WANT_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
+demo_arg_parser_demo_SOURCES = demo/arg_parser_demo.cc
+demo_graph_to_eps_demo_SOURCES = demo/graph_to_eps_demo.cc
+demo_lgf_demo_SOURCES = demo/lgf_demo.cc
Index: demo/arg_parser_demo.cc
===================================================================
--- demo/arg_parser_demo.cc	(revision 956)
+++ demo/arg_parser_demo.cc	(revision 311)
@@ -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).
@@ -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: demo/graph_to_eps_demo.cc
===================================================================
--- demo/graph_to_eps_demo.cc	(revision 659)
+++ demo/graph_to_eps_demo.cc	(revision 313)
@@ -3,5 +3,5 @@
  * This file is a part of LEMON, a generic C++ optimization library.
  *
- * Copyright (C) 2003-2009
+ * Copyright (C) 2003-2008
  * Egervary Jeno Kombinatorikus Optimalizalasi Kutatocsoport
  * (Egervary Research Group on Combinatorial Optimization, EGRES).
@@ -86,5 +86,5 @@
     coords(coords).
     title("Sample .eps figure").
-    copyright("(C) 2003-2009 LEMON Project").
+    copyright("(C) 2003-2008 LEMON Project").
     run();
 
@@ -93,5 +93,5 @@
     coords(coords).
     title("Sample .eps figure").
-    copyright("(C) 2003-2009 LEMON Project").
+    copyright("(C) 2003-2008 LEMON Project").
     absoluteNodeSizes().absoluteArcWidths().
     nodeScale(2).nodeSizes(sizes).
@@ -106,5 +106,5 @@
   graphToEps(g,"graph_to_eps_demo_out_3_arr.eps").
     title("Sample .eps figure (with arrowheads)").
-    copyright("(C) 2003-2009 LEMON Project").
+    copyright("(C) 2003-2008 LEMON Project").
     absoluteNodeSizes().absoluteArcWidths().
     nodeColors(composeMap(palette,colors)).
@@ -133,5 +133,5 @@
   graphToEps(g,"graph_to_eps_demo_out_4_par.eps").
     title("Sample .eps figure (parallel arcs)").
-    copyright("(C) 2003-2009 LEMON Project").
+    copyright("(C) 2003-2008 LEMON Project").
     absoluteNodeSizes().absoluteArcWidths().
     nodeShapes(shapes).
@@ -148,5 +148,5 @@
   graphToEps(g,"graph_to_eps_demo_out_5_par_arr.eps").
     title("Sample .eps figure (parallel arcs and arrowheads)").
-    copyright("(C) 2003-2009 LEMON Project").
+    copyright("(C) 2003-2008 LEMON Project").
     absoluteNodeSizes().absoluteArcWidths().
     nodeScale(2).nodeSizes(sizes).
@@ -164,5 +164,5 @@
   graphToEps(g,"graph_to_eps_demo_out_6_par_arr_a4.eps").
     title("Sample .eps figure (fits to A4)").
-    copyright("(C) 2003-2009 LEMON Project").
+    copyright("(C) 2003-2008 LEMON Project").
     scaleToA4().
     absoluteNodeSizes().absoluteArcWidths().
@@ -183,5 +183,5 @@
   ListDigraph::NodeMap<Point> hcoords(h);
 
-  int cols=int(std::sqrt(double(palette.size())));
+  int cols=int(sqrt(double(palette.size())));
   for(int i=0;i<int(paletteW.size());i++) {
     Node n=h.addNode();
@@ -194,5 +194,5 @@
     scale(60).
     title("Sample .eps figure (Palette demo)").
-    copyright("(C) 2003-2009 LEMON Project").
+    copyright("(C) 2003-2008 LEMON Project").
     coords(hcoords).
     absoluteNodeSizes().absoluteArcWidths().
Index: demo/lgf_demo.cc
===================================================================
--- demo/lgf_demo.cc	(revision 463)
+++ demo/lgf_demo.cc	(revision 294)
@@ -3,5 +3,5 @@
  * This file is a part of LEMON, a generic C++ optimization library.
  *
- * Copyright (C) 2003-2009
+ * Copyright (C) 2003-2008
  * Egervary Jeno Kombinatorikus Optimalizalasi Kutatocsoport
  * (Egervary Research Group on Combinatorial Optimization, EGRES).
Index: doc/CMakeLists.txt
===================================================================
--- doc/CMakeLists.txt	(revision 943)
+++ doc/CMakeLists.txt	(revision 520)
@@ -1,54 +1,42 @@
 SET(PACKAGE_NAME ${PROJECT_NAME})
 SET(PACKAGE_VERSION ${PROJECT_VERSION})
-SET(abs_top_srcdir ${PROJECT_SOURCE_DIR})
-SET(abs_top_builddir ${PROJECT_BINARY_DIR})
+SET(abs_top_srcdir ${CMAKE_SOURCE_DIR})
+SET(abs_top_builddir ${CMAKE_BINARY_DIR})
 
 CONFIGURE_FILE(
-  ${PROJECT_SOURCE_DIR}/doc/Doxyfile.in
-  ${PROJECT_BINARY_DIR}/doc/Doxyfile
-  @ONLY
-)
+  ${CMAKE_SOURCE_DIR}/doc/Doxyfile.in
+  ${CMAKE_BINARY_DIR}/doc/Doxyfile
+  @ONLY)
 
-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)
-  ADD_CUSTOM_TARGET(html
-    COMMAND ${CMAKE_COMMAND} -E remove_directory gen-images
-    COMMAND ${CMAKE_COMMAND} -E make_directory gen-images
-    COMMAND ${GHOSTSCRIPT_EXECUTABLE} ${GHOSTSCRIPT_OPTIONS} -r18 -sOutputFile=gen-images/bipartite_matching.png ${CMAKE_CURRENT_SOURCE_DIR}/images/bipartite_matching.eps
-    COMMAND ${GHOSTSCRIPT_EXECUTABLE} ${GHOSTSCRIPT_OPTIONS} -r18 -sOutputFile=gen-images/bipartite_partitions.png ${CMAKE_CURRENT_SOURCE_DIR}/images/bipartite_partitions.eps
-    COMMAND ${GHOSTSCRIPT_EXECUTABLE} ${GHOSTSCRIPT_OPTIONS} -r18 -sOutputFile=gen-images/connected_components.png ${CMAKE_CURRENT_SOURCE_DIR}/images/connected_components.eps
-    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
-    COMMAND ${GHOSTSCRIPT_EXECUTABLE} ${GHOSTSCRIPT_OPTIONS} -r18 -sOutputFile=gen-images/nodeshape_1.png ${CMAKE_CURRENT_SOURCE_DIR}/images/nodeshape_1.eps
-    COMMAND ${GHOSTSCRIPT_EXECUTABLE} ${GHOSTSCRIPT_OPTIONS} -r18 -sOutputFile=gen-images/nodeshape_2.png ${CMAKE_CURRENT_SOURCE_DIR}/images/nodeshape_2.eps
-    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}
-  )
-
-  SET_TARGET_PROPERTIES(html PROPERTIES PROJECT_LABEL BUILD_DOC)
-
   IF(UNIX)
-    INSTALL(
-      DIRECTORY ${CMAKE_CURRENT_BINARY_DIR}/html/
-      DESTINATION share/doc/lemon/html
-      COMPONENT html_documentation
-    )
+    ADD_CUSTOM_TARGET(html
+      COMMAND rm -rf gen-images
+      COMMAND mkdir gen-images
+      COMMAND ${GHOSTSCRIPT_EXECUTABLE} -dNOPAUSE -dBATCH -q -dEPSCrop -dTextAlphaBits=4 -dGraphicsAlphaBits=4 -sDEVICE=pngalpha -r18 -sOutputFile=gen-images/nodeshape_0.png ${CMAKE_CURRENT_SOURCE_DIR}/images/nodeshape_0.eps
+      COMMAND ${GHOSTSCRIPT_EXECUTABLE} -dNOPAUSE -dBATCH -q -dEPSCrop -dTextAlphaBits=4 -dGraphicsAlphaBits=4 -sDEVICE=pngalpha -r18 -sOutputFile=gen-images/nodeshape_1.png ${CMAKE_CURRENT_SOURCE_DIR}/images/nodeshape_1.eps
+      COMMAND ${GHOSTSCRIPT_EXECUTABLE} -dNOPAUSE -dBATCH -q -dEPSCrop -dTextAlphaBits=4 -dGraphicsAlphaBits=4 -sDEVICE=pngalpha -r18 -sOutputFile=gen-images/nodeshape_2.png ${CMAKE_CURRENT_SOURCE_DIR}/images/nodeshape_2.eps
+      COMMAND ${GHOSTSCRIPT_EXECUTABLE} -dNOPAUSE -dBATCH -q -dEPSCrop -dTextAlphaBits=4 -dGraphicsAlphaBits=4 -sDEVICE=pngalpha -r18 -sOutputFile=gen-images/nodeshape_3.png ${CMAKE_CURRENT_SOURCE_DIR}/images/nodeshape_3.eps
+      COMMAND ${GHOSTSCRIPT_EXECUTABLE} -dNOPAUSE -dBATCH -q -dEPSCrop -dTextAlphaBits=4 -dGraphicsAlphaBits=4 -sDEVICE=pngalpha -r18 -sOutputFile=gen-images/nodeshape_4.png ${CMAKE_CURRENT_SOURCE_DIR}/images/nodeshape_4.eps
+      COMMAND rm -rf html
+      COMMAND ${DOXYGEN_EXECUTABLE} Doxyfile
+      WORKING_DIRECTORY ${CMAKE_CURRENT_BINARY_DIR})
   ELSEIF(WIN32)
-    INSTALL(
-      DIRECTORY ${CMAKE_CURRENT_BINARY_DIR}/html/
-      DESTINATION doc
-      COMPONENT html_documentation
-    )
-  ENDIF()
-
-ENDIF()
+    ADD_CUSTOM_TARGET(html
+      COMMAND if exist gen-images rmdir /s /q gen-images
+      COMMAND mkdir gen-images
+      COMMAND ${GHOSTSCRIPT_EXECUTABLE} -dNOPAUSE -dBATCH -q -dEPSCrop -dTextAlphaBits=4 -dGraphicsAlphaBits=4 -sDEVICE=pngalpha -r18 -sOutputFile=gen-images/nodeshape_0.png ${CMAKE_CURRENT_SOURCE_DIR}/images/nodeshape_0.eps
+      COMMAND ${GHOSTSCRIPT_EXECUTABLE} -dNOPAUSE -dBATCH -q -dEPSCrop -dTextAlphaBits=4 -dGraphicsAlphaBits=4 -sDEVICE=pngalpha -r18 -sOutputFile=gen-images/nodeshape_1.png ${CMAKE_CURRENT_SOURCE_DIR}/images/nodeshape_1.eps
+      COMMAND ${GHOSTSCRIPT_EXECUTABLE} -dNOPAUSE -dBATCH -q -dEPSCrop -dTextAlphaBits=4 -dGraphicsAlphaBits=4 -sDEVICE=pngalpha -r18 -sOutputFile=gen-images/nodeshape_2.png ${CMAKE_CURRENT_SOURCE_DIR}/images/nodeshape_2.eps
+      COMMAND ${GHOSTSCRIPT_EXECUTABLE} -dNOPAUSE -dBATCH -q -dEPSCrop -dTextAlphaBits=4 -dGraphicsAlphaBits=4 -sDEVICE=pngalpha -r18 -sOutputFile=gen-images/nodeshape_3.png ${CMAKE_CURRENT_SOURCE_DIR}/images/nodeshape_3.eps
+      COMMAND ${GHOSTSCRIPT_EXECUTABLE} -dNOPAUSE -dBATCH -q -dEPSCrop -dTextAlphaBits=4 -dGraphicsAlphaBits=4 -sDEVICE=pngalpha -r18 -sOutputFile=gen-images/nodeshape_4.png ${CMAKE_CURRENT_SOURCE_DIR}/images/nodeshape_4.eps
+      COMMAND if exist html rmdir /s /q html
+      COMMAND ${DOXYGEN_EXECUTABLE} Doxyfile
+      WORKING_DIRECTORY ${CMAKE_CURRENT_BINARY_DIR})
+  ENDIF(UNIX)
+  INSTALL(
+    DIRECTORY ${CMAKE_CURRENT_BINARY_DIR}/html/
+    DESTINATION share/doc
+    COMPONENT html_documentation)
+ENDIF(DOXYGEN_EXECUTABLE AND GHOSTSCRIPT_EXECUTABLE)
Index: doc/Doxyfile.in
===================================================================
--- doc/Doxyfile.in	(revision 803)
+++ doc/Doxyfile.in	(revision 316)
@@ -1,3 +1,3 @@
-# Doxyfile 1.5.9
+# Doxyfile 1.5.7.1
 
 #---------------------------------------------------------------------------
@@ -22,4 +22,5 @@
 QT_AUTOBRIEF           = NO
 MULTILINE_CPP_IS_BRIEF = NO
+DETAILS_AT_TOP         = YES
 INHERIT_DOCS           = NO
 SEPARATE_MEMBER_PAGES  = NO
@@ -66,5 +67,5 @@
 ENABLED_SECTIONS       = 
 MAX_INITIALIZER_LINES  = 5
-SHOW_USED_FILES        = NO
+SHOW_USED_FILES        = YES
 SHOW_DIRECTORIES       = YES
 SHOW_FILES             = YES
@@ -91,6 +92,5 @@
                          "@abs_top_srcdir@/demo" \
                          "@abs_top_srcdir@/tools" \
-                         "@abs_top_srcdir@/test/test_tools.h" \
-                         "@abs_top_builddir@/doc/references.dox"
+                         "@abs_top_srcdir@/test/test_tools.h"
 INPUT_ENCODING         = UTF-8
 FILE_PATTERNS          = *.h \
@@ -224,5 +224,5 @@
 SKIP_FUNCTION_MACROS   = YES
 #---------------------------------------------------------------------------
-# Options related to the search engine   
+# Configuration::additions related to external references   
 #---------------------------------------------------------------------------
 TAGFILES               = "@abs_top_srcdir@/doc/libstdc++.tag = http://gcc.gnu.org/onlinedocs/libstdc++/latest-doxygen/  "
Index: doc/Makefile.am
===================================================================
--- doc/Makefile.am	(revision 943)
+++ doc/Makefile.am	(revision 317)
@@ -9,5 +9,4 @@
 	doc/mainpage.dox \
 	doc/migration.dox \
-	doc/min_cost_flow.dox \
 	doc/named-param.dox \
 	doc/namespaces.dox \
@@ -16,5 +15,4 @@
 
 DOC_EPS_IMAGES18 = \
-	grid_graph.eps \
 	nodeshape_0.eps \
 	nodeshape_1.eps \
@@ -23,17 +21,6 @@
 	nodeshape_4.eps
 
-DOC_EPS_IMAGES27 = \
-	bipartite_matching.eps \
-	bipartite_partitions.eps \
-	connected_components.eps \
-	edge_biconnected_components.eps \
-	matching.eps \
-	node_biconnected_components.eps \
-	planar.eps \
-	strongly_connected_components.eps
-
 DOC_EPS_IMAGES = \
-	$(DOC_EPS_IMAGES18) \
-	$(DOC_EPS_IMAGES27)
+	$(DOC_EPS_IMAGES18)
 
 DOC_PNG_IMAGES = \
@@ -58,28 +45,5 @@
 	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
-
-references.dox: doc/references.bib
-	if test ${python_found} = yes; then \
-	  cd doc; \
-	  python @abs_top_srcdir@/scripts/bib2dox.py @abs_top_builddir@/$< >$@; \
-	  cd ..; \
-	else \
-	  echo; \
-	  echo "Python not found."; \
-	  echo; \
-	  exit 1; \
-	fi
-
-html-local: $(DOC_PNG_IMAGES) references.dox
+html-local: $(DOC_PNG_IMAGES)
 	if test ${doxygen_found} = yes; then \
 	  cd doc; \
@@ -106,9 +70,9 @@
 install-html-local: doc/html
 	@$(NORMAL_INSTALL)
-	$(mkinstalldirs) $(DESTDIR)$(htmldir)/html
+	$(mkinstalldirs) $(DESTDIR)$(htmldir)/docs
 	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; \
+	  echo " $(INSTALL_DATA) $$p $(DESTDIR)$(htmldir)/docs/$$f"; \
+	  $(INSTALL_DATA) $$p $(DESTDIR)$(htmldir)/docs/$$f; \
 	done
 
@@ -117,6 +81,6 @@
 	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; \
+	  echo " rm -f $(DESTDIR)$(htmldir)/docs/$$f"; \
+	  rm -f $(DESTDIR)$(htmldir)/docs/$$f; \
 	done
 
Index: doc/coding_style.dox
===================================================================
--- doc/coding_style.dox	(revision 463)
+++ doc/coding_style.dox	(revision 210)
@@ -3,5 +3,5 @@
  * This file is a part of LEMON, a generic C++ optimization library.
  *
- * Copyright (C) 2003-2009
+ * Copyright (C) 2003-2008
  * Egervary Jeno Kombinatorikus Optimalizalasi Kutatocsoport
  * (Egervary Research Group on Combinatorial Optimization, EGRES).
Index: doc/dirs.dox
===================================================================
--- doc/dirs.dox	(revision 463)
+++ doc/dirs.dox	(revision 318)
@@ -3,5 +3,5 @@
  * This file is a part of LEMON, a generic C++ optimization library.
  *
- * Copyright (C) 2003-2009
+ * Copyright (C) 2003-2008
  * Egervary Jeno Kombinatorikus Optimalizalasi Kutatocsoport
  * (Egervary Research Group on Combinatorial Optimization, EGRES).
@@ -72,5 +72,5 @@
 \brief Auxiliary tools for implementation.
 
-This directory contains some auxiliary classes for implementing graphs,
+This directory contains some auxiliary classes for implementing graphs, 
 maps and some other classes.
 As a user you typically don't have to deal with these files.
Index: doc/groups.dox
===================================================================
--- doc/groups.dox	(revision 963)
+++ doc/groups.dox	(revision 318)
@@ -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).
@@ -17,9 +17,7 @@
  */
 
-namespace lemon {
-
 /**
 @defgroup datas Data Structures
-This group contains the several data structures implemented in LEMON.
+This group describes the several data structures implemented in LEMON.
 */
 
@@ -63,77 +61,11 @@
 
 /**
-@defgroup graph_adaptors Adaptor Classes for Graphs
+@defgroup semi_adaptors Semi-Adaptor Classes for Graphs
 @ingroup graphs
-\brief Adaptor classes for digraphs and graphs
-
-This group contains several useful adaptor classes for digraphs and graphs.
-
-The main parts of LEMON are the different graph structures, generic
-graph algorithms, graph concepts, which couple them, and graph
-adaptors. While the previous notions are more or less clear, the
-latter one needs further explanation. Graph adaptors are graph classes
-which serve for considering graph structures in different ways.
-
-A short example makes this much clearer.  Suppose that we have an
-instance \c g of a directed graph type, say ListDigraph and an algorithm
-\code
-template <typename Digraph>
-int algorithm(const Digraph&);
-\endcode
-is needed to run on the reverse oriented graph.  It may be expensive
-(in time or in memory usage) to copy \c g with the reversed
-arcs.  In this case, an adaptor class is used, which (according
-to LEMON \ref concepts::Digraph "digraph concepts") works as a digraph.
-The adaptor uses the original digraph structure and digraph operations when
-methods of the reversed oriented graph are called.  This means that the adaptor
-have minor memory usage, and do not perform sophisticated algorithmic
-actions.  The purpose of it is to give a tool for the cases when a
-graph have to be used in a specific alteration.  If this alteration is
-obtained by a usual construction like filtering the node or the arc set or
-considering a new orientation, then an adaptor is worthwhile to use.
-To come back to the reverse oriented graph, in this situation
-\code
-template<typename Digraph> class ReverseDigraph;
-\endcode
-template class can be used. The code looks as follows
-\code
-ListDigraph g;
-ReverseDigraph<ListDigraph> rg(g);
-int result = algorithm(rg);
-\endcode
-During running the algorithm, the original digraph \c g is untouched.
-This techniques give rise to an elegant code, and based on stable
-graph adaptors, complex algorithms can be implemented easily.
-
-In flow, circulation and matching problems, the residual
-graph is of particular importance. Combining an adaptor implementing
-this with shortest path algorithms or minimum mean cycle algorithms,
-a range of weighted and cardinality optimization algorithms can be
-obtained. For other examples, the interested user is referred to the
-detailed documentation of particular adaptors.
-
-The behavior of graph adaptors can be very different. Some of them keep
-capabilities of the original graph while in other cases this would be
-meaningless. This means that the concepts that they meet depend
-on the graph adaptor, and the wrapped graph.
-For example, if an arc of a reversed digraph is deleted, this is carried
-out by deleting the corresponding arc of the original digraph, thus the
-adaptor modifies the original digraph.
-However in case of a residual digraph, this operation has no sense.
-
-Let us stand one more example here to simplify your work.
-ReverseDigraph has constructor
-\code
-ReverseDigraph(Digraph& digraph);
-\endcode
-This means that in a situation, when a <tt>const %ListDigraph&</tt>
-reference to a graph is given, then it have to be instantiated with
-<tt>Digraph=const %ListDigraph</tt>.
-\code
-int algorithm1(const ListDigraph& g) {
-  ReverseDigraph<const ListDigraph> rg(g);
-  return algorithm2(rg);
-}
-\endcode
+\brief Graph types between real graphs and graph adaptors.
+
+This group describes some graph types between real graphs and graph adaptors.
+These classes wrap graphs to give new functionality as the adaptors do it.
+On the other hand they are not light-weight structures as the adaptors.
 */
 
@@ -143,5 +75,5 @@
 \brief Map structures implemented in LEMON.
 
-This group contains the map structures implemented in LEMON.
+This group describes the map structures implemented in LEMON.
 
 LEMON provides several special purpose maps and map adaptors that e.g. combine
@@ -156,9 +88,6 @@
 \brief Special graph-related maps.
 
-This group contains maps that are specifically designed to assign
-values to the nodes and arcs/edges of graphs.
-
-If you are looking for the standard graph maps (\c NodeMap, \c ArcMap,
-\c EdgeMap), see the \ref graph_concepts "Graph Structure Concepts".
+This group describes maps that are specifically designed to assign
+values to the nodes and arcs of graphs.
 */
 
@@ -168,8 +97,8 @@
 \brief Tools to create new maps from existing ones
 
-This group contains map adaptors that are used to create "implicit"
+This group describes map adaptors that are used to create "implicit"
 maps from other maps.
 
-Most of them are \ref concepts::ReadMap "read-only maps".
+Most of them are \ref lemon::concepts::ReadMap "read-only maps".
 They can make arithmetic and logical operations between one or two maps
 (negation, shifting, addition, multiplication, logical 'and', 'or',
@@ -227,9 +156,17 @@
 
 /**
+@defgroup matrices Matrices
+@ingroup datas
+\brief Two dimensional data storages implemented in LEMON.
+
+This group describes two dimensional data storages implemented in LEMON.
+*/
+
+/**
 @defgroup paths Path Structures
 @ingroup datas
 \brief %Path structures implemented in LEMON.
 
-This group contains the path structures implemented in LEMON.
+This group describes the path structures implemented in LEMON.
 
 LEMON provides flexible data structures to work with paths.
@@ -239,26 +176,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
 */
 
@@ -268,28 +184,14 @@
 \brief Auxiliary data structures implemented in LEMON.
 
-This group contains some data structures implemented in LEMON in
+This group describes some data structures implemented in LEMON in
 order to make it easier to implement combinatorial algorithms.
 */
 
 /**
-@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 algs Algorithms
-\brief This group contains the several algorithms
+\brief This group describes the several algorithms
 implemented in LEMON.
 
-This group contains the several algorithms
+This group describes the several algorithms
 implemented in LEMON.
 */
@@ -300,7 +202,6 @@
 \brief Common graph search algorithms.
 
-This group contains the common graph search algorithms, namely
-\e breadth-first \e search (BFS) and \e depth-first \e search (DFS)
-\ref clrs01algorithms.
+This group describes the common graph search algorithms like
+Breadth-First Search (BFS) and Depth-First Search (DFS).
 */
 
@@ -310,24 +211,5 @@
 \brief Algorithms for finding shortest paths.
 
-This group contains the algorithms for finding shortest paths in digraphs
-\ref clrs01algorithms.
-
- - \ref Dijkstra algorithm for finding shortest paths from a source node
-   when all arc lengths are non-negative.
- - \ref BellmanFord "Bellman-Ford" algorithm for finding shortest paths
-   from a source node when arc lenghts can be either positive or negative,
-   but the digraph should not contain directed cycles with negative total
-   length.
- - \ref Suurballe A successive shortest path algorithm for finding
-   arc-disjoint paths between two nodes having minimum total length.
-*/
-
-/**
-@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.
+This group describes the algorithms for finding shortest paths in graphs.
 */
 
@@ -337,56 +219,38 @@
 \brief Algorithms for finding maximum flows.
 
-This group contains the algorithms for finding maximum flows and
-feasible circulations \ref clrs01algorithms, \ref amo93networkflows.
-
-The \e maximum \e flow \e problem is to find a flow of maximum value between
-a single source and a single target. Formally, there is a \f$G=(V,A)\f$
-digraph, a \f$cap: A\rightarrow\mathbf{R}^+_0\f$ capacity function and
-\f$s, t \in V\f$ source and target nodes.
-A maximum flow is an \f$f: A\rightarrow\mathbf{R}^+_0\f$ solution of the
-following optimization problem.
-
-\f[ \max\sum_{sv\in A} f(sv) - \sum_{vs\in A} f(vs) \f]
-\f[ \sum_{uv\in A} f(uv) = \sum_{vu\in A} f(vu)
-    \quad \forall u\in V\setminus\{s,t\} \f]
-\f[ 0 \leq f(uv) \leq cap(uv) \quad \forall uv\in A \f]
-
-\ref Preflow is an efficient implementation of Goldberg-Tarjan's
-preflow push-relabel algorithm \ref goldberg88newapproach for finding
-maximum flows. It also provides functions to query the minimum cut,
-which is the dual problem of maximum flow.
-
-\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.
-For more information, see \ref Circulation.
-*/
-
-/**
-@defgroup min_cost_flow_algs Minimum Cost Flow Algorithms
+This group describes the algorithms for finding maximum flows and
+feasible circulations.
+
+The maximum flow problem is to find a flow between a single source and
+a single target that is maximum. Formally, there is a \f$G=(V,A)\f$
+directed graph, an \f$c_a:A\rightarrow\mathbf{R}^+_0\f$ capacity
+function and given \f$s, t \in V\f$ source and target node. The
+maximum flow is the \f$f_a\f$ solution of the next optimization problem:
+
+\f[ 0 \le f_a \le c_a \f]
+\f[ \sum_{v\in\delta^{-}(u)}f_{vu}=\sum_{v\in\delta^{+}(u)}f_{uv}
+\qquad \forall u \in V \setminus \{s,t\}\f]
+\f[ \max \sum_{v\in\delta^{+}(s)}f_{uv} - \sum_{v\in\delta^{-}(s)}f_{vu}\f]
+
+LEMON contains several algorithms for solving maximum flow problems:
+- \ref lemon::EdmondsKarp "Edmonds-Karp"
+- \ref lemon::Preflow "Goldberg's Preflow algorithm"
+- \ref lemon::DinitzSleatorTarjan "Dinitz's blocking flow algorithm with dynamic trees"
+- \ref lemon::GoldbergTarjan "Preflow algorithm with dynamic trees"
+
+In most cases the \ref lemon::Preflow "Preflow" algorithm provides the
+fastest method to compute the maximum flow. All impelementations
+provides functions to query the minimum cut, which is the dual linear
+programming problem of the maximum flow.
+*/
+
+/**
+@defgroup min_cost_flow Minimum Cost Flow Algorithms
 @ingroup algs
 
 \brief Algorithms for finding minimum cost flows and circulations.
 
-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".
-
-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 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,
-CapacityScaling is usually the fastest algorithm (without effective scaling).
+This group describes the algorithms for finding minimum cost flows and
+circulations.
 */
 
@@ -397,61 +261,50 @@
 \brief Algorithms for finding minimum cut in graphs.
 
-This group contains the algorithms for finding minimum cut in graphs.
-
-The \e minimum \e cut \e problem is to find a non-empty and non-complete
-\f$X\f$ subset of the nodes with minimum overall capacity on
-outgoing arcs. Formally, there is a \f$G=(V,A)\f$ digraph, a
-\f$cap: A\rightarrow\mathbf{R}^+_0\f$ capacity function. The minimum
+This group describes the algorithms for finding minimum cut in graphs.
+
+The minimum cut problem is to find a non-empty and non-complete
+\f$X\f$ subset of the vertices with minimum overall capacity on
+outgoing arcs. Formally, there is \f$G=(V,A)\f$ directed graph, an
+\f$c_a:A\rightarrow\mathbf{R}^+_0\f$ capacity function. The minimum
 cut is the \f$X\f$ solution of the next optimization problem:
 
 \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}c_{uv}\f]
 
 LEMON contains several algorithms related to minimum cut problems:
 
-- \ref HaoOrlin "Hao-Orlin algorithm" for calculating minimum cut
-  in directed graphs.
-- \ref GomoryHu "Gomory-Hu tree computation" for calculating
-  all-pairs minimum cut in undirected graphs.
+- \ref lemon::HaoOrlin "Hao-Orlin algorithm" to calculate minimum cut
+  in directed graphs
+- \ref lemon::NagamochiIbaraki "Nagamochi-Ibaraki algorithm" to
+  calculate minimum cut in undirected graphs
+- \ref lemon::GomoryHuTree "Gomory-Hu tree computation" to calculate all
+  pairs minimum cut in undirected graphs
 
 If you want to find minimum cut just between two distinict nodes,
-see the \ref max_flow "maximum flow problem".
-*/
-
-/**
-@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 proved 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.
+please see the \ref max_flow "Maximum Flow page".
+*/
+
+/**
+@defgroup graph_prop Connectivity and Other Graph Properties
+@ingroup algs
+\brief Algorithms for discovering the graph properties
+
+This group describes 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 describes the algorithms for planarity checking,
+embedding and drawing.
+
+\image html planar.png
+\image latex planar.eps "Plane graph" width=\textwidth
 */
 
@@ -461,58 +314,47 @@
 \brief Algorithms for finding matchings in graphs and bipartite graphs.
 
-This group contains the algorithms for calculating
+This group contains algorithm objects and functions to calculate
 matchings in graphs and bipartite graphs. The general matching problem is
-finding a subset of the edges for which each node has at most one incident
-edge.
+finding a subset of the arcs which does not shares common endpoints.
 
 There are several different algorithms for calculate matchings in
 graphs.  The matching problems in bipartite graphs are generally
 easier than in general graphs. The goal of the matching optimization
-can be finding maximum cardinality, maximum weight or minimum cost
+can be the finding maximum cardinality, maximum weight or minimum cost
 matching. The search can be constrained to find perfect or
 maximum cardinality matching.
 
-The matching algorithms implemented in LEMON:
-- \ref MaxMatching Edmond's blossom shrinking algorithm for calculating
-  maximum cardinality matching in general graphs.
-- \ref MaxWeightedMatching Edmond's blossom shrinking algorithm for calculating
-  maximum weighted matching in general graphs.
-- \ref MaxWeightedPerfectMatching
-  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 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
+LEMON contains the next algorithms:
+- \ref lemon::MaxBipartiteMatching "MaxBipartiteMatching" Hopcroft-Karp
+  augmenting path algorithm for calculate maximum cardinality matching in
+  bipartite graphs
+- \ref lemon::PrBipartiteMatching "PrBipartiteMatching" Push-Relabel
+  algorithm for calculate maximum cardinality matching in bipartite graphs
+- \ref lemon::MaxWeightedBipartiteMatching "MaxWeightedBipartiteMatching"
+  Successive shortest path algorithm for calculate maximum weighted matching
+  and maximum weighted bipartite matching in bipartite graph
+- \ref lemon::MinCostMaxBipartiteMatching "MinCostMaxBipartiteMatching"
+  Successive shortest path algorithm for calculate minimum cost maximum
+  matching in bipartite graph
+- \ref lemon::MaxMatching "MaxMatching" Edmond's blossom shrinking algorithm
+  for calculate maximum cardinality matching in general graph
+- \ref lemon::MaxWeightedMatching "MaxWeightedMatching" Edmond's blossom
+  shrinking algorithm for calculate maximum weighted matching in general
+  graph
+- \ref lemon::MaxWeightedPerfectMatching "MaxWeightedPerfectMatching"
+  Edmond's blossom shrinking algorithm for calculate maximum weighted
+  perfect matching in general graph
+
+\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 a minimum cost spanning tree in a graph.
+
+This group describes the algorithms for finding a minimum cost spanning
+tree in a graph
 */
 
@@ -522,28 +364,51 @@
 \brief Auxiliary algorithms implemented in LEMON.
 
-This group contains some algorithms implemented in LEMON
+This group describes some algorithms implemented in LEMON
 in order to make it easier to implement complex algorithms.
 */
 
 /**
+@defgroup approx Approximation Algorithms
+@ingroup algs
+\brief Approximation algorithms.
+
+This group describes the approximation and heuristic algorithms
+implemented in LEMON.
+*/
+
+/**
 @defgroup gen_opt_group General Optimization Tools
-\brief This group contains some general optimization frameworks
+\brief This group describes some general optimization frameworks
 implemented in LEMON.
 
-This group contains some general optimization frameworks
+This group describes some general optimization frameworks
 implemented in LEMON.
 */
 
 /**
-@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 describes Lp and Mip solver interfaces for LEMON. The
+various LP solvers could be used in the same manner with this
+interface.
+*/
+
+/**
+@defgroup lp_utils Tools for Lp and Mip Solvers
+@ingroup lp_group
+\brief Helper tools to the Lp and Mip solvers.
+
+This group adds some helper tools to general optimization framework
+implemented in LEMON.
+*/
+
+/**
+@defgroup metah Metaheuristics
+@ingroup gen_opt_group
+\brief Metaheuristics for LEMON library.
+
+This group describes some metaheuristic optimization tools.
 */
 
@@ -560,5 +425,5 @@
 \brief Simple basic graph utilities.
 
-This group contains some simple basic graph utilities.
+This group describes some simple basic graph utilities.
 */
 
@@ -568,5 +433,5 @@
 \brief Tools for development, debugging and testing.
 
-This group contains several useful tools for development,
+This group describes several useful tools for development,
 debugging and testing.
 */
@@ -577,5 +442,5 @@
 \brief Simple tools for measuring the performance of algorithms.
 
-This group contains simple tools for measuring the performance
+This group describes simple tools for measuring the performance
 of algorithms.
 */
@@ -586,5 +451,5 @@
 \brief Exceptions defined in LEMON.
 
-This group contains the exceptions defined in LEMON.
+This group describes the exceptions defined in LEMON.
 */
 
@@ -593,5 +458,5 @@
 \brief Graph Input-Output methods
 
-This group contains the tools for importing and exporting graphs
+This group describes the tools for importing and exporting graphs
 and graph related data. Now it supports the \ref lgf-format
 "LEMON Graph Format", the \c DIMACS format and the encapsulated
@@ -600,9 +465,9 @@
 
 /**
-@defgroup lemon_io LEMON Graph Format
+@defgroup lemon_io LEMON Input-Output
 @ingroup io_group
 \brief Reading and writing LEMON Graph Format.
 
-This group contains methods for reading and writing
+This group describes methods for reading and writing
 \ref lgf-format "LEMON Graph Format".
 */
@@ -613,22 +478,6 @@
 \brief General \c EPS drawer and graph exporter
 
-This group contains general \c EPS drawing methods and special
+This group describes general \c EPS drawing methods and special
 graph exporting tools.
-*/
-
-/**
-@defgroup dimacs_group DIMACS Format
-@ingroup io_group
-\brief Read and write files in DIMACS format
-
-Tools to read a digraph from or write it to a file in DIMACS format data.
-*/
-
-/**
-@defgroup nauty_group NAUTY Format
-@ingroup io_group
-\brief Read \e Nauty format
-
-Tool to read graphs from \e Nauty format data.
 */
 
@@ -637,5 +486,5 @@
 \brief Skeleton classes and concept checking classes
 
-This group contains the data/algorithm skeletons and concept checking
+This group describes the data/algorithm skeletons and concept checking
 classes implemented in LEMON.
 
@@ -667,6 +516,6 @@
 \brief Skeleton and concept checking classes for graph structures
 
-This group contains the skeletons and concept checking classes of
-graph structures.
+This group describes the skeletons and concept checking classes of LEMON's
+graph structures and helper classes used to implement these.
 */
 
@@ -676,9 +525,21 @@
 \brief Skeleton and concept checking classes for maps
 
-This group contains the skeletons and concept checking classes of maps.
-*/
-
-/**
-@defgroup tools Standalone Utility Applications
+This group describes the skeletons and concept checking classes of maps.
+*/
+
+/**
+\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.
+
+It order to compile them, use <tt>--enable-demo</tt> configure option when
+build the library.
+*/
+
+/**
+@defgroup tools Standalone utility applications
 
 Some utility applications are listed here.
@@ -688,15 +549,2 @@
 */
 
-/**
-\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/bipartite_matching.eps
===================================================================
--- doc/images/bipartite_matching.eps	(revision 633)
+++ 	(revision )
@@ -1,586 +1,0 @@
-%!PS-Adobe-3.0 EPSF-3.0
-%%BoundingBox: 15 18 829 570
-%%HiResBoundingBox: 15.1913 18.4493 828.078 569.438
-%%Creator: Karbon14 EPS Exportfilter 0.5
-%%CreationDate: (04/15/06 15:20:26)
-%%For: (Balazs Dezso) ()
-%%Title: ()
-
-/N {newpath} def
-/C {closepath} def
-/m {moveto} def
-/c {curveto} def
-/l {lineto} def
-/s {stroke} def
-/f {fill} def
-/w {setlinewidth} def
-/d {setdash} def
-/r {setrgbcolor} def
-/S {gsave} def
-/R {grestore} def
-
-N
-251.402 32.047 m
-532.945 293.946 814.484 555.844 814.484 555.844 c
-[] 0 d 1 0 0 r 3.92814 w s
-
-N
-749.012 32.047 m
-742.465 293.946 735.918 555.844 735.918 555.844 c
-[] 0 d 0 0 0 r 1.96407 w s
-
-N
-539.492 32.047 m
-637.703 293.946 735.918 555.844 735.918 555.844 c
-[] 0 d 0 0 0 r 1.96407 w s
-
-N
-172.832 32.047 m
-454.375 293.946 735.918 555.844 735.918 555.844 c
-[] 0 d 0 0 0 r 1.96407 w s
-
-N
-107.355 32.047 m
-421.637 293.946 735.918 555.844 735.918 555.844 c
-[] 0 d 1 0 0 r 3.92814 w s
-
-N
-644.25 555.844 m
-696.633 293.946 749.012 32.047 749.012 32.047 c
-[] 0 d 0 0 0 r 1.96407 w s
-
-N
-474.016 555.844 m
-611.516 293.946 749.012 32.047 749.012 32.047 c
-[] 0 d 1 0 0 r 3.92814 w s
-
-N
-683.535 32.047 m
-663.894 293.946 644.25 555.844 644.25 555.844 c
-[] 0 d 0 0 0 r 1.96407 w s
-
-N
-120.453 555.844 m
-401.992 293.946 683.535 32.047 683.535 32.047 c
-[] 0 d 0 0 0 r 1.96407 w s
-
-N
-28.7853 555.844 m
-356.16 293.946 683.535 32.047 683.535 32.047 c
-[] 0 d 1 0 0 r 3.92814 w s
-
-N
-539.492 32.047 m
-546.039 293.946 552.586 555.844 552.586 555.844 c
-[] 0 d 1 0 0 r 3.92814 w s
-
-N
-316.875 32.047 m
-349.613 293.946 382.351 555.844 382.351 555.844 c
-[] 0 d 1 0 0 r 3.92814 w s
-
-N
-107.355 32.047 m
-244.855 293.946 382.351 555.844 382.351 555.844 c
-[] 0 d 0 0 0 r 1.96407 w s
-
-N
-290.687 555.844 m
-375.805 293.946 460.922 32.047 460.922 32.047 c
-[] 0 d 1 0 0 r 3.92814 w s
-
-N
-120.453 555.844 m
-290.687 293.946 460.922 32.047 460.922 32.047 c
-[] 0 d 0 0 0 r 1.96407 w s
-
-N
-172.832 32.047 m
-146.64 293.946 120.453 555.844 120.453 555.844 c
-[] 0 d 1 0 0 r 3.92814 w s
-
-N
-15.6913 555.844 m
-15.6913 555.844 l
-15.6913 548.614 21.5553 542.75 28.7853 542.75 c
-36.0163 542.75 41.8833 548.614 41.8833 555.844 c
-41.8833 563.075 36.0163 568.938 28.7853 568.938 c
-21.5553 568.938 15.6913 563.075 15.6913 555.844 c
-15.6913 555.844 l
-C
-S 0 0 0 r f R
-
-N
-16.8833 555.844 m
-16.8833 555.844 l
-16.8833 549.27 22.2113 543.942 28.7853 543.942 c
-35.3593 543.942 40.6913 549.27 40.6913 555.844 c
-40.6913 562.418 35.3593 567.747 28.7853 567.747 c
-22.2113 567.747 16.8833 562.418 16.8833 555.844 c
-16.8833 555.844 l
-C
-S 1 0.5 1 r f R
-
-N
-107.355 555.844 m
-107.355 555.844 l
-107.355 548.614 113.223 542.75 120.453 542.75 c
-127.683 542.75 133.547 548.614 133.547 555.844 c
-133.547 563.075 127.683 568.938 120.453 568.938 c
-113.223 568.938 107.355 563.075 107.355 555.844 c
-107.355 555.844 l
-C
-S 0 0 0 r f R
-
-N
-108.547 555.844 m
-108.547 555.844 l
-108.547 549.27 113.879 543.942 120.453 543.942 c
-127.027 543.942 132.355 549.27 132.355 555.844 c
-132.355 562.418 127.027 567.747 120.453 567.747 c
-113.879 567.747 108.547 562.418 108.547 555.844 c
-108.547 555.844 l
-C
-S 1 0 1 r f R
-
-N
-199.019 555.844 m
-199.019 555.844 l
-199.019 548.614 204.887 542.75 212.117 542.75 c
-219.348 542.75 225.211 548.614 225.211 555.844 c
-225.211 563.075 219.348 568.938 212.117 568.938 c
-204.887 568.938 199.019 563.075 199.019 555.844 c
-199.019 555.844 l
-C
-S 0 0 0 r f R
-
-N
-200.211 555.844 m
-200.211 555.844 l
-200.211 549.27 205.543 543.942 212.117 543.942 c
-218.691 543.942 224.019 549.27 224.019 555.844 c
-224.019 562.418 218.691 567.747 212.117 567.747 c
-205.543 567.747 200.211 562.418 200.211 555.844 c
-200.211 555.844 l
-C
-S 1 0.5 1 r f R
-
-N
-277.59 555.844 m
-277.59 555.844 l
-277.59 548.614 283.457 542.75 290.687 542.75 c
-297.918 542.75 303.781 548.614 303.781 555.844 c
-303.781 563.075 297.918 568.938 290.687 568.938 c
-283.457 568.938 277.59 563.075 277.59 555.844 c
-277.59 555.844 l
-C
-S 0 0 0 r f R
-
-N
-278.781 555.844 m
-278.781 555.844 l
-278.781 549.27 284.113 543.942 290.687 543.942 c
-297.262 543.942 302.59 549.27 302.59 555.844 c
-302.59 562.418 297.262 567.747 290.687 567.747 c
-284.113 567.747 278.781 562.418 278.781 555.844 c
-278.781 555.844 l
-C
-S 1 0 1 r f R
-
-N
-369.258 555.844 m
-369.258 555.844 l
-369.258 548.614 375.121 542.75 382.351 542.75 c
-389.582 542.75 395.445 548.614 395.445 555.844 c
-395.445 563.075 389.582 568.938 382.351 568.938 c
-375.121 568.938 369.258 563.075 369.258 555.844 c
-369.258 555.844 l
-C
-S 0 0 0 r f R
-
-N
-370.445 555.844 m
-370.445 555.844 l
-370.445 549.27 375.777 543.942 382.351 543.942 c
-388.926 543.942 394.258 549.27 394.258 555.844 c
-394.258 562.418 388.926 567.747 382.351 567.747 c
-375.777 567.747 370.445 562.418 370.445 555.844 c
-370.445 555.844 l
-C
-S 1 0 1 r f R
-
-N
-460.922 555.844 m
-460.922 555.844 l
-460.922 548.614 466.785 542.75 474.016 542.75 c
-481.246 542.75 487.109 548.614 487.109 555.844 c
-487.109 563.075 481.246 568.938 474.016 568.938 c
-466.785 568.938 460.922 563.075 460.922 555.844 c
-460.922 555.844 l
-C
-S 0 0 0 r f R
-
-N
-462.113 555.844 m
-462.113 555.844 l
-462.113 549.27 467.441 543.942 474.016 543.942 c
-480.59 543.942 485.922 549.27 485.922 555.844 c
-485.922 562.418 480.59 567.747 474.016 567.747 c
-467.441 567.747 462.113 562.418 462.113 555.844 c
-462.113 555.844 l
-C
-S 1 0.5 1 r f R
-
-N
-539.492 555.844 m
-539.492 555.844 l
-539.492 548.614 545.355 542.75 552.586 542.75 c
-559.816 542.75 565.68 548.614 565.68 555.844 c
-565.68 563.075 559.816 568.938 552.586 568.938 c
-545.355 568.938 539.492 563.075 539.492 555.844 c
-539.492 555.844 l
-C
-S 0 0 0 r f R
-
-N
-540.683 555.844 m
-540.683 555.844 l
-540.683 549.27 546.012 543.942 552.586 543.942 c
-559.16 543.942 564.492 549.27 564.492 555.844 c
-564.492 562.418 559.16 567.747 552.586 567.747 c
-546.012 567.747 540.683 562.418 540.683 555.844 c
-540.683 555.844 l
-C
-S 1 0 1 r f R
-
-N
-631.156 555.844 m
-631.156 555.844 l
-631.156 548.614 637.019 542.75 644.25 542.75 c
-651.48 542.75 657.348 548.614 657.348 555.844 c
-657.348 563.075 651.48 568.938 644.25 568.938 c
-637.019 568.938 631.156 563.075 631.156 555.844 c
-631.156 555.844 l
-C
-S 0 0 0 r f R
-
-N
-632.348 555.844 m
-632.348 555.844 l
-632.348 549.27 637.676 543.942 644.25 543.942 c
-650.824 543.942 656.156 549.27 656.156 555.844 c
-656.156 562.418 650.824 567.747 644.25 567.747 c
-637.676 567.747 632.348 562.418 632.348 555.844 c
-632.348 555.844 l
-C
-S 1 0.5 1 r f R
-
-N
-722.82 555.844 m
-722.82 555.844 l
-722.82 548.614 728.687 542.75 735.918 542.75 c
-743.149 542.75 749.012 548.614 749.012 555.844 c
-749.012 563.075 743.149 568.938 735.918 568.938 c
-728.687 568.938 722.82 563.075 722.82 555.844 c
-722.82 555.844 l
-C
-S 0 0 0 r f R
-
-N
-724.012 555.844 m
-724.012 555.844 l
-724.012 549.27 729.344 543.942 735.918 543.942 c
-742.492 543.942 747.82 549.27 747.82 555.844 c
-747.82 562.418 742.492 567.747 735.918 567.747 c
-729.344 567.747 724.012 562.418 724.012 555.844 c
-724.012 555.844 l
-C
-S 1 0 1 r f R
-
-N
-801.391 555.844 m
-801.391 555.844 l
-801.391 548.614 807.254 542.75 814.484 542.75 c
-821.715 542.75 827.578 548.614 827.578 555.844 c
-827.578 563.075 821.715 568.938 814.484 568.938 c
-807.254 568.938 801.391 563.075 801.391 555.844 c
-801.391 555.844 l
-C
-S 0 0 0 r f R
-
-N
-802.582 555.844 m
-802.582 555.844 l
-802.582 549.27 807.91 543.942 814.484 543.942 c
-821.059 543.942 826.387 549.27 826.387 555.844 c
-826.387 562.418 821.059 567.747 814.484 567.747 c
-807.91 567.747 802.582 562.418 802.582 555.844 c
-802.582 555.844 l
-C
-S 1 0 1 r f R
-
-N
-15.6913 32.047 m
-15.6913 32.047 l
-15.6913 24.8165 21.5553 18.9493 28.7853 18.9493 c
-36.0163 18.9493 41.8833 24.8165 41.8833 32.047 c
-41.8833 39.2775 36.0163 45.1407 28.7853 45.1407 c
-21.5553 45.1407 15.6913 39.2775 15.6913 32.047 c
-15.6913 32.047 l
-C
-S 0 0 0 r f R
-
-N
-16.8833 32.047 m
-16.8833 32.047 l
-16.8833 25.4728 22.2113 20.1407 28.7853 20.1407 c
-35.3593 20.1407 40.6913 25.4728 40.6913 32.047 c
-40.6913 38.6212 35.3593 43.9493 28.7853 43.9493 c
-22.2113 43.9493 16.8833 38.6212 16.8833 32.047 c
-16.8833 32.047 l
-C
-S 0.5 0.5 1 r f R
-
-N
-94.2623 32.047 m
-94.2623 32.047 l
-94.2623 24.8165 100.125 18.9493 107.355 18.9493 c
-114.586 18.9493 120.453 24.8165 120.453 32.047 c
-120.453 39.2775 114.586 45.1407 107.355 45.1407 c
-100.125 45.1407 94.2623 39.2775 94.2623 32.047 c
-94.2623 32.047 l
-C
-S 0 0 0 r f R
-
-N
-95.4533 32.047 m
-95.4533 32.047 l
-95.4533 25.4728 100.781 20.1407 107.355 20.1407 c
-113.93 20.1407 119.262 25.4728 119.262 32.047 c
-119.262 38.6212 113.93 43.9493 107.355 43.9493 c
-100.781 43.9493 95.4533 38.6212 95.4533 32.047 c
-95.4533 32.047 l
-C
-S 0.5 0.5 1 r f R
-
-N
-159.734 32.047 m
-159.734 32.047 l
-159.734 24.8165 165.601 18.9493 172.832 18.9493 c
-180.062 18.9493 185.926 24.8165 185.926 32.047 c
-185.926 39.2775 180.062 45.1407 172.832 45.1407 c
-165.601 45.1407 159.734 39.2775 159.734 32.047 c
-159.734 32.047 l
-C
-S 0 0 0 r f R
-
-N
-160.926 32.047 m
-160.926 32.047 l
-160.926 25.4728 166.258 20.1407 172.832 20.1407 c
-179.406 20.1407 184.734 25.4728 184.734 32.047 c
-184.734 38.6212 179.406 43.9493 172.832 43.9493 c
-166.258 43.9493 160.926 38.6212 160.926 32.047 c
-160.926 32.047 l
-C
-S 0.5 0.5 1 r f R
-
-N
-238.305 32.047 m
-238.305 32.047 l
-238.305 24.8165 244.172 18.9493 251.402 18.9493 c
-258.633 18.9493 264.496 24.8165 264.496 32.047 c
-264.496 39.2775 258.633 45.1407 251.402 45.1407 c
-244.172 45.1407 238.305 39.2775 238.305 32.047 c
-238.305 32.047 l
-C
-S 0 0 0 r f R
-
-N
-239.496 32.047 m
-239.496 32.047 l
-239.496 25.4728 244.828 20.1407 251.402 20.1407 c
-257.976 20.1407 263.305 25.4728 263.305 32.047 c
-263.305 38.6212 257.976 43.9493 251.402 43.9493 c
-244.828 43.9493 239.496 38.6212 239.496 32.047 c
-239.496 32.047 l
-C
-S 0.5 0.5 1 r f R
-
-N
-303.781 32.047 m
-303.781 32.047 l
-303.781 24.8165 309.644 18.9493 316.875 18.9493 c
-324.105 18.9493 329.973 24.8165 329.973 32.047 c
-329.973 39.2775 324.105 45.1407 316.875 45.1407 c
-309.644 45.1407 303.781 39.2775 303.781 32.047 c
-303.781 32.047 l
-C
-S 0 0 0 r f R
-
-N
-304.973 32.047 m
-304.973 32.047 l
-304.973 25.4728 310.301 20.1407 316.875 20.1407 c
-323.449 20.1407 328.781 25.4728 328.781 32.047 c
-328.781 38.6212 323.449 43.9493 316.875 43.9493 c
-310.301 43.9493 304.973 38.6212 304.973 32.047 c
-304.973 32.047 l
-C
-S 0.5 0.5 1 r f R
-
-N
-382.351 32.047 m
-382.351 32.047 l
-382.351 24.8165 388.215 18.9493 395.445 18.9493 c
-402.676 18.9493 408.543 24.8165 408.543 32.047 c
-408.543 39.2775 402.676 45.1407 395.445 45.1407 c
-388.215 45.1407 382.351 39.2775 382.351 32.047 c
-382.351 32.047 l
-C
-S 0 0 0 r f R
-
-N
-383.543 32.047 m
-383.543 32.047 l
-383.543 25.4728 388.871 20.1407 395.445 20.1407 c
-402.019 20.1407 407.351 25.4728 407.351 32.047 c
-407.351 38.6212 402.019 43.9493 395.445 43.9493 c
-388.871 43.9493 383.543 38.6212 383.543 32.047 c
-383.543 32.047 l
-C
-S 0.5 0.5 1 r f R
-
-N
-447.828 32.047 m
-447.828 32.047 l
-447.828 24.8165 453.691 18.9493 460.922 18.9493 c
-468.152 18.9493 474.016 24.8165 474.016 32.047 c
-474.016 39.2775 468.152 45.1407 460.922 45.1407 c
-453.691 45.1407 447.828 39.2775 447.828 32.047 c
-447.828 32.047 l
-C
-S 0 0 0 r f R
-
-N
-449.016 32.047 m
-449.016 32.047 l
-449.016 25.4728 454.348 20.1407 460.922 20.1407 c
-467.496 20.1407 472.824 25.4728 472.824 32.047 c
-472.824 38.6212 467.496 43.9493 460.922 43.9493 c
-454.348 43.9493 449.016 38.6212 449.016 32.047 c
-449.016 32.047 l
-C
-S 0.5 0.5 1 r f R
-
-N
-526.394 32.047 m
-526.394 32.047 l
-526.394 24.8165 532.262 18.9493 539.492 18.9493 c
-546.723 18.9493 552.586 24.8165 552.586 32.047 c
-552.586 39.2775 546.723 45.1407 539.492 45.1407 c
-532.262 45.1407 526.394 39.2775 526.394 32.047 c
-526.394 32.047 l
-C
-S 0 0 0 r f R
-
-N
-527.586 32.047 m
-527.586 32.047 l
-527.586 25.4728 532.918 20.1407 539.492 20.1407 c
-546.066 20.1407 551.394 25.4728 551.394 32.047 c
-551.394 38.6212 546.066 43.9493 539.492 43.9493 c
-532.918 43.9493 527.586 38.6212 527.586 32.047 c
-527.586 32.047 l
-C
-S 0.5 0.5 1 r f R
-
-N
-591.871 32.047 m
-591.871 32.047 l
-591.871 24.8165 597.734 18.9493 604.965 18.9493 c
-612.195 18.9493 618.062 24.8165 618.062 32.047 c
-618.062 39.2775 612.195 45.1407 604.965 45.1407 c
-597.734 45.1407 591.871 39.2775 591.871 32.047 c
-591.871 32.047 l
-C
-S 0 0 0 r f R
-
-N
-593.062 32.047 m
-593.062 32.047 l
-593.062 25.4728 598.39 20.1407 604.965 20.1407 c
-611.539 20.1407 616.871 25.4728 616.871 32.047 c
-616.871 38.6212 611.539 43.9493 604.965 43.9493 c
-598.39 43.9493 593.062 38.6212 593.062 32.047 c
-593.062 32.047 l
-C
-S 0.5 0.5 1 r f R
-
-N
-670.441 32.047 m
-670.441 32.047 l
-670.441 24.8165 676.305 18.9493 683.535 18.9493 c
-690.766 18.9493 696.633 24.8165 696.633 32.047 c
-696.633 39.2775 690.766 45.1407 683.535 45.1407 c
-676.305 45.1407 670.441 39.2775 670.441 32.047 c
-670.441 32.047 l
-C
-S 0 0 0 r f R
-
-N
-671.633 32.047 m
-671.633 32.047 l
-671.633 25.4728 676.961 20.1407 683.535 20.1407 c
-690.109 20.1407 695.441 25.4728 695.441 32.047 c
-695.441 38.6212 690.109 43.9493 683.535 43.9493 c
-676.961 43.9493 671.633 38.6212 671.633 32.047 c
-671.633 32.047 l
-C
-S 0 0 1 r f R
-
-N
-735.918 32.047 m
-735.918 32.047 l
-735.918 24.8165 741.781 18.9493 749.012 18.9493 c
-756.242 18.9493 762.106 24.8165 762.106 32.047 c
-762.106 39.2775 756.242 45.1407 749.012 45.1407 c
-741.781 45.1407 735.918 39.2775 735.918 32.047 c
-735.918 32.047 l
-C
-S 0 0 0 r f R
-
-N
-737.105 32.047 m
-737.105 32.047 l
-737.105 25.4728 742.437 20.1407 749.012 20.1407 c
-755.586 20.1407 760.914 25.4728 760.914 32.047 c
-760.914 38.6212 755.586 43.9493 749.012 43.9493 c
-742.437 43.9493 737.105 38.6212 737.105 32.047 c
-737.105 32.047 l
-C
-S 0 0 1 r f R
-
-N
-801.391 32.047 m
-801.391 32.047 l
-801.391 24.8165 807.254 18.9493 814.484 18.9493 c
-821.715 18.9493 827.578 24.8165 827.578 32.047 c
-827.578 39.2775 821.715 45.1407 814.484 45.1407 c
-807.254 45.1407 801.391 39.2775 801.391 32.047 c
-801.391 32.047 l
-C
-S 0 0 0 r f R
-
-N
-802.582 32.047 m
-802.582 32.047 l
-802.582 25.4728 807.91 20.1407 814.484 20.1407 c
-821.059 20.1407 826.387 25.4728 826.387 32.047 c
-826.387 38.6212 821.059 43.9493 814.484 43.9493 c
-807.91 43.9493 802.582 38.6212 802.582 32.047 c
-802.582 32.047 l
-C
-S 0.5 0.5 1 r f R
-
-%%EOF
Index: c/images/bipartite_partitions.eps
===================================================================
--- doc/images/bipartite_partitions.eps	(revision 634)
+++ 	(revision )
@@ -1,114 +1,0 @@
-%!PS-Adobe-2.0 EPSF-2.0
-%%Creator: LEMON, graphToEps()
-%%CreationDate: Tue Nov 15 16:51:43 2005
-%%BoundingBox: 0 0 842 596
-%%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
-/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
-90 rotate
-0 -842 translate
-71.6378 15 translate
-0.389093 dup scale
-90 rotate
-1197.47 -613.138 translate
-%Edges:
-gsave
-513.857 -446.322 296.569 -487.43 79.2808 -528.539 0 0 0 2 lb
-513.857 -446.322 575.52 -315.655 637.183 -184.989 0 0 0 2 lb
-393.468 566.711 494.771 434.577 596.074 302.442 0 0 0 2 lb
-393.468 566.711 155.625 579.925 -82.2171 593.138 0 0 0 2 lb
-393.468 566.711 251.056 450.726 108.644 334.741 0 0 0 2 lb
-869.153 52.8539 732.613 177.648 596.074 302.442 0 0 0 2 lb
-869.153 52.8539 753.168 -66.0676 637.183 -184.989 0 0 0 2 lb
--82.2171 593.138 -91.0261 346.487 -99.8351 99.8351 0 0 0 2 lb
--663.61 546.157 -753.168 394.936 -842.726 243.715 0 0 0 2 lb
--663.61 546.157 -574.052 437.513 -484.494 328.869 0 0 0 2 lb
--1077.63 161.498 -960.178 202.606 -842.726 243.715 0 0 0 2 lb
--1077.63 161.498 -968.987 66.0674 -860.344 -29.3633 0 0 0 2 lb
--1177.47 -234.906 -1029.18 -381.722 -880.898 -528.539 0 0 0 2 lb
--1177.47 -234.906 -1018.91 -132.135 -860.344 -29.3633 0 0 0 2 lb
--880.898 -528.539 -744.359 -387.595 -607.82 -246.651 0 0 0 2 lb
--499.175 -499.175 -355.295 -475.685 -211.415 -452.194 0 0 0 2 lb
--499.175 -499.175 -553.498 -372.913 -607.82 -246.651 0 0 0 2 lb
--499.175 -499.175 -386.587 -315.087 -274 -131 0 0 0 2 lb
-79.2808 -528.539 -66.0671 -490.366 -211.415 -452.194 0 0 0 2 lb
-637.183 -184.989 421.363 -253.993 205.543 -322.996 0 0 0 2 lb
-205.543 -322.996 162.966 -226.097 120.389 -129.198 0 0 0 2 lb
-399.34 88.0898 259.865 -20.5541 120.389 -129.198 0 0 0 2 lb
-399.34 88.0898 253.992 211.415 108.644 334.741 0 0 0 2 lb
--842.726 243.715 -471.281 171.775 -99.8351 99.8351 0 0 0 2 lb
--842.726 243.715 -558.363 56.3575 -274 -131 0 0 0 2 lb
--860.344 -29.3633 -734.082 -138.007 -607.82 -246.651 0 0 0 2 lb
--211.415 -452.194 -45.513 -290.696 120.389 -129.198 0 0 0 2 lb
--99.8351 99.8351 4.40445 217.288 108.644 334.741 0 0 0 2 lb
--99.8351 99.8351 -292.165 214.352 -484.494 328.869 0 0 0 2 lb
-120.389 -129.198 -76.8055 -130.099 -274 -131 0 0 0 2 lb
-grestore
-%Nodes:
-gsave
--274 -131 20 1 0 0 nc
--607.82 -246.651 20 1 0 0 nc
--484.494 328.869 20 0 0 1 nc
-108.644 334.741 20 0 0 1 nc
-120.389 -129.198 20 0 0 1 nc
--99.8351 99.8351 20 1 0 0 nc
--211.415 -452.194 20 1 0 0 nc
--860.344 -29.3633 20 0 0 1 nc
--842.726 243.715 20 0 0 1 nc
-399.34 88.0898 20 1 0 0 nc
-205.543 -322.996 20 1 0 0 nc
-637.183 -184.989 20 0 0 1 nc
-79.2808 -528.539 20 0 0 1 nc
--499.175 -499.175 20 0 0 1 nc
--880.898 -528.539 20 0 0 1 nc
--1177.47 -234.906 20 1 0 0 nc
--1077.63 161.498 20 1 0 0 nc
--663.61 546.157 20 1 0 0 nc
--82.2171 593.138 20 0 0 1 nc
-596.074 302.442 20 0 0 1 nc
-869.153 52.8539 20 1 0 0 nc
-393.468 566.711 20 1 0 0 nc
-513.857 -446.322 20 1 0 0 nc
-grestore
-grestore
-showpage
Index: c/images/connected_components.eps
===================================================================
--- doc/images/connected_components.eps	(revision 634)
+++ 	(revision )
@@ -1,159 +1,0 @@
-%!PS-Adobe-2.0 EPSF-2.0
-%%Creator: LEMON, graphToEps()
-%%CreationDate: Fri Nov  4 13:47:12 2005
-%%BoundingBox: 0 0 842 596
-%%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
-/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
-90 rotate
-0 -842 translate
-71.0944 15 translate
-0.434694 dup scale
-90 rotate
-860.856 -588.349 translate
-%Edges:
-gsave
-574.035 177.301 622.149 225.748 670.264 274.195 0 0 0 2 lb
-694.579 115.483 682.421 194.839 670.264 274.195 0 0 0 2 lb
-280.402 10.3938 246.402 -6.60595 212.403 -23.6057 0 0 0 2 lb
-280.402 10.3938 283.493 -18.9695 286.584 -48.3327 0 0 0 2 lb
-212.403 -23.6057 249.493 -35.9692 286.584 -48.3327 0 0 0 2 lb
-286.584 -48.3327 326.765 -79.2414 366.947 -110.15 0 0 0 2 lb
-286.584 -48.3327 278.857 -111.695 271.13 -175.058 0 0 0 2 lb
-438.037 -88.514 417.946 -142.604 397.855 -196.694 0 0 0 2 lb
-438.037 -88.514 402.492 -99.332 366.947 -110.15 0 0 0 2 lb
-397.855 -196.694 382.401 -153.422 366.947 -110.15 0 0 0 2 lb
-366.947 -110.15 319.038 -142.604 271.13 -175.058 0 0 0 2 lb
-271.13 -175.058 274.221 -213.694 277.311 -252.33 0 0 0 2 lb
-271.13 -175.058 238.675 -190.512 206.221 -205.967 0 0 0 2 lb
-277.311 -252.33 241.766 -229.149 206.221 -205.967 0 0 0 2 lb
--840.856 -246.718 -804.351 -66.7145 -767.847 113.289 0 0 0 2 lb
--579.033 445.603 -673.44 279.446 -767.847 113.289 0 0 0 2 lb
--579.033 445.603 -524.906 302.104 -470.779 158.605 0 0 0 2 lb
--767.847 113.289 -619.313 135.947 -470.779 158.605 0 0 0 2 lb
-906.312 201.403 946.592 42.798 986.873 -115.807 0 0 0 2 lb
-906.312 201.403 834.562 91.8901 762.812 -17.6227 0 0 0 2 lb
-986.873 -115.807 874.842 -66.7148 762.812 -17.6227 0 0 0 2 lb
--470.779 158.605 -390.218 50.3508 -309.657 -57.9033 0 0 0 2 lb
-422.945 521.129 208.955 541.269 -5.03507 561.41 0 0 0 2 lb
-422.945 521.129 376.371 417.911 329.797 314.692 0 0 0 2 lb
-422.945 521.129 474.554 276.928 526.164 32.7279 0 0 0 2 lb
--5.03507 561.41 -36.5042 440.568 -67.9734 319.727 0 0 0 2 lb
-329.797 314.692 130.912 317.209 -67.9734 319.727 0 0 0 2 lb
--67.9734 319.727 229.095 176.227 526.164 32.7279 0 0 0 2 lb
-762.812 -17.6227 644.488 7.5526 526.164 32.7279 0 0 0 2 lb
-762.812 -17.6227 746.448 -162.381 730.084 -307.139 0 0 0 2 lb
-526.164 32.7279 470.779 -128.394 415.393 -289.516 0 0 0 2 lb
-730.084 -307.139 572.738 -298.327 415.393 -289.516 0 0 0 2 lb
-415.393 -289.516 173.71 -318.468 -67.9734 -347.42 0 0 0 2 lb
--67.9734 -347.42 -188.815 -202.662 -309.657 -57.9033 0 0 0 2 lb
--67.9734 -347.42 -195.758 -390.692 -323.543 -433.964 0 0 0 2 lb
--309.657 -57.9033 -424.775 -160.272 -539.894 -262.64 0 0 0 2 lb
--323.543 -433.964 -431.719 -348.302 -539.894 -262.64 0 0 0 2 lb
--26.6953 -19.9585 44.8558 -96.8093 116.407 -173.66 0 0 0 2 lb
--26.6953 -19.9585 87.2563 9.19185 201.208 38.3422 0 0 0 2 lb
--26.6953 -19.9585 -144.622 43.6422 -262.548 107.243 0 0 0 2 lb
--26.6953 -19.9585 -20.0703 56.8923 -13.4452 133.743 0 0 0 2 lb
-116.407 -173.66 158.808 -67.6589 201.208 38.3422 0 0 0 2 lb
--262.548 107.243 -137.997 120.493 -13.4452 133.743 0 0 0 2 lb
--262.548 107.243 -221.472 176.144 -180.397 245.045 0 0 0 2 lb
--13.4452 133.743 -96.9211 189.394 -180.397 245.045 0 0 0 2 lb
--180.397 245.045 -142.256 345.099 -132.697 451.748 0 0 0 2 lb
--180.397 245.045 -170.838 351.694 -132.697 451.748 0 0 0 2 lb
--416.25 345.746 -274.474 398.747 -132.697 451.748 0 0 0 2 lb
--416.25 345.746 -393.725 457.048 -371.2 568.349 0 0 0 2 lb
--132.697 451.748 -251.948 510.048 -371.2 568.349 0 0 0 2 lb
-670.264 274.195 629.188 409.347 588.113 544.499 0 0 0 2 lb
-670.264 274.195 797.466 341.771 924.667 409.347 0 0 0 2 lb
-588.113 544.499 756.39 476.923 924.667 409.347 0 0 0 2 lb
--689.204 -237.261 -614.799 -102.648 -567.302 43.6423 0 0 0 2 lb
--689.204 -237.261 -641.707 -90.9706 -567.302 43.6423 0 0 0 2 lb
-grestore
-%Nodes:
-gsave
--567.302 43.6423 20 0 0 0 nc
--689.204 -237.261 20 0 0 0 nc
-924.667 409.347 20 1 0 0 nc
-588.113 544.499 20 1 0 0 nc
-670.264 274.195 20 1 0 0 nc
--371.2 568.349 20 0 1 0 nc
--132.697 451.748 20 0 1 0 nc
--416.25 345.746 20 0 1 0 nc
--180.397 245.045 20 0 1 0 nc
--13.4452 133.743 20 0 1 0 nc
--262.548 107.243 20 0 1 0 nc
-201.208 38.3422 20 0 1 0 nc
-116.407 -173.66 20 0 1 0 nc
--26.6953 -19.9585 20 0 1 0 nc
--539.894 -262.64 20 0 0 1 nc
--323.543 -433.964 20 0 0 1 nc
--309.657 -57.9033 20 0 0 1 nc
--67.9734 -347.42 20 0 0 1 nc
-415.393 -289.516 20 0 0 1 nc
-730.084 -307.139 20 0 0 1 nc
-526.164 32.7279 20 0 0 1 nc
-762.812 -17.6227 20 0 0 1 nc
--67.9734 319.727 20 0 0 1 nc
-329.797 314.692 20 0 0 1 nc
--5.03507 561.41 20 0 0 1 nc
-422.945 521.129 20 0 0 1 nc
--470.779 158.605 20 0 0 1 nc
-986.873 -115.807 20 0 0 1 nc
-906.312 201.403 20 0 0 1 nc
--767.847 113.289 20 0 0 1 nc
--579.033 445.603 20 0 0 1 nc
--840.856 -246.718 20 0 0 1 nc
-206.221 -205.967 20 1 1 0 nc
-277.311 -252.33 20 1 1 0 nc
-271.13 -175.058 20 1 1 0 nc
-366.947 -110.15 20 1 1 0 nc
-397.855 -196.694 20 1 1 0 nc
-438.037 -88.514 20 1 1 0 nc
-286.584 -48.3327 20 1 1 0 nc
-212.403 -23.6057 20 1 1 0 nc
-280.402 10.3938 20 1 1 0 nc
-694.579 115.483 20 1 0 0 nc
-574.035 177.301 20 1 0 0 nc
-grestore
-grestore
-showpage
Index: c/images/edge_biconnected_components.eps
===================================================================
--- doc/images/edge_biconnected_components.eps	(revision 634)
+++ 	(revision )
@@ -1,159 +1,0 @@
-%!PS-Adobe-2.0 EPSF-2.0
-%%Creator: LEMON, graphToEps()
-%%CreationDate: Fri Nov  4 13:47:12 2005
-%%BoundingBox: 0 0 842 596
-%%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
-/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
-90 rotate
-0 -842 translate
-71.0944 15 translate
-0.434694 dup scale
-90 rotate
-860.856 -588.349 translate
-%Edges:
-gsave
-574.035 177.301 622.149 225.748 670.264 274.195 1 0 0 2 lb
-694.579 115.483 682.421 194.839 670.264 274.195 1 0 0 2 lb
-280.402 10.3938 246.402 -6.60595 212.403 -23.6057 0 0 1 2 lb
-280.402 10.3938 283.493 -18.9695 286.584 -48.3327 0 0 1 2 lb
-212.403 -23.6057 249.493 -35.9692 286.584 -48.3327 0 0 1 2 lb
-286.584 -48.3327 326.765 -79.2414 366.947 -110.15 0 0 1 2 lb
-286.584 -48.3327 278.857 -111.695 271.13 -175.058 0 0 1 2 lb
-438.037 -88.514 417.946 -142.604 397.855 -196.694 0 0 1 2 lb
-438.037 -88.514 402.492 -99.332 366.947 -110.15 0 0 1 2 lb
-397.855 -196.694 382.401 -153.422 366.947 -110.15 0 0 1 2 lb
-366.947 -110.15 319.038 -142.604 271.13 -175.058 0 0 1 2 lb
-271.13 -175.058 274.221 -213.694 277.311 -252.33 0 0 1 2 lb
-271.13 -175.058 238.675 -190.512 206.221 -205.967 0 0 1 2 lb
-277.311 -252.33 241.766 -229.149 206.221 -205.967 0 0 1 2 lb
--840.856 -246.718 -804.351 -66.7145 -767.847 113.289 1 0 0 2 lb
--579.033 445.603 -673.44 279.446 -767.847 113.289 0 0 1 2 lb
--579.033 445.603 -524.906 302.104 -470.779 158.605 0 0 1 2 lb
--767.847 113.289 -619.313 135.947 -470.779 158.605 0 0 1 2 lb
-906.312 201.403 946.592 42.798 986.873 -115.807 0 0 1 2 lb
-906.312 201.403 834.562 91.8901 762.812 -17.6227 0 0 1 2 lb
-986.873 -115.807 874.842 -66.7148 762.812 -17.6227 0 0 1 2 lb
--470.779 158.605 -390.218 50.3508 -309.657 -57.9033 1 0 0 2 lb
-422.945 521.129 208.955 541.269 -5.03507 561.41 0 0 1 2 lb
-422.945 521.129 376.371 417.911 329.797 314.692 0 0 1 2 lb
-422.945 521.129 474.554 276.928 526.164 32.7279 0 0 1 2 lb
--5.03507 561.41 -36.5042 440.568 -67.9734 319.727 0 0 1 2 lb
-329.797 314.692 130.912 317.209 -67.9734 319.727 0 0 1 2 lb
--67.9734 319.727 229.095 176.227 526.164 32.7279 0 0 1 2 lb
-762.812 -17.6227 644.488 7.5526 526.164 32.7279 0 0 1 2 lb
-762.812 -17.6227 746.448 -162.381 730.084 -307.139 0 0 1 2 lb
-526.164 32.7279 470.779 -128.394 415.393 -289.516 0 0 1 2 lb
-730.084 -307.139 572.738 -298.327 415.393 -289.516 0 0 1 2 lb
-415.393 -289.516 173.71 -318.468 -67.9734 -347.42 1 0 0 2 lb
--67.9734 -347.42 -188.815 -202.662 -309.657 -57.9033 0 0 1 2 lb
--67.9734 -347.42 -195.758 -390.692 -323.543 -433.964 0 0 1 2 lb
--309.657 -57.9033 -424.775 -160.272 -539.894 -262.64 0 0 1 2 lb
--323.543 -433.964 -431.719 -348.302 -539.894 -262.64 0 0 1 2 lb
--26.6953 -19.9585 44.8558 -96.8093 116.407 -173.66 0 0 1 2 lb
--26.6953 -19.9585 87.2563 9.19185 201.208 38.3422 0 0 1 2 lb
--26.6953 -19.9585 -144.622 43.6422 -262.548 107.243 0 0 1 2 lb
--26.6953 -19.9585 -20.0703 56.8923 -13.4452 133.743 0 0 1 2 lb
-116.407 -173.66 158.808 -67.6589 201.208 38.3422 0 0 1 2 lb
--262.548 107.243 -137.997 120.493 -13.4452 133.743 0 0 1 2 lb
--262.548 107.243 -221.472 176.144 -180.397 245.045 0 0 1 2 lb
--13.4452 133.743 -96.9211 189.394 -180.397 245.045 0 0 1 2 lb
--180.397 245.045 -142.256 345.099 -132.697 451.748 0 0 1 2 lb
--180.397 245.045 -170.838 351.694 -132.697 451.748 0 0 1 2 lb
--416.25 345.746 -274.474 398.747 -132.697 451.748 0 0 1 2 lb
--416.25 345.746 -393.725 457.048 -371.2 568.349 0 0 1 2 lb
--132.697 451.748 -251.948 510.048 -371.2 568.349 0 0 1 2 lb
-670.264 274.195 629.188 409.347 588.113 544.499 0 0 1 2 lb
-670.264 274.195 797.466 341.771 924.667 409.347 0 0 1 2 lb
-588.113 544.499 756.39 476.923 924.667 409.347 0 0 1 2 lb
--689.204 -237.261 -614.799 -102.648 -567.302 43.6423 0 0 1 2 lb
--689.204 -237.261 -641.707 -90.9706 -567.302 43.6423 0 0 1 2 lb
-grestore
-%Nodes:
-gsave
--567.302 43.6423 20 0 0 0 nc
--689.204 -237.261 20 0 0 0 nc
-924.667 409.347 20 0 0 1 nc
-588.113 544.499 20 0 0 1 nc
-670.264 274.195 20 0 0 1 nc
--371.2 568.349 20 1 1 0 nc
--132.697 451.748 20 1 1 0 nc
--416.25 345.746 20 1 1 0 nc
--180.397 245.045 20 1 1 0 nc
--13.4452 133.743 20 1 1 0 nc
--262.548 107.243 20 1 1 0 nc
-201.208 38.3422 20 1 1 0 nc
-116.407 -173.66 20 1 1 0 nc
--26.6953 -19.9585 20 1 1 0 nc
--539.894 -262.64 20 0 0.5 0 nc
--323.543 -433.964 20 0 0.5 0 nc
--309.657 -57.9033 20 0 0.5 0 nc
--67.9734 -347.42 20 0 0.5 0 nc
-415.393 -289.516 20 0.5 0 0 nc
-730.084 -307.139 20 0.5 0 0 nc
-526.164 32.7279 20 0.5 0 0 nc
-762.812 -17.6227 20 0.5 0 0 nc
--67.9734 319.727 20 0.5 0 0 nc
-329.797 314.692 20 0.5 0 0 nc
--5.03507 561.41 20 0.5 0 0 nc
-422.945 521.129 20 0.5 0 0 nc
--470.779 158.605 20 0 1 1 nc
-986.873 -115.807 20 0.5 0 0 nc
-906.312 201.403 20 0.5 0 0 nc
--767.847 113.289 20 0 1 1 nc
--579.033 445.603 20 0 1 1 nc
--840.856 -246.718 20 1 0 1 nc
-206.221 -205.967 20 0 0 0.5 nc
-277.311 -252.33 20 0 0 0.5 nc
-271.13 -175.058 20 0 0 0.5 nc
-366.947 -110.15 20 0 0 0.5 nc
-397.855 -196.694 20 0 0 0.5 nc
-438.037 -88.514 20 0 0 0.5 nc
-286.584 -48.3327 20 0 0 0.5 nc
-212.403 -23.6057 20 0 0 0.5 nc
-280.402 10.3938 20 0 0 0.5 nc
-694.579 115.483 20 1 0 0 nc
-574.035 177.301 20 0 1 0 nc
-grestore
-grestore
-showpage
Index: c/images/grid_graph.eps
===================================================================
--- doc/images/grid_graph.eps	(revision 347)
+++ 	(revision )
@@ -1,286 +1,0 @@
-%!PS-Adobe-2.0 EPSF-2.0
-%%Title: Grid undirected graph
-%%Copyright: (C) 2006 LEMON Project
-%%Creator: LEMON, graphToEps()
-%%CreationDate: Fri Sep 29 11:55:56 2006
-%%BoundingBox: 0 0 985 1144
-%%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
-/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
-2 2 scale
-50 40 translate
-5.5000 5.5000 scale
-% 1.14018 1.14018 translate
-%Edges:
-gsave
-70 80 70 90 0 0 0 0.5000 l
-70 70 70 80 0 0 0 0.5000 l
-70 60 70 70 0 0 0 0.5000 l
-70 50 70 60 0 0 0 0.5000 l
-70 40 70 50 0 0 0 0.5000 l
-70 30 70 40 0 0 0 0.5000 l
-70 20 70 30 0 0 0 0.5000 l
-70 10 70 20 0 0 0 0.5000 l
-70 0 70 10 0 0 0 0.5000 l
-60 80 60 90 0 0 0 0.5000 l
-60 70 60 80 0 0 0 0.5000 l
-60 60 60 70 0 0 0 0.5000 l
-60 50 60 60 0 0 0 0.5000 l
-60 40 60 50 0 0 0 0.5000 l
-60 30 60 40 0 0 0 0.5000 l
-60 20 60 30 0 0 0 0.5000 l
-60 10 60 20 0 0 0 0.5000 l
-60 0 60 10 0 0 0 0.5000 l
-50 80 50 90 0 0 0 0.5000 l
-50 70 50 80 0 0 0 0.5000 l
-50 60 50 70 0 0 0 0.5000 l
-50 50 50 60 0 0 0 0.5000 l
-50 40 50 50 0 0 0 0.5000 l
-50 30 50 40 0 0 0 0.5000 l
-50 20 50 30 0 0 0 0.5000 l
-50 10 50 20 0 0 0 0.5000 l
-50 0 50 10 0 0 0 0.5000 l
-40 80 40 90 0 0 0 0.5000 l
-40 70 40 80 0 0 0 0.5000 l
-40 60 40 70 0 0 0 0.5000 l
-40 50 40 60 0 0 0 0.5000 l
-40 40 40 50 0 0 0 0.5000 l
-40 30 40 40 0 0 0 0.5000 l
-40 20 40 30 0 0 0 0.5000 l
-40 10 40 20 0 0 0 0.5000 l
-40 0 40 10 0 0 0 0.5000 l
-30 80 30 90 0 0 0 0.5000 l
-30 70 30 80 0 0 0 0.5000 l
-30 60 30 70 0 0 0 0.5000 l
-30 50 30 60 0 0 0 0.5000 l
-30 40 30 50 0 0 0 0.5000 l
-30 30 30 40 0 0 0 0.5000 l
-30 20 30 30 0 0 0 0.5000 l
-30 10 30 20 0 0 0 0.5000 l
-30 0 30 10 0 0 0 0.5000 l
-20 80 20 90 0 0 0 0.5000 l
-20 70 20 80 0 0 0 0.5000 l
-20 60 20 70 0 0 0 0.5000 l
-20 50 20 60 0 0 0 0.5000 l
-20 40 20 50 0 0 0 0.5000 l
-20 30 20 40 0 0 0 0.5000 l
-20 20 20 30 0 0 0 0.5000 l
-20 10 20 20 0 0 0 0.5000 l
-20 0 20 10 0 0 0 0.5000 l
-10 80 10 90 0 0 0 0.5000 l
-10 70 10 80 0 0 0 0.5000 l
-10 60 10 70 0 0 0 0.5000 l
-10 50 10 60 0 0 0 0.5000 l
-10 40 10 50 0 0 0 0.5000 l
-10 30 10 40 0 0 0 0.5000 l
-10 20 10 30 0 0 0 0.5000 l
-10 10 10 20 0 0 0 0.5000 l
-10 0 10 10 0 0 0 0.5000 l
-0 80 0 90 0 0 0 0.5000 l
-0 70 0 80 0 0 0 0.5000 l
-0 60 0 70 0 0 0 0.5000 l
-0 50 0 60 0 0 0 0.5000 l
-0 40 0 50 0 0 0 0.5000 l
-0 30 0 40 0 0 0 0.5000 l
-0 20 0 30 0 0 0 0.5000 l
-0 10 0 20 0 0 0 0.5000 l
-0 0 0 10 0 0 0 0.5000 l
-60 90 70 90 0 0 0 0.5000 l
-60 80 70 80 0 0 0 0.5000 l
-60 70 70 70 0 0 0 0.5000 l
-60 60 70 60 0 0 0 0.5000 l
-60 50 70 50 0 0 0 0.5000 l
-60 40 70 40 0 0 0 0.5000 l
-60 30 70 30 0 0 0 0.5000 l
-60 20 70 20 0 0 0 0.5000 l
-60 10 70 10 0 0 0 0.5000 l
-60 0 70 0 0 0 0 0.5000 l
-50 90 60 90 0 0 0 0.5000 l
-50 80 60 80 0 0 0 0.5000 l
-50 70 60 70 0 0 0 0.5000 l
-50 60 60 60 0 0 0 0.5000 l
-50 50 60 50 0 0 0 0.5000 l
-50 40 60 40 0 0 0 0.5000 l
-50 30 60 30 0 0 0 0.5000 l
-50 20 60 20 0 0 0 0.5000 l
-50 10 60 10 0 0 0 0.5000 l
-50 0 60 0 0 0 0 0.5000 l
-40 90 50 90 0 0 0 0.5000 l
-40 80 50 80 0 0 0 0.5000 l
-40 70 50 70 0 0 0 0.5000 l
-40 60 50 60 0 0 0 0.5000 l
-40 50 50 50 0 0 0 0.5000 l
-40 40 50 40 0 0 0 0.5000 l
-40 30 50 30 0 0 0 0.5000 l
-40 20 50 20 0 0 0 0.5000 l
-40 10 50 10 0 0 0 0.5000 l
-40 0 50 0 0 0 0 0.5000 l
-30 90 40 90 0 0 0 0.5000 l
-30 80 40 80 0 0 0 0.5000 l
-30 70 40 70 0 0 0 0.5000 l
-30 60 40 60 0 0 0 0.5000 l
-30 50 40 50 0 0 0 0.5000 l
-30 40 40 40 0 0 0 0.5000 l
-30 30 40 30 0 0 0 0.5000 l
-30 20 40 20 0 0 0 0.5000 l
-30 10 40 10 0 0 0 0.5000 l
-30 0 40 0 0 0 0 0.5000 l
-20 90 30 90 0 0 0 0.5000 l
-20 80 30 80 0 0 0 0.5000 l
-20 70 30 70 0 0 0 0.5000 l
-20 60 30 60 0 0 0 0.5000 l
-20 50 30 50 0 0 0 0.5000 l
-20 40 30 40 0 0 0 0.5000 l
-20 30 30 30 0 0 0 0.5000 l
-20 20 30 20 0 0 0 0.5000 l
-20 10 30 10 0 0 0 0.5000 l
-20 0 30 0 0 0 0 0.5000 l
-10 90 20 90 0 0 0 0.5000 l
-10 80 20 80 0 0 0 0.5000 l
-10 70 20 70 0 0 0 0.5000 l
-10 60 20 60 0 0 0 0.5000 l
-10 50 20 50 0 0 0 0.5000 l
-10 40 20 40 0 0 0 0.5000 l
-10 30 20 30 0 0 0 0.5000 l
-10 20 20 20 0 0 0 0.5000 l
-10 10 20 10 0 0 0 0.5000 l
-10 0 20 0 0 0 0 0.5000 l
-0 90 10 90 0 0 0 0.5000 l
-0 80 10 80 0 0 0 0.5000 l
-0 70 10 70 0 0 0 0.5000 l
-0 60 10 60 0 0 0 0.5000 l
-0 50 10 50 0 0 0 0.5000 l
-0 40 10 40 0 0 0 0.5000 l
-0 30 10 30 0 0 0 0.5000 l
-0 20 10 20 0 0 0 0.5000 l
-0 10 10 10 0 0 0 0.5000 l
-0 0 10 0 0 0 0 0.5000 l
-grestore
-%Nodes:
-gsave
-70 90 1.4000 0 0 0 nc
-70 80 1.4000 1 1 1 nc
-70 70 1.4000 1 1 1 nc
-70 60 1.4000 1 1 1 nc
-70 50 1.4000 1 1 1 nc
-70 40 1.4000 1 1 1 nc
-70 30 1.4000 1 1 1 nc
-70 20 1.4000 1 1 1 nc
-70 10 1.4000 1 1 1 nc
-70 0 1.4000 0 0 0 nc
-60 90 1.4000 1 1 1 nc
-60 80 1.4000 1 1 1 nc
-60 70 1.4000 1 1 1 nc
-60 60 1.4000 1 1 1 nc
-60 50 1.4000 1 1 1 nc
-60 40 1.4000 1 1 1 nc
-60 30 1.4000 1 1 1 nc
-60 20 1.4000 1 1 1 nc
-60 10 1.4000 1 1 1 nc
-60 0 1.4000 1 1 1 nc
-50 90 1.4000 1 1 1 nc
-50 80 1.4000 1 1 1 nc
-50 70 1.4000 1 1 1 nc
-50 60 1.4000 1 1 1 nc
-50 50 1.4000 1 1 1 nc
-50 40 1.4000 1 1 1 nc
-50 30 1.4000 1 1 1 nc
-50 20 1.4000 1 1 1 nc
-50 10 1.4000 1 1 1 nc
-50 0 1.4000 1 1 1 nc
-40 90 1.4000 1 1 1 nc
-40 80 1.4000 1 1 1 nc
-40 70 1.4000 1 1 1 nc
-40 60 1.4000 1 1 1 nc
-40 50 1.4000 1 1 1 nc
-40 40 1.4000 1 1 1 nc
-40 30 1.4000 1 1 1 nc
-40 20 1.4000 1 1 1 nc
-40 10 1.4000 1 1 1 nc
-40 0 1.4000 1 1 1 nc
-30 90 1.4000 1 1 1 nc
-30 80 1.4000 1 1 1 nc
-30 70 1.4000 1 1 1 nc
-30 60 1.4000 1 1 1 nc
-30 50 1.4000 1 1 1 nc
-30 40 1.4000 1 1 1 nc
-30 30 1.4000 1 1 1 nc
-30 20 1.4000 1 1 1 nc
-30 10 1.4000 1 1 1 nc
-30 0 1.4000 1 1 1 nc
-20 90 1.4000 1 1 1 nc
-20 80 1.4000 1 1 1 nc
-20 70 1.4000 1 1 1 nc
-20 60 1.4000 1 1 1 nc
-20 50 1.4000 1 1 1 nc
-20 40 1.4000 1 1 1 nc
-20 30 1.4000 1 1 1 nc
-20 20 1.4000 1 1 1 nc
-20 10 1.4000 1 1 1 nc
-20 0 1.4000 1 1 1 nc
-10 90 1.4000 1 1 1 nc
-10 80 1.4000 1 1 1 nc
-10 70 1.4000 1 1 1 nc
-10 60 1.4000 1 1 1 nc
-10 50 1.4000 1 1 1 nc
-10 40 1.4000 1 1 1 nc
-10 30 1.4000 1 1 1 nc
-10 20 1.4000 1 1 1 nc
-10 10 1.4000 1 1 1 nc
-10 0 1.4000 1 1 1 nc
-0 90 1.4000 0 0 0 nc
-0 80 1.4000 1 1 1 nc
-0 70 1.4000 1 1 1 nc
-0 60 1.4000 1 1 1 nc
-0 50 1.4000 1 1 1 nc
-0 40 1.4000 1 1 1 nc
-0 30 1.4000 1 1 1 nc
-0 20 1.4000 1 1 1 nc
-0 10 1.4000 1 1 1 nc
-0 0 1.4000 0 0 0 nc
-grestore
-gsave
-/fosi 3.5 def
-(Helvetica) findfont fosi scalefont setfont
-0 0 0 setrgbcolor
-0 95 ((0,height-1)) cshow
-67 95 ((width-1,height-1)) cshow
-0 -5 ((0,0)) cshow
-70 -5 ((width-1,0)) cshow
-grestore
-grestore
-showpage
Index: c/images/matching.eps
===================================================================
--- doc/images/matching.eps	(revision 943)
+++ 	(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/node_biconnected_components.eps
===================================================================
--- doc/images/node_biconnected_components.eps	(revision 634)
+++ 	(revision )
@@ -1,159 +1,0 @@
-%!PS-Adobe-2.0 EPSF-2.0
-%%Creator: LEMON, graphToEps()
-%%CreationDate: Fri Nov  4 13:47:12 2005
-%%BoundingBox: 0 0 842 596
-%%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
-/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
-90 rotate
-0 -842 translate
-71.0944 15 translate
-0.434694 dup scale
-90 rotate
-860.856 -588.349 translate
-%Edges:
-gsave
-574.035 177.301 622.149 225.748 670.264 274.195 0 1 0 5 lb
-694.579 115.483 682.421 194.839 670.264 274.195 1 0 0 5 lb
-280.402 10.3938 246.402 -6.60595 212.403 -23.6057 1 1 0.5 5 lb
-280.402 10.3938 283.493 -18.9695 286.584 -48.3327 1 1 0.5 5 lb
-212.403 -23.6057 249.493 -35.9692 286.584 -48.3327 1 1 0.5 5 lb
-286.584 -48.3327 326.765 -79.2414 366.947 -110.15 1 0.5 1 5 lb
-286.584 -48.3327 278.857 -111.695 271.13 -175.058 1 0.5 1 5 lb
-438.037 -88.514 417.946 -142.604 397.855 -196.694 0.5 0.5 1 5 lb
-438.037 -88.514 402.492 -99.332 366.947 -110.15 0.5 0.5 1 5 lb
-397.855 -196.694 382.401 -153.422 366.947 -110.15 0.5 0.5 1 5 lb
-366.947 -110.15 319.038 -142.604 271.13 -175.058 1 0.5 1 5 lb
-271.13 -175.058 274.221 -213.694 277.311 -252.33 0.5 1 1 5 lb
-271.13 -175.058 238.675 -190.512 206.221 -205.967 0.5 1 1 5 lb
-277.311 -252.33 241.766 -229.149 206.221 -205.967 0.5 1 1 5 lb
--840.856 -246.718 -804.351 -66.7145 -767.847 113.289 0 0.5 0 5 lb
--579.033 445.603 -673.44 279.446 -767.847 113.289 0 0 0.5 5 lb
--579.033 445.603 -524.906 302.104 -470.779 158.605 0 0 0.5 5 lb
--767.847 113.289 -619.313 135.947 -470.779 158.605 0 0 0.5 5 lb
-906.312 201.403 946.592 42.798 986.873 -115.807 0 0.5 0.5 5 lb
-906.312 201.403 834.562 91.8901 762.812 -17.6227 0 0.5 0.5 5 lb
-986.873 -115.807 874.842 -66.7148 762.812 -17.6227 0 0.5 0.5 5 lb
--470.779 158.605 -390.218 50.3508 -309.657 -57.9033 0.5 0.5 0 5 lb
-422.945 521.129 208.955 541.269 -5.03507 561.41 0.5 0 0.5 5 lb
-422.945 521.129 376.371 417.911 329.797 314.692 0.5 0 0.5 5 lb
-422.945 521.129 474.554 276.928 526.164 32.7279 0.5 0 0.5 5 lb
--5.03507 561.41 -36.5042 440.568 -67.9734 319.727 0.5 0 0.5 5 lb
-329.797 314.692 130.912 317.209 -67.9734 319.727 0.5 0 0.5 5 lb
--67.9734 319.727 229.095 176.227 526.164 32.7279 0.5 0 0.5 5 lb
-762.812 -17.6227 644.488 7.5526 526.164 32.7279 0.5 0.5 0.5 5 lb
-762.812 -17.6227 746.448 -162.381 730.084 -307.139 0.5 0.5 0.5 5 lb
-526.164 32.7279 470.779 -128.394 415.393 -289.516 0.5 0.5 0.5 5 lb
-730.084 -307.139 572.738 -298.327 415.393 -289.516 0.5 0.5 0.5 5 lb
-415.393 -289.516 173.71 -318.468 -67.9734 -347.42 1 0.5 0.5 5 lb
--67.9734 -347.42 -188.815 -202.662 -309.657 -57.9033 0.5 1 0.5 5 lb
--67.9734 -347.42 -195.758 -390.692 -323.543 -433.964 0.5 1 0.5 5 lb
--309.657 -57.9033 -424.775 -160.272 -539.894 -262.64 0.5 1 0.5 5 lb
--323.543 -433.964 -431.719 -348.302 -539.894 -262.64 0.5 1 0.5 5 lb
--26.6953 -19.9585 44.8558 -96.8093 116.407 -173.66 1 1 0 5 lb
--26.6953 -19.9585 87.2563 9.19185 201.208 38.3422 1 1 0 5 lb
--26.6953 -19.9585 -144.622 43.6422 -262.548 107.243 1 0 1 5 lb
--26.6953 -19.9585 -20.0703 56.8923 -13.4452 133.743 1 0 1 5 lb
-116.407 -173.66 158.808 -67.6589 201.208 38.3422 1 1 0 5 lb
--262.548 107.243 -137.997 120.493 -13.4452 133.743 1 0 1 5 lb
--262.548 107.243 -221.472 176.144 -180.397 245.045 1 0 1 5 lb
--13.4452 133.743 -96.9211 189.394 -180.397 245.045 1 0 1 5 lb
--180.397 245.045 -140.307 344.649 -132.697 451.748 0 1 1 5 lb
--180.397 245.045 -172.787 352.144 -132.697 451.748 0 1 1 5 lb
--416.25 345.746 -274.474 398.747 -132.697 451.748 0.5 0 0 5 lb
--416.25 345.746 -393.725 457.048 -371.2 568.349 0.5 0 0 5 lb
--132.697 451.748 -251.948 510.048 -371.2 568.349 0.5 0 0 5 lb
-670.264 274.195 629.188 409.347 588.113 544.499 0 0 1 5 lb
-670.264 274.195 797.466 341.771 924.667 409.347 0 0 1 5 lb
-588.113 544.499 756.39 476.923 924.667 409.347 0 0 1 5 lb
--689.204 -237.261 -612.964 -103.444 -567.302 43.6423 0 0 0 5 lb
--689.204 -237.261 -643.542 -90.1744 -567.302 43.6423 0 0 0 5 lb
-grestore
-%Nodes:
-gsave
--567.302 43.6423 20 0 0 1 nc
--689.204 -237.261 20 0 0 1 nc
-924.667 409.347 20 0 0 1 nc
-588.113 544.499 20 0 0 1 nc
-670.264 274.195 20 1 0 0 nc
--371.2 568.349 20 0 0 1 nc
--132.697 451.748 20 1 0 0 nc
--416.25 345.746 20 0 0 1 nc
--180.397 245.045 20 1 0 0 nc
--13.4452 133.743 20 0 0 1 nc
--262.548 107.243 20 0 0 1 nc
-201.208 38.3422 20 0 0 1 nc
-116.407 -173.66 20 0 0 1 nc
--26.6953 -19.9585 20 1 0 0 nc
--539.894 -262.64 20 0 0 1 nc
--323.543 -433.964 20 0 0 1 nc
--309.657 -57.9033 20 1 0 0 nc
--67.9734 -347.42 20 1 0 0 nc
-415.393 -289.516 20 1 0 0 nc
-730.084 -307.139 20 0 0 1 nc
-526.164 32.7279 20 1 0 0 nc
-762.812 -17.6227 20 1 0 0 nc
--67.9734 319.727 20 0 0 1 nc
-329.797 314.692 20 0 0 1 nc
--5.03507 561.41 20 0 0 1 nc
-422.945 521.129 20 0 0 1 nc
--470.779 158.605 20 1 0 0 nc
-986.873 -115.807 20 0 0 1 nc
-906.312 201.403 20 0 0 1 nc
--767.847 113.289 20 1 0 0 nc
--579.033 445.603 20 0 0 1 nc
--840.856 -246.718 20 0 0 1 nc
-206.221 -205.967 20 0 0 1 nc
-277.311 -252.33 20 0 0 1 nc
-271.13 -175.058 20 1 0 0 nc
-366.947 -110.15 20 1 0 0 nc
-397.855 -196.694 20 0 0 1 nc
-438.037 -88.514 20 0 0 1 nc
-286.584 -48.3327 20 1 0 0 nc
-212.403 -23.6057 20 0 0 1 nc
-280.402 10.3938 20 0 0 1 nc
-694.579 115.483 20 0 0 1 nc
-574.035 177.301 20 0 0 1 nc
-grestore
-grestore
-showpage
Index: c/images/planar.eps
===================================================================
--- doc/images/planar.eps	(revision 895)
+++ 	(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: c/images/strongly_connected_components.eps
===================================================================
--- doc/images/strongly_connected_components.eps	(revision 634)
+++ 	(revision )
@@ -1,180 +1,0 @@
-%!PS-Adobe-2.0 EPSF-2.0
-%%Creator: LEMON, graphToEps()
-%%CreationDate: Fri Nov  4 13:47:12 2005
-%%BoundingBox: 0 0 842 596
-%%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
-/arrl 10 def
-/arrw 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
-90 rotate
-0 -842 translate
-77.1122 15 translate
-0.585745 dup scale
-90 rotate
-695.963 -397.916 translate
-%Edges:
-gsave
-2 setlinewidth 0 0 1 setrgbcolor newpath
-218.178 27.2723 moveto
-192.373 -40.1551 188.622 -49.9556 169.228 -100.631 curveto stroke
-newpath 164.939 -111.838 moveto 165.492 -99.2013 lineto 172.964 -102.061 lineto closepath fill
-2 setlinewidth 0 0 1 setrgbcolor newpath
-44.8044 15.5841 moveto
-119.293 20.6059 129.775 21.3125 186.25 25.1199 curveto stroke
-newpath 198.223 25.927 moveto 186.519 21.1289 lineto 185.981 29.1108 lineto closepath fill
-2 setlinewidth 1 0 0 setrgbcolor newpath
-218.178 27.2723 moveto
-285.395 -87.4449 290.763 -96.6058 348.102 -194.464 curveto stroke
-newpath 354.169 -204.818 moveto 344.651 -196.487 lineto 351.554 -192.442 lineto closepath fill
-2 setlinewidth 0 0 1 setrgbcolor newpath
-157.79 -130.517 moveto
-108.71 -67.0521 102.27 -58.7243 64.3804 -9.72954 curveto stroke
-newpath 57.0394 -0.236898 moveto 67.5446 -7.28254 lineto 61.2162 -12.1765 lineto closepath fill
-2 setlinewidth 1 0 0 setrgbcolor newpath
--105.193 -261.035 moveto
--35.6576 -132.801 -30.5923 -123.459 29.5506 -12.5464 curveto stroke
-newpath 35.2708 -1.99743 moveto 33.0669 -14.4531 lineto 26.0343 -10.6397 lineto closepath fill
-2 setlinewidth 0 0 1 setrgbcolor newpath
--465.576 -42.8564 moveto
--559.078 -25.5413 -569.47 -23.6169 -644.498 -9.72286 curveto stroke
-newpath -656.297 -7.5378 moveto -643.77 -5.78973 lineto -645.226 -13.656 lineto closepath fill
-2 setlinewidth 0 0 1 setrgbcolor newpath
--574.666 -153.893 moveto
--528.842 -107.252 -521.515 -99.794 -488.002 -65.683 curveto stroke
-newpath -479.592 -57.123 moveto -485.149 -68.4863 lineto -490.856 -62.8797 lineto closepath fill
-2 setlinewidth 1 0 0 setrgbcolor newpath
--490.901 120.777 moveto
--480.122 51.1328 -478.519 40.7713 -470.47 -11.2329 curveto stroke
-newpath -468.635 -23.0917 moveto -474.423 -11.8447 lineto -466.517 -10.6212 lineto closepath fill
-2 setlinewidth 0 0 1 setrgbcolor newpath
--675.963 -3.89604 moveto
--632.116 -68.8235 -626.228 -77.5422 -592.575 -127.374 curveto stroke
-newpath -585.859 -137.319 moveto -595.89 -129.612 lineto -589.26 -125.135 lineto closepath fill
-2 setlinewidth 0 0 1 setrgbcolor newpath
--490.901 120.777 moveto
--435.445 215.844 -430.107 224.995 -384.3 303.522 curveto stroke
-newpath -378.253 313.887 moveto -380.845 301.507 lineto -387.755 305.537 lineto closepath fill
-2 setlinewidth 0 0 1 setrgbcolor newpath
--266.879 114.933 moveto
--367.067 117.547 -377.642 117.822 -458.912 119.943 curveto stroke
-newpath -470.908 120.255 moveto -458.807 123.941 lineto -459.016 115.944 lineto closepath fill
-2 setlinewidth 0 0 1 setrgbcolor newpath
--368.176 331.163 moveto
--322.511 233.685 -318.018 224.095 -280.454 143.911 curveto stroke
-newpath -275.364 133.044 moveto -284.076 142.214 lineto -276.832 145.608 lineto closepath fill
-2 setlinewidth 1 0 0 setrgbcolor newpath
--266.879 114.933 moveto
--224.004 235.52 -220.448 245.52 -184.094 347.765 curveto stroke
-newpath -180.074 359.072 moveto -180.325 346.425 lineto -187.863 349.105 lineto closepath fill
-2 setlinewidth 0 0 1 setrgbcolor newpath
--251.294 -335.059 moveto
--189.25 -303.624 -179.902 -298.887 -133.738 -275.498 curveto stroke
-newpath -123.034 -270.074 moveto -131.93 -279.066 lineto -135.546 -271.93 lineto closepath fill
-2 setlinewidth 0 0 1 setrgbcolor newpath
--389.604 -136.361 moveto
--327.15 -226.083 -321.098 -234.777 -269.576 -308.795 curveto stroke
-newpath -262.72 -318.644 moveto -272.859 -311.081 lineto -266.293 -306.51 lineto closepath fill
-2 setlinewidth 1 0 0 setrgbcolor newpath
-5.84406 175.322 moveto
--76.0754 267.926 -83.1051 275.873 -152.172 353.948 curveto stroke
-newpath -160.122 362.936 moveto -149.176 356.598 lineto -155.168 351.298 lineto closepath fill
-2 setlinewidth 0 0 1 setrgbcolor newpath
-169.478 311.683 moveto
-96.8003 251.119 88.6819 244.353 30.4273 195.808 curveto stroke
-newpath 21.2086 188.126 moveto 27.8666 198.881 lineto 32.988 192.735 lineto closepath fill
-2 setlinewidth 0 0 1 setrgbcolor newpath
-342.851 111.037 moveto
-263.766 202.563 256.831 210.589 190.4 287.47 curveto stroke
-newpath 182.554 296.55 moveto 193.427 290.085 lineto 187.373 284.855 lineto closepath fill
-2 setlinewidth 0 0 1 setrgbcolor newpath
-5.84406 175.322 moveto
-163.16 145.314 173.605 143.321 311.418 117.033 curveto stroke
-newpath 323.205 114.784 moveto 310.668 113.104 lineto 312.167 120.962 lineto closepath fill
-2 setlinewidth 0 0 1 setrgbcolor newpath
-342.851 111.037 moveto
-497.255 2.58683 505.964 -3.53033 643.932 -100.436 curveto stroke
-newpath 653.752 -107.334 moveto 641.633 -103.71 lineto 646.231 -97.163 lineto closepath fill
-2 setlinewidth 0 0 1 setrgbcolor newpath
-364.28 -222.074 moveto
-354.298 -66.9063 353.616 -56.2971 344.905 79.1029 curveto stroke
-newpath 344.135 91.0781 moveto 348.897 79.3597 lineto 340.914 78.8461 lineto closepath fill
-2 setlinewidth 0 0 1 setrgbcolor newpath
-670.118 -118.829 moveto
-528.037 -166.793 517.967 -170.192 394.599 -211.839 curveto stroke
-newpath 383.229 -215.677 moveto 393.32 -208.049 lineto 395.878 -215.629 lineto closepath fill
-2 setlinewidth 1 0 0 setrgbcolor newpath
--105.193 -261.035 moveto
-118.401 -242.479 129.015 -241.598 332.39 -224.721 curveto stroke
-newpath 344.348 -223.728 moveto 332.72 -228.707 lineto 332.059 -220.734 lineto closepath fill
-2 setlinewidth 0 0 1 setrgbcolor newpath
--105.193 -261.035 moveto
--160.867 -161.176 -166.028 -151.918 -212.336 -68.858 curveto stroke
-newpath -218.179 -58.3769 moveto -208.842 -66.9102 lineto -215.829 -70.8058 lineto closepath fill
-2 setlinewidth 0 0 1 setrgbcolor newpath
--227.918 -40.9084 moveto
--298.35 -82.4884 -307.42 -87.8432 -362.048 -120.093 curveto stroke
-newpath -372.381 -126.193 moveto -364.081 -116.648 lineto -360.014 -123.537 lineto closepath fill
-grestore
-%Nodes:
-gsave
--389.604 -136.361 20 0 1 0 nc
--227.918 -40.9084 20 0 1 0 nc
--105.193 -261.035 20 0 1 0 nc
-364.28 -222.074 20 1 1 0 nc
-670.118 -118.829 20 1 1 0 nc
-342.851 111.037 20 1 1 0 nc
-5.84406 175.322 20 1 1 0 nc
-169.478 311.683 20 1 1 0 nc
--173.374 377.916 20 1 0 1 nc
--251.294 -335.059 20 0 1 0 nc
--266.879 114.933 20 0 0 0 nc
--368.176 331.163 20 0 0 0 nc
--490.901 120.777 20 0 0 0 nc
--574.666 -153.893 20 1 0 0 nc
--675.963 -3.89604 20 1 0 0 nc
--465.576 -42.8564 20 1 0 0 nc
-44.8044 15.5841 20 0 0 1 nc
-157.79 -130.517 20 0 0 1 nc
-218.178 27.2723 20 0 0 1 nc
-grestore
-grestore
-showpage
Index: doc/lgf.dox
===================================================================
--- doc/lgf.dox	(revision 463)
+++ doc/lgf.dox	(revision 313)
@@ -3,5 +3,5 @@
  * This file is a part of LEMON, a generic C++ optimization library.
  *
- * Copyright (C) 2003-2009
+ * Copyright (C) 2003-2008
  * Egervary Jeno Kombinatorikus Optimalizalasi Kutatocsoport
  * (Egervary Research Group on Combinatorial Optimization, EGRES).
Index: doc/license.dox
===================================================================
--- doc/license.dox	(revision 463)
+++ doc/license.dox	(revision 209)
@@ -3,5 +3,5 @@
  * This file is a part of LEMON, a generic C++ optimization library.
  *
- * Copyright (C) 2003-2009
+ * Copyright (C) 2003-2008
  * Egervary Jeno Kombinatorikus Optimalizalasi Kutatocsoport
  * (Egervary Research Group on Combinatorial Optimization, EGRES).
Index: doc/mainpage.dox
===================================================================
--- doc/mainpage.dox	(revision 956)
+++ doc/mainpage.dox	(revision 314)
@@ -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).
@@ -22,9 +22,13 @@
 \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 of <b>E</b>fficient <b>M</b>odels
+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,24 +40,20 @@
 </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.
+\subsection howtoread How to read the documentation
 
-\section howtoread How to Read the Documentation
+If you want to get a quick start and see the most important features then
+take a look at our \ref quicktour
+"Quick Tour to LEMON" which will guide you along.
 
-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 already feel like using our library, see the page that tells you
+\ref getstart "How to start using LEMON".
 
-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
+want to see how LEMON works, see
+some \ref demoprograms "demo programs".
 
-If you know what you are looking for, then try to find it under the
-<a class="el" href="modules.html">Modules</a> section.
+If you know what you are looking for then try to find it under the
+<a class="el" href="modules.html">Modules</a>
+section.
 
 If you are a user of the old (0.x) series of LEMON, please check out the
Index: doc/migration.dox
===================================================================
--- doc/migration.dox	(revision 463)
+++ doc/migration.dox	(revision 314)
@@ -3,5 +3,5 @@
  * This file is a part of LEMON, a generic C++ optimization library.
  *
- * Copyright (C) 2003-2009
+ * Copyright (C) 2003-2008
  * Egervary Jeno Kombinatorikus Optimalizalasi Kutatocsoport
  * (Egervary Research Group on Combinatorial Optimization, EGRES).
@@ -26,5 +26,5 @@
 
 Many of these changes adjusted automatically by the
-<tt>lemon-0.x-to-1.x.sh</tt> tool. Those requiring manual
+<tt>script/lemon-0.x-to-1.x.sh</tt> tool. Those requiring manual
 update are typeset <b>boldface</b>.
 
@@ -54,9 +54,7 @@
 
 \warning
-<b>The <tt>lemon-0.x-to-1.x.sh</tt> script replaces the words \c graph,
-\c ugraph, \c edge and \c uedge in your own identifiers and in
-strings, comments etc. as well as in all LEMON specific identifiers.
-So use the script carefully and make a backup copy of your source files
-before applying the script to them.</b>
+<b>The <tt>script/lemon-0.x-to-1.x.sh</tt> tool replaces all instances of
+the words \c graph, \c digraph, \c edge and \c arc, so it replaces them
+in strings, comments etc. as well as in all identifiers.</b>
 
 \section migration-lgf LGF tools
Index: c/min_cost_flow.dox
===================================================================
--- doc/min_cost_flow.dox	(revision 956)
+++ 	(revision )
@@ -1,153 +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.
- *
- */
-
-namespace lemon {
-
-/**
-\page min_cost_flow Minimum Cost Flow Problem
-
-\section mcf_def Definition (GEQ form)
-
-The \e minimum \e cost \e flow \e problem is to find a feasible flow of
-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.
-
-Formally, let \f$G=(V,A)\f$ be a digraph, \f$lower: A\rightarrow\mathbf{R}\f$,
-\f$upper: A\rightarrow\mathbf{R}\cup\{+\infty\}\f$ denote the lower and
-upper bounds for the flow values on the arcs, for which
-\f$lower(uv) \leq upper(uv)\f$ must hold for all \f$uv\in A\f$,
-\f$cost: A\rightarrow\mathbf{R}\f$ denotes the cost per unit flow
-on the arcs and \f$sup: V\rightarrow\mathbf{R}\f$ denotes the
-signed supply values of the nodes.
-If \f$sup(u)>0\f$, then \f$u\f$ is a supply node with \f$sup(u)\f$
-supply, if \f$sup(u)<0\f$, then \f$u\f$ is a demand node with
-\f$-sup(u)\f$ demand.
-A minimum cost flow is an \f$f: A\rightarrow\mathbf{R}\f$ solution
-of the following optimization problem.
-
-\f[ \min\sum_{uv\in A} f(uv) \cdot cost(uv) \f]
-\f[ \sum_{uv\in A} f(uv) - \sum_{vu\in A} f(vu) \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
-of the expressions on the left-hand side of the inequalities is zero).
-It means that the total demand must be greater or equal to the total
-supply and all the supplies have to be carried out from the supply nodes,
-but there could be demands that are not satisfied.
-If \f$\sum_{u\in V} sup(u)\f$ is zero, then all the supply/demand
-constraints have to be satisfied with equality, i.e. all demands
-have to be satisfied and all supplies have to be used.
-
-
-\section mcf_algs Algorithms
-
-LEMON contains several algorithms for solving this problem, for more
-information see \ref min_cost_flow_algs "Minimum Cost Flow Algorithms".
-
-A feasible solution for this problem can be found using \ref Circulation.
-
-
-\section mcf_dual Dual Solution
-
-The dual solution of the minimum cost flow problem is represented by
-node potentials \f$\pi: V\rightarrow\mathbf{R}\f$.
-An \f$f: A\rightarrow\mathbf{R}\f$ primal feasible solution is optimal
-if and only if for some \f$\pi: V\rightarrow\mathbf{R}\f$ node potentials
-the following \e complementary \e slackness optimality conditions hold.
-
- - For all \f$uv\in A\f$ arcs:
-   - if \f$cost^\pi(uv)>0\f$, then \f$f(uv)=lower(uv)\f$;
-   - if \f$lower(uv)<f(uv)<upper(uv)\f$, then \f$cost^\pi(uv)=0\f$;
-   - 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$;
-   - 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.
-\f[ cost^\pi(uv) = cost(uv) + \pi(u) - \pi(v).\f]
-
-All algorithms provide dual solution (node potentials), as well,
-if an optimal flow is found.
-
-
-\section mcf_eq Equality Form
-
-The above \ref mcf_def "definition" is actually more general than the
-usual formulation of the minimum cost flow problem, in which strict
-equalities are required in the supply/demand contraints.
-
-\f[ \min\sum_{uv\in A} f(uv) \cdot cost(uv) \f]
-\f[ \sum_{uv\in A} f(uv) - \sum_{vu\in A} f(vu) =
-    sup(u) \quad \forall u\in V \f]
-\f[ lower(uv) \leq f(uv) \leq upper(uv) \quad \forall uv\in A \f]
-
-However if the sum of the supply values is zero, then these two problems
-are equivalent.
-The \ref min_cost_flow_algs "algorithms" in LEMON support the general
-form, so if you need the equality form, you have to ensure this additional
-contraint manually.
-
-
-\section mcf_leq Opposite Inequalites (LEQ Form)
-
-Another possible definition of the minimum cost flow problem is
-when there are <em>"less or equal"</em> (LEQ) supply/demand constraints,
-instead of the <em>"greater or equal"</em> (GEQ) constraints.
-
-\f[ \min\sum_{uv\in A} f(uv) \cdot cost(uv) \f]
-\f[ \sum_{uv\in A} f(uv) - \sum_{vu\in A} f(vu) \leq
-    sup(u) \quad \forall u\in V \f]
-\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
-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
-could be supplies that are not carried out from the supply
-nodes.
-The equality form is also a special case of this form, of course.
-
-You could easily transform this case to the \ref mcf_def "GEQ form"
-of the problem by reversing the direction of the arcs and taking the
-negative of the supply values (e.g. using \ref ReverseDigraph and
-\ref NegMap adaptors).
-However \ref NetworkSimplex algorithm also supports this form directly
-for the sake of convenience.
-
-Note that the optimality conditions for this supply constraint type are
-slightly differ from the conditions that are discussed for the GEQ form,
-namely the potentials have to be non-negative instead of non-positive.
-An \f$f: A\rightarrow\mathbf{R}\f$ feasible solution of this problem
-is optimal if and only if for some \f$\pi: V\rightarrow\mathbf{R}\f$
-node potentials the following conditions hold.
-
- - For all \f$uv\in A\f$ arcs:
-   - if \f$cost^\pi(uv)>0\f$, then \f$f(uv)=lower(uv)\f$;
-   - if \f$lower(uv)<f(uv)<upper(uv)\f$, then \f$cost^\pi(uv)=0\f$;
-   - 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$;
-   - 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: doc/named-param.dox
===================================================================
--- doc/named-param.dox	(revision 463)
+++ doc/named-param.dox	(revision 269)
@@ -3,5 +3,5 @@
  * This file is a part of LEMON, a generic C++ optimization library.
  *
- * Copyright (C) 2003-2009
+ * Copyright (C) 2003-2008
  * Egervary Jeno Kombinatorikus Optimalizalasi Kutatocsoport
  * (Egervary Research Group on Combinatorial Optimization, EGRES).
Index: doc/namespaces.dox
===================================================================
--- doc/namespaces.dox	(revision 463)
+++ doc/namespaces.dox	(revision 209)
@@ -3,5 +3,5 @@
  * This file is a part of LEMON, a generic C++ optimization library.
  *
- * Copyright (C) 2003-2009
+ * Copyright (C) 2003-2008
  * Egervary Jeno Kombinatorikus Optimalizalasi Kutatocsoport
  * (Egervary Research Group on Combinatorial Optimization, EGRES).
Index: c/references.bib
===================================================================
--- doc/references.bib	(revision 802)
+++ 	(revision )
@@ -1,301 +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,
-}
Index: doc/template.h
===================================================================
--- doc/template.h	(revision 463)
+++ doc/template.h	(revision 209)
@@ -3,5 +3,5 @@
  * This file is a part of LEMON, a generic C++ optimization library.
  *
- * Copyright (C) 2003-2009
+ * Copyright (C) 2003-2008
  * Egervary Jeno Kombinatorikus Optimalizalasi Kutatocsoport
  * (Egervary Research Group on Combinatorial Optimization, EGRES).
Index: lemon/CMakeLists.txt
===================================================================
--- lemon/CMakeLists.txt	(revision 726)
+++ lemon/CMakeLists.txt	(revision 539)
@@ -1,4 +1,4 @@
 INCLUDE_DIRECTORIES(
-  ${PROJECT_SOURCE_DIR}
+  ${CMAKE_SOURCE_DIR}
   ${PROJECT_BINARY_DIR}
 )
@@ -9,49 +9,16 @@
 )
 
-SET(LEMON_SOURCES
+ADD_LIBRARY(lemon
   arg_parser.cc
   base.cc
   color.cc
-  lp_base.cc
-  lp_skeleton.cc
   random.cc
   bits/windows.cc
 )
 
-IF(LEMON_HAVE_GLPK)
-  SET(LEMON_SOURCES ${LEMON_SOURCES} glpk.cc)
-  INCLUDE_DIRECTORIES(${GLPK_INCLUDE_DIRS})
-  IF(WIN32)
-    INSTALL(FILES ${GLPK_BIN_DIR}/glpk.dll DESTINATION bin)
-    INSTALL(FILES ${GLPK_BIN_DIR}/libltdl3.dll DESTINATION bin)
-    INSTALL(FILES ${GLPK_BIN_DIR}/zlib1.dll DESTINATION bin)
-  ENDIF()
-ENDIF()
-
-IF(LEMON_HAVE_CPLEX)
-  SET(LEMON_SOURCES ${LEMON_SOURCES} cplex.cc)
-  INCLUDE_DIRECTORIES(${CPLEX_INCLUDE_DIRS})
-ENDIF()
-
-IF(LEMON_HAVE_CLP)
-  SET(LEMON_SOURCES ${LEMON_SOURCES} clp.cc)
-  INCLUDE_DIRECTORIES(${COIN_INCLUDE_DIRS})
-ENDIF()
-
-IF(LEMON_HAVE_CBC)
-  SET(LEMON_SOURCES ${LEMON_SOURCES} cbc.cc)
-  INCLUDE_DIRECTORIES(${COIN_INCLUDE_DIRS})
-ENDIF()
-
-ADD_LIBRARY(lemon ${LEMON_SOURCES})
-IF(UNIX)
-  SET_TARGET_PROPERTIES(lemon PROPERTIES OUTPUT_NAME emon)
-ENDIF()
-
 INSTALL(
   TARGETS lemon
   ARCHIVE DESTINATION lib
-  COMPONENT library
-)
+  COMPONENT library)
 
 INSTALL(
@@ -59,10 +26,8 @@
   DESTINATION include/lemon
   COMPONENT headers
-  FILES_MATCHING PATTERN "*.h"
-)
+  FILES_MATCHING PATTERN "*.h")
 
 INSTALL(
   FILES ${CMAKE_CURRENT_BINARY_DIR}/config.h
   DESTINATION include/lemon
-  COMPONENT headers
-)
+  COMPONENT headers)
Index: lemon/Makefile.am
===================================================================
--- lemon/Makefile.am	(revision 953)
+++ lemon/Makefile.am	(revision 543)
@@ -1,6 +1,5 @@
 EXTRA_DIST += \
 	lemon/lemon.pc.in \
-	lemon/CMakeLists.txt \
-	lemon/config.h.cmake
+	lemon/CMakeLists.txt
 
 pkgconfig_DATA += lemon/lemon.pc
@@ -9,118 +8,40 @@
 
 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/arg_parser.cc \
+        lemon/base.cc \
+        lemon/color.cc \
+        lemon/random.cc \
 	lemon/bits/windows.cc
 
-nodist_lemon_HEADERS = lemon/config.h	
+#lemon_libemon_la_CXXFLAGS = $(GLPK_CFLAGS) $(CPLEX_CFLAGS) $(SOPLEX_CXXFLAGS)
+#lemon_libemon_la_LDFLAGS = $(GLPK_LIBS) $(CPLEX_LIBS) $(SOPLEX_LIBS)
 
-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
+nodist_lemon_HEADERS = lemon/config.h
 
 lemon_HEADERS += \
-	lemon/adaptors.h \
-	lemon/arg_parser.h \
+        lemon/arg_parser.h \
 	lemon/assert.h \
-	lemon/bellman_ford.h \
-	lemon/bfs.h \
-	lemon/bin_heap.h \
-	lemon/binomial_heap.h \
-	lemon/bucket_heap.h \
-	lemon/capacity_scaling.h \
-	lemon/cbc.h \
-	lemon/circulation.h \
-	lemon/clp.h \
-	lemon/color.h \
+        lemon/bfs.h \
+        lemon/bin_heap.h \
+        lemon/color.h \
 	lemon/concept_check.h \
-	lemon/connectivity.h \
+        lemon/counter.h \
 	lemon/core.h \
-	lemon/cost_scaling.h \
-	lemon/counter.h \
-	lemon/cplex.h \
-	lemon/cycle_canceling.h \
-	lemon/dfs.h \
-	lemon/dheap.h \
-	lemon/dijkstra.h \
-	lemon/dim2.h \
-	lemon/dimacs.h \
-	lemon/edge_set.h \
-	lemon/elevator.h \
+        lemon/dfs.h \
+        lemon/dijkstra.h \
+        lemon/dim2.h \
 	lemon/error.h \
-	lemon/euler.h \
-	lemon/fib_heap.h \
-	lemon/fractional_matching.h \
-	lemon/full_graph.h \
-	lemon/glpk.h \
-	lemon/gomory_hu.h \
-	lemon/graph_to_eps.h \
-	lemon/grid_graph.h \
-	lemon/hartmann_orlin_mmc.h \
-	lemon/howard_mmc.h \
-	lemon/hypercube_graph.h \
-	lemon/karp_mmc.h \
+        lemon/graph_to_eps.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/pairing_heap.h \
 	lemon/path.h \
-	lemon/planarity.h \
-	lemon/preflow.h \
-	lemon/quad_heap.h \
-	lemon/radix_heap.h \
-	lemon/radix_sort.h \
-	lemon/random.h \
+        lemon/random.h \
 	lemon/smart_graph.h \
-	lemon/soplex.h \
-	lemon/static_graph.h \
-	lemon/suurballe.h \
-	lemon/time_measure.h \
-	lemon/tolerance.h \
+        lemon/time_measure.h \
+        lemon/tolerance.h \
 	lemon/unionfind.h \
 	lemon/bits/windows.h
@@ -129,15 +50,12 @@
 	lemon/bits/alteration_notifier.h \
 	lemon/bits/array_map.h \
-	lemon/bits/bezier.h \
+	lemon/bits/base_extender.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/enable_if.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
 
Index: mon/adaptors.h
===================================================================
--- lemon/adaptors.h	(revision 956)
+++ 	(revision )
@@ -1,3638 +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_ADAPTORS_H
-#define LEMON_ADAPTORS_H
-
-/// \ingroup graph_adaptors
-/// \file
-/// \brief Adaptor classes for digraphs and graphs
-///
-/// This file contains several useful adaptors for digraphs and graphs.
-
-#include <lemon/core.h>
-#include <lemon/maps.h>
-#include <lemon/bits/variant.h>
-
-#include <lemon/bits/graph_adaptor_extender.h>
-#include <lemon/bits/map_extender.h>
-#include <lemon/tolerance.h>
-
-#include <algorithm>
-
-namespace lemon {
-
-#ifdef _MSC_VER
-#define LEMON_SCOPE_FIX(OUTER, NESTED) OUTER::NESTED
-#else
-#define LEMON_SCOPE_FIX(OUTER, NESTED) typename OUTER::template NESTED
-#endif
-
-  template<typename DGR>
-  class DigraphAdaptorBase {
-  public:
-    typedef DGR Digraph;
-    typedef DigraphAdaptorBase Adaptor;
-
-  protected:
-    DGR* _digraph;
-    DigraphAdaptorBase() : _digraph(0) { }
-    void initialize(DGR& digraph) { _digraph = &digraph; }
-
-  public:
-    DigraphAdaptorBase(DGR& digraph) : _digraph(&digraph) { }
-
-    typedef typename DGR::Node Node;
-    typedef typename DGR::Arc Arc;
-
-    void first(Node& i) const { _digraph->first(i); }
-    void first(Arc& i) const { _digraph->first(i); }
-    void firstIn(Arc& i, const Node& n) const { _digraph->firstIn(i, n); }
-    void firstOut(Arc& i, const Node& n ) const { _digraph->firstOut(i, n); }
-
-    void next(Node& i) const { _digraph->next(i); }
-    void next(Arc& i) const { _digraph->next(i); }
-    void nextIn(Arc& i) const { _digraph->nextIn(i); }
-    void nextOut(Arc& i) const { _digraph->nextOut(i); }
-
-    Node source(const Arc& a) const { return _digraph->source(a); }
-    Node target(const Arc& a) const { return _digraph->target(a); }
-
-    typedef NodeNumTagIndicator<DGR> NodeNumTag;
-    int nodeNum() const { return _digraph->nodeNum(); }
-
-    typedef ArcNumTagIndicator<DGR> ArcNumTag;
-    int arcNum() const { return _digraph->arcNum(); }
-
-    typedef FindArcTagIndicator<DGR> FindArcTag;
-    Arc findArc(const Node& u, const Node& v, const Arc& prev = INVALID) const {
-      return _digraph->findArc(u, v, prev);
-    }
-
-    Node addNode() { return _digraph->addNode(); }
-    Arc addArc(const Node& u, const Node& v) { return _digraph->addArc(u, v); }
-
-    void erase(const Node& n) { _digraph->erase(n); }
-    void erase(const Arc& a) { _digraph->erase(a); }
-
-    void clear() { _digraph->clear(); }
-
-    int id(const Node& n) const { return _digraph->id(n); }
-    int id(const Arc& a) const { return _digraph->id(a); }
-
-    Node nodeFromId(int ix) const { return _digraph->nodeFromId(ix); }
-    Arc arcFromId(int ix) const { return _digraph->arcFromId(ix); }
-
-    int maxNodeId() const { return _digraph->maxNodeId(); }
-    int maxArcId() const { return _digraph->maxArcId(); }
-
-    typedef typename ItemSetTraits<DGR, Node>::ItemNotifier NodeNotifier;
-    NodeNotifier& notifier(Node) const { return _digraph->notifier(Node()); }
-
-    typedef typename ItemSetTraits<DGR, Arc>::ItemNotifier ArcNotifier;
-    ArcNotifier& notifier(Arc) const { return _digraph->notifier(Arc()); }
-
-    template <typename V>
-    class NodeMap : public DGR::template NodeMap<V> {
-      typedef typename DGR::template NodeMap<V> Parent;
-
-    public:
-      explicit NodeMap(const Adaptor& adaptor)
-        : Parent(*adaptor._digraph) {}
-      NodeMap(const Adaptor& adaptor, const V& value)
-        : Parent(*adaptor._digraph, value) { }
-
-    private:
-      NodeMap& operator=(const NodeMap& cmap) {
-        return operator=<NodeMap>(cmap);
-      }
-
-      template <typename CMap>
-      NodeMap& operator=(const CMap& cmap) {
-        Parent::operator=(cmap);
-        return *this;
-      }
-
-    };
-
-    template <typename V>
-    class ArcMap : public DGR::template ArcMap<V> {
-      typedef typename DGR::template ArcMap<V> Parent;
-
-    public:
-      explicit ArcMap(const DigraphAdaptorBase<DGR>& adaptor)
-        : Parent(*adaptor._digraph) {}
-      ArcMap(const DigraphAdaptorBase<DGR>& adaptor, const V& value)
-        : Parent(*adaptor._digraph, value) {}
-
-    private:
-      ArcMap& operator=(const ArcMap& cmap) {
-        return operator=<ArcMap>(cmap);
-      }
-
-      template <typename CMap>
-      ArcMap& operator=(const CMap& cmap) {
-        Parent::operator=(cmap);
-        return *this;
-      }
-
-    };
-
-  };
-
-  template<typename GR>
-  class GraphAdaptorBase {
-  public:
-    typedef GR Graph;
-
-  protected:
-    GR* _graph;
-
-    GraphAdaptorBase() : _graph(0) {}
-
-    void initialize(GR& graph) { _graph = &graph; }
-
-  public:
-    GraphAdaptorBase(GR& graph) : _graph(&graph) {}
-
-    typedef typename GR::Node Node;
-    typedef typename GR::Arc Arc;
-    typedef typename GR::Edge Edge;
-
-    void first(Node& i) const { _graph->first(i); }
-    void first(Arc& i) const { _graph->first(i); }
-    void first(Edge& i) const { _graph->first(i); }
-    void firstIn(Arc& i, const Node& n) const { _graph->firstIn(i, n); }
-    void firstOut(Arc& i, const Node& n ) const { _graph->firstOut(i, n); }
-    void firstInc(Edge &i, bool &d, const Node &n) const {
-      _graph->firstInc(i, d, n);
-    }
-
-    void next(Node& i) const { _graph->next(i); }
-    void next(Arc& i) const { _graph->next(i); }
-    void next(Edge& i) const { _graph->next(i); }
-    void nextIn(Arc& i) const { _graph->nextIn(i); }
-    void nextOut(Arc& i) const { _graph->nextOut(i); }
-    void nextInc(Edge &i, bool &d) const { _graph->nextInc(i, d); }
-
-    Node u(const Edge& e) const { return _graph->u(e); }
-    Node v(const Edge& e) const { return _graph->v(e); }
-
-    Node source(const Arc& a) const { return _graph->source(a); }
-    Node target(const Arc& a) const { return _graph->target(a); }
-
-    typedef NodeNumTagIndicator<Graph> NodeNumTag;
-    int nodeNum() const { return _graph->nodeNum(); }
-
-    typedef ArcNumTagIndicator<Graph> ArcNumTag;
-    int arcNum() const { return _graph->arcNum(); }
-
-    typedef EdgeNumTagIndicator<Graph> EdgeNumTag;
-    int edgeNum() const { return _graph->edgeNum(); }
-
-    typedef FindArcTagIndicator<Graph> FindArcTag;
-    Arc findArc(const Node& u, const Node& v,
-                const Arc& prev = INVALID) const {
-      return _graph->findArc(u, v, prev);
-    }
-
-    typedef FindEdgeTagIndicator<Graph> FindEdgeTag;
-    Edge findEdge(const Node& u, const Node& v,
-                  const Edge& prev = INVALID) const {
-      return _graph->findEdge(u, v, prev);
-    }
-
-    Node addNode() { return _graph->addNode(); }
-    Edge addEdge(const Node& u, const Node& v) { return _graph->addEdge(u, v); }
-
-    void erase(const Node& i) { _graph->erase(i); }
-    void erase(const Edge& i) { _graph->erase(i); }
-
-    void clear() { _graph->clear(); }
-
-    bool direction(const Arc& a) const { return _graph->direction(a); }
-    Arc direct(const Edge& e, bool d) const { return _graph->direct(e, d); }
-
-    int id(const Node& v) const { return _graph->id(v); }
-    int id(const Arc& a) const { return _graph->id(a); }
-    int id(const Edge& e) const { return _graph->id(e); }
-
-    Node nodeFromId(int ix) const { return _graph->nodeFromId(ix); }
-    Arc arcFromId(int ix) const { return _graph->arcFromId(ix); }
-    Edge edgeFromId(int ix) const { return _graph->edgeFromId(ix); }
-
-    int maxNodeId() const { return _graph->maxNodeId(); }
-    int maxArcId() const { return _graph->maxArcId(); }
-    int maxEdgeId() const { return _graph->maxEdgeId(); }
-
-    typedef typename ItemSetTraits<GR, Node>::ItemNotifier NodeNotifier;
-    NodeNotifier& notifier(Node) const { return _graph->notifier(Node()); }
-
-    typedef typename ItemSetTraits<GR, Arc>::ItemNotifier ArcNotifier;
-    ArcNotifier& notifier(Arc) const { return _graph->notifier(Arc()); }
-
-    typedef typename ItemSetTraits<GR, Edge>::ItemNotifier EdgeNotifier;
-    EdgeNotifier& notifier(Edge) const { return _graph->notifier(Edge()); }
-
-    template <typename V>
-    class NodeMap : public GR::template NodeMap<V> {
-      typedef typename GR::template NodeMap<V> Parent;
-
-    public:
-      explicit NodeMap(const GraphAdaptorBase<GR>& adapter)
-        : Parent(*adapter._graph) {}
-      NodeMap(const GraphAdaptorBase<GR>& adapter, const V& value)
-        : Parent(*adapter._graph, value) {}
-
-    private:
-      NodeMap& operator=(const NodeMap& cmap) {
-        return operator=<NodeMap>(cmap);
-      }
-
-      template <typename CMap>
-      NodeMap& operator=(const CMap& cmap) {
-        Parent::operator=(cmap);
-        return *this;
-      }
-
-    };
-
-    template <typename V>
-    class ArcMap : public GR::template ArcMap<V> {
-      typedef typename GR::template ArcMap<V> Parent;
-
-    public:
-      explicit ArcMap(const GraphAdaptorBase<GR>& adapter)
-        : Parent(*adapter._graph) {}
-      ArcMap(const GraphAdaptorBase<GR>& adapter, const V& value)
-        : Parent(*adapter._graph, value) {}
-
-    private:
-      ArcMap& operator=(const ArcMap& cmap) {
-        return operator=<ArcMap>(cmap);
-      }
-
-      template <typename CMap>
-      ArcMap& operator=(const CMap& cmap) {
-        Parent::operator=(cmap);
-        return *this;
-      }
-    };
-
-    template <typename V>
-    class EdgeMap : public GR::template EdgeMap<V> {
-      typedef typename GR::template EdgeMap<V> Parent;
-
-    public:
-      explicit EdgeMap(const GraphAdaptorBase<GR>& adapter)
-        : Parent(*adapter._graph) {}
-      EdgeMap(const GraphAdaptorBase<GR>& adapter, const V& value)
-        : Parent(*adapter._graph, value) {}
-
-    private:
-      EdgeMap& operator=(const EdgeMap& cmap) {
-        return operator=<EdgeMap>(cmap);
-      }
-
-      template <typename CMap>
-      EdgeMap& operator=(const CMap& cmap) {
-        Parent::operator=(cmap);
-        return *this;
-      }
-    };
-
-  };
-
-  template <typename DGR>
-  class ReverseDigraphBase : public DigraphAdaptorBase<DGR> {
-    typedef DigraphAdaptorBase<DGR> Parent;
-  public:
-    typedef DGR Digraph;
-  protected:
-    ReverseDigraphBase() : Parent() { }
-  public:
-    typedef typename Parent::Node Node;
-    typedef typename Parent::Arc Arc;
-
-    void firstIn(Arc& a, const Node& n) const { Parent::firstOut(a, n); }
-    void firstOut(Arc& a, const Node& n ) const { Parent::firstIn(a, n); }
-
-    void nextIn(Arc& a) const { Parent::nextOut(a); }
-    void nextOut(Arc& a) const { Parent::nextIn(a); }
-
-    Node source(const Arc& a) const { return Parent::target(a); }
-    Node target(const Arc& a) const { return Parent::source(a); }
-
-    Arc addArc(const Node& u, const Node& v) { return Parent::addArc(v, u); }
-
-    typedef FindArcTagIndicator<DGR> FindArcTag;
-    Arc findArc(const Node& u, const Node& v,
-                const Arc& prev = INVALID) const {
-      return Parent::findArc(v, u, prev);
-    }
-
-  };
-
-  /// \ingroup graph_adaptors
-  ///
-  /// \brief Adaptor class for reversing the orientation of the arcs in
-  /// a digraph.
-  ///
-  /// ReverseDigraph can be used for reversing the arcs in a digraph.
-  /// It conforms to the \ref concepts::Digraph "Digraph" concept.
-  ///
-  /// The adapted digraph can also be modified through this adaptor
-  /// 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
-  /// digraph structure.
-  ///
-  /// \tparam DGR The type of the adapted digraph.
-  /// It must conform to the \ref concepts::Digraph "Digraph" concept.
-  /// It can also be specified to be \c const.
-  ///
-  /// \note The \c Node and \c Arc types of this adaptor and the adapted
-  /// digraph are convertible to each other.
-  template<typename DGR>
-#ifdef DOXYGEN
-  class ReverseDigraph {
-#else
-  class ReverseDigraph :
-    public DigraphAdaptorExtender<ReverseDigraphBase<DGR> > {
-#endif
-    typedef DigraphAdaptorExtender<ReverseDigraphBase<DGR> > Parent;
-  public:
-    /// The type of the adapted digraph.
-    typedef DGR Digraph;
-  protected:
-    ReverseDigraph() { }
-  public:
-
-    /// \brief Constructor
-    ///
-    /// Creates a reverse digraph adaptor for the given digraph.
-    explicit ReverseDigraph(DGR& digraph) {
-      Parent::initialize(digraph);
-    }
-  };
-
-  /// \brief Returns a read-only ReverseDigraph adaptor
-  ///
-  /// This function just returns a read-only \ref ReverseDigraph adaptor.
-  /// \ingroup graph_adaptors
-  /// \relates ReverseDigraph
-  template<typename DGR>
-  ReverseDigraph<const DGR> reverseDigraph(const DGR& digraph) {
-    return ReverseDigraph<const DGR>(digraph);
-  }
-
-
-  template <typename DGR, typename NF, typename AF, bool ch = true>
-  class SubDigraphBase : public DigraphAdaptorBase<DGR> {
-    typedef DigraphAdaptorBase<DGR> Parent;
-  public:
-    typedef DGR Digraph;
-    typedef NF NodeFilterMap;
-    typedef AF ArcFilterMap;
-
-    typedef SubDigraphBase Adaptor;
-  protected:
-    NF* _node_filter;
-    AF* _arc_filter;
-    SubDigraphBase()
-      : Parent(), _node_filter(0), _arc_filter(0) { }
-
-    void initialize(DGR& digraph, NF& node_filter, AF& arc_filter) {
-      Parent::initialize(digraph);
-      _node_filter = &node_filter;
-      _arc_filter = &arc_filter;
-    }
-
-  public:
-
-    typedef typename Parent::Node Node;
-    typedef typename Parent::Arc Arc;
-
-    void first(Node& i) const {
-      Parent::first(i);
-      while (i != INVALID && !(*_node_filter)[i]) Parent::next(i);
-    }
-
-    void first(Arc& i) const {
-      Parent::first(i);
-      while (i != INVALID && (!(*_arc_filter)[i]
-                              || !(*_node_filter)[Parent::source(i)]
-                              || !(*_node_filter)[Parent::target(i)]))
-        Parent::next(i);
-    }
-
-    void firstIn(Arc& i, const Node& n) const {
-      Parent::firstIn(i, n);
-      while (i != INVALID && (!(*_arc_filter)[i]
-                              || !(*_node_filter)[Parent::source(i)]))
-        Parent::nextIn(i);
-    }
-
-    void firstOut(Arc& i, const Node& n) const {
-      Parent::firstOut(i, n);
-      while (i != INVALID && (!(*_arc_filter)[i]
-                              || !(*_node_filter)[Parent::target(i)]))
-        Parent::nextOut(i);
-    }
-
-    void next(Node& i) const {
-      Parent::next(i);
-      while (i != INVALID && !(*_node_filter)[i]) Parent::next(i);
-    }
-
-    void next(Arc& i) const {
-      Parent::next(i);
-      while (i != INVALID && (!(*_arc_filter)[i]
-                              || !(*_node_filter)[Parent::source(i)]
-                              || !(*_node_filter)[Parent::target(i)]))
-        Parent::next(i);
-    }
-
-    void nextIn(Arc& i) const {
-      Parent::nextIn(i);
-      while (i != INVALID && (!(*_arc_filter)[i]
-                              || !(*_node_filter)[Parent::source(i)]))
-        Parent::nextIn(i);
-    }
-
-    void nextOut(Arc& i) const {
-      Parent::nextOut(i);
-      while (i != INVALID && (!(*_arc_filter)[i]
-                              || !(*_node_filter)[Parent::target(i)]))
-        Parent::nextOut(i);
-    }
-
-    void status(const Node& n, bool v) const { _node_filter->set(n, v); }
-    void status(const Arc& a, bool v) const { _arc_filter->set(a, v); }
-
-    bool status(const Node& n) const { return (*_node_filter)[n]; }
-    bool status(const Arc& a) const { return (*_arc_filter)[a]; }
-
-    typedef False NodeNumTag;
-    typedef False ArcNumTag;
-
-    typedef FindArcTagIndicator<DGR> FindArcTag;
-    Arc findArc(const Node& source, const Node& target,
-                const Arc& prev = INVALID) const {
-      if (!(*_node_filter)[source] || !(*_node_filter)[target]) {
-        return INVALID;
-      }
-      Arc arc = Parent::findArc(source, target, prev);
-      while (arc != INVALID && !(*_arc_filter)[arc]) {
-        arc = Parent::findArc(source, target, arc);
-      }
-      return arc;
-    }
-
-  public:
-
-    template <typename 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;
-
-    public:
-      typedef V Value;
-
-      NodeMap(const SubDigraphBase<DGR, NF, AF, ch>& adaptor)
-        : Parent(adaptor) {}
-      NodeMap(const SubDigraphBase<DGR, NF, AF, ch>& adaptor, const V& value)
-        : Parent(adaptor, value) {}
-
-    private:
-      NodeMap& operator=(const NodeMap& cmap) {
-        return operator=<NodeMap>(cmap);
-      }
-
-      template <typename CMap>
-      NodeMap& operator=(const CMap& cmap) {
-        Parent::operator=(cmap);
-        return *this;
-      }
-    };
-
-    template <typename V>
-    class ArcMap
-      : public SubMapExtender<SubDigraphBase<DGR, NF, AF, ch>,
-              LEMON_SCOPE_FIX(DigraphAdaptorBase<DGR>, ArcMap<V>)> {
-      typedef SubMapExtender<SubDigraphBase<DGR, NF, AF, ch>,
-        LEMON_SCOPE_FIX(DigraphAdaptorBase<DGR>, ArcMap<V>)> Parent;
-
-    public:
-      typedef V Value;
-
-      ArcMap(const SubDigraphBase<DGR, NF, AF, ch>& adaptor)
-        : Parent(adaptor) {}
-      ArcMap(const SubDigraphBase<DGR, NF, AF, ch>& adaptor, const V& value)
-        : Parent(adaptor, value) {}
-
-    private:
-      ArcMap& operator=(const ArcMap& cmap) {
-        return operator=<ArcMap>(cmap);
-      }
-
-      template <typename CMap>
-      ArcMap& operator=(const CMap& cmap) {
-        Parent::operator=(cmap);
-        return *this;
-      }
-    };
-
-  };
-
-  template <typename DGR, typename NF, typename AF>
-  class SubDigraphBase<DGR, NF, AF, false>
-    : public DigraphAdaptorBase<DGR> {
-    typedef DigraphAdaptorBase<DGR> Parent;
-  public:
-    typedef DGR Digraph;
-    typedef NF NodeFilterMap;
-    typedef AF ArcFilterMap;
-
-    typedef SubDigraphBase Adaptor;
-  protected:
-    NF* _node_filter;
-    AF* _arc_filter;
-    SubDigraphBase()
-      : Parent(), _node_filter(0), _arc_filter(0) { }
-
-    void initialize(DGR& digraph, NF& node_filter, AF& arc_filter) {
-      Parent::initialize(digraph);
-      _node_filter = &node_filter;
-      _arc_filter = &arc_filter;
-    }
-
-  public:
-
-    typedef typename Parent::Node Node;
-    typedef typename Parent::Arc Arc;
-
-    void first(Node& i) const {
-      Parent::first(i);
-      while (i!=INVALID && !(*_node_filter)[i]) Parent::next(i);
-    }
-
-    void first(Arc& i) const {
-      Parent::first(i);
-      while (i!=INVALID && !(*_arc_filter)[i]) Parent::next(i);
-    }
-
-    void firstIn(Arc& i, const Node& n) const {
-      Parent::firstIn(i, n);
-      while (i!=INVALID && !(*_arc_filter)[i]) Parent::nextIn(i);
-    }
-
-    void firstOut(Arc& i, const Node& n) const {
-      Parent::firstOut(i, n);
-      while (i!=INVALID && !(*_arc_filter)[i]) Parent::nextOut(i);
-    }
-
-    void next(Node& i) const {
-      Parent::next(i);
-      while (i!=INVALID && !(*_node_filter)[i]) Parent::next(i);
-    }
-    void next(Arc& i) const {
-      Parent::next(i);
-      while (i!=INVALID && !(*_arc_filter)[i]) Parent::next(i);
-    }
-    void nextIn(Arc& i) const {
-      Parent::nextIn(i);
-      while (i!=INVALID && !(*_arc_filter)[i]) Parent::nextIn(i);
-    }
-
-    void nextOut(Arc& i) const {
-      Parent::nextOut(i);
-      while (i!=INVALID && !(*_arc_filter)[i]) Parent::nextOut(i);
-    }
-
-    void status(const Node& n, bool v) const { _node_filter->set(n, v); }
-    void status(const Arc& a, bool v) const { _arc_filter->set(a, v); }
-
-    bool status(const Node& n) const { return (*_node_filter)[n]; }
-    bool status(const Arc& a) const { return (*_arc_filter)[a]; }
-
-    typedef False NodeNumTag;
-    typedef False ArcNumTag;
-
-    typedef FindArcTagIndicator<DGR> FindArcTag;
-    Arc findArc(const Node& source, const Node& target,
-                const Arc& prev = INVALID) const {
-      if (!(*_node_filter)[source] || !(*_node_filter)[target]) {
-        return INVALID;
-      }
-      Arc arc = Parent::findArc(source, target, prev);
-      while (arc != INVALID && !(*_arc_filter)[arc]) {
-        arc = Parent::findArc(source, target, arc);
-      }
-      return arc;
-    }
-
-    template <typename V>
-    class NodeMap
-      : public SubMapExtender<SubDigraphBase<DGR, NF, AF, false>,
-          LEMON_SCOPE_FIX(DigraphAdaptorBase<DGR>, NodeMap<V>)> {
-      typedef SubMapExtender<SubDigraphBase<DGR, NF, AF, false>,
-        LEMON_SCOPE_FIX(DigraphAdaptorBase<DGR>, NodeMap<V>)> Parent;
-
-    public:
-      typedef V Value;
-
-      NodeMap(const SubDigraphBase<DGR, NF, AF, false>& adaptor)
-        : Parent(adaptor) {}
-      NodeMap(const SubDigraphBase<DGR, NF, AF, false>& adaptor, const V& value)
-        : Parent(adaptor, value) {}
-
-    private:
-      NodeMap& operator=(const NodeMap& cmap) {
-        return operator=<NodeMap>(cmap);
-      }
-
-      template <typename CMap>
-      NodeMap& operator=(const CMap& cmap) {
-        Parent::operator=(cmap);
-        return *this;
-      }
-    };
-
-    template <typename V>
-    class ArcMap
-      : public SubMapExtender<SubDigraphBase<DGR, NF, AF, false>,
-          LEMON_SCOPE_FIX(DigraphAdaptorBase<DGR>, ArcMap<V>)> {
-      typedef SubMapExtender<SubDigraphBase<DGR, NF, AF, false>,
-        LEMON_SCOPE_FIX(DigraphAdaptorBase<DGR>, ArcMap<V>)> Parent;
-
-    public:
-      typedef V Value;
-
-      ArcMap(const SubDigraphBase<DGR, NF, AF, false>& adaptor)
-        : Parent(adaptor) {}
-      ArcMap(const SubDigraphBase<DGR, NF, AF, false>& adaptor, const V& value)
-        : Parent(adaptor, value) {}
-
-    private:
-      ArcMap& operator=(const ArcMap& cmap) {
-        return operator=<ArcMap>(cmap);
-      }
-
-      template <typename CMap>
-      ArcMap& operator=(const CMap& cmap) {
-        Parent::operator=(cmap);
-        return *this;
-      }
-    };
-
-  };
-
-  /// \ingroup graph_adaptors
-  ///
-  /// \brief Adaptor class for hiding nodes and arcs in a digraph
-  ///
-  /// SubDigraph can be used for hiding nodes and arcs in a digraph.
-  /// A \c bool node map and a \c bool arc map must be specified, which
-  /// define the filters for nodes and arcs.
-  /// Only the nodes and arcs with \c true filter value are
-  /// shown in the subdigraph. The arcs that are incident to hidden
-  /// nodes are also filtered out.
-  /// This adaptor conforms to the \ref concepts::Digraph "Digraph" concept.
-  ///
-  /// The adapted digraph can also be modified through this adaptor
-  /// 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.
-  /// It must conform to the \ref concepts::Digraph "Digraph" concept.
-  /// It can also be specified to be \c const.
-  /// \tparam NF The type of the node filter map.
-  /// It must be a \c bool (or convertible) node map of the
-  /// adapted digraph. The default type is
-  /// \ref concepts::Digraph::NodeMap "DGR::NodeMap<bool>".
-  /// \tparam AF The type of the arc filter map.
-  /// It must be \c bool (or convertible) arc map of the
-  /// adapted digraph. The default type is
-  /// \ref concepts::Digraph::ArcMap "DGR::ArcMap<bool>".
-  ///
-  /// \note The \c Node and \c Arc types of this adaptor and the adapted
-  /// digraph are convertible to each other.
-  ///
-  /// \see FilterNodes
-  /// \see FilterArcs
-#ifdef DOXYGEN
-  template<typename DGR, typename NF, typename AF>
-  class SubDigraph {
-#else
-  template<typename DGR,
-           typename NF = typename DGR::template NodeMap<bool>,
-           typename AF = typename DGR::template ArcMap<bool> >
-  class SubDigraph :
-    public DigraphAdaptorExtender<SubDigraphBase<DGR, NF, AF, true> > {
-#endif
-  public:
-    /// The type of the adapted digraph.
-    typedef DGR Digraph;
-    /// The type of the node filter map.
-    typedef NF NodeFilterMap;
-    /// The type of the arc filter map.
-    typedef AF ArcFilterMap;
-
-    typedef DigraphAdaptorExtender<SubDigraphBase<DGR, NF, AF, true> >
-      Parent;
-
-    typedef typename Parent::Node Node;
-    typedef typename Parent::Arc Arc;
-
-  protected:
-    SubDigraph() { }
-  public:
-
-    /// \brief Constructor
-    ///
-    /// Creates a subdigraph for the given digraph with the
-    /// given node and arc filter maps.
-    SubDigraph(DGR& digraph, NF& node_filter, AF& arc_filter) {
-      Parent::initialize(digraph, node_filter, arc_filter);
-    }
-
-    /// \brief Sets the status of the given node
-    ///
-    /// This function sets the status of the given node.
-    /// It is done by simply setting the assigned value of \c n
-    /// to \c v in the node filter map.
-    void status(const Node& n, bool v) const { Parent::status(n, v); }
-
-    /// \brief Sets the status of the given arc
-    ///
-    /// This function sets the status of the given arc.
-    /// It is done by simply setting the assigned value of \c a
-    /// to \c v in the arc filter map.
-    void status(const Arc& a, bool v) const { Parent::status(a, v); }
-
-    /// \brief Returns the status of the given node
-    ///
-    /// This function returns the status of the given node.
-    /// It is \c true if the given node is enabled (i.e. not hidden).
-    bool status(const Node& n) const { return Parent::status(n); }
-
-    /// \brief Returns the status of the given arc
-    ///
-    /// This function returns the status of the given arc.
-    /// It is \c true if the given arc is enabled (i.e. not hidden).
-    bool status(const Arc& a) const { return Parent::status(a); }
-
-    /// \brief Disables the given node
-    ///
-    /// This function disables the given node in the subdigraph,
-    /// so the iteration jumps over it.
-    /// It is the same as \ref status() "status(n, false)".
-    void disable(const Node& n) const { Parent::status(n, false); }
-
-    /// \brief Disables the given arc
-    ///
-    /// This function disables the given arc in the subdigraph,
-    /// so the iteration jumps over it.
-    /// It is the same as \ref status() "status(a, false)".
-    void disable(const Arc& a) const { Parent::status(a, false); }
-
-    /// \brief Enables the given node
-    ///
-    /// This function enables the given node in the subdigraph.
-    /// It is the same as \ref status() "status(n, true)".
-    void enable(const Node& n) const { Parent::status(n, true); }
-
-    /// \brief Enables the given arc
-    ///
-    /// This function enables the given arc in the subdigraph.
-    /// It is the same as \ref status() "status(a, true)".
-    void enable(const Arc& a) const { Parent::status(a, true); }
-
-  };
-
-  /// \brief Returns a read-only SubDigraph adaptor
-  ///
-  /// This function just returns a read-only \ref SubDigraph adaptor.
-  /// \ingroup graph_adaptors
-  /// \relates SubDigraph
-  template<typename DGR, typename NF, typename AF>
-  SubDigraph<const DGR, NF, AF>
-  subDigraph(const DGR& digraph,
-             NF& node_filter, AF& arc_filter) {
-    return SubDigraph<const DGR, NF, AF>
-      (digraph, node_filter, arc_filter);
-  }
-
-  template<typename DGR, typename NF, typename AF>
-  SubDigraph<const DGR, const NF, AF>
-  subDigraph(const DGR& digraph,
-             const NF& node_filter, AF& arc_filter) {
-    return SubDigraph<const DGR, const NF, AF>
-      (digraph, node_filter, arc_filter);
-  }
-
-  template<typename DGR, typename NF, typename AF>
-  SubDigraph<const DGR, NF, const AF>
-  subDigraph(const DGR& digraph,
-             NF& node_filter, const AF& arc_filter) {
-    return SubDigraph<const DGR, NF, const AF>
-      (digraph, node_filter, arc_filter);
-  }
-
-  template<typename DGR, typename NF, typename AF>
-  SubDigraph<const DGR, const NF, const AF>
-  subDigraph(const DGR& digraph,
-             const NF& node_filter, const AF& arc_filter) {
-    return SubDigraph<const DGR, const NF, const AF>
-      (digraph, node_filter, arc_filter);
-  }
-
-
-  template <typename GR, typename NF, typename EF, bool ch = true>
-  class SubGraphBase : public GraphAdaptorBase<GR> {
-    typedef GraphAdaptorBase<GR> Parent;
-  public:
-    typedef GR Graph;
-    typedef NF NodeFilterMap;
-    typedef EF EdgeFilterMap;
-
-    typedef SubGraphBase Adaptor;
-  protected:
-
-    NF* _node_filter;
-    EF* _edge_filter;
-
-    SubGraphBase()
-      : Parent(), _node_filter(0), _edge_filter(0) { }
-
-    void initialize(GR& graph, NF& node_filter, EF& edge_filter) {
-      Parent::initialize(graph);
-      _node_filter = &node_filter;
-      _edge_filter = &edge_filter;
-    }
-
-  public:
-
-    typedef typename Parent::Node Node;
-    typedef typename Parent::Arc Arc;
-    typedef typename Parent::Edge Edge;
-
-    void first(Node& i) const {
-      Parent::first(i);
-      while (i!=INVALID && !(*_node_filter)[i]) Parent::next(i);
-    }
-
-    void first(Arc& i) const {
-      Parent::first(i);
-      while (i!=INVALID && (!(*_edge_filter)[i]
-                            || !(*_node_filter)[Parent::source(i)]
-                            || !(*_node_filter)[Parent::target(i)]))
-        Parent::next(i);
-    }
-
-    void first(Edge& i) const {
-      Parent::first(i);
-      while (i!=INVALID && (!(*_edge_filter)[i]
-                            || !(*_node_filter)[Parent::u(i)]
-                            || !(*_node_filter)[Parent::v(i)]))
-        Parent::next(i);
-    }
-
-    void firstIn(Arc& i, const Node& n) const {
-      Parent::firstIn(i, n);
-      while (i!=INVALID && (!(*_edge_filter)[i]
-                            || !(*_node_filter)[Parent::source(i)]))
-        Parent::nextIn(i);
-    }
-
-    void firstOut(Arc& i, const Node& n) const {
-      Parent::firstOut(i, n);
-      while (i!=INVALID && (!(*_edge_filter)[i]
-                            || !(*_node_filter)[Parent::target(i)]))
-        Parent::nextOut(i);
-    }
-
-    void firstInc(Edge& i, bool& d, const Node& n) const {
-      Parent::firstInc(i, d, n);
-      while (i!=INVALID && (!(*_edge_filter)[i]
-                            || !(*_node_filter)[Parent::u(i)]
-                            || !(*_node_filter)[Parent::v(i)]))
-        Parent::nextInc(i, d);
-    }
-
-    void next(Node& i) const {
-      Parent::next(i);
-      while (i!=INVALID && !(*_node_filter)[i]) Parent::next(i);
-    }
-
-    void next(Arc& i) const {
-      Parent::next(i);
-      while (i!=INVALID && (!(*_edge_filter)[i]
-                            || !(*_node_filter)[Parent::source(i)]
-                            || !(*_node_filter)[Parent::target(i)]))
-        Parent::next(i);
-    }
-
-    void next(Edge& i) const {
-      Parent::next(i);
-      while (i!=INVALID && (!(*_edge_filter)[i]
-                            || !(*_node_filter)[Parent::u(i)]
-                            || !(*_node_filter)[Parent::v(i)]))
-        Parent::next(i);
-    }
-
-    void nextIn(Arc& i) const {
-      Parent::nextIn(i);
-      while (i!=INVALID && (!(*_edge_filter)[i]
-                            || !(*_node_filter)[Parent::source(i)]))
-        Parent::nextIn(i);
-    }
-
-    void nextOut(Arc& i) const {
-      Parent::nextOut(i);
-      while (i!=INVALID && (!(*_edge_filter)[i]
-                            || !(*_node_filter)[Parent::target(i)]))
-        Parent::nextOut(i);
-    }
-
-    void nextInc(Edge& i, bool& d) const {
-      Parent::nextInc(i, d);
-      while (i!=INVALID && (!(*_edge_filter)[i]
-                            || !(*_node_filter)[Parent::u(i)]
-                            || !(*_node_filter)[Parent::v(i)]))
-        Parent::nextInc(i, d);
-    }
-
-    void status(const Node& n, bool v) const { _node_filter->set(n, v); }
-    void status(const Edge& e, bool v) const { _edge_filter->set(e, v); }
-
-    bool status(const Node& n) const { return (*_node_filter)[n]; }
-    bool status(const Edge& e) const { return (*_edge_filter)[e]; }
-
-    typedef False NodeNumTag;
-    typedef False ArcNumTag;
-    typedef False EdgeNumTag;
-
-    typedef FindArcTagIndicator<Graph> FindArcTag;
-    Arc findArc(const Node& u, const Node& v,
-                const Arc& prev = INVALID) const {
-      if (!(*_node_filter)[u] || !(*_node_filter)[v]) {
-        return INVALID;
-      }
-      Arc arc = Parent::findArc(u, v, prev);
-      while (arc != INVALID && !(*_edge_filter)[arc]) {
-        arc = Parent::findArc(u, v, arc);
-      }
-      return arc;
-    }
-
-    typedef FindEdgeTagIndicator<Graph> FindEdgeTag;
-    Edge findEdge(const Node& u, const Node& v,
-                  const Edge& prev = INVALID) const {
-      if (!(*_node_filter)[u] || !(*_node_filter)[v]) {
-        return INVALID;
-      }
-      Edge edge = Parent::findEdge(u, v, prev);
-      while (edge != INVALID && !(*_edge_filter)[edge]) {
-        edge = Parent::findEdge(u, v, edge);
-      }
-      return edge;
-    }
-
-    template <typename V>
-    class NodeMap
-      : public SubMapExtender<SubGraphBase<GR, NF, EF, ch>,
-          LEMON_SCOPE_FIX(GraphAdaptorBase<GR>, NodeMap<V>)> {
-      typedef SubMapExtender<SubGraphBase<GR, NF, EF, ch>,
-        LEMON_SCOPE_FIX(GraphAdaptorBase<GR>, NodeMap<V>)> Parent;
-
-    public:
-      typedef V Value;
-
-      NodeMap(const SubGraphBase<GR, NF, EF, ch>& adaptor)
-        : Parent(adaptor) {}
-      NodeMap(const SubGraphBase<GR, NF, EF, ch>& adaptor, const V& value)
-        : Parent(adaptor, value) {}
-
-    private:
-      NodeMap& operator=(const NodeMap& cmap) {
-        return operator=<NodeMap>(cmap);
-      }
-
-      template <typename CMap>
-      NodeMap& operator=(const CMap& cmap) {
-        Parent::operator=(cmap);
-        return *this;
-      }
-    };
-
-    template <typename V>
-    class ArcMap
-      : public SubMapExtender<SubGraphBase<GR, NF, EF, ch>,
-          LEMON_SCOPE_FIX(GraphAdaptorBase<GR>, ArcMap<V>)> {
-      typedef SubMapExtender<SubGraphBase<GR, NF, EF, ch>,
-        LEMON_SCOPE_FIX(GraphAdaptorBase<GR>, ArcMap<V>)> Parent;
-
-    public:
-      typedef V Value;
-
-      ArcMap(const SubGraphBase<GR, NF, EF, ch>& adaptor)
-        : Parent(adaptor) {}
-      ArcMap(const SubGraphBase<GR, NF, EF, ch>& adaptor, const V& value)
-        : Parent(adaptor, value) {}
-
-    private:
-      ArcMap& operator=(const ArcMap& cmap) {
-        return operator=<ArcMap>(cmap);
-      }
-
-      template <typename CMap>
-      ArcMap& operator=(const CMap& cmap) {
-        Parent::operator=(cmap);
-        return *this;
-      }
-    };
-
-    template <typename V>
-    class EdgeMap
-      : public SubMapExtender<SubGraphBase<GR, NF, EF, ch>,
-        LEMON_SCOPE_FIX(GraphAdaptorBase<GR>, EdgeMap<V>)> {
-      typedef SubMapExtender<SubGraphBase<GR, NF, EF, ch>,
-        LEMON_SCOPE_FIX(GraphAdaptorBase<GR>, EdgeMap<V>)> Parent;
-
-    public:
-      typedef V Value;
-
-      EdgeMap(const SubGraphBase<GR, NF, EF, ch>& adaptor)
-        : Parent(adaptor) {}
-
-      EdgeMap(const SubGraphBase<GR, NF, EF, ch>& adaptor, const V& value)
-        : Parent(adaptor, value) {}
-
-    private:
-      EdgeMap& operator=(const EdgeMap& cmap) {
-        return operator=<EdgeMap>(cmap);
-      }
-
-      template <typename CMap>
-      EdgeMap& operator=(const CMap& cmap) {
-        Parent::operator=(cmap);
-        return *this;
-      }
-    };
-
-  };
-
-  template <typename GR, typename NF, typename EF>
-  class SubGraphBase<GR, NF, EF, false>
-    : public GraphAdaptorBase<GR> {
-    typedef GraphAdaptorBase<GR> Parent;
-  public:
-    typedef GR Graph;
-    typedef NF NodeFilterMap;
-    typedef EF EdgeFilterMap;
-
-    typedef SubGraphBase Adaptor;
-  protected:
-    NF* _node_filter;
-    EF* _edge_filter;
-    SubGraphBase()
-          : Parent(), _node_filter(0), _edge_filter(0) { }
-
-    void initialize(GR& graph, NF& node_filter, EF& edge_filter) {
-      Parent::initialize(graph);
-      _node_filter = &node_filter;
-      _edge_filter = &edge_filter;
-    }
-
-  public:
-
-    typedef typename Parent::Node Node;
-    typedef typename Parent::Arc Arc;
-    typedef typename Parent::Edge Edge;
-
-    void first(Node& i) const {
-      Parent::first(i);
-      while (i!=INVALID && !(*_node_filter)[i]) Parent::next(i);
-    }
-
-    void first(Arc& i) const {
-      Parent::first(i);
-      while (i!=INVALID && !(*_edge_filter)[i]) Parent::next(i);
-    }
-
-    void first(Edge& i) const {
-      Parent::first(i);
-      while (i!=INVALID && !(*_edge_filter)[i]) Parent::next(i);
-    }
-
-    void firstIn(Arc& i, const Node& n) const {
-      Parent::firstIn(i, n);
-      while (i!=INVALID && !(*_edge_filter)[i]) Parent::nextIn(i);
-    }
-
-    void firstOut(Arc& i, const Node& n) const {
-      Parent::firstOut(i, n);
-      while (i!=INVALID && !(*_edge_filter)[i]) Parent::nextOut(i);
-    }
-
-    void firstInc(Edge& i, bool& d, const Node& n) const {
-      Parent::firstInc(i, d, n);
-      while (i!=INVALID && !(*_edge_filter)[i]) Parent::nextInc(i, d);
-    }
-
-    void next(Node& i) const {
-      Parent::next(i);
-      while (i!=INVALID && !(*_node_filter)[i]) Parent::next(i);
-    }
-    void next(Arc& i) const {
-      Parent::next(i);
-      while (i!=INVALID && !(*_edge_filter)[i]) Parent::next(i);
-    }
-    void next(Edge& i) const {
-      Parent::next(i);
-      while (i!=INVALID && !(*_edge_filter)[i]) Parent::next(i);
-    }
-    void nextIn(Arc& i) const {
-      Parent::nextIn(i);
-      while (i!=INVALID && !(*_edge_filter)[i]) Parent::nextIn(i);
-    }
-
-    void nextOut(Arc& i) const {
-      Parent::nextOut(i);
-      while (i!=INVALID && !(*_edge_filter)[i]) Parent::nextOut(i);
-    }
-    void nextInc(Edge& i, bool& d) const {
-      Parent::nextInc(i, d);
-      while (i!=INVALID && !(*_edge_filter)[i]) Parent::nextInc(i, d);
-    }
-
-    void status(const Node& n, bool v) const { _node_filter->set(n, v); }
-    void status(const Edge& e, bool v) const { _edge_filter->set(e, v); }
-
-    bool status(const Node& n) const { return (*_node_filter)[n]; }
-    bool status(const Edge& e) const { return (*_edge_filter)[e]; }
-
-    typedef False NodeNumTag;
-    typedef False ArcNumTag;
-    typedef False EdgeNumTag;
-
-    typedef FindArcTagIndicator<Graph> FindArcTag;
-    Arc findArc(const Node& u, const Node& v,
-                const Arc& prev = INVALID) const {
-      Arc arc = Parent::findArc(u, v, prev);
-      while (arc != INVALID && !(*_edge_filter)[arc]) {
-        arc = Parent::findArc(u, v, arc);
-      }
-      return arc;
-    }
-
-    typedef FindEdgeTagIndicator<Graph> FindEdgeTag;
-    Edge findEdge(const Node& u, const Node& v,
-                  const Edge& prev = INVALID) const {
-      Edge edge = Parent::findEdge(u, v, prev);
-      while (edge != INVALID && !(*_edge_filter)[edge]) {
-        edge = Parent::findEdge(u, v, edge);
-      }
-      return edge;
-    }
-
-    template <typename V>
-    class NodeMap
-      : public SubMapExtender<SubGraphBase<GR, NF, EF, false>,
-          LEMON_SCOPE_FIX(GraphAdaptorBase<GR>, NodeMap<V>)> {
-      typedef SubMapExtender<SubGraphBase<GR, NF, EF, false>,
-        LEMON_SCOPE_FIX(GraphAdaptorBase<GR>, NodeMap<V>)> Parent;
-
-    public:
-      typedef V Value;
-
-      NodeMap(const SubGraphBase<GR, NF, EF, false>& adaptor)
-        : Parent(adaptor) {}
-      NodeMap(const SubGraphBase<GR, NF, EF, false>& adaptor, const V& value)
-        : Parent(adaptor, value) {}
-
-    private:
-      NodeMap& operator=(const NodeMap& cmap) {
-        return operator=<NodeMap>(cmap);
-      }
-
-      template <typename CMap>
-      NodeMap& operator=(const CMap& cmap) {
-        Parent::operator=(cmap);
-        return *this;
-      }
-    };
-
-    template <typename V>
-    class ArcMap
-      : public SubMapExtender<SubGraphBase<GR, NF, EF, false>,
-          LEMON_SCOPE_FIX(GraphAdaptorBase<GR>, ArcMap<V>)> {
-      typedef SubMapExtender<SubGraphBase<GR, NF, EF, false>,
-        LEMON_SCOPE_FIX(GraphAdaptorBase<GR>, ArcMap<V>)> Parent;
-
-    public:
-      typedef V Value;
-
-      ArcMap(const SubGraphBase<GR, NF, EF, false>& adaptor)
-        : Parent(adaptor) {}
-      ArcMap(const SubGraphBase<GR, NF, EF, false>& adaptor, const V& value)
-        : Parent(adaptor, value) {}
-
-    private:
-      ArcMap& operator=(const ArcMap& cmap) {
-        return operator=<ArcMap>(cmap);
-      }
-
-      template <typename CMap>
-      ArcMap& operator=(const CMap& cmap) {
-        Parent::operator=(cmap);
-        return *this;
-      }
-    };
-
-    template <typename V>
-    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;
-
-    public:
-      typedef V Value;
-
-      EdgeMap(const SubGraphBase<GR, NF, EF, false>& adaptor)
-        : Parent(adaptor) {}
-
-      EdgeMap(const SubGraphBase<GR, NF, EF, false>& adaptor, const V& value)
-        : Parent(adaptor, value) {}
-
-    private:
-      EdgeMap& operator=(const EdgeMap& cmap) {
-        return operator=<EdgeMap>(cmap);
-      }
-
-      template <typename CMap>
-      EdgeMap& operator=(const CMap& cmap) {
-        Parent::operator=(cmap);
-        return *this;
-      }
-    };
-
-  };
-
-  /// \ingroup graph_adaptors
-  ///
-  /// \brief Adaptor class for hiding nodes and edges in an undirected
-  /// graph.
-  ///
-  /// SubGraph can be used for hiding nodes and edges in a graph.
-  /// A \c bool node map and a \c bool edge map must be specified, which
-  /// define the filters for nodes and edges.
-  /// Only the nodes and edges with \c true filter value are
-  /// shown in the subgraph. The edges that are incident to hidden
-  /// nodes are also filtered out.
-  /// This adaptor conforms to the \ref concepts::Graph "Graph" concept.
-  ///
-  /// The adapted graph can also be modified through this adaptor
-  /// 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.
-  /// It must conform to the \ref concepts::Graph "Graph" concept.
-  /// It can also be specified to be \c const.
-  /// \tparam NF The type of the node filter map.
-  /// It must be a \c bool (or convertible) node map of the
-  /// adapted graph. The default type is
-  /// \ref concepts::Graph::NodeMap "GR::NodeMap<bool>".
-  /// \tparam EF The type of the edge filter map.
-  /// It must be a \c bool (or convertible) edge map of the
-  /// adapted graph. The default type is
-  /// \ref concepts::Graph::EdgeMap "GR::EdgeMap<bool>".
-  ///
-  /// \note The \c Node, \c Edge and \c Arc types of this adaptor and the
-  /// adapted graph are convertible to each other.
-  ///
-  /// \see FilterNodes
-  /// \see FilterEdges
-#ifdef DOXYGEN
-  template<typename GR, typename NF, typename EF>
-  class SubGraph {
-#else
-  template<typename GR,
-           typename NF = typename GR::template NodeMap<bool>,
-           typename EF = typename GR::template EdgeMap<bool> >
-  class SubGraph :
-    public GraphAdaptorExtender<SubGraphBase<GR, NF, EF, true> > {
-#endif
-  public:
-    /// The type of the adapted graph.
-    typedef GR Graph;
-    /// The type of the node filter map.
-    typedef NF NodeFilterMap;
-    /// The type of the edge filter map.
-    typedef EF EdgeFilterMap;
-
-    typedef GraphAdaptorExtender<SubGraphBase<GR, NF, EF, true> >
-      Parent;
-
-    typedef typename Parent::Node Node;
-    typedef typename Parent::Edge Edge;
-
-  protected:
-    SubGraph() { }
-  public:
-
-    /// \brief Constructor
-    ///
-    /// Creates a subgraph for the given graph with the given node
-    /// and edge filter maps.
-    SubGraph(GR& graph, NF& node_filter, EF& edge_filter) {
-      initialize(graph, node_filter, edge_filter);
-    }
-
-    /// \brief Sets the status of the given node
-    ///
-    /// This function sets the status of the given node.
-    /// It is done by simply setting the assigned value of \c n
-    /// to \c v in the node filter map.
-    void status(const Node& n, bool v) const { Parent::status(n, v); }
-
-    /// \brief Sets the status of the given edge
-    ///
-    /// This function sets the status of the given edge.
-    /// It is done by simply setting the assigned value of \c e
-    /// to \c v in the edge filter map.
-    void status(const Edge& e, bool v) const { Parent::status(e, v); }
-
-    /// \brief Returns the status of the given node
-    ///
-    /// This function returns the status of the given node.
-    /// It is \c true if the given node is enabled (i.e. not hidden).
-    bool status(const Node& n) const { return Parent::status(n); }
-
-    /// \brief Returns the status of the given edge
-    ///
-    /// This function returns the status of the given edge.
-    /// It is \c true if the given edge is enabled (i.e. not hidden).
-    bool status(const Edge& e) const { return Parent::status(e); }
-
-    /// \brief Disables the given node
-    ///
-    /// This function disables the given node in the subdigraph,
-    /// so the iteration jumps over it.
-    /// It is the same as \ref status() "status(n, false)".
-    void disable(const Node& n) const { Parent::status(n, false); }
-
-    /// \brief Disables the given edge
-    ///
-    /// This function disables the given edge in the subgraph,
-    /// so the iteration jumps over it.
-    /// It is the same as \ref status() "status(e, false)".
-    void disable(const Edge& e) const { Parent::status(e, false); }
-
-    /// \brief Enables the given node
-    ///
-    /// This function enables the given node in the subdigraph.
-    /// It is the same as \ref status() "status(n, true)".
-    void enable(const Node& n) const { Parent::status(n, true); }
-
-    /// \brief Enables the given edge
-    ///
-    /// This function enables the given edge in the subgraph.
-    /// It is the same as \ref status() "status(e, true)".
-    void enable(const Edge& e) const { Parent::status(e, true); }
-
-  };
-
-  /// \brief Returns a read-only SubGraph adaptor
-  ///
-  /// This function just returns a read-only \ref SubGraph adaptor.
-  /// \ingroup graph_adaptors
-  /// \relates SubGraph
-  template<typename GR, typename NF, typename EF>
-  SubGraph<const GR, NF, EF>
-  subGraph(const GR& graph, NF& node_filter, EF& edge_filter) {
-    return SubGraph<const GR, NF, EF>
-      (graph, node_filter, edge_filter);
-  }
-
-  template<typename GR, typename NF, typename EF>
-  SubGraph<const GR, const NF, EF>
-  subGraph(const GR& graph, const NF& node_filter, EF& edge_filter) {
-    return SubGraph<const GR, const NF, EF>
-      (graph, node_filter, edge_filter);
-  }
-
-  template<typename GR, typename NF, typename EF>
-  SubGraph<const GR, NF, const EF>
-  subGraph(const GR& graph, NF& node_filter, const EF& edge_filter) {
-    return SubGraph<const GR, NF, const EF>
-      (graph, node_filter, edge_filter);
-  }
-
-  template<typename GR, typename NF, typename EF>
-  SubGraph<const GR, const NF, const EF>
-  subGraph(const GR& graph, const NF& node_filter, const EF& edge_filter) {
-    return SubGraph<const GR, const NF, const EF>
-      (graph, node_filter, edge_filter);
-  }
-
-
-  /// \ingroup graph_adaptors
-  ///
-  /// \brief Adaptor class for hiding nodes in a digraph or a graph.
-  ///
-  /// FilterNodes adaptor can be used for hiding nodes in a digraph or a
-  /// graph. A \c bool node map must be specified, which defines the filter
-  /// for the nodes. Only the nodes with \c true filter value and the
-  /// arcs/edges incident to nodes both with \c true filter value are shown
-  /// in the subgraph. This adaptor conforms to the \ref concepts::Digraph
-  /// "Digraph" concept or the \ref concepts::Graph "Graph" concept
-  /// depending on the \c GR template parameter.
-  ///
-  /// The adapted (di)graph can also be modified through this adaptor
-  /// 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.
-  /// It must conform to the \ref concepts::Digraph "Digraph" concept
-  /// or the \ref concepts::Graph "Graph" concept.
-  /// It can also be specified to be \c const.
-  /// \tparam NF The type of the node filter map.
-  /// It must be a \c bool (or convertible) node map of the
-  /// adapted (di)graph. The default type is
-  /// \ref concepts::Graph::NodeMap "GR::NodeMap<bool>".
-  ///
-  /// \note The \c Node and <tt>Arc/Edge</tt> types of this adaptor and the
-  /// adapted (di)graph are convertible to each other.
-#ifdef DOXYGEN
-  template<typename GR, typename NF>
-  class FilterNodes {
-#else
-  template<typename GR,
-           typename NF = typename GR::template NodeMap<bool>,
-           typename Enable = void>
-  class FilterNodes :
-    public DigraphAdaptorExtender<
-      SubDigraphBase<GR, NF, ConstMap<typename GR::Arc, Const<bool, true> >,
-                     true> > {
-#endif
-    typedef DigraphAdaptorExtender<
-      SubDigraphBase<GR, NF, ConstMap<typename GR::Arc, Const<bool, true> >,
-                     true> > Parent;
-
-  public:
-
-    typedef GR Digraph;
-    typedef NF NodeFilterMap;
-
-    typedef typename Parent::Node Node;
-
-  protected:
-    ConstMap<typename Digraph::Arc, Const<bool, true> > const_true_map;
-
-    FilterNodes() : const_true_map() {}
-
-  public:
-
-    /// \brief Constructor
-    ///
-    /// Creates a subgraph for the given digraph or graph with the
-    /// given node filter map.
-    FilterNodes(GR& graph, NF& node_filter)
-      : Parent(), const_true_map()
-    {
-      Parent::initialize(graph, node_filter, const_true_map);
-    }
-
-    /// \brief Sets the status of the given node
-    ///
-    /// This function sets the status of the given node.
-    /// It is done by simply setting the assigned value of \c n
-    /// to \c v in the node filter map.
-    void status(const Node& n, bool v) const { Parent::status(n, v); }
-
-    /// \brief Returns the status of the given node
-    ///
-    /// This function returns the status of the given node.
-    /// It is \c true if the given node is enabled (i.e. not hidden).
-    bool status(const Node& n) const { return Parent::status(n); }
-
-    /// \brief Disables the given node
-    ///
-    /// This function disables the given node, so the iteration
-    /// jumps over it.
-    /// It is the same as \ref status() "status(n, false)".
-    void disable(const Node& n) const { Parent::status(n, false); }
-
-    /// \brief Enables the given node
-    ///
-    /// This function enables the given node.
-    /// It is the same as \ref status() "status(n, true)".
-    void enable(const Node& n) const { Parent::status(n, true); }
-
-  };
-
-  template<typename GR, typename NF>
-  class FilterNodes<GR, NF,
-                    typename enable_if<UndirectedTagIndicator<GR> >::type> :
-    public GraphAdaptorExtender<
-      SubGraphBase<GR, NF, ConstMap<typename GR::Edge, Const<bool, true> >,
-                   true> > {
-
-    typedef GraphAdaptorExtender<
-      SubGraphBase<GR, NF, ConstMap<typename GR::Edge, Const<bool, true> >,
-                   true> > Parent;
-
-  public:
-
-    typedef GR Graph;
-    typedef NF NodeFilterMap;
-
-    typedef typename Parent::Node Node;
-
-  protected:
-    ConstMap<typename GR::Edge, Const<bool, true> > const_true_map;
-
-    FilterNodes() : const_true_map() {}
-
-  public:
-
-    FilterNodes(GR& graph, NodeFilterMap& node_filter) :
-      Parent(), const_true_map() {
-      Parent::initialize(graph, node_filter, const_true_map);
-    }
-
-    void status(const Node& n, bool v) const { Parent::status(n, v); }
-    bool status(const Node& n) const { return Parent::status(n); }
-    void disable(const Node& n) const { Parent::status(n, false); }
-    void enable(const Node& n) const { Parent::status(n, true); }
-
-  };
-
-
-  /// \brief Returns a read-only FilterNodes adaptor
-  ///
-  /// This function just returns a read-only \ref FilterNodes adaptor.
-  /// \ingroup graph_adaptors
-  /// \relates FilterNodes
-  template<typename GR, typename NF>
-  FilterNodes<const GR, NF>
-  filterNodes(const GR& graph, NF& node_filter) {
-    return FilterNodes<const GR, NF>(graph, node_filter);
-  }
-
-  template<typename GR, typename NF>
-  FilterNodes<const GR, const NF>
-  filterNodes(const GR& graph, const NF& node_filter) {
-    return FilterNodes<const GR, const NF>(graph, node_filter);
-  }
-
-  /// \ingroup graph_adaptors
-  ///
-  /// \brief Adaptor class for hiding arcs in a digraph.
-  ///
-  /// FilterArcs adaptor can be used for hiding arcs in a digraph.
-  /// A \c bool arc map must be specified, which defines the filter for
-  /// the arcs. Only the arcs with \c true filter value are shown in the
-  /// subdigraph. This adaptor conforms to the \ref concepts::Digraph
-  /// "Digraph" concept.
-  ///
-  /// The adapted digraph can also be modified through this adaptor
-  /// 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.
-  /// It must conform to the \ref concepts::Digraph "Digraph" concept.
-  /// It can also be specified to be \c const.
-  /// \tparam AF The type of the arc filter map.
-  /// It must be a \c bool (or convertible) arc map of the
-  /// adapted digraph. The default type is
-  /// \ref concepts::Digraph::ArcMap "DGR::ArcMap<bool>".
-  ///
-  /// \note The \c Node and \c Arc types of this adaptor and the adapted
-  /// digraph are convertible to each other.
-#ifdef DOXYGEN
-  template<typename DGR,
-           typename AF>
-  class FilterArcs {
-#else
-  template<typename DGR,
-           typename AF = typename DGR::template ArcMap<bool> >
-  class FilterArcs :
-    public DigraphAdaptorExtender<
-      SubDigraphBase<DGR, ConstMap<typename DGR::Node, Const<bool, true> >,
-                     AF, false> > {
-#endif
-    typedef DigraphAdaptorExtender<
-      SubDigraphBase<DGR, ConstMap<typename DGR::Node, Const<bool, true> >,
-                     AF, false> > Parent;
-
-  public:
-
-    /// The type of the adapted digraph.
-    typedef DGR Digraph;
-    /// The type of the arc filter map.
-    typedef AF ArcFilterMap;
-
-    typedef typename Parent::Arc Arc;
-
-  protected:
-    ConstMap<typename DGR::Node, Const<bool, true> > const_true_map;
-
-    FilterArcs() : const_true_map() {}
-
-  public:
-
-    /// \brief Constructor
-    ///
-    /// Creates a subdigraph for the given digraph with the given arc
-    /// filter map.
-    FilterArcs(DGR& digraph, ArcFilterMap& arc_filter)
-      : Parent(), const_true_map() {
-      Parent::initialize(digraph, const_true_map, arc_filter);
-    }
-
-    /// \brief Sets the status of the given arc
-    ///
-    /// This function sets the status of the given arc.
-    /// It is done by simply setting the assigned value of \c a
-    /// to \c v in the arc filter map.
-    void status(const Arc& a, bool v) const { Parent::status(a, v); }
-
-    /// \brief Returns the status of the given arc
-    ///
-    /// This function returns the status of the given arc.
-    /// It is \c true if the given arc is enabled (i.e. not hidden).
-    bool status(const Arc& a) const { return Parent::status(a); }
-
-    /// \brief Disables the given arc
-    ///
-    /// This function disables the given arc in the subdigraph,
-    /// so the iteration jumps over it.
-    /// It is the same as \ref status() "status(a, false)".
-    void disable(const Arc& a) const { Parent::status(a, false); }
-
-    /// \brief Enables the given arc
-    ///
-    /// This function enables the given arc in the subdigraph.
-    /// It is the same as \ref status() "status(a, true)".
-    void enable(const Arc& a) const { Parent::status(a, true); }
-
-  };
-
-  /// \brief Returns a read-only FilterArcs adaptor
-  ///
-  /// This function just returns a read-only \ref FilterArcs adaptor.
-  /// \ingroup graph_adaptors
-  /// \relates FilterArcs
-  template<typename DGR, typename AF>
-  FilterArcs<const DGR, AF>
-  filterArcs(const DGR& digraph, AF& arc_filter) {
-    return FilterArcs<const DGR, AF>(digraph, arc_filter);
-  }
-
-  template<typename DGR, typename AF>
-  FilterArcs<const DGR, const AF>
-  filterArcs(const DGR& digraph, const AF& arc_filter) {
-    return FilterArcs<const DGR, const AF>(digraph, arc_filter);
-  }
-
-  /// \ingroup graph_adaptors
-  ///
-  /// \brief Adaptor class for hiding edges in a graph.
-  ///
-  /// FilterEdges adaptor can be used for hiding edges in a graph.
-  /// A \c bool edge map must be specified, which defines the filter for
-  /// the edges. Only the edges with \c true filter value are shown in the
-  /// subgraph. This adaptor conforms to the \ref concepts::Graph
-  /// "Graph" concept.
-  ///
-  /// The adapted graph can also be modified through this adaptor
-  /// 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.
-  /// It must conform to the \ref concepts::Graph "Graph" concept.
-  /// It can also be specified to be \c const.
-  /// \tparam EF The type of the edge filter map.
-  /// It must be a \c bool (or convertible) edge map of the
-  /// adapted graph. The default type is
-  /// \ref concepts::Graph::EdgeMap "GR::EdgeMap<bool>".
-  ///
-  /// \note The \c Node, \c Edge and \c Arc types of this adaptor and the
-  /// adapted graph are convertible to each other.
-#ifdef DOXYGEN
-  template<typename GR,
-           typename EF>
-  class FilterEdges {
-#else
-  template<typename GR,
-           typename EF = typename GR::template EdgeMap<bool> >
-  class FilterEdges :
-    public GraphAdaptorExtender<
-      SubGraphBase<GR, ConstMap<typename GR::Node, Const<bool, true> >,
-                   EF, false> > {
-#endif
-    typedef GraphAdaptorExtender<
-      SubGraphBase<GR, ConstMap<typename GR::Node, Const<bool, true > >,
-                   EF, false> > Parent;
-
-  public:
-
-    /// The type of the adapted graph.
-    typedef GR Graph;
-    /// The type of the edge filter map.
-    typedef EF EdgeFilterMap;
-
-    typedef typename Parent::Edge Edge;
-
-  protected:
-    ConstMap<typename GR::Node, Const<bool, true> > const_true_map;
-
-    FilterEdges() : const_true_map(true) {
-      Parent::setNodeFilterMap(const_true_map);
-    }
-
-  public:
-
-    /// \brief Constructor
-    ///
-    /// Creates a subgraph for the given graph with the given edge
-    /// filter map.
-    FilterEdges(GR& graph, EF& edge_filter)
-      : Parent(), const_true_map() {
-      Parent::initialize(graph, const_true_map, edge_filter);
-    }
-
-    /// \brief Sets the status of the given edge
-    ///
-    /// This function sets the status of the given edge.
-    /// It is done by simply setting the assigned value of \c e
-    /// to \c v in the edge filter map.
-    void status(const Edge& e, bool v) const { Parent::status(e, v); }
-
-    /// \brief Returns the status of the given edge
-    ///
-    /// This function returns the status of the given edge.
-    /// It is \c true if the given edge is enabled (i.e. not hidden).
-    bool status(const Edge& e) const { return Parent::status(e); }
-
-    /// \brief Disables the given edge
-    ///
-    /// This function disables the given edge in the subgraph,
-    /// so the iteration jumps over it.
-    /// It is the same as \ref status() "status(e, false)".
-    void disable(const Edge& e) const { Parent::status(e, false); }
-
-    /// \brief Enables the given edge
-    ///
-    /// This function enables the given edge in the subgraph.
-    /// It is the same as \ref status() "status(e, true)".
-    void enable(const Edge& e) const { Parent::status(e, true); }
-
-  };
-
-  /// \brief Returns a read-only FilterEdges adaptor
-  ///
-  /// This function just returns a read-only \ref FilterEdges adaptor.
-  /// \ingroup graph_adaptors
-  /// \relates FilterEdges
-  template<typename GR, typename EF>
-  FilterEdges<const GR, EF>
-  filterEdges(const GR& graph, EF& edge_filter) {
-    return FilterEdges<const GR, EF>(graph, edge_filter);
-  }
-
-  template<typename GR, typename EF>
-  FilterEdges<const GR, const EF>
-  filterEdges(const GR& graph, const EF& edge_filter) {
-    return FilterEdges<const GR, const EF>(graph, edge_filter);
-  }
-
-
-  template <typename DGR>
-  class UndirectorBase {
-  public:
-    typedef DGR Digraph;
-    typedef UndirectorBase Adaptor;
-
-    typedef True UndirectedTag;
-
-    typedef typename Digraph::Arc Edge;
-    typedef typename Digraph::Node Node;
-
-    class Arc {
-      friend class UndirectorBase;
-    protected:
-      Edge _edge;
-      bool _forward;
-
-      Arc(const Edge& edge, bool forward)
-        : _edge(edge), _forward(forward) {}
-
-    public:
-      Arc() {}
-
-      Arc(Invalid) : _edge(INVALID), _forward(true) {}
-
-      operator const Edge&() const { return _edge; }
-
-      bool operator==(const Arc &other) const {
-        return _forward == other._forward && _edge == other._edge;
-      }
-      bool operator!=(const Arc &other) const {
-        return _forward != other._forward || _edge != other._edge;
-      }
-      bool operator<(const Arc &other) const {
-        return _forward < other._forward ||
-          (_forward == other._forward && _edge < other._edge);
-      }
-    };
-
-    void first(Node& n) const {
-      _digraph->first(n);
-    }
-
-    void next(Node& n) const {
-      _digraph->next(n);
-    }
-
-    void first(Arc& a) const {
-      _digraph->first(a._edge);
-      a._forward = true;
-    }
-
-    void next(Arc& a) const {
-      if (a._forward) {
-        a._forward = false;
-      } else {
-        _digraph->next(a._edge);
-        a._forward = true;
-      }
-    }
-
-    void first(Edge& e) const {
-      _digraph->first(e);
-    }
-
-    void next(Edge& e) const {
-      _digraph->next(e);
-    }
-
-    void firstOut(Arc& a, const Node& n) const {
-      _digraph->firstIn(a._edge, n);
-      if (a._edge != INVALID ) {
-        a._forward = false;
-      } else {
-        _digraph->firstOut(a._edge, n);
-        a._forward = true;
-      }
-    }
-    void nextOut(Arc &a) const {
-      if (!a._forward) {
-        Node n = _digraph->target(a._edge);
-        _digraph->nextIn(a._edge);
-        if (a._edge == INVALID) {
-          _digraph->firstOut(a._edge, n);
-          a._forward = true;
-        }
-      }
-      else {
-        _digraph->nextOut(a._edge);
-      }
-    }
-
-    void firstIn(Arc &a, const Node &n) const {
-      _digraph->firstOut(a._edge, n);
-      if (a._edge != INVALID ) {
-        a._forward = false;
-      } else {
-        _digraph->firstIn(a._edge, n);
-        a._forward = true;
-      }
-    }
-    void nextIn(Arc &a) const {
-      if (!a._forward) {
-        Node n = _digraph->source(a._edge);
-        _digraph->nextOut(a._edge);
-        if (a._edge == INVALID ) {
-          _digraph->firstIn(a._edge, n);
-          a._forward = true;
-        }
-      }
-      else {
-        _digraph->nextIn(a._edge);
-      }
-    }
-
-    void firstInc(Edge &e, bool &d, const Node &n) const {
-      d = true;
-      _digraph->firstOut(e, n);
-      if (e != INVALID) return;
-      d = false;
-      _digraph->firstIn(e, n);
-    }
-
-    void nextInc(Edge &e, bool &d) const {
-      if (d) {
-        Node s = _digraph->source(e);
-        _digraph->nextOut(e);
-        if (e != INVALID) return;
-        d = false;
-        _digraph->firstIn(e, s);
-      } else {
-        _digraph->nextIn(e);
-      }
-    }
-
-    Node u(const Edge& e) const {
-      return _digraph->source(e);
-    }
-
-    Node v(const Edge& e) const {
-      return _digraph->target(e);
-    }
-
-    Node source(const Arc &a) const {
-      return a._forward ? _digraph->source(a._edge) : _digraph->target(a._edge);
-    }
-
-    Node target(const Arc &a) const {
-      return a._forward ? _digraph->target(a._edge) : _digraph->source(a._edge);
-    }
-
-    static Arc direct(const Edge &e, bool d) {
-      return Arc(e, d);
-    }
-
-    static bool direction(const Arc &a) { return a._forward; }
-
-    Node nodeFromId(int ix) const { return _digraph->nodeFromId(ix); }
-    Arc arcFromId(int ix) const {
-      return direct(_digraph->arcFromId(ix >> 1), bool(ix & 1));
-    }
-    Edge edgeFromId(int ix) const { return _digraph->arcFromId(ix); }
-
-    int id(const Node &n) const { return _digraph->id(n); }
-    int id(const Arc &a) const {
-      return  (_digraph->id(a) << 1) | (a._forward ? 1 : 0);
-    }
-    int id(const Edge &e) const { return _digraph->id(e); }
-
-    int maxNodeId() const { return _digraph->maxNodeId(); }
-    int maxArcId() const { return (_digraph->maxArcId() << 1) | 1; }
-    int maxEdgeId() const { return _digraph->maxArcId(); }
-
-    Node addNode() { return _digraph->addNode(); }
-    Edge addEdge(const Node& u, const Node& v) {
-      return _digraph->addArc(u, v);
-    }
-
-    void erase(const Node& i) { _digraph->erase(i); }
-    void erase(const Edge& i) { _digraph->erase(i); }
-
-    void clear() { _digraph->clear(); }
-
-    typedef NodeNumTagIndicator<Digraph> NodeNumTag;
-    int nodeNum() const { return _digraph->nodeNum(); }
-
-    typedef ArcNumTagIndicator<Digraph> ArcNumTag;
-    int arcNum() const { return 2 * _digraph->arcNum(); }
-
-    typedef ArcNumTag EdgeNumTag;
-    int edgeNum() const { return _digraph->arcNum(); }
-
-    typedef FindArcTagIndicator<Digraph> FindArcTag;
-    Arc findArc(Node s, Node t, Arc p = INVALID) const {
-      if (p == INVALID) {
-        Edge arc = _digraph->findArc(s, t);
-        if (arc != INVALID) return direct(arc, true);
-        arc = _digraph->findArc(t, s);
-        if (arc != INVALID) return direct(arc, false);
-      } else if (direction(p)) {
-        Edge arc = _digraph->findArc(s, t, p);
-        if (arc != INVALID) return direct(arc, true);
-        arc = _digraph->findArc(t, s);
-        if (arc != INVALID) return direct(arc, false);
-      } else {
-        Edge arc = _digraph->findArc(t, s, p);
-        if (arc != INVALID) return direct(arc, false);
-      }
-      return INVALID;
-    }
-
-    typedef FindArcTag FindEdgeTag;
-    Edge findEdge(Node s, Node t, Edge p = INVALID) const {
-      if (s != t) {
-        if (p == INVALID) {
-          Edge arc = _digraph->findArc(s, t);
-          if (arc != INVALID) return arc;
-          arc = _digraph->findArc(t, s);
-          if (arc != INVALID) return arc;
-        } else if (_digraph->source(p) == s) {
-          Edge arc = _digraph->findArc(s, t, p);
-          if (arc != INVALID) return arc;
-          arc = _digraph->findArc(t, s);
-          if (arc != INVALID) return arc;
-        } else {
-          Edge arc = _digraph->findArc(t, s, p);
-          if (arc != INVALID) return arc;
-        }
-      } else {
-        return _digraph->findArc(s, t, p);
-      }
-      return INVALID;
-    }
-
-  private:
-
-    template <typename V>
-    class ArcMapBase {
-    private:
-
-      typedef typename DGR::template ArcMap<V> MapImpl;
-
-    public:
-
-      typedef typename MapTraits<MapImpl>::ReferenceMapTag ReferenceMapTag;
-
-      typedef V Value;
-      typedef Arc Key;
-      typedef typename MapTraits<MapImpl>::ConstReturnValue ConstReturnValue;
-      typedef typename MapTraits<MapImpl>::ReturnValue ReturnValue;
-      typedef typename MapTraits<MapImpl>::ConstReturnValue ConstReference;
-      typedef typename MapTraits<MapImpl>::ReturnValue Reference;
-
-      ArcMapBase(const UndirectorBase<DGR>& adaptor) :
-        _forward(*adaptor._digraph), _backward(*adaptor._digraph) {}
-
-      ArcMapBase(const UndirectorBase<DGR>& adaptor, const V& value)
-        : _forward(*adaptor._digraph, value),
-          _backward(*adaptor._digraph, value) {}
-
-      void set(const Arc& a, const V& value) {
-        if (direction(a)) {
-          _forward.set(a, value);
-        } else {
-          _backward.set(a, value);
-        }
-      }
-
-      ConstReturnValue operator[](const Arc& a) const {
-        if (direction(a)) {
-          return _forward[a];
-        } else {
-          return _backward[a];
-        }
-      }
-
-      ReturnValue operator[](const Arc& a) {
-        if (direction(a)) {
-          return _forward[a];
-        } else {
-          return _backward[a];
-        }
-      }
-
-    protected:
-
-      MapImpl _forward, _backward;
-
-    };
-
-  public:
-
-    template <typename V>
-    class NodeMap : public DGR::template NodeMap<V> {
-      typedef typename DGR::template NodeMap<V> Parent;
-
-    public:
-      typedef V Value;
-
-      explicit NodeMap(const UndirectorBase<DGR>& adaptor)
-        : Parent(*adaptor._digraph) {}
-
-      NodeMap(const UndirectorBase<DGR>& adaptor, const V& value)
-        : Parent(*adaptor._digraph, value) { }
-
-    private:
-      NodeMap& operator=(const NodeMap& cmap) {
-        return operator=<NodeMap>(cmap);
-      }
-
-      template <typename CMap>
-      NodeMap& operator=(const CMap& cmap) {
-        Parent::operator=(cmap);
-        return *this;
-      }
-
-    };
-
-    template <typename V>
-    class ArcMap
-      : public SubMapExtender<UndirectorBase<DGR>, ArcMapBase<V> > {
-      typedef SubMapExtender<UndirectorBase<DGR>, ArcMapBase<V> > Parent;
-
-    public:
-      typedef V Value;
-
-      explicit ArcMap(const UndirectorBase<DGR>& adaptor)
-        : Parent(adaptor) {}
-
-      ArcMap(const UndirectorBase<DGR>& adaptor, const V& value)
-        : Parent(adaptor, value) {}
-
-    private:
-      ArcMap& operator=(const ArcMap& cmap) {
-        return operator=<ArcMap>(cmap);
-      }
-
-      template <typename CMap>
-      ArcMap& operator=(const CMap& cmap) {
-        Parent::operator=(cmap);
-        return *this;
-      }
-    };
-
-    template <typename V>
-    class EdgeMap : public Digraph::template ArcMap<V> {
-      typedef typename Digraph::template ArcMap<V> Parent;
-
-    public:
-      typedef V Value;
-
-      explicit EdgeMap(const UndirectorBase<DGR>& adaptor)
-        : Parent(*adaptor._digraph) {}
-
-      EdgeMap(const UndirectorBase<DGR>& adaptor, const V& value)
-        : Parent(*adaptor._digraph, value) {}
-
-    private:
-      EdgeMap& operator=(const EdgeMap& cmap) {
-        return operator=<EdgeMap>(cmap);
-      }
-
-      template <typename CMap>
-      EdgeMap& operator=(const CMap& cmap) {
-        Parent::operator=(cmap);
-        return *this;
-      }
-
-    };
-
-    typedef typename ItemSetTraits<DGR, Node>::ItemNotifier NodeNotifier;
-    NodeNotifier& notifier(Node) const { return _digraph->notifier(Node()); }
-
-    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()); }
-
-  protected:
-
-    UndirectorBase() : _digraph(0) {}
-
-    DGR* _digraph;
-
-    void initialize(DGR& digraph) {
-      _digraph = &digraph;
-    }
-
-  };
-
-  /// \ingroup graph_adaptors
-  ///
-  /// \brief Adaptor class for viewing a digraph as an undirected graph.
-  ///
-  /// Undirector adaptor can be used for viewing a digraph as an undirected
-  /// graph. All arcs of the underlying digraph are showed in the
-  /// adaptor as an edge (and also as a pair of arcs, of course).
-  /// This adaptor conforms to the \ref concepts::Graph "Graph" concept.
-  ///
-  /// The adapted digraph can also be modified through this adaptor
-  /// 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.
-  /// It must conform to the \ref concepts::Digraph "Digraph" concept.
-  /// It can also be specified to be \c const.
-  ///
-  /// \note The \c Node type of this adaptor and the adapted digraph are
-  /// convertible to each other, moreover the \c Edge type of the adaptor
-  /// and the \c Arc type of the adapted digraph are also convertible to
-  /// each other.
-  /// (Thus the \c Arc type of the adaptor is convertible to the \c Arc type
-  /// of the adapted digraph.)
-  template<typename DGR>
-#ifdef DOXYGEN
-  class Undirector {
-#else
-  class Undirector :
-    public GraphAdaptorExtender<UndirectorBase<DGR> > {
-#endif
-    typedef GraphAdaptorExtender<UndirectorBase<DGR> > Parent;
-  public:
-    /// The type of the adapted digraph.
-    typedef DGR Digraph;
-  protected:
-    Undirector() { }
-  public:
-
-    /// \brief Constructor
-    ///
-    /// Creates an undirected graph from the given digraph.
-    Undirector(DGR& digraph) {
-      initialize(digraph);
-    }
-
-    /// \brief Arc map combined from two original arc maps
-    ///
-    /// This map adaptor class adapts two arc maps of the underlying
-    /// digraph to get an arc map of the undirected graph.
-    /// Its value type is inherited from the first arc map type (\c FW).
-    /// \tparam FW The type of the "foward" arc map.
-    /// \tparam BK The type of the "backward" arc map.
-    template <typename FW, typename BK>
-    class CombinedArcMap {
-    public:
-
-      /// The key type of the map
-      typedef typename Parent::Arc Key;
-      /// The value type of the map
-      typedef typename FW::Value Value;
-
-      typedef typename MapTraits<FW>::ReferenceMapTag ReferenceMapTag;
-
-      typedef typename MapTraits<FW>::ReturnValue ReturnValue;
-      typedef typename MapTraits<FW>::ConstReturnValue ConstReturnValue;
-      typedef typename MapTraits<FW>::ReturnValue Reference;
-      typedef typename MapTraits<FW>::ConstReturnValue ConstReference;
-
-      /// Constructor
-      CombinedArcMap(FW& forward, BK& backward)
-        : _forward(&forward), _backward(&backward) {}
-
-      /// Sets the value associated with the given key.
-      void set(const Key& e, const Value& a) {
-        if (Parent::direction(e)) {
-          _forward->set(e, a);
-        } else {
-          _backward->set(e, a);
-        }
-      }
-
-      /// Returns the value associated with the given key.
-      ConstReturnValue operator[](const Key& e) const {
-        if (Parent::direction(e)) {
-          return (*_forward)[e];
-        } else {
-          return (*_backward)[e];
-        }
-      }
-
-      /// Returns a reference to the value associated with the given key.
-      ReturnValue operator[](const Key& e) {
-        if (Parent::direction(e)) {
-          return (*_forward)[e];
-        } else {
-          return (*_backward)[e];
-        }
-      }
-
-    protected:
-
-      FW* _forward;
-      BK* _backward;
-
-    };
-
-    /// \brief Returns a combined arc map
-    ///
-    /// This function just returns a combined arc map.
-    template <typename FW, typename BK>
-    static CombinedArcMap<FW, BK>
-    combinedArcMap(FW& forward, BK& backward) {
-      return CombinedArcMap<FW, BK>(forward, backward);
-    }
-
-    template <typename FW, typename BK>
-    static CombinedArcMap<const FW, BK>
-    combinedArcMap(const FW& forward, BK& backward) {
-      return CombinedArcMap<const FW, BK>(forward, backward);
-    }
-
-    template <typename FW, typename BK>
-    static CombinedArcMap<FW, const BK>
-    combinedArcMap(FW& forward, const BK& backward) {
-      return CombinedArcMap<FW, const BK>(forward, backward);
-    }
-
-    template <typename FW, typename BK>
-    static CombinedArcMap<const FW, const BK>
-    combinedArcMap(const FW& forward, const BK& backward) {
-      return CombinedArcMap<const FW, const BK>(forward, backward);
-    }
-
-  };
-
-  /// \brief Returns a read-only Undirector adaptor
-  ///
-  /// This function just returns a read-only \ref Undirector adaptor.
-  /// \ingroup graph_adaptors
-  /// \relates Undirector
-  template<typename DGR>
-  Undirector<const DGR> undirector(const DGR& digraph) {
-    return Undirector<const DGR>(digraph);
-  }
-
-
-  template <typename GR, typename DM>
-  class OrienterBase {
-  public:
-
-    typedef GR Graph;
-    typedef DM DirectionMap;
-
-    typedef typename GR::Node Node;
-    typedef typename GR::Edge Arc;
-
-    void reverseArc(const Arc& arc) {
-      _direction->set(arc, !(*_direction)[arc]);
-    }
-
-    void first(Node& i) const { _graph->first(i); }
-    void first(Arc& i) const { _graph->first(i); }
-    void firstIn(Arc& i, const Node& n) const {
-      bool d = true;
-      _graph->firstInc(i, d, n);
-      while (i != INVALID && d == (*_direction)[i]) _graph->nextInc(i, d);
-    }
-    void firstOut(Arc& i, const Node& n ) const {
-      bool d = true;
-      _graph->firstInc(i, d, n);
-      while (i != INVALID && d != (*_direction)[i]) _graph->nextInc(i, d);
-    }
-
-    void next(Node& i) const { _graph->next(i); }
-    void next(Arc& i) const { _graph->next(i); }
-    void nextIn(Arc& i) const {
-      bool d = !(*_direction)[i];
-      _graph->nextInc(i, d);
-      while (i != INVALID && d == (*_direction)[i]) _graph->nextInc(i, d);
-    }
-    void nextOut(Arc& i) const {
-      bool d = (*_direction)[i];
-      _graph->nextInc(i, d);
-      while (i != INVALID && d != (*_direction)[i]) _graph->nextInc(i, d);
-    }
-
-    Node source(const Arc& e) const {
-      return (*_direction)[e] ? _graph->u(e) : _graph->v(e);
-    }
-    Node target(const Arc& e) const {
-      return (*_direction)[e] ? _graph->v(e) : _graph->u(e);
-    }
-
-    typedef NodeNumTagIndicator<Graph> NodeNumTag;
-    int nodeNum() const { return _graph->nodeNum(); }
-
-    typedef EdgeNumTagIndicator<Graph> ArcNumTag;
-    int arcNum() const { return _graph->edgeNum(); }
-
-    typedef FindEdgeTagIndicator<Graph> FindArcTag;
-    Arc findArc(const Node& u, const Node& v,
-                const Arc& prev = INVALID) const {
-      Arc arc = _graph->findEdge(u, v, prev);
-      while (arc != INVALID && source(arc) != u) {
-        arc = _graph->findEdge(u, v, arc);
-      }
-      return arc;
-    }
-
-    Node addNode() {
-      return Node(_graph->addNode());
-    }
-
-    Arc addArc(const Node& u, const Node& v) {
-      Arc arc = _graph->addEdge(u, v);
-      _direction->set(arc, _graph->u(arc) == u);
-      return arc;
-    }
-
-    void erase(const Node& i) { _graph->erase(i); }
-    void erase(const Arc& i) { _graph->erase(i); }
-
-    void clear() { _graph->clear(); }
-
-    int id(const Node& v) const { return _graph->id(v); }
-    int id(const Arc& e) const { return _graph->id(e); }
-
-    Node nodeFromId(int idx) const { return _graph->nodeFromId(idx); }
-    Arc arcFromId(int idx) const { return _graph->edgeFromId(idx); }
-
-    int maxNodeId() const { return _graph->maxNodeId(); }
-    int maxArcId() const { return _graph->maxEdgeId(); }
-
-    typedef typename ItemSetTraits<GR, Node>::ItemNotifier NodeNotifier;
-    NodeNotifier& notifier(Node) const { return _graph->notifier(Node()); }
-
-    typedef typename ItemSetTraits<GR, Arc>::ItemNotifier ArcNotifier;
-    ArcNotifier& notifier(Arc) const { return _graph->notifier(Arc()); }
-
-    template <typename V>
-    class NodeMap : public GR::template NodeMap<V> {
-      typedef typename GR::template NodeMap<V> Parent;
-
-    public:
-
-      explicit NodeMap(const OrienterBase<GR, DM>& adapter)
-        : Parent(*adapter._graph) {}
-
-      NodeMap(const OrienterBase<GR, DM>& adapter, const V& value)
-        : Parent(*adapter._graph, value) {}
-
-    private:
-      NodeMap& operator=(const NodeMap& cmap) {
-        return operator=<NodeMap>(cmap);
-      }
-
-      template <typename CMap>
-      NodeMap& operator=(const CMap& cmap) {
-        Parent::operator=(cmap);
-        return *this;
-      }
-
-    };
-
-    template <typename V>
-    class ArcMap : public GR::template EdgeMap<V> {
-      typedef typename Graph::template EdgeMap<V> Parent;
-
-    public:
-
-      explicit ArcMap(const OrienterBase<GR, DM>& adapter)
-        : Parent(*adapter._graph) { }
-
-      ArcMap(const OrienterBase<GR, DM>& adapter, const V& value)
-        : Parent(*adapter._graph, value) { }
-
-    private:
-      ArcMap& operator=(const ArcMap& cmap) {
-        return operator=<ArcMap>(cmap);
-      }
-
-      template <typename CMap>
-      ArcMap& operator=(const CMap& cmap) {
-        Parent::operator=(cmap);
-        return *this;
-      }
-    };
-
-
-
-  protected:
-    Graph* _graph;
-    DM* _direction;
-
-    void initialize(GR& graph, DM& direction) {
-      _graph = &graph;
-      _direction = &direction;
-    }
-
-  };
-
-  /// \ingroup graph_adaptors
-  ///
-  /// \brief Adaptor class for orienting the edges of a graph to get a digraph
-  ///
-  /// Orienter adaptor can be used for orienting the edges of a graph to
-  /// get a digraph. A \c bool edge map of the underlying graph must be
-  /// specified, which define the direction of the arcs in the adaptor.
-  /// The arcs can be easily reversed by the \c reverseArc() member function
-  /// of the adaptor.
-  /// This class conforms to the \ref concepts::Digraph "Digraph" concept.
-  ///
-  /// The adapted graph can also be modified through this adaptor
-  /// 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.
-  /// It must conform to the \ref concepts::Graph "Graph" concept.
-  /// It can also be specified to be \c const.
-  /// \tparam DM The type of the direction map.
-  /// It must be a \c bool (or convertible) edge map of the
-  /// adapted graph. The default type is
-  /// \ref concepts::Graph::EdgeMap "GR::EdgeMap<bool>".
-  ///
-  /// \note The \c Node type of this adaptor and the adapted graph are
-  /// convertible to each other, moreover the \c Arc type of the adaptor
-  /// and the \c Edge type of the adapted graph are also convertible to
-  /// each other.
-#ifdef DOXYGEN
-  template<typename GR,
-           typename DM>
-  class Orienter {
-#else
-  template<typename GR,
-           typename DM = typename GR::template EdgeMap<bool> >
-  class Orienter :
-    public DigraphAdaptorExtender<OrienterBase<GR, DM> > {
-#endif
-    typedef DigraphAdaptorExtender<OrienterBase<GR, DM> > Parent;
-  public:
-
-    /// The type of the adapted graph.
-    typedef GR Graph;
-    /// The type of the direction edge map.
-    typedef DM DirectionMap;
-
-    typedef typename Parent::Arc Arc;
-
-  protected:
-    Orienter() { }
-
-  public:
-
-    /// \brief Constructor
-    ///
-    /// Constructor of the adaptor.
-    Orienter(GR& graph, DM& direction) {
-      Parent::initialize(graph, direction);
-    }
-
-    /// \brief Reverses the given arc
-    ///
-    /// This function reverses the given arc.
-    /// It is done by simply negate the assigned value of \c a
-    /// in the direction map.
-    void reverseArc(const Arc& a) {
-      Parent::reverseArc(a);
-    }
-  };
-
-  /// \brief Returns a read-only Orienter adaptor
-  ///
-  /// This function just returns a read-only \ref Orienter adaptor.
-  /// \ingroup graph_adaptors
-  /// \relates Orienter
-  template<typename GR, typename DM>
-  Orienter<const GR, DM>
-  orienter(const GR& graph, DM& direction) {
-    return Orienter<const GR, DM>(graph, direction);
-  }
-
-  template<typename GR, typename DM>
-  Orienter<const GR, const DM>
-  orienter(const GR& graph, const DM& direction) {
-    return Orienter<const GR, const DM>(graph, direction);
-  }
-
-  namespace _adaptor_bits {
-
-    template <typename DGR, typename CM, typename FM, typename TL>
-    class ResForwardFilter {
-    public:
-
-      typedef typename DGR::Arc Key;
-      typedef bool Value;
-
-    private:
-
-      const CM* _capacity;
-      const FM* _flow;
-      TL _tolerance;
-
-    public:
-
-      ResForwardFilter(const CM& capacity, const FM& flow,
-                       const TL& tolerance = TL())
-        : _capacity(&capacity), _flow(&flow), _tolerance(tolerance) { }
-
-      bool operator[](const typename DGR::Arc& a) const {
-        return _tolerance.positive((*_capacity)[a] - (*_flow)[a]);
-      }
-    };
-
-    template<typename DGR,typename CM, typename FM, typename TL>
-    class ResBackwardFilter {
-    public:
-
-      typedef typename DGR::Arc Key;
-      typedef bool Value;
-
-    private:
-
-      const CM* _capacity;
-      const FM* _flow;
-      TL _tolerance;
-
-    public:
-
-      ResBackwardFilter(const CM& capacity, const FM& flow,
-                        const TL& tolerance = TL())
-        : _capacity(&capacity), _flow(&flow), _tolerance(tolerance) { }
-
-      bool operator[](const typename DGR::Arc& a) const {
-        return _tolerance.positive((*_flow)[a]);
-      }
-    };
-
-  }
-
-  /// \ingroup graph_adaptors
-  ///
-  /// \brief Adaptor class for composing the residual digraph for directed
-  /// flow and circulation problems.
-  ///
-  /// ResidualDigraph can be used for composing the \e residual digraph
-  /// for directed flow and circulation problems. Let \f$ G=(V, A) \f$
-  /// be a directed graph and let \f$ F \f$ be a number type.
-  /// Let \f$ flow, cap: A\to F \f$ be functions on the arcs.
-  /// This adaptor implements a digraph structure with node set \f$ V \f$
-  /// and arc set \f$ A_{forward}\cup A_{backward} \f$,
-  /// where \f$ A_{forward}=\{uv : uv\in A, flow(uv)<cap(uv)\} \f$ and
-  /// \f$ A_{backward}=\{vu : uv\in A, flow(uv)>0\} \f$, i.e. the so
-  /// called residual digraph.
-  /// When the union \f$ A_{forward}\cup A_{backward} \f$ is taken,
-  /// multiplicities are counted, i.e. the adaptor has exactly
-  /// \f$ |A_{forward}| + |A_{backward}|\f$ arcs (it may have parallel
-  /// arcs).
-  /// 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.
-  /// It is implicitly \c const.
-  /// \tparam CM The type of the capacity map.
-  /// It must be an arc map of some numerical type, which defines
-  /// the capacities in the flow problem. It is implicitly \c const.
-  /// The default type is
-  /// \ref concepts::Digraph::ArcMap "GR::ArcMap<int>".
-  /// \tparam FM The type of the flow map.
-  /// It must be an arc map of some numerical type, which defines
-  /// the flow values in the flow problem. The default type is \c CM.
-  /// \tparam TL The tolerance type for handling inexact computation.
-  /// The default tolerance type depends on the value type of the
-  /// capacity map.
-  ///
-  /// \note This adaptor is implemented using Undirector and FilterArcs
-  /// adaptors.
-  ///
-  /// \note The \c Node type of this adaptor and the adapted digraph are
-  /// convertible to each other, moreover the \c Arc type of the adaptor
-  /// is convertible to the \c Arc type of the adapted digraph.
-#ifdef DOXYGEN
-  template<typename DGR, typename CM, typename FM, typename TL>
-  class ResidualDigraph
-#else
-  template<typename DGR,
-           typename CM = typename DGR::template ArcMap<int>,
-           typename FM = CM,
-           typename TL = Tolerance<typename CM::Value> >
-  class ResidualDigraph
-    : public SubDigraph<
-        Undirector<const DGR>,
-        ConstMap<typename DGR::Node, Const<bool, true> >,
-        typename Undirector<const DGR>::template CombinedArcMap<
-          _adaptor_bits::ResForwardFilter<const DGR, CM, FM, TL>,
-          _adaptor_bits::ResBackwardFilter<const DGR, CM, FM, TL> > >
-#endif
-  {
-  public:
-
-    /// The type of the underlying digraph.
-    typedef DGR Digraph;
-    /// The type of the capacity map.
-    typedef CM CapacityMap;
-    /// The type of the flow map.
-    typedef FM FlowMap;
-    /// The tolerance type.
-    typedef TL Tolerance;
-
-    typedef typename CapacityMap::Value Value;
-    typedef ResidualDigraph Adaptor;
-
-  protected:
-
-    typedef Undirector<const Digraph> Undirected;
-
-    typedef ConstMap<typename DGR::Node, Const<bool, true> > NodeFilter;
-
-    typedef _adaptor_bits::ResForwardFilter<const DGR, CM,
-                                            FM, TL> ForwardFilter;
-
-    typedef _adaptor_bits::ResBackwardFilter<const DGR, CM,
-                                             FM, TL> BackwardFilter;
-
-    typedef typename Undirected::
-      template CombinedArcMap<ForwardFilter, BackwardFilter> ArcFilter;
-
-    typedef SubDigraph<Undirected, NodeFilter, ArcFilter> Parent;
-
-    const CapacityMap* _capacity;
-    FlowMap* _flow;
-
-    Undirected _graph;
-    NodeFilter _node_filter;
-    ForwardFilter _forward_filter;
-    BackwardFilter _backward_filter;
-    ArcFilter _arc_filter;
-
-  public:
-
-    /// \brief Constructor
-    ///
-    /// Constructor of the residual digraph adaptor. The parameters are the
-    /// digraph, the capacity map, the flow map, and a tolerance object.
-    ResidualDigraph(const DGR& digraph, const CM& capacity,
-                    FM& flow, const TL& tolerance = Tolerance())
-      : Parent(), _capacity(&capacity), _flow(&flow),
-        _graph(digraph), _node_filter(),
-        _forward_filter(capacity, flow, tolerance),
-        _backward_filter(capacity, flow, tolerance),
-        _arc_filter(_forward_filter, _backward_filter)
-    {
-      Parent::initialize(_graph, _node_filter, _arc_filter);
-    }
-
-    typedef typename Parent::Arc Arc;
-
-    /// \brief Returns the residual capacity of the given arc.
-    ///
-    /// Returns the residual capacity of the given arc.
-    Value residualCapacity(const Arc& a) const {
-      if (Undirected::direction(a)) {
-        return (*_capacity)[a] - (*_flow)[a];
-      } else {
-        return (*_flow)[a];
-      }
-    }
-
-    /// \brief Augments on the given arc in the residual digraph.
-    ///
-    /// Augments on the given arc in the residual digraph. It increases
-    /// or decreases the flow value on the original arc according to the
-    /// direction of the residual arc.
-    void augment(const Arc& a, const Value& v) const {
-      if (Undirected::direction(a)) {
-        _flow->set(a, (*_flow)[a] + v);
-      } else {
-        _flow->set(a, (*_flow)[a] - v);
-      }
-    }
-
-    /// \brief Returns \c true if the given residual arc is a forward arc.
-    ///
-    /// Returns \c true if the given residual arc has the same orientation
-    /// as the original arc, i.e. it is a so called forward arc.
-    static bool forward(const Arc& a) {
-      return Undirected::direction(a);
-    }
-
-    /// \brief Returns \c true if the given residual arc is a backward arc.
-    ///
-    /// Returns \c true if the given residual arc has the opposite orientation
-    /// than the original arc, i.e. it is a so called backward arc.
-    static bool backward(const Arc& a) {
-      return !Undirected::direction(a);
-    }
-
-    /// \brief Returns the forward oriented residual arc.
-    ///
-    /// Returns the forward oriented residual arc related to the given
-    /// arc of the underlying digraph.
-    static Arc forward(const typename Digraph::Arc& a) {
-      return Undirected::direct(a, true);
-    }
-
-    /// \brief Returns the backward oriented residual arc.
-    ///
-    /// Returns the backward oriented residual arc related to the given
-    /// arc of the underlying digraph.
-    static Arc backward(const typename Digraph::Arc& a) {
-      return Undirected::direct(a, false);
-    }
-
-    /// \brief Residual capacity map.
-    ///
-    /// This map adaptor class can be used for obtaining the residual
-    /// capacities as an arc map of the residual digraph.
-    /// Its value type is inherited from the capacity map.
-    class ResidualCapacity {
-    protected:
-      const Adaptor* _adaptor;
-    public:
-      /// The key type of the map
-      typedef Arc Key;
-      /// The value type of the map
-      typedef typename CapacityMap::Value Value;
-
-      /// Constructor
-      ResidualCapacity(const ResidualDigraph<DGR, CM, FM, TL>& adaptor)
-        : _adaptor(&adaptor) {}
-
-      /// Returns the value associated with the given residual arc
-      Value operator[](const Arc& a) const {
-        return _adaptor->residualCapacity(a);
-      }
-
-    };
-
-    /// \brief Returns a residual capacity map
-    ///
-    /// This function just returns a residual capacity map.
-    ResidualCapacity residualCapacity() const {
-      return ResidualCapacity(*this);
-    }
-
-  };
-
-  /// \brief Returns a (read-only) Residual adaptor
-  ///
-  /// This function just returns a (read-only) \ref ResidualDigraph adaptor.
-  /// \ingroup graph_adaptors
-  /// \relates ResidualDigraph
-    template<typename DGR, typename CM, typename FM>
-  ResidualDigraph<DGR, CM, FM>
-  residualDigraph(const DGR& digraph, const CM& capacity_map, FM& flow_map) {
-    return ResidualDigraph<DGR, CM, FM> (digraph, capacity_map, flow_map);
-  }
-
-
-  template <typename DGR>
-  class SplitNodesBase {
-    typedef DigraphAdaptorBase<const DGR> Parent;
-
-  public:
-
-    typedef DGR Digraph;
-    typedef SplitNodesBase Adaptor;
-
-    typedef typename DGR::Node DigraphNode;
-    typedef typename DGR::Arc DigraphArc;
-
-    class Node;
-    class Arc;
-
-  private:
-
-    template <typename T> class NodeMapBase;
-    template <typename T> class ArcMapBase;
-
-  public:
-
-    class Node : public DigraphNode {
-      friend class SplitNodesBase;
-      template <typename T> friend class NodeMapBase;
-    private:
-
-      bool _in;
-      Node(DigraphNode node, bool in)
-        : DigraphNode(node), _in(in) {}
-
-    public:
-
-      Node() {}
-      Node(Invalid) : DigraphNode(INVALID), _in(true) {}
-
-      bool operator==(const Node& node) const {
-        return DigraphNode::operator==(node) && _in == node._in;
-      }
-
-      bool operator!=(const Node& node) const {
-        return !(*this == node);
-      }
-
-      bool operator<(const Node& node) const {
-        return DigraphNode::operator<(node) ||
-          (DigraphNode::operator==(node) && _in < node._in);
-      }
-    };
-
-    class Arc {
-      friend class SplitNodesBase;
-      template <typename T> friend class ArcMapBase;
-    private:
-      typedef BiVariant<DigraphArc, DigraphNode> ArcImpl;
-
-      explicit Arc(const DigraphArc& arc) : _item(arc) {}
-      explicit Arc(const DigraphNode& node) : _item(node) {}
-
-      ArcImpl _item;
-
-    public:
-      Arc() {}
-      Arc(Invalid) : _item(DigraphArc(INVALID)) {}
-
-      bool operator==(const Arc& arc) const {
-        if (_item.firstState()) {
-          if (arc._item.firstState()) {
-            return _item.first() == arc._item.first();
-          }
-        } else {
-          if (arc._item.secondState()) {
-            return _item.second() == arc._item.second();
-          }
-        }
-        return false;
-      }
-
-      bool operator!=(const Arc& arc) const {
-        return !(*this == arc);
-      }
-
-      bool operator<(const Arc& arc) const {
-        if (_item.firstState()) {
-          if (arc._item.firstState()) {
-            return _item.first() < arc._item.first();
-          }
-          return false;
-        } else {
-          if (arc._item.secondState()) {
-            return _item.second() < arc._item.second();
-          }
-          return true;
-        }
-      }
-
-      operator DigraphArc() const { return _item.first(); }
-      operator DigraphNode() const { return _item.second(); }
-
-    };
-
-    void first(Node& n) const {
-      _digraph->first(n);
-      n._in = true;
-    }
-
-    void next(Node& n) const {
-      if (n._in) {
-        n._in = false;
-      } else {
-        n._in = true;
-        _digraph->next(n);
-      }
-    }
-
-    void first(Arc& e) const {
-      e._item.setSecond();
-      _digraph->first(e._item.second());
-      if (e._item.second() == INVALID) {
-        e._item.setFirst();
-        _digraph->first(e._item.first());
-      }
-    }
-
-    void next(Arc& e) const {
-      if (e._item.secondState()) {
-        _digraph->next(e._item.second());
-        if (e._item.second() == INVALID) {
-          e._item.setFirst();
-          _digraph->first(e._item.first());
-        }
-      } else {
-        _digraph->next(e._item.first());
-      }
-    }
-
-    void firstOut(Arc& e, const Node& n) const {
-      if (n._in) {
-        e._item.setSecond(n);
-      } else {
-        e._item.setFirst();
-        _digraph->firstOut(e._item.first(), n);
-      }
-    }
-
-    void nextOut(Arc& e) const {
-      if (!e._item.firstState()) {
-        e._item.setFirst(INVALID);
-      } else {
-        _digraph->nextOut(e._item.first());
-      }
-    }
-
-    void firstIn(Arc& e, const Node& n) const {
-      if (!n._in) {
-        e._item.setSecond(n);
-      } else {
-        e._item.setFirst();
-        _digraph->firstIn(e._item.first(), n);
-      }
-    }
-
-    void nextIn(Arc& e) const {
-      if (!e._item.firstState()) {
-        e._item.setFirst(INVALID);
-      } else {
-        _digraph->nextIn(e._item.first());
-      }
-    }
-
-    Node source(const Arc& e) const {
-      if (e._item.firstState()) {
-        return Node(_digraph->source(e._item.first()), false);
-      } else {
-        return Node(e._item.second(), true);
-      }
-    }
-
-    Node target(const Arc& e) const {
-      if (e._item.firstState()) {
-        return Node(_digraph->target(e._item.first()), true);
-      } else {
-        return Node(e._item.second(), false);
-      }
-    }
-
-    int id(const Node& n) const {
-      return (_digraph->id(n) << 1) | (n._in ? 0 : 1);
-    }
-    Node nodeFromId(int ix) const {
-      return Node(_digraph->nodeFromId(ix >> 1), (ix & 1) == 0);
-    }
-    int maxNodeId() const {
-      return 2 * _digraph->maxNodeId() + 1;
-    }
-
-    int id(const Arc& e) const {
-      if (e._item.firstState()) {
-        return _digraph->id(e._item.first()) << 1;
-      } else {
-        return (_digraph->id(e._item.second()) << 1) | 1;
-      }
-    }
-    Arc arcFromId(int ix) const {
-      if ((ix & 1) == 0) {
-        return Arc(_digraph->arcFromId(ix >> 1));
-      } else {
-        return Arc(_digraph->nodeFromId(ix >> 1));
-      }
-    }
-    int maxArcId() const {
-      return std::max(_digraph->maxNodeId() << 1,
-                      (_digraph->maxArcId() << 1) | 1);
-    }
-
-    static bool inNode(const Node& n) {
-      return n._in;
-    }
-
-    static bool outNode(const Node& n) {
-      return !n._in;
-    }
-
-    static bool origArc(const Arc& e) {
-      return e._item.firstState();
-    }
-
-    static bool bindArc(const Arc& e) {
-      return e._item.secondState();
-    }
-
-    static Node inNode(const DigraphNode& n) {
-      return Node(n, true);
-    }
-
-    static Node outNode(const DigraphNode& n) {
-      return Node(n, false);
-    }
-
-    static Arc arc(const DigraphNode& n) {
-      return Arc(n);
-    }
-
-    static Arc arc(const DigraphArc& e) {
-      return Arc(e);
-    }
-
-    typedef True NodeNumTag;
-    int nodeNum() const {
-      return  2 * countNodes(*_digraph);
-    }
-
-    typedef True ArcNumTag;
-    int arcNum() const {
-      return countArcs(*_digraph) + countNodes(*_digraph);
-    }
-
-    typedef True FindArcTag;
-    Arc findArc(const Node& u, const Node& v,
-                const Arc& prev = INVALID) const {
-      if (inNode(u) && outNode(v)) {
-        if (static_cast<const DigraphNode&>(u) ==
-            static_cast<const DigraphNode&>(v) && prev == INVALID) {
-          return Arc(u);
-        }
-      }
-      else if (outNode(u) && inNode(v)) {
-        return Arc(::lemon::findArc(*_digraph, u, v, prev));
-      }
-      return INVALID;
-    }
-
-  private:
-
-    template <typename V>
-    class NodeMapBase
-      : public MapTraits<typename Parent::template NodeMap<V> > {
-      typedef typename Parent::template NodeMap<V> NodeImpl;
-    public:
-      typedef Node Key;
-      typedef V Value;
-      typedef typename MapTraits<NodeImpl>::ReferenceMapTag ReferenceMapTag;
-      typedef typename MapTraits<NodeImpl>::ReturnValue ReturnValue;
-      typedef typename MapTraits<NodeImpl>::ConstReturnValue ConstReturnValue;
-      typedef typename MapTraits<NodeImpl>::ReturnValue Reference;
-      typedef typename MapTraits<NodeImpl>::ConstReturnValue ConstReference;
-
-      NodeMapBase(const SplitNodesBase<DGR>& adaptor)
-        : _in_map(*adaptor._digraph), _out_map(*adaptor._digraph) {}
-      NodeMapBase(const SplitNodesBase<DGR>& adaptor, const V& value)
-        : _in_map(*adaptor._digraph, value),
-          _out_map(*adaptor._digraph, value) {}
-
-      void set(const Node& key, const V& val) {
-        if (SplitNodesBase<DGR>::inNode(key)) { _in_map.set(key, val); }
-        else {_out_map.set(key, val); }
-      }
-
-      ReturnValue operator[](const Node& key) {
-        if (SplitNodesBase<DGR>::inNode(key)) { return _in_map[key]; }
-        else { return _out_map[key]; }
-      }
-
-      ConstReturnValue operator[](const Node& key) const {
-        if (Adaptor::inNode(key)) { return _in_map[key]; }
-        else { return _out_map[key]; }
-      }
-
-    private:
-      NodeImpl _in_map, _out_map;
-    };
-
-    template <typename V>
-    class ArcMapBase
-      : public MapTraits<typename Parent::template ArcMap<V> > {
-      typedef typename Parent::template ArcMap<V> ArcImpl;
-      typedef typename Parent::template NodeMap<V> NodeImpl;
-    public:
-      typedef Arc Key;
-      typedef V Value;
-      typedef typename MapTraits<ArcImpl>::ReferenceMapTag ReferenceMapTag;
-      typedef typename MapTraits<ArcImpl>::ReturnValue ReturnValue;
-      typedef typename MapTraits<ArcImpl>::ConstReturnValue ConstReturnValue;
-      typedef typename MapTraits<ArcImpl>::ReturnValue Reference;
-      typedef typename MapTraits<ArcImpl>::ConstReturnValue ConstReference;
-
-      ArcMapBase(const SplitNodesBase<DGR>& adaptor)
-        : _arc_map(*adaptor._digraph), _node_map(*adaptor._digraph) {}
-      ArcMapBase(const SplitNodesBase<DGR>& adaptor, const V& value)
-        : _arc_map(*adaptor._digraph, value),
-          _node_map(*adaptor._digraph, value) {}
-
-      void set(const Arc& key, const V& val) {
-        if (SplitNodesBase<DGR>::origArc(key)) {
-          _arc_map.set(static_cast<const DigraphArc&>(key), val);
-        } else {
-          _node_map.set(static_cast<const DigraphNode&>(key), val);
-        }
-      }
-
-      ReturnValue operator[](const Arc& key) {
-        if (SplitNodesBase<DGR>::origArc(key)) {
-          return _arc_map[static_cast<const DigraphArc&>(key)];
-        } else {
-          return _node_map[static_cast<const DigraphNode&>(key)];
-        }
-      }
-
-      ConstReturnValue operator[](const Arc& key) const {
-        if (SplitNodesBase<DGR>::origArc(key)) {
-          return _arc_map[static_cast<const DigraphArc&>(key)];
-        } else {
-          return _node_map[static_cast<const DigraphNode&>(key)];
-        }
-      }
-
-    private:
-      ArcImpl _arc_map;
-      NodeImpl _node_map;
-    };
-
-  public:
-
-    template <typename V>
-    class NodeMap
-      : public SubMapExtender<SplitNodesBase<DGR>, NodeMapBase<V> > {
-      typedef SubMapExtender<SplitNodesBase<DGR>, NodeMapBase<V> > Parent;
-
-    public:
-      typedef V Value;
-
-      NodeMap(const SplitNodesBase<DGR>& adaptor)
-        : Parent(adaptor) {}
-
-      NodeMap(const SplitNodesBase<DGR>& adaptor, const V& value)
-        : Parent(adaptor, value) {}
-
-    private:
-      NodeMap& operator=(const NodeMap& cmap) {
-        return operator=<NodeMap>(cmap);
-      }
-
-      template <typename CMap>
-      NodeMap& operator=(const CMap& cmap) {
-        Parent::operator=(cmap);
-        return *this;
-      }
-    };
-
-    template <typename V>
-    class ArcMap
-      : public SubMapExtender<SplitNodesBase<DGR>, ArcMapBase<V> > {
-      typedef SubMapExtender<SplitNodesBase<DGR>, ArcMapBase<V> > Parent;
-
-    public:
-      typedef V Value;
-
-      ArcMap(const SplitNodesBase<DGR>& adaptor)
-        : Parent(adaptor) {}
-
-      ArcMap(const SplitNodesBase<DGR>& adaptor, const V& value)
-        : Parent(adaptor, value) {}
-
-    private:
-      ArcMap& operator=(const ArcMap& cmap) {
-        return operator=<ArcMap>(cmap);
-      }
-
-      template <typename CMap>
-      ArcMap& operator=(const CMap& cmap) {
-        Parent::operator=(cmap);
-        return *this;
-      }
-    };
-
-  protected:
-
-    SplitNodesBase() : _digraph(0) {}
-
-    DGR* _digraph;
-
-    void initialize(Digraph& digraph) {
-      _digraph = &digraph;
-    }
-
-  };
-
-  /// \ingroup graph_adaptors
-  ///
-  /// \brief Adaptor class for splitting the nodes of a digraph.
-  ///
-  /// SplitNodes adaptor can be used for splitting each node into an
-  /// \e in-node and an \e out-node in a digraph. Formaly, the adaptor
-  /// replaces each node \f$ u \f$ in the digraph with two nodes,
-  /// namely node \f$ u_{in} \f$ and node \f$ u_{out} \f$.
-  /// If there is a \f$ (v, u) \f$ arc in the original digraph, then the
-  /// new target of the arc will be \f$ u_{in} \f$ and similarly the
-  /// source of each original \f$ (u, v) \f$ arc will be \f$ u_{out} \f$.
-  /// The adaptor adds an additional \e bind \e arc from \f$ u_{in} \f$
-  /// to \f$ u_{out} \f$ for each node \f$ u \f$ of the original digraph.
-  ///
-  /// The aim of this class is running an algorithm with respect to node
-  /// costs or capacities if the algorithm considers only arc costs or
-  /// capacities directly.
-  /// In this case you can use \c SplitNodes adaptor, and set the node
-  /// costs/capacities of the original digraph to the \e bind \e arcs
-  /// 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.
-  /// It is implicitly \c const.
-  ///
-  /// \note The \c Node type of this adaptor is converible to the \c Node
-  /// type of the adapted digraph.
-  template <typename DGR>
-#ifdef DOXYGEN
-  class SplitNodes {
-#else
-  class SplitNodes
-    : public DigraphAdaptorExtender<SplitNodesBase<const DGR> > {
-#endif
-    typedef DigraphAdaptorExtender<SplitNodesBase<const DGR> > Parent;
-
-  public:
-    typedef DGR Digraph;
-
-    typedef typename DGR::Node DigraphNode;
-    typedef typename DGR::Arc DigraphArc;
-
-    typedef typename Parent::Node Node;
-    typedef typename Parent::Arc Arc;
-
-    /// \brief Constructor
-    ///
-    /// Constructor of the adaptor.
-    SplitNodes(const DGR& g) {
-      Parent::initialize(g);
-    }
-
-    /// \brief Returns \c true if the given node is an in-node.
-    ///
-    /// Returns \c true if the given node is an in-node.
-    static bool inNode(const Node& n) {
-      return Parent::inNode(n);
-    }
-
-    /// \brief Returns \c true if the given node is an out-node.
-    ///
-    /// Returns \c true if the given node is an out-node.
-    static bool outNode(const Node& n) {
-      return Parent::outNode(n);
-    }
-
-    /// \brief Returns \c true if the given arc is an original arc.
-    ///
-    /// Returns \c true if the given arc is one of the arcs in the
-    /// original digraph.
-    static bool origArc(const Arc& a) {
-      return Parent::origArc(a);
-    }
-
-    /// \brief Returns \c true if the given arc is a bind arc.
-    ///
-    /// Returns \c true if the given arc is a bind arc, i.e. it connects
-    /// an in-node and an out-node.
-    static bool bindArc(const Arc& a) {
-      return Parent::bindArc(a);
-    }
-
-    /// \brief Returns the in-node created from the given original node.
-    ///
-    /// Returns the in-node created from the given original node.
-    static Node inNode(const DigraphNode& n) {
-      return Parent::inNode(n);
-    }
-
-    /// \brief Returns the out-node created from the given original node.
-    ///
-    /// Returns the out-node created from the given original node.
-    static Node outNode(const DigraphNode& n) {
-      return Parent::outNode(n);
-    }
-
-    /// \brief Returns the bind arc that corresponds to the given
-    /// original node.
-    ///
-    /// Returns the bind arc in the adaptor that corresponds to the given
-    /// original node, i.e. the arc connecting the in-node and out-node
-    /// of \c n.
-    static Arc arc(const DigraphNode& n) {
-      return Parent::arc(n);
-    }
-
-    /// \brief Returns the arc that corresponds to the given original arc.
-    ///
-    /// Returns the arc in the adaptor that corresponds to the given
-    /// original arc.
-    static Arc arc(const DigraphArc& a) {
-      return Parent::arc(a);
-    }
-
-    /// \brief Node map combined from two original node maps
-    ///
-    /// This map adaptor class adapts two node maps of the original digraph
-    /// to get a node map of the split digraph.
-    /// Its value type is inherited from the first node map type (\c IN).
-    /// \tparam IN The type of the node map for the in-nodes.
-    /// \tparam OUT The type of the node map for the out-nodes.
-    template <typename IN, typename OUT>
-    class CombinedNodeMap {
-    public:
-
-      /// The key type of the map
-      typedef Node Key;
-      /// The value type of the map
-      typedef typename IN::Value Value;
-
-      typedef typename MapTraits<IN>::ReferenceMapTag ReferenceMapTag;
-      typedef typename MapTraits<IN>::ReturnValue ReturnValue;
-      typedef typename MapTraits<IN>::ConstReturnValue ConstReturnValue;
-      typedef typename MapTraits<IN>::ReturnValue Reference;
-      typedef typename MapTraits<IN>::ConstReturnValue ConstReference;
-
-      /// Constructor
-      CombinedNodeMap(IN& in_map, OUT& out_map)
-        : _in_map(in_map), _out_map(out_map) {}
-
-      /// Returns the value associated with the given key.
-      Value operator[](const Key& key) const {
-        if (SplitNodesBase<const DGR>::inNode(key)) {
-          return _in_map[key];
-        } else {
-          return _out_map[key];
-        }
-      }
-
-      /// Returns a reference to the value associated with the given key.
-      Value& operator[](const Key& key) {
-        if (SplitNodesBase<const DGR>::inNode(key)) {
-          return _in_map[key];
-        } else {
-          return _out_map[key];
-        }
-      }
-
-      /// Sets the value associated with the given key.
-      void set(const Key& key, const Value& value) {
-        if (SplitNodesBase<const DGR>::inNode(key)) {
-          _in_map.set(key, value);
-        } else {
-          _out_map.set(key, value);
-        }
-      }
-
-    private:
-
-      IN& _in_map;
-      OUT& _out_map;
-
-    };
-
-
-    /// \brief Returns a combined node map
-    ///
-    /// This function just returns a combined node map.
-    template <typename IN, typename OUT>
-    static CombinedNodeMap<IN, OUT>
-    combinedNodeMap(IN& in_map, OUT& out_map) {
-      return CombinedNodeMap<IN, OUT>(in_map, out_map);
-    }
-
-    template <typename IN, typename OUT>
-    static CombinedNodeMap<const IN, OUT>
-    combinedNodeMap(const IN& in_map, OUT& out_map) {
-      return CombinedNodeMap<const IN, OUT>(in_map, out_map);
-    }
-
-    template <typename IN, typename OUT>
-    static CombinedNodeMap<IN, const OUT>
-    combinedNodeMap(IN& in_map, const OUT& out_map) {
-      return CombinedNodeMap<IN, const OUT>(in_map, out_map);
-    }
-
-    template <typename IN, typename OUT>
-    static CombinedNodeMap<const IN, const OUT>
-    combinedNodeMap(const IN& in_map, const OUT& out_map) {
-      return CombinedNodeMap<const IN, const OUT>(in_map, out_map);
-    }
-
-    /// \brief Arc map combined from an arc map and a node map of the
-    /// original digraph.
-    ///
-    /// This map adaptor class adapts an arc map and a node map of the
-    /// original digraph to get an arc map of the split digraph.
-    /// Its value type is inherited from the original arc map type (\c AM).
-    /// \tparam AM The type of the arc map.
-    /// \tparam NM the type of the node map.
-    template <typename AM, typename NM>
-    class CombinedArcMap {
-    public:
-
-      /// The key type of the map
-      typedef Arc Key;
-      /// The value type of the map
-      typedef typename AM::Value Value;
-
-      typedef typename MapTraits<AM>::ReferenceMapTag ReferenceMapTag;
-      typedef typename MapTraits<AM>::ReturnValue ReturnValue;
-      typedef typename MapTraits<AM>::ConstReturnValue ConstReturnValue;
-      typedef typename MapTraits<AM>::ReturnValue Reference;
-      typedef typename MapTraits<AM>::ConstReturnValue ConstReference;
-
-      /// Constructor
-      CombinedArcMap(AM& arc_map, NM& node_map)
-        : _arc_map(arc_map), _node_map(node_map) {}
-
-      /// Returns the value associated with the given key.
-      Value operator[](const Key& arc) const {
-        if (SplitNodesBase<const DGR>::origArc(arc)) {
-          return _arc_map[arc];
-        } else {
-          return _node_map[arc];
-        }
-      }
-
-      /// Returns a reference to the value associated with the given key.
-      Value& operator[](const Key& arc) {
-        if (SplitNodesBase<const DGR>::origArc(arc)) {
-          return _arc_map[arc];
-        } else {
-          return _node_map[arc];
-        }
-      }
-
-      /// Sets the value associated with the given key.
-      void set(const Arc& arc, const Value& val) {
-        if (SplitNodesBase<const DGR>::origArc(arc)) {
-          _arc_map.set(arc, val);
-        } else {
-          _node_map.set(arc, val);
-        }
-      }
-
-    private:
-
-      AM& _arc_map;
-      NM& _node_map;
-
-    };
-
-    /// \brief Returns a combined arc map
-    ///
-    /// This function just returns a combined arc map.
-    template <typename ArcMap, typename NodeMap>
-    static CombinedArcMap<ArcMap, NodeMap>
-    combinedArcMap(ArcMap& arc_map, NodeMap& node_map) {
-      return CombinedArcMap<ArcMap, NodeMap>(arc_map, node_map);
-    }
-
-    template <typename ArcMap, typename NodeMap>
-    static CombinedArcMap<const ArcMap, NodeMap>
-    combinedArcMap(const ArcMap& arc_map, NodeMap& node_map) {
-      return CombinedArcMap<const ArcMap, NodeMap>(arc_map, node_map);
-    }
-
-    template <typename ArcMap, typename NodeMap>
-    static CombinedArcMap<ArcMap, const NodeMap>
-    combinedArcMap(ArcMap& arc_map, const NodeMap& node_map) {
-      return CombinedArcMap<ArcMap, const NodeMap>(arc_map, node_map);
-    }
-
-    template <typename ArcMap, typename NodeMap>
-    static CombinedArcMap<const ArcMap, const NodeMap>
-    combinedArcMap(const ArcMap& arc_map, const NodeMap& node_map) {
-      return CombinedArcMap<const ArcMap, const NodeMap>(arc_map, node_map);
-    }
-
-  };
-
-  /// \brief Returns a (read-only) SplitNodes adaptor
-  ///
-  /// This function just returns a (read-only) \ref SplitNodes adaptor.
-  /// \ingroup graph_adaptors
-  /// \relates SplitNodes
-  template<typename DGR>
-  SplitNodes<DGR>
-  splitNodes(const DGR& digraph) {
-    return SplitNodes<DGR>(digraph);
-  }
-
-#undef LEMON_SCOPE_FIX
-
-} //namespace lemon
-
-#endif //LEMON_ADAPTORS_H
Index: lemon/arg_parser.cc
===================================================================
--- lemon/arg_parser.cc	(revision 956)
+++ lemon/arg_parser.cc	(revision 311)
@@ -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).
@@ -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 959)
+++ lemon/arg_parser.h	(revision 311)
@@ -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).
@@ -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: lemon/assert.h
===================================================================
--- lemon/assert.h	(revision 463)
+++ lemon/assert.h	(revision 290)
@@ -3,5 +3,5 @@
  * This file is a part of LEMON, a generic C++ optimization library.
  *
- * Copyright (C) 2003-2009
+ * Copyright (C) 2003-2008
  * Egervary Jeno Kombinatorikus Optimalizalasi Kutatocsoport
  * (Egervary Research Group on Combinatorial Optimization, EGRES).
Index: lemon/base.cc
===================================================================
--- lemon/base.cc	(revision 554)
+++ lemon/base.cc	(revision 220)
@@ -3,5 +3,5 @@
  * This file is a part of LEMON, a generic C++ optimization library.
  *
- * Copyright (C) 2003-2009
+ * Copyright (C) 2003-2008
  * Egervary Jeno Kombinatorikus Optimalizalasi Kutatocsoport
  * (Egervary Research Group on Combinatorial Optimization, EGRES).
@@ -24,5 +24,5 @@
 namespace lemon {
 
-  float Tolerance<float>::def_epsilon = static_cast<float>(1e-4);
+  float Tolerance<float>::def_epsilon = 1e-4;
   double Tolerance<double>::def_epsilon = 1e-10;
   long double Tolerance<long double>::def_epsilon = 1e-14;
Index: mon/bellman_ford.h
===================================================================
--- lemon/bellman_ford.h	(revision 960)
+++ 	(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 956)
+++ lemon/bfs.h	(revision 301)
@@ -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).
@@ -48,11 +48,11 @@
     ///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.
-
-    ///This function instantiates a \ref PredMap.
+    ///Instantiates a PredMap.
+
+    ///This function instantiates a PredMap.
     ///\param g is the digraph, to which we would like to define the
-    ///\ref PredMap.
+    ///PredMap.
     static PredMap *createPredMap(const Digraph &g)
     {
@@ -63,12 +63,11 @@
 
     ///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.
-
-    ///This function instantiates a \ref ProcessedMap.
+    ///Instantiates a ProcessedMap.
+
+    ///This function instantiates a ProcessedMap.
     ///\param g is the digraph, to which
-    ///we would like to define the \ref ProcessedMap
+    ///we would like to define the ProcessedMap
 #ifdef DOXYGEN
     static ProcessedMap *createProcessedMap(const Digraph &g)
@@ -83,12 +82,11 @@
 
     ///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.
-
-    ///This function instantiates a \ref ReachedMap.
+    ///Instantiates a ReachedMap.
+
+    ///This function instantiates a ReachedMap.
     ///\param g is the digraph, to which
-    ///we would like to define the \ref ReachedMap.
+    ///we would like to define the ReachedMap.
     static ReachedMap *createReachedMap(const Digraph &g)
     {
@@ -99,11 +97,11 @@
 
     ///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.
-
-    ///This function instantiates a \ref DistMap.
+    ///Instantiates a DistMap.
+
+    ///This function instantiates a DistMap.
     ///\param g is the digraph, to which we would like to define the
-    ///\ref DistMap.
+    ///DistMap.
     static DistMap *createDistMap(const Digraph &g)
     {
@@ -122,10 +120,11 @@
   ///
   ///\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.
+  ///The default value is \ref ListDigraph. The value of GR is not used
+  ///directly by \ref Bfs, it is only passed to \ref BfsDefaultTraits.
+  ///\tparam TR Traits class to set various data types used by the algorithm.
+  ///The default traits class is
+  ///\ref BfsDefaultTraits "BfsDefaultTraits<GR>".
+  ///See \ref BfsDefaultTraits for the documentation of
+  ///a Bfs traits class.
 #ifdef DOXYGEN
   template <typename GR,
@@ -153,5 +152,5 @@
     typedef PredMapPath<Digraph, PredMap> Path;
 
-    ///The \ref BfsDefaultTraits "traits class" of the algorithm.
+    ///The traits class.
     typedef TR Traits;
 
@@ -215,5 +214,5 @@
     typedef Bfs Create;
 
-    ///\name Named Template Parameters
+    ///\name Named template parameters
 
     ///@{
@@ -229,9 +228,8 @@
     };
     ///\brief \ref named-templ-param "Named parameter" for setting
-    ///\c PredMap type.
+    ///PredMap type.
     ///
     ///\ref named-templ-param "Named parameter" for setting
-    ///\c PredMap type.
-    ///It must conform to the \ref concepts::WriteMap "WriteMap" concept.
+    ///PredMap type.
     template <class T>
     struct SetPredMap : public Bfs< Digraph, SetPredMapTraits<T> > {
@@ -249,9 +247,8 @@
     };
     ///\brief \ref named-templ-param "Named parameter" for setting
-    ///\c DistMap type.
+    ///DistMap type.
     ///
     ///\ref named-templ-param "Named parameter" for setting
-    ///\c DistMap type.
-    ///It must conform to the \ref concepts::WriteMap "WriteMap" concept.
+    ///DistMap type.
     template <class T>
     struct SetDistMap : public Bfs< Digraph, SetDistMapTraits<T> > {
@@ -269,10 +266,8 @@
     };
     ///\brief \ref named-templ-param "Named parameter" for setting
-    ///\c ReachedMap type.
+    ///ReachedMap type.
     ///
     ///\ref named-templ-param "Named parameter" for setting
-    ///\c ReachedMap type.
-    ///It must conform to
-    ///the \ref concepts::ReadWriteMap "ReadWriteMap" concept.
+    ///ReachedMap type.
     template <class T>
     struct SetReachedMap : public Bfs< Digraph, SetReachedMapTraits<T> > {
@@ -290,9 +285,8 @@
     };
     ///\brief \ref named-templ-param "Named parameter" for setting
-    ///\c ProcessedMap type.
+    ///ProcessedMap type.
     ///
     ///\ref named-templ-param "Named parameter" for setting
-    ///\c ProcessedMap type.
-    ///It must conform to the \ref concepts::WriteMap "WriteMap" concept.
+    ///ProcessedMap type.
     template <class T>
     struct SetProcessedMap : public Bfs< Digraph, SetProcessedMapTraits<T> > {
@@ -309,8 +303,8 @@
     };
     ///\brief \ref named-templ-param "Named parameter" for setting
-    ///\c ProcessedMap type to be <tt>Digraph::NodeMap<bool></tt>.
+    ///ProcessedMap type to be <tt>Digraph::NodeMap<bool></tt>.
     ///
     ///\ref named-templ-param "Named parameter" for setting
-    ///\c ProcessedMap type to be <tt>Digraph::NodeMap<bool></tt>.
+    ///ProcessedMap type to be <tt>Digraph::NodeMap<bool></tt>.
     ///If you don't set it explicitly, it will be automatically allocated.
     struct SetStandardProcessedMap :
@@ -347,8 +341,7 @@
 
     ///Sets the map that stores the predecessor arcs.
-    ///If you don't use this function before calling \ref run(Node) "run()"
-    ///or \ref init(), an instance will be allocated automatically.
-    ///The destructor deallocates this automatically allocated map,
-    ///of course.
+    ///If you don't use this function before calling \ref run(),
+    ///it will allocate one. The destructor deallocates this
+    ///automatically allocated map, of course.
     ///\return <tt> (*this) </tt>
     Bfs &predMap(PredMap &m)
@@ -365,8 +358,7 @@
 
     ///Sets the map that indicates which nodes are reached.
-    ///If you don't use this function before calling \ref run(Node) "run()"
-    ///or \ref init(), an instance will be allocated automatically.
-    ///The destructor deallocates this automatically allocated map,
-    ///of course.
+    ///If you don't use this function before calling \ref run(),
+    ///it will allocate one. The destructor deallocates this
+    ///automatically allocated map, of course.
     ///\return <tt> (*this) </tt>
     Bfs &reachedMap(ReachedMap &m)
@@ -383,8 +375,7 @@
 
     ///Sets the map that indicates which nodes are processed.
-    ///If you don't use this function before calling \ref run(Node) "run()"
-    ///or \ref init(), an instance will be allocated automatically.
-    ///The destructor deallocates this automatically allocated map,
-    ///of course.
+    ///If you don't use this function before calling \ref run(),
+    ///it will allocate one. The destructor deallocates this
+    ///automatically allocated map, of course.
     ///\return <tt> (*this) </tt>
     Bfs &processedMap(ProcessedMap &m)
@@ -402,8 +393,7 @@
     ///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(Node) "run()"
-    ///or \ref init(), an instance will be allocated automatically.
-    ///The destructor deallocates this automatically allocated map,
-    ///of course.
+    ///If you don't use this function before calling \ref run(),
+    ///it will allocate one. The destructor deallocates this
+    ///automatically allocated map, of course.
     ///\return <tt> (*this) </tt>
     Bfs &distMap(DistMap &m)
@@ -419,17 +409,20 @@
   public:
 
-    ///\name Execution Control
-    ///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
-    ///\ref addSource(). Finally the actual path computation can be
-    ///performed with one of the \ref start() functions.
+    ///\name Execution control
+    ///The simplest way to execute the algorithm is to use
+    ///one of the member functions called \ref lemon::Bfs::run() "run()".
+    ///\n
+    ///If you need more control on the execution, first you must call
+    ///\ref lemon::Bfs::init() "init()", then you can add several source
+    ///nodes with \ref lemon::Bfs::addSource() "addSource()".
+    ///Finally \ref lemon::Bfs::start() "start()" will perform the
+    ///actual path computation.
 
     ///@{
 
-    ///\brief Initializes the internal data structures.
-    ///
     ///Initializes the internal data structures.
+
+    ///Initializes the internal data structures.
+    ///
     void init()
     {
@@ -565,14 +558,14 @@
     }
 
-    ///Returns \c false if there are nodes to be processed.
-
-    ///Returns \c false if there are nodes to be processed
-    ///in the queue.
+    ///\brief Returns \c false if there are nodes
+    ///to be processed.
+    ///
+    ///Returns \c false if there are nodes
+    ///to be processed in the queue.
     bool emptyQueue() const { return _queue_tail==_queue_head; }
 
     ///Returns the number of the nodes to be processed.
 
-    ///Returns the number of the nodes to be processed
-    ///in the queue.
+    ///Returns the number of the nodes to be processed in the queue.
     int queueSize() const { return _queue_head-_queue_tail; }
 
@@ -709,6 +702,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.
@@ -735,60 +732,58 @@
 
     ///\name Query Functions
-    ///The results of the BFS algorithm can be obtained using these
+    ///The result of the %BFS algorithm can be obtained using these
     ///functions.\n
-    ///Either \ref run(Node) "run()" or \ref start() should be called
-    ///before using them.
+    ///Either \ref lemon::Bfs::run() "run()" or \ref lemon::Bfs::start()
+    ///"start()" must be called before using them.
 
     ///@{
 
-    ///The shortest path to the given node.
-
-    ///Returns 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(Node) "run()" or \ref init()
-    ///must be called before using this function.
+    ///The shortest path to a node.
+
+    ///Returns the shortest path to a node.
+    ///
+    ///\warning \c t should be reachable from the root(s).
+    ///
+    ///\pre Either \ref run() or \ref start() must be called before
+    ///using this function.
     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).
-    ///
-    ///\warning If node \c v is not reached from the root(s), then
+    ///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 reachable from the root(s), then
     ///the return value of this function is undefined.
     ///
-    ///\pre Either \ref run(Node) "run()" or \ref init()
-    ///must be called before using this function.
+    ///\pre Either \ref run() or \ref start() must be called before
+    ///using this function.
     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
-    ///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.
+    ///shortest path from the root(s) to \c v. It is \c INVALID if \c v
+    ///is not reachable 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(Node) "run()" or \ref init()
-    ///must be called before using this function.
+    ///tree used in \ref predNode().
+    ///
+    ///\pre Either \ref run() or \ref start() 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.
-    ///
+    ///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
-    ///if \c v is not reached from the root(s) or if \c v is a root.
+    ///from a shortest path from the root(s) to \c v. It is \c INVALID
+    ///if \c v is not reachable 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(Node) "run()" or \ref init()
-    ///must be called before using this function.
+    ///tree used in \ref predArc().
+    ///
+    ///\pre Either \ref run() or \ref start() must be called before
+    ///using this function.
     Node predNode(Node v) const { return (*_pred)[v]==INVALID ? INVALID:
                                   G->source((*_pred)[v]); }
@@ -800,5 +795,5 @@
     ///of the nodes calculated by the algorithm.
     ///
-    ///\pre Either \ref run(Node) "run()" or \ref init()
+    ///\pre Either \ref run() or \ref init()
     ///must be called before using this function.
     const DistMap &distMap() const { return *_dist;}
@@ -808,15 +803,14 @@
     ///
     ///Returns a const reference to the node map that stores the predecessor
-    ///arcs, which form the shortest path tree (forest).
-    ///
-    ///\pre Either \ref run(Node) "run()" or \ref init()
+    ///arcs, which form the shortest path tree.
+    ///
+    ///\pre Either \ref run() or \ref init()
     ///must be called before using this function.
     const PredMap &predMap() const { return *_pred;}
 
-    ///Checks if the given node is reached from the root(s).
-
-    ///Returns \c true if \c v is reached from the root(s).
-    ///
-    ///\pre Either \ref run(Node) "run()" or \ref init()
+    ///Checks if a node is reachable from the root(s).
+
+    ///Returns \c true if \c v is reachable from the root(s).
+    ///\pre Either \ref run() or \ref start()
     ///must be called before using this function.
     bool reached(Node v) const { return (*_reached)[v]; }
@@ -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),
@@ -961,12 +958,9 @@
   /// This auxiliary class is created to implement the
   /// \ref bfs() "function-type interface" of \ref Bfs algorithm.
-  /// It does not have own \ref run(Node) "run()" method, it uses the
-  /// functions and features of the plain \ref Bfs.
+  /// It does not have own \ref run() method, it uses the functions
+  /// and features of the plain \ref Bfs.
   ///
   /// 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)
@@ -1183,5 +1179,5 @@
   ///  bool reached = bfs(g).path(p).dist(d).run(s,t);
   ///\endcode
-  ///\warning Don't forget to put the \ref BfsWizard::run(Node) "run()"
+  ///\warning Don't forget to put the \ref BfsWizard::run() "run()"
   ///to the end of the parameter list.
   ///\sa BfsWizard
@@ -1199,7 +1195,7 @@
   /// This class defines the interface of the BfsVisit events, and
   /// it could be the base of a real visitor class.
-  template <typename GR>
+  template <typename _Digraph>
   struct BfsVisitor {
-    typedef GR Digraph;
+    typedef _Digraph Digraph;
     typedef typename Digraph::Arc Arc;
     typedef typename Digraph::Node Node;
@@ -1229,7 +1225,7 @@
   };
 #else
-  template <typename GR>
+  template <typename _Digraph>
   struct BfsVisitor {
-    typedef GR Digraph;
+    typedef _Digraph Digraph;
     typedef typename Digraph::Arc Arc;
     typedef typename Digraph::Node Node;
@@ -1259,16 +1255,15 @@
   ///
   /// Default traits class of BfsVisit class.
-  /// \tparam GR The type of the digraph the algorithm runs on.
-  template<class GR>
+  /// \tparam _Digraph The type of the digraph the algorithm runs on.
+  template<class _Digraph>
   struct BfsVisitDefaultTraits {
 
     /// \brief The type of the digraph the algorithm runs on.
-    typedef GR Digraph;
+    typedef _Digraph Digraph;
 
     /// \brief The type of the map that indicates which nodes are reached.
     ///
     /// 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;
 
@@ -1286,10 +1281,10 @@
   /// \ingroup search
   ///
-  /// \brief BFS algorithm class with visitor interface.
+  /// \brief %BFS algorithm class with visitor interface.
   ///
-  /// This class provides an efficient implementation of the BFS algorithm
+  /// This class provides an efficient implementation of the %BFS algorithm
   /// with visitor interface.
   ///
-  /// The BfsVisit class provides an alternative interface to the Bfs
+  /// The %BfsVisit class provides an alternative interface to the Bfs
   /// class. It works with callback mechanism, the BfsVisit object calls
   /// the member functions of the \c Visitor class on every BFS event.
@@ -1300,23 +1295,23 @@
   /// instead.
   ///
-  /// \tparam GR The type of the digraph the algorithm runs on.
-  /// The default type is \ref ListDigraph.
-  /// The value of GR is not used directly by \ref BfsVisit,
-  /// it is only passed to \ref BfsVisitDefaultTraits.
-  /// \tparam VS The Visitor type that is used by the algorithm.
-  /// \ref BfsVisitor "BfsVisitor<GR>" is an empty visitor, which
+  /// \tparam _Digraph The type of the digraph the algorithm runs on.
+  /// The default value is
+  /// \ref ListDigraph. The value of _Digraph is not used directly by
+  /// \ref BfsVisit, it is only passed to \ref BfsVisitDefaultTraits.
+  /// \tparam _Visitor The Visitor type that is used by the algorithm.
+  /// \ref BfsVisitor "BfsVisitor<_Digraph>" is an empty visitor, which
   /// 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 _Traits Traits class to set various data types used by the
+  /// algorithm. The default traits class is
+  /// \ref BfsVisitDefaultTraits "BfsVisitDefaultTraits<_Digraph>".
+  /// See \ref BfsVisitDefaultTraits for the documentation of
+  /// a BFS visit traits class.
 #ifdef DOXYGEN
-  template <typename GR, typename VS, typename TR>
+  template <typename _Digraph, typename _Visitor, typename _Traits>
 #else
-  template <typename GR = ListDigraph,
-            typename VS = BfsVisitor<GR>,
-            typename TR = BfsVisitDefaultTraits<GR> >
+  template <typename _Digraph = ListDigraph,
+            typename _Visitor = BfsVisitor<_Digraph>,
+            typename _Traits = BfsVisitDefaultTraits<_Digraph> >
 #endif
   class BfsVisit {
@@ -1324,5 +1319,5 @@
 
     ///The traits class.
-    typedef TR Traits;
+    typedef _Traits Traits;
 
     ///The type of the digraph the algorithm runs on.
@@ -1330,5 +1325,5 @@
 
     ///The visitor type used by the algorithm.
-    typedef VS Visitor;
+    typedef _Visitor Visitor;
 
     ///The type of the map that indicates which nodes are reached.
@@ -1370,5 +1365,5 @@
     typedef BfsVisit Create;
 
-    /// \name Named Template Parameters
+    /// \name Named template parameters
 
     ///@{
@@ -1412,8 +1407,7 @@
     ///
     /// Sets the map that indicates which nodes are reached.
-    /// If you don't use this function before calling \ref run(Node) "run()"
-    /// or \ref init(), an instance will be allocated automatically.
-    /// The destructor deallocates this automatically allocated map,
-    /// of course.
+    /// If you don't use this function before calling \ref run(),
+    /// it will allocate one. The destructor deallocates this
+    /// automatically allocated map, of course.
     /// \return <tt> (*this) </tt>
     BfsVisit &reachedMap(ReachedMap &m) {
@@ -1428,11 +1422,14 @@
   public:
 
-    /// \name Execution Control
-    /// 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
-    /// \ref addSource(). Finally the actual path computation can be
-    /// performed with one of the \ref start() functions.
+    /// \name Execution control
+    /// The simplest way to execute the algorithm is to use
+    /// one of the member functions called \ref lemon::BfsVisit::run()
+    /// "run()".
+    /// \n
+    /// If you need more control on the execution, first you must call
+    /// \ref lemon::BfsVisit::init() "init()", then you can add several
+    /// source nodes with \ref lemon::BfsVisit::addSource() "addSource()".
+    /// Finally \ref lemon::BfsVisit::start() "start()" will perform the
+    /// actual path computation.
 
     /// @{
@@ -1704,6 +1701,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.
@@ -1730,18 +1731,17 @@
 
     /// \name Query Functions
-    /// The results of the BFS algorithm can be obtained using these
+    /// The result of the %BFS algorithm can be obtained using these
     /// functions.\n
-    /// Either \ref run(Node) "run()" or \ref start() should be called
-    /// before using them.
-
+    /// Either \ref lemon::BfsVisit::run() "run()" or
+    /// \ref lemon::BfsVisit::start() "start()" must be called before
+    /// using them.
     ///@{
 
-    /// \brief Checks if the given node is reached from the root(s).
-    ///
-    /// Returns \c true if \c v is reached from the root(s).
-    ///
-    /// \pre Either \ref run(Node) "run()" or \ref init()
+    /// \brief Checks if a node is reachable from the root(s).
+    ///
+    /// Returns \c true if \c v is reachable from the root(s).
+    /// \pre Either \ref run() or \ref start()
     /// must be called before using this function.
-    bool reached(Node v) const { return (*_reached)[v]; }
+    bool reached(Node v) { return (*_reached)[v]; }
 
     ///@}
Index: lemon/bin_heap.h
===================================================================
--- lemon/bin_heap.h	(revision 758)
+++ lemon/bin_heap.h	(revision 209)
@@ -3,5 +3,5 @@
  * This file is a part of LEMON, a generic C++ optimization library.
  *
- * Copyright (C) 2003-2009
+ * Copyright (C) 2003-2008
  * Egervary Jeno Kombinatorikus Optimalizalasi Kutatocsoport
  * (Egervary Research Group on Combinatorial Optimization, EGRES).
@@ -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,94 +30,96 @@
 namespace lemon {
 
-  /// \ingroup heaps
+  ///\ingroup auxdat
   ///
-  /// \brief Binary heap data structure.
+  ///\brief A Binary Heap implementation.
   ///
-  /// This class implements the \e binary \e heap data structure.
-  /// It fully conforms to the \ref concepts::Heap "heap concept".
+  ///This class implements the \e binary \e heap data structure. A \e heap
+  ///is a data structure for storing items with specified values called \e
+  ///priorities in such a way that finding the item with minimum priority is
+  ///efficient. \c Compare specifies the ordering of the priorities. In a heap
+  ///one can change the priority of an item, add or erase an item, etc.
   ///
-  /// \tparam PR Type of the 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
+  ///\tparam _Prio Type of the priority of the items.
+  ///\tparam _ItemIntMap A read and writable Item int map, used internally
+  ///to handle the cross references.
+  ///\tparam _Compare A class for the ordering of the priorities. The
+  ///default is \c std::less<_Prio>.
+  ///
+  ///\sa FibHeap
+  ///\sa Dijkstra
+  template <typename _Prio, typename _ItemIntMap,
+            typename _Compare = std::less<_Prio> >
   class BinHeap {
+
   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.
+    ///\e
+    typedef _ItemIntMap ItemIntMap;
+    ///\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.
-    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
+    ///\e
+    typedef _Compare Compare;
+
+    /// \brief Type to represent the items states.
+    ///
+    /// Each Item element have a state associated to it. It may be "in heap",
+    /// "pre heap" or "post heap". The latter two are indifferent from the
     /// 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
     };
 
   private:
-    std::vector<Pair> _data;
-    Compare _comp;
-    ItemIntMap &_iim;
+    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 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.
-    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.
-    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.
+    /// \brief The constructor.
+    ///
+    /// The constructor.
+    /// \param _iim should be given to the constructor, since it is used
+    /// internally to handle the cross references. The value of the map
+    /// should be PRE_HEAP (-1) for each element.
+    explicit BinHeap(ItemIntMap &_iim) : iim(_iim) {}
+
+    /// \brief The constructor.
+    ///
+    /// The constructor.
+    /// \param _iim should be given to the constructor, since it is used
+    /// internally to handle the cross references. The value of the map
+    /// should be PRE_HEAP (-1) for each element.
+    ///
+    /// \param _comp The comparator function object.
+    BinHeap(ItemIntMap &_iim, const Compare &_comp)
+      : iim(_iim), comp(_comp) {}
+
+
+    /// The number of items stored in the heap.
+    ///
+    /// \brief Returns the number of items stored in the heap.
+    int size() const { return data.size(); }
+
+    /// \brief Checks if the heap stores no items.
+    ///
+    /// Returns \c true if and only if the heap stores no items.
+    bool empty() const { return data.empty(); }
+
+    /// \brief Make empty this heap.
+    ///
+    /// Make empty this heap. It does not change the cross reference map.
+    /// If you want to reuse what is not surely empty you should first clear
+    /// the heap and after that you should set the cross reference map for
+    /// each item to \c PRE_HEAP.
     void clear() {
-      _data.clear();
+      data.clear();
     }
 
@@ -125,13 +127,13 @@
     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) {
+      return comp(p1.second, p2.second);
+    }
+
+    int bubble_up(int hole, Pair p) {
       int par = parent(hole);
-      while( hole>0 && less(p,_data[par]) ) {
-        move(_data[par],hole);
+      while( hole>0 && less(p,data[par]) ) {
+        move(data[par],hole);
         hole = par;
         par = parent(hole);
@@ -141,19 +143,19 @@
     }
 
-    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]) ) {
+        if( less(data[child-1], data[child]) ) {
           --child;
         }
-        if( !less(_data[child], p) )
+        if( !less(data[child], p) )
           goto ok;
-        move(_data[child], hole);
+        move(data[child], hole);
         hole = child;
-        child = secondChild(hole);
+        child = second_child(hole);
       }
       child--;
-      if( child<length && less(_data[child], p) ) {
-        move(_data[child], hole);
+      if( child<length && less(data[child], p) ) {
+        move(data[child], hole);
         hole=child;
       }
@@ -164,141 +166,139 @@
 
     void move(const Pair &p, int i) {
-      _data[i] = p;
-      _iim.set(p.first, i);
+      data[i] = p;
+      iim.set(p.first, i);
     }
 
   public:
-
     /// \brief Insert a pair of item and priority into the heap.
     ///
-    /// 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.
+      int n = data.size();
+      data.resize(n+1);
+      bubble_up(n, p);
+    }
+
+    /// \brief Insert an item into the heap with the given heap.
+    ///
+    /// Adds \c i to the heap with priority \c p.
     /// \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.
+      return data[0].first;
+    }
+
+    /// \brief Returns the minimum priority relative to \c Compare.
+    ///
+    /// It returns the minimum priority relative to \c Compare.
+    /// \pre The heap must be nonempty.
     Prio prio() const {
-      return _data[0].second;
-    }
-
-    /// \brief Remove the item having minimum priority.
-    ///
-    /// This function removes the item having minimum priority.
+      return data[0].second;
+    }
+
+    /// \brief Deletes the item with minimum priority relative to \c Compare.
+    ///
+    /// This method deletes the item with minimum priority relative to \c
+    /// Compare from the heap.
     /// \pre The heap must be non-empty.
     void pop() {
-      int n = _data.size()-1;
-      _iim.set(_data[0].first, POST_HEAP);
+      int n = data.size()-1;
+      iim.set(data[0].first, POST_HEAP);
       if (n > 0) {
-        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.
+        bubble_down(0, data[n], n);
+      }
+      data.pop_back();
+    }
+
+    /// \brief Deletes \c i from the heap.
+    ///
+    /// This method deletes item \c i from the heap.
+    /// \param i The item to erase.
+    /// \pre The item should be in the heap.
     void erase(const Item &i) {
-      int h = _iim[i];
-      int n = _data.size()-1;
-      _iim.set(_data[h].first, POST_HEAP);
+      int h = iim[i];
+      int n = data.size()-1;
+      iim.set(data[h].first, POST_HEAP);
       if( h < n ) {
-        if ( bubbleUp(h, _data[n]) == h) {
-          bubbleDown(h, _data[n], n);
+        if ( bubble_up(h, data[n]) == h) {
+          bubble_down(h, data[n], 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.
+      data.pop_back();
+    }
+
+
+    /// \brief Returns the priority of \c i.
+    ///
+    /// This function returns the priority of item \c i.
+    /// \pre \c i must be in the heap.
+    /// \param i The item.
     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.
+      int idx = iim[i];
+      return data[idx].second;
+    }
+
+    /// \brief \c i gets to the heap with priority \c p independently
+    /// if \c i was already there.
+    ///
+    /// This method calls \ref push(\c i, \c p) if \c i is not stored
+    /// in the heap and sets the priority of \c i to \c p otherwise.
     /// \param i The item.
     /// \param p The priority.
     void set(const Item &i, const Prio &p) {
-      int idx = _iim[i];
+      int idx = iim[i];
       if( idx < 0 ) {
         push(i,p);
       }
-      else if( _comp(p, _data[idx].second) ) {
-        bubbleUp(idx, Pair(i,p));
+      else if( comp(p, data[idx].second) ) {
+        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.
+    /// \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];
-      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.
+      int idx = iim[i];
+      bubble_up(idx, Pair(i,p));
+    }
+
+    /// \brief Increases the priority of \c i to \c p.
+    ///
+    /// This method sets the priority of item \c i to \c p.
+    /// \pre \c i must be stored in the heap with priority at most \c
+    /// p relative to \c Compare.
     /// \param i The item.
     /// \param p The priority.
-    /// \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.
+      int idx = iim[i];
+      bubble_down(idx, Pair(i,p), data.size());
+    }
+
+    /// \brief Returns if \c item is in, has already been in, or has
+    /// never been in the heap.
+    ///
+    /// This method returns PRE_HEAP if \c item has never been in the
+    /// heap, IN_HEAP if it is in the heap at the moment, and POST_HEAP
+    /// otherwise. In the latter case it is possible that \c item will
+    /// get back to the heap again.
     /// \param i The item.
     State state(const Item &i) const {
-      int s = _iim[i];
+      int s = iim[i];
       if( s>=0 )
         s=0;
@@ -306,9 +306,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.
@@ -320,5 +320,5 @@
           erase(i);
         }
-        _iim[i] = st;
+        iim[i] = st;
         break;
       case IN_HEAP:
@@ -327,16 +327,15 @@
     }
 
-    /// \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];
-      _iim.set(i, _iim[j]);
-      _iim.set(j, idx);
-      _data[idx].first = j;
+      int idx = iim[i];
+      iim.set(i, iim[j]);
+      iim.set(j, idx);
+      data[idx].first = j;
     }
 
Index: mon/binomial_heap.h
===================================================================
--- lemon/binomial_heap.h	(revision 956)
+++ 	(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 463)
+++ lemon/bits/alteration_notifier.h	(revision 314)
@@ -3,5 +3,5 @@
  * This file is a part of LEMON, a generic C++ optimization library.
  *
- * Copyright (C) 2003-2009
+ * Copyright (C) 2003-2008
  * Egervary Jeno Kombinatorikus Optimalizalasi Kutatocsoport
  * (Egervary Research Group on Combinatorial Optimization, EGRES).
@@ -36,60 +36,59 @@
   // a container.
   //
-  // The simple graphs can be refered as two containers: a node container
-  // and an edge container. But they do not store values directly, they
-  // are just key continars for more value containers, which are the
-  // node and edge maps.
-  //
-  // The node and edge sets of the graphs can be changed as we add or erase
+  // The simple graph's can be refered as two containers, one node container
+  // and one edge container. But they are not standard containers they
+  // does not store values directly they are just key continars for more
+  // value containers which are the node and edge maps.
+  //
+  // The graph's node and edge sets can be changed as we add or erase
   // nodes and edges in the graph. LEMON would like to handle easily
   // that the node and edge maps should contain values for all nodes or
   // edges. If we want to check on every indicing if the map contains
   // the current indicing key that cause a drawback in the performance
-  // in the library. We use another solution: we notify all maps about
+  // in the library. We use another solution we notify all maps about
   // an alteration in the graph, which cause only drawback on the
   // alteration of the graph.
   //
-  // This class provides an interface to a node or edge container.
-  // The first() and next() member functions make possible
-  // to iterate on the keys of the container.
-  // The id() function returns an integer id for each key.
-  // The maxId() function gives back an upper bound of the ids.
+  // This class provides an interface to the container. The \e first() and \e
+  // next() member functions make possible to iterate on the keys of the
+  // container. The \e id() function returns an integer id for each key.
+  // The \e maxId() function gives back an upper bound of the ids.
   //
   // For the proper functonality of this class, we should notify it
-  // about each alteration in the container. The alterations have four type:
-  // add(), erase(), build() and clear(). The add() and
-  // erase() signal that only one or few items added or erased to or
-  // from the graph. If all items are erased from the graph or if a new graph
-  // is built from an empty graph, then it can be signaled with the
+  // about each alteration in the container. The alterations have four type
+  // as \e add(), \e erase(), \e build() and \e clear(). The \e add() and
+  // \e erase() signals that only one or few items added or erased to or
+  // from the graph. If all items are erased from the graph or from an empty
+  // graph a new graph is builded then it can be signaled with the
   // clear() and build() members. Important rule that if we erase items
-  // from graphs we should first signal the alteration and after that erase
+  // from graph we should first signal the alteration and after that erase
   // them from the container, on the other way on item addition we should
   // first extend the container and just after that signal the alteration.
   //
   // The alteration can be observed with a class inherited from the
-  // ObserverBase nested class. The signals can be handled with
+  // \e ObserverBase nested class. The signals can be handled with
   // overriding the virtual functions defined in the base class.  The
   // observer base can be attached to the notifier with the
-  // attach() member and can be detached with detach() function. The
+  // \e attach() member and can be detached with detach() function. The
   // alteration handlers should not call any function which signals
   // an other alteration in the same notifier and should not
   // detach any observer from the notifier.
   //
-  // Alteration observers try to be exception safe. If an add() or
-  // a clear() function throws an exception then the remaining
+  // Alteration observers try to be exception safe. If an \e add() or
+  // a \e clear() function throws an exception then the remaining
   // observeres will not be notified and the fulfilled additions will
-  // be rolled back by calling the erase() or clear() functions.
-  // Hence erase() and clear() should not throw exception.
-  // Actullay, they can throw only \ref ImmediateDetach exception,
-  // which detach the observer from the notifier.
-  //
-  // There are some cases, when the alteration observing is not completly
+  // be rolled back by calling the \e erase() or \e clear()
+  // functions. Thence the \e erase() and \e clear() should not throw
+  // exception. Actullay, it can be throw only \ref ImmediateDetach
+  // exception which detach the observer from the notifier.
+  //
+  // There are some place when the alteration observing is not completly
   // reliable. If we want to carry out the node degree in the graph
-  // as in the \ref InDegMap and we use the reverseArc(), then it cause
+  // as in the \ref InDegMap and we use the reverseEdge that cause
   // unreliable functionality. Because the alteration observing signals
-  // only erasing and adding but not the reversing, it will stores bad
-  // degrees. Apart form that the subgraph adaptors cannot even signal
-  // the alterations because just a setting in the filter map can modify
-  // the graph and this cannot be watched in any way.
+  // only erasing and adding but not the reversing it will stores bad
+  // degrees. The sub graph adaptors cannot signal the alterations because
+  // just a setting in the filter map can modify the graph and this cannot
+  // be watched in any way.
   //
   // \param _Container The container which is observed.
@@ -105,11 +104,11 @@
     typedef _Item Item;
 
-    // \brief Exception which can be called from clear() and
-    // erase().
-    //
-    // From the clear() and erase() function only this
+    // \brief Exception which can be called from \e clear() and
+    // \e erase().
+    //
+    // From the \e clear() and \e erase() function only this
     // exception is allowed to throw. The exception immediatly
     // detaches the current observer from the notifier. Because the
-    // clear() and erase() should not throw other exceptions
+    // \e clear() and \e erase() should not throw other exceptions
     // it can be used to invalidate the observer.
     struct ImmediateDetach {};
@@ -123,5 +122,6 @@
     // The observer interface contains some pure virtual functions
     // to override. The add() and erase() functions are
-    // to notify the oberver when one item is added or erased.
+    // to notify the oberver when one item is added or
+    // erased.
     //
     // The build() and clear() members are to notify the observer
Index: lemon/bits/array_map.h
===================================================================
--- lemon/bits/array_map.h	(revision 956)
+++ lemon/bits/array_map.h	(revision 314)
@@ -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).
@@ -37,9 +37,10 @@
   // \brief Graph map based on the array storage.
   //
-  // The ArrayMap template class is graph map structure that automatically
-  // updates the map when a key is added to or erased from the graph.
-  // This map uses the allocators to implement the container functionality.
+  // The ArrayMap template class is graph map structure what
+  // automatically updates the map when a key is added to or erased from
+  // the map. This map uses the allocators to implement
+  // the container functionality.
   //
-  // The template parameters are the Graph, the current Item type and
+  // The template parameters are the Graph the current Item type and
   // the Value type of the map.
   template <typename _Graph, typename _Item, typename _Value>
@@ -47,12 +48,12 @@
     : public ItemSetTraits<_Graph, _Item>::ItemNotifier::ObserverBase {
   public:
-    // The graph type.
-    typedef _Graph GraphType;
-    // The item type.
+    // The graph type of the maps.
+    typedef _Graph Graph;
+    // The item type of the map.
     typedef _Item Item;
     // The reference map tag.
     typedef True ReferenceMapTag;
 
-    // The key type of the map.
+    // The key type of the maps.
     typedef _Item Key;
     // The value type of the map.
@@ -64,15 +65,11 @@
     typedef _Value& Reference;
 
-    // The map type.
-    typedef ArrayMap Map;
-
     // The notifier type.
     typedef typename ItemSetTraits<_Graph, _Item>::ItemNotifier Notifier;
 
-  private:
-
     // The MapBase of the Map which imlements the core regisitry function.
     typedef typename Notifier::ObserverBase Parent;
 
+  private:
     typedef std::allocator<Value> Allocator;
 
@@ -82,5 +79,5 @@
     //
     // Graph initialized map constructor.
-    explicit ArrayMap(const GraphType& graph) {
+    explicit ArrayMap(const Graph& graph) {
       Parent::attach(graph.notifier(Item()));
       allocate_memory();
@@ -96,5 +93,5 @@
     //
     // It constructs a map and initialize all of the the map.
-    ArrayMap(const GraphType& graph, const Value& value) {
+    ArrayMap(const Graph& graph, const Value& value) {
       Parent::attach(graph.notifier(Item()));
       allocate_memory();
@@ -140,5 +137,5 @@
     // \brief Template assign operator.
     //
-    // The given parameter should conform to the ReadMap
+    // The given parameter should be conform to the ReadMap
     // concecpt and could be indiced by the current item set of
     // the NodeMap. In this case the value for each item
@@ -204,5 +201,5 @@
     // \brief Adds a new key to the map.
     //
-    // It adds a new key to the map. It is called by the observer notifier
+    // It adds a new key to the map. It called by the observer notifier
     // and it overrides the add() member function of the observer base.
     virtual void add(const Key& key) {
@@ -232,5 +229,5 @@
     // \brief Adds more new keys to the map.
     //
-    // It adds more new keys to the map. It is called by the observer notifier
+    // It adds more new keys to the map. It called by the observer notifier
     // and it overrides the add() member function of the observer base.
     virtual void add(const std::vector<Key>& keys) {
@@ -276,5 +273,5 @@
     // \brief Erase a key from the map.
     //
-    // Erase a key from the map. It is called by the observer notifier
+    // Erase a key from the map. It called by the observer notifier
     // and it overrides the erase() member function of the observer base.
     virtual void erase(const Key& key) {
@@ -285,5 +282,5 @@
     // \brief Erase more keys from the map.
     //
-    // Erase more keys from the map. It is called by the observer notifier
+    // Erase more keys from the map. It called by the observer notifier
     // and it overrides the erase() member function of the observer base.
     virtual void erase(const std::vector<Key>& keys) {
@@ -294,7 +291,7 @@
     }
 
-    // \brief Builds the map.
-    //
-    // It builds the map. It is called by the observer notifier
+    // \brief Buildes the map.
+    //
+    // It buildes the map. It called by the observer notifier
     // and it overrides the build() member function of the observer base.
     virtual void build() {
@@ -310,5 +307,5 @@
     // \brief Clear the map.
     //
-    // It erase all items from the map. It is called by the observer notifier
+    // It erase all items from the map. It called by the observer notifier
     // and it overrides the clear() member function of the observer base.
     virtual void clear() {
Index: lemon/bits/base_extender.h
===================================================================
--- lemon/bits/base_extender.h	(revision 314)
+++ lemon/bits/base_extender.h	(revision 314)
@@ -0,0 +1,494 @@
+/* -*- mode: C++; indent-tabs-mode: nil; -*-
+ *
+ * This file is a part of LEMON, a generic C++ optimization library.
+ *
+ * Copyright (C) 2003-2008
+ * Egervary Jeno Kombinatorikus Optimalizalasi Kutatocsoport
+ * (Egervary Research Group on Combinatorial Optimization, EGRES).
+ *
+ * Permission to use, modify and distribute this software is granted
+ * provided that this copyright notice appears in all copies. For
+ * precise terms see the accompanying LICENSE file.
+ *
+ * This software is provided "AS IS" with no warranty of any kind,
+ * express or implied, and with no claim as to its suitability for any
+ * purpose.
+ *
+ */
+
+#ifndef LEMON_BITS_BASE_EXTENDER_H
+#define LEMON_BITS_BASE_EXTENDER_H
+
+#include <lemon/core.h>
+#include <lemon/error.h>
+
+#include <lemon/bits/map_extender.h>
+#include <lemon/bits/default_map.h>
+
+#include <lemon/concept_check.h>
+#include <lemon/concepts/maps.h>
+
+//\ingroup digraphbits
+//\file
+//\brief Extenders for the digraph types
+namespace lemon {
+
+  // \ingroup digraphbits
+  //
+  // \brief BaseDigraph to BaseGraph extender
+  template <typename Base>
+  class UndirDigraphExtender : public Base {
+
+  public:
+
+    typedef Base Parent;
+    typedef typename Parent::Arc Edge;
+    typedef typename Parent::Node Node;
+
+    typedef True UndirectedTag;
+
+    class Arc : public Edge {
+      friend class UndirDigraphExtender;
+
+    protected:
+      bool forward;
+
+      Arc(const Edge &ue, bool _forward) :
+        Edge(ue), forward(_forward) {}
+
+    public:
+      Arc() {}
+
+      // Invalid arc constructor
+      Arc(Invalid i) : Edge(i), forward(true) {}
+
+      bool operator==(const Arc &that) const {
+        return forward==that.forward && Edge(*this)==Edge(that);
+      }
+      bool operator!=(const Arc &that) const {
+        return forward!=that.forward || Edge(*this)!=Edge(that);
+      }
+      bool operator<(const Arc &that) const {
+        return forward<that.forward ||
+          (!(that.forward<forward) && Edge(*this)<Edge(that));
+      }
+    };
+
+    // First node of the edge
+    Node u(const Edge &e) const {
+      return Parent::source(e);
+    }
+
+    // Source of the given arc
+    Node source(const Arc &e) const {
+      return e.forward ? Parent::source(e) : Parent::target(e);
+    }
+
+    // Second node of the edge
+    Node v(const Edge &e) const {
+      return Parent::target(e);
+    }
+
+    // Target of the given arc
+    Node target(const Arc &e) const {
+      return e.forward ? Parent::target(e) : Parent::source(e);
+    }
+
+    // \brief Directed arc from an edge.
+    //
+    // Returns a directed arc corresponding to the specified edge.
+    // If the given bool is true, the first node of the given edge and
+    // the source node of the returned arc are the same.
+    static Arc direct(const Edge &e, bool d) {
+      return Arc(e, d);
+    }
+
+    // Returns whether the given directed arc has the same orientation
+    // as the corresponding edge.
+    static bool direction(const Arc &a) { return a.forward; }
+
+    using Parent::first;
+    using Parent::next;
+
+    void first(Arc &e) const {
+      Parent::first(e);
+      e.forward=true;
+    }
+
+    void next(Arc &e) const {
+      if( e.forward ) {
+        e.forward = false;
+      }
+      else {
+        Parent::next(e);
+        e.forward = true;
+      }
+    }
+
+    void firstOut(Arc &e, const Node &n) const {
+      Parent::firstIn(e,n);
+      if( Edge(e) != INVALID ) {
+        e.forward = false;
+      }
+      else {
+        Parent::firstOut(e,n);
+        e.forward = true;
+      }
+    }
+    void nextOut(Arc &e) const {
+      if( ! e.forward ) {
+        Node n = Parent::target(e);
+        Parent::nextIn(e);
+        if( Edge(e) == INVALID ) {
+          Parent::firstOut(e, n);
+          e.forward = true;
+        }
+      }
+      else {
+        Parent::nextOut(e);
+      }
+    }
+
+    void firstIn(Arc &e, const Node &n) const {
+      Parent::firstOut(e,n);
+      if( Edge(e) != INVALID ) {
+        e.forward = false;
+      }
+      else {
+        Parent::firstIn(e,n);
+        e.forward = true;
+      }
+    }
+    void nextIn(Arc &e) const {
+      if( ! e.forward ) {
+        Node n = Parent::source(e);
+        Parent::nextOut(e);
+        if( Edge(e) == INVALID ) {
+          Parent::firstIn(e, n);
+          e.forward = true;
+        }
+      }
+      else {
+        Parent::nextIn(e);
+      }
+    }
+
+    void firstInc(Edge &e, bool &d, const Node &n) const {
+      d = true;
+      Parent::firstOut(e, n);
+      if (e != INVALID) return;
+      d = false;
+      Parent::firstIn(e, n);
+    }
+
+    void nextInc(Edge &e, bool &d) const {
+      if (d) {
+        Node s = Parent::source(e);
+        Parent::nextOut(e);
+        if (e != INVALID) return;
+        d = false;
+        Parent::firstIn(e, s);
+      } else {
+        Parent::nextIn(e);
+      }
+    }
+
+    Node nodeFromId(int ix) const {
+      return Parent::nodeFromId(ix);
+    }
+
+    Arc arcFromId(int ix) const {
+      return direct(Parent::arcFromId(ix >> 1), bool(ix & 1));
+    }
+
+    Edge edgeFromId(int ix) const {
+      return Parent::arcFromId(ix);
+    }
+
+    int id(const Node &n) const {
+      return Parent::id(n);
+    }
+
+    int id(const Edge &e) const {
+      return Parent::id(e);
+    }
+
+    int id(const Arc &e) const {
+      return 2 * Parent::id(e) + int(e.forward);
+    }
+
+    int maxNodeId() const {
+      return Parent::maxNodeId();
+    }
+
+    int maxArcId() const {
+      return 2 * Parent::maxArcId() + 1;
+    }
+
+    int maxEdgeId() const {
+      return Parent::maxArcId();
+    }
+
+    int arcNum() const {
+      return 2 * Parent::arcNum();
+    }
+
+    int edgeNum() const {
+      return Parent::arcNum();
+    }
+
+    Arc findArc(Node s, Node t, Arc p = INVALID) const {
+      if (p == INVALID) {
+        Edge arc = Parent::findArc(s, t);
+        if (arc != INVALID) return direct(arc, true);
+        arc = Parent::findArc(t, s);
+        if (arc != INVALID) return direct(arc, false);
+      } else if (direction(p)) {
+        Edge arc = Parent::findArc(s, t, p);
+        if (arc != INVALID) return direct(arc, true);
+        arc = Parent::findArc(t, s);
+        if (arc != INVALID) return direct(arc, false);
+      } else {
+        Edge arc = Parent::findArc(t, s, p);
+        if (arc != INVALID) return direct(arc, false);
+      }
+      return INVALID;
+    }
+
+    Edge findEdge(Node s, Node t, Edge p = INVALID) const {
+      if (s != t) {
+        if (p == INVALID) {
+          Edge arc = Parent::findArc(s, t);
+          if (arc != INVALID) return arc;
+          arc = Parent::findArc(t, s);
+          if (arc != INVALID) return arc;
+        } else if (Parent::s(p) == s) {
+          Edge arc = Parent::findArc(s, t, p);
+          if (arc != INVALID) return arc;
+          arc = Parent::findArc(t, s);
+          if (arc != INVALID) return arc;
+        } else {
+          Edge arc = Parent::findArc(t, s, p);
+          if (arc != INVALID) return arc;
+        }
+      } else {
+        return Parent::findArc(s, t, p);
+      }
+      return INVALID;
+    }
+  };
+
+  template <typename Base>
+  class BidirBpGraphExtender : public Base {
+  public:
+    typedef Base Parent;
+    typedef BidirBpGraphExtender Digraph;
+
+    typedef typename Parent::Node Node;
+    typedef typename Parent::Edge Edge;
+
+
+    using Parent::first;
+    using Parent::next;
+
+    using Parent::id;
+
+    class Red : public Node {
+      friend class BidirBpGraphExtender;
+    public:
+      Red() {}
+      Red(const Node& node) : Node(node) {
+        LEMON_DEBUG(Parent::red(node) || node == INVALID,
+                    typename Parent::NodeSetError());
+      }
+      Red& operator=(const Node& node) {
+        LEMON_DEBUG(Parent::red(node) || node == INVALID,
+                    typename Parent::NodeSetError());
+        Node::operator=(node);
+        return *this;
+      }
+      Red(Invalid) : Node(INVALID) {}
+      Red& operator=(Invalid) {
+        Node::operator=(INVALID);
+        return *this;
+      }
+    };
+
+    void first(Red& node) const {
+      Parent::firstRed(static_cast<Node&>(node));
+    }
+    void next(Red& node) const {
+      Parent::nextRed(static_cast<Node&>(node));
+    }
+
+    int id(const Red& node) const {
+      return Parent::redId(node);
+    }
+
+    class Blue : public Node {
+      friend class BidirBpGraphExtender;
+    public:
+      Blue() {}
+      Blue(const Node& node) : Node(node) {
+        LEMON_DEBUG(Parent::blue(node) || node == INVALID,
+                    typename Parent::NodeSetError());
+      }
+      Blue& operator=(const Node& node) {
+        LEMON_DEBUG(Parent::blue(node) || node == INVALID,
+                    typename Parent::NodeSetError());
+        Node::operator=(node);
+        return *this;
+      }
+      Blue(Invalid) : Node(INVALID) {}
+      Blue& operator=(Invalid) {
+        Node::operator=(INVALID);
+        return *this;
+      }
+    };
+
+    void first(Blue& node) const {
+      Parent::firstBlue(static_cast<Node&>(node));
+    }
+    void next(Blue& node) const {
+      Parent::nextBlue(static_cast<Node&>(node));
+    }
+
+    int id(const Blue& node) const {
+      return Parent::redId(node);
+    }
+
+    Node source(const Edge& arc) const {
+      return red(arc);
+    }
+    Node target(const Edge& arc) const {
+      return blue(arc);
+    }
+
+    void firstInc(Edge& arc, bool& dir, const Node& node) const {
+      if (Parent::red(node)) {
+        Parent::firstFromRed(arc, node);
+        dir = true;
+      } else {
+        Parent::firstFromBlue(arc, node);
+        dir = static_cast<Edge&>(arc) == INVALID;
+      }
+    }
+    void nextInc(Edge& arc, bool& dir) const {
+      if (dir) {
+        Parent::nextFromRed(arc);
+      } else {
+        Parent::nextFromBlue(arc);
+        if (arc == INVALID) dir = true;
+      }
+    }
+
+    class Arc : public Edge {
+      friend class BidirBpGraphExtender;
+    protected:
+      bool forward;
+
+      Arc(const Edge& arc, bool _forward)
+        : Edge(arc), forward(_forward) {}
+
+    public:
+      Arc() {}
+      Arc (Invalid) : Edge(INVALID), forward(true) {}
+      bool operator==(const Arc& i) const {
+        return Edge::operator==(i) && forward == i.forward;
+      }
+      bool operator!=(const Arc& i) const {
+        return Edge::operator!=(i) || forward != i.forward;
+      }
+      bool operator<(const Arc& i) const {
+        return Edge::operator<(i) ||
+          (!(i.forward<forward) && Edge(*this)<Edge(i));
+      }
+    };
+
+    void first(Arc& arc) const {
+      Parent::first(static_cast<Edge&>(arc));
+      arc.forward = true;
+    }
+
+    void next(Arc& arc) const {
+      if (!arc.forward) {
+        Parent::next(static_cast<Edge&>(arc));
+      }
+      arc.forward = !arc.forward;
+    }
+
+    void firstOut(Arc& arc, const Node& node) const {
+      if (Parent::red(node)) {
+        Parent::firstFromRed(arc, node);
+        arc.forward = true;
+      } else {
+        Parent::firstFromBlue(arc, node);
+        arc.forward = static_cast<Edge&>(arc) == INVALID;
+      }
+    }
+    void nextOut(Arc& arc) const {
+      if (arc.forward) {
+        Parent::nextFromRed(arc);
+      } else {
+        Parent::nextFromBlue(arc);
+        arc.forward = static_cast<Edge&>(arc) == INVALID;
+      }
+    }
+
+    void firstIn(Arc& arc, const Node& node) const {
+      if (Parent::blue(node)) {
+        Parent::firstFromBlue(arc, node);
+        arc.forward = true;
+      } else {
+        Parent::firstFromRed(arc, node);
+        arc.forward = static_cast<Edge&>(arc) == INVALID;
+      }
+    }
+    void nextIn(Arc& arc) const {
+      if (arc.forward) {
+        Parent::nextFromBlue(arc);
+      } else {
+        Parent::nextFromRed(arc);
+        arc.forward = static_cast<Edge&>(arc) == INVALID;
+      }
+    }
+
+    Node source(const Arc& arc) const {
+      return arc.forward ? Parent::red(arc) : Parent::blue(arc);
+    }
+    Node target(const Arc& arc) const {
+      return arc.forward ? Parent::blue(arc) : Parent::red(arc);
+    }
+
+    int id(const Arc& arc) const {
+      return (Parent::id(static_cast<const Edge&>(arc)) << 1) +
+        (arc.forward ? 0 : 1);
+    }
+    Arc arcFromId(int ix) const {
+      return Arc(Parent::fromEdgeId(ix >> 1), (ix & 1) == 0);
+    }
+    int maxArcId() const {
+      return (Parent::maxEdgeId() << 1) + 1;
+    }
+
+    bool direction(const Arc& arc) const {
+      return arc.forward;
+    }
+
+    Arc direct(const Edge& arc, bool dir) const {
+      return Arc(arc, dir);
+    }
+
+    int arcNum() const {
+      return 2 * Parent::edgeNum();
+    }
+
+    int edgeNum() const {
+      return Parent::edgeNum();
+    }
+
+
+  };
+}
+
+#endif
Index: lemon/bits/bezier.h
===================================================================
--- lemon/bits/bezier.h	(revision 463)
+++ lemon/bits/bezier.h	(revision 314)
@@ -3,5 +3,5 @@
  * This file is a part of LEMON, a generic C++ optimization library.
  *
- * Copyright (C) 2003-2009
+ * Copyright (C) 2003-2008
  * Egervary Jeno Kombinatorikus Optimalizalasi Kutatocsoport
  * (Egervary Research Group on Combinatorial Optimization, EGRES).
Index: lemon/bits/default_map.h
===================================================================
--- lemon/bits/default_map.h	(revision 956)
+++ lemon/bits/default_map.h	(revision 540)
@@ -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).
@@ -154,14 +154,13 @@
   class DefaultMap
     : public DefaultMapSelector<_Graph, _Item, _Value>::Map {
+  public:
     typedef typename DefaultMapSelector<_Graph, _Item, _Value>::Map Parent;
-
-  public:
     typedef DefaultMap<_Graph, _Item, _Value> Map;
 
-    typedef typename Parent::GraphType GraphType;
+    typedef typename Parent::Graph Graph;
     typedef typename Parent::Value Value;
 
-    explicit DefaultMap(const GraphType& graph) : Parent(graph) {}
-    DefaultMap(const GraphType& graph, const Value& value)
+    explicit DefaultMap(const Graph& graph) : Parent(graph) {}
+    DefaultMap(const Graph& graph, const Value& value)
       : Parent(graph, value) {}
 
Index: mon/bits/edge_set_extender.h
===================================================================
--- lemon/bits/edge_set_extender.h	(revision 968)
+++ 	(revision )
@@ -1,627 +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_BITS_EDGE_SET_EXTENDER_H
-#define LEMON_BITS_EDGE_SET_EXTENDER_H
-
-#include <lemon/core.h>
-#include <lemon/error.h>
-#include <lemon/bits/default_map.h>
-#include <lemon/bits/map_extender.h>
-
-//\ingroup digraphbits
-//\file
-//\brief Extenders for the arc set types
-namespace lemon {
-
-  // \ingroup digraphbits
-  //
-  // \brief Extender for the ArcSets
-  template <typename Base>
-  class ArcSetExtender : public Base {
-    typedef Base Parent;
-
-  public:
-
-    typedef ArcSetExtender Digraph;
-
-    // Base extensions
-
-    typedef typename Parent::Node Node;
-    typedef typename Parent::Arc Arc;
-
-    int maxId(Node) const {
-      return Parent::maxNodeId();
-    }
-
-    int maxId(Arc) const {
-      return Parent::maxArcId();
-    }
-
-    Node fromId(int id, Node) const {
-      return Parent::nodeFromId(id);
-    }
-
-    Arc fromId(int id, Arc) const {
-      return Parent::arcFromId(id);
-    }
-
-    Node oppositeNode(const Node &n, const Arc &e) const {
-      if (n == Parent::source(e))
-        return Parent::target(e);
-      else if(n==Parent::target(e))
-        return Parent::source(e);
-      else
-        return INVALID;
-    }
-
-
-    // Alteration notifier extensions
-
-    // The arc observer registry.
-    typedef AlterationNotifier<ArcSetExtender, Arc> ArcNotifier;
-
-  protected:
-
-    mutable ArcNotifier arc_notifier;
-
-  public:
-
-    using Parent::notifier;
-
-    // Gives back the arc alteration notifier.
-    ArcNotifier& notifier(Arc) const {
-      return arc_notifier;
-    }
-
-    // Iterable extensions
-
-    class NodeIt : public Node {
-      const Digraph* digraph;
-    public:
-
-      NodeIt() {}
-
-      NodeIt(Invalid i) : Node(i) { }
-
-      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 {
-      const Digraph* digraph;
-    public:
-
-      ArcIt() { }
-
-      ArcIt(Invalid i) : Arc(i) { }
-
-      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 {
-      const Digraph* digraph;
-    public:
-
-      OutArcIt() { }
-
-      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 {
-      const Digraph* digraph;
-    public:
-
-      InArcIt() { }
-
-      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;
-      }
-
-    };
-
-    // \brief Base node of the iterator
-    //
-    // Returns the base node (ie. the source in this case) of the iterator
-    Node baseNode(const OutArcIt &e) const {
-      return Parent::source(static_cast<const Arc&>(e));
-    }
-    // \brief Running node of the iterator
-    //
-    // Returns the running node (ie. the target in this case) of the
-    // iterator
-    Node runningNode(const OutArcIt &e) const {
-      return Parent::target(static_cast<const Arc&>(e));
-    }
-
-    // \brief Base node of the iterator
-    //
-    // Returns the base node (ie. the target in this case) of the iterator
-    Node baseNode(const InArcIt &e) const {
-      return Parent::target(static_cast<const Arc&>(e));
-    }
-    // \brief Running node of the iterator
-    //
-    // Returns the running node (ie. the source in this case) of the
-    // iterator
-    Node runningNode(const InArcIt &e) const {
-      return Parent::source(static_cast<const Arc&>(e));
-    }
-
-    using Parent::first;
-
-    // Mappable extension
-
-    template <typename _Value>
-    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) {}
-
-      ArcMap& operator=(const ArcMap& cmap) {
-        return operator=<ArcMap>(cmap);
-      }
-
-      template <typename CMap>
-      ArcMap& operator=(const CMap& cmap) {
-        Parent::operator=(cmap);
-        return *this;
-      }
-
-    };
-
-
-    // Alteration extension
-
-    Arc addArc(const Node& from, const Node& to) {
-      Arc arc = Parent::addArc(from, to);
-      notifier(Arc()).add(arc);
-      return arc;
-    }
-
-    void clear() {
-      notifier(Arc()).clear();
-      Parent::clear();
-    }
-
-    void erase(const Arc& arc) {
-      notifier(Arc()).erase(arc);
-      Parent::erase(arc);
-    }
-
-    ArcSetExtender() {
-      arc_notifier.setContainer(*this);
-    }
-
-    ~ArcSetExtender() {
-      arc_notifier.clear();
-    }
-
-  };
-
-
-  // \ingroup digraphbits
-  //
-  // \brief Extender for the EdgeSets
-  template <typename Base>
-  class EdgeSetExtender : public Base {
-    typedef Base Parent;
-
-  public:
-
-    typedef EdgeSetExtender Graph;
-
-    typedef True UndirectedTag;
-
-    typedef typename Parent::Node Node;
-    typedef typename Parent::Arc Arc;
-    typedef typename Parent::Edge Edge;
-
-    int maxId(Node) const {
-      return Parent::maxNodeId();
-    }
-
-    int maxId(Arc) const {
-      return Parent::maxArcId();
-    }
-
-    int maxId(Edge) const {
-      return Parent::maxEdgeId();
-    }
-
-    Node fromId(int id, Node) const {
-      return Parent::nodeFromId(id);
-    }
-
-    Arc fromId(int id, Arc) const {
-      return Parent::arcFromId(id);
-    }
-
-    Edge fromId(int id, Edge) const {
-      return Parent::edgeFromId(id);
-    }
-
-    Node oppositeNode(const Node &n, const Edge &e) const {
-      if( n == Parent::u(e))
-        return Parent::v(e);
-      else if( n == Parent::v(e))
-        return Parent::u(e);
-      else
-        return INVALID;
-    }
-
-    Arc oppositeArc(const Arc &e) const {
-      return Parent::direct(e, !Parent::direction(e));
-    }
-
-    using Parent::direct;
-    Arc direct(const Edge &e, const Node &s) const {
-      return Parent::direct(e, Parent::u(e) == s);
-    }
-
-    typedef AlterationNotifier<EdgeSetExtender, Arc> ArcNotifier;
-    typedef AlterationNotifier<EdgeSetExtender, Edge> EdgeNotifier;
-
-
-  protected:
-
-    mutable ArcNotifier arc_notifier;
-    mutable EdgeNotifier edge_notifier;
-
-  public:
-
-    using Parent::notifier;
-
-    ArcNotifier& notifier(Arc) const {
-      return arc_notifier;
-    }
-
-    EdgeNotifier& notifier(Edge) const {
-      return edge_notifier;
-    }
-
-
-    class NodeIt : public Node {
-      const Graph* graph;
-    public:
-
-      NodeIt() {}
-
-      NodeIt(Invalid i) : Node(i) { }
-
-      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 {
-      const Graph* graph;
-    public:
-
-      ArcIt() { }
-
-      ArcIt(Invalid i) : Arc(i) { }
-
-      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 {
-      const Graph* graph;
-    public:
-
-      OutArcIt() { }
-
-      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 {
-      const Graph* graph;
-    public:
-
-      InArcIt() { }
-
-      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 {
-      const Graph* graph;
-    public:
-
-      EdgeIt() { }
-
-      EdgeIt(Invalid i) : Edge(i) { }
-
-      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;
-      }
-
-    };
-
-    class IncEdgeIt : public Parent::Edge {
-      friend class EdgeSetExtender;
-      const Graph* graph;
-      bool direction;
-    public:
-
-      IncEdgeIt() { }
-
-      IncEdgeIt(Invalid i) : Edge(i), direction(false) { }
-
-      IncEdgeIt(const Graph& _graph, const Node &n) : graph(&_graph) {
-        _graph.firstInc(*this, direction, n);
-      }
-
-      IncEdgeIt(const Graph& _graph, const Edge &ue, const Node &n)
-        : graph(&_graph), Edge(ue) {
-        direction = (_graph.source(ue) == n);
-      }
-
-      IncEdgeIt& operator++() {
-        graph->nextInc(*this, direction);
-        return *this;
-      }
-    };
-
-    // \brief Base node of the iterator
-    //
-    // Returns the base node (ie. the source in this case) of the iterator
-    Node baseNode(const OutArcIt &e) const {
-      return Parent::source(static_cast<const Arc&>(e));
-    }
-    // \brief Running node of the iterator
-    //
-    // Returns the running node (ie. the target in this case) of the
-    // iterator
-    Node runningNode(const OutArcIt &e) const {
-      return Parent::target(static_cast<const Arc&>(e));
-    }
-
-    // \brief Base node of the iterator
-    //
-    // Returns the base node (ie. the target in this case) of the iterator
-    Node baseNode(const InArcIt &e) const {
-      return Parent::target(static_cast<const Arc&>(e));
-    }
-    // \brief Running node of the iterator
-    //
-    // Returns the running node (ie. the source in this case) of the
-    // iterator
-    Node runningNode(const InArcIt &e) const {
-      return Parent::source(static_cast<const Arc&>(e));
-    }
-
-    // Base node of the iterator
-    //
-    // Returns the base node of the iterator
-    Node baseNode(const IncEdgeIt &e) const {
-      return e.direction ? u(e) : v(e);
-    }
-    // Running node of the iterator
-    //
-    // Returns the running node of the iterator
-    Node runningNode(const IncEdgeIt &e) const {
-      return e.direction ? v(e) : u(e);
-    }
-
-
-    template <typename _Value>
-    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) {}
-
-      ArcMap& operator=(const ArcMap& cmap) {
-        return operator=<ArcMap>(cmap);
-      }
-
-      template <typename CMap>
-      ArcMap& operator=(const CMap& cmap) {
-        Parent::operator=(cmap);
-        return *this;
-      }
-
-    };
-
-
-    template <typename _Value>
-    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) {}
-
-      EdgeMap& operator=(const EdgeMap& cmap) {
-        return operator=<EdgeMap>(cmap);
-      }
-
-      template <typename CMap>
-      EdgeMap& operator=(const CMap& cmap) {
-        Parent::operator=(cmap);
-        return *this;
-      }
-
-    };
-
-
-    // Alteration extension
-
-    Edge addEdge(const Node& from, const Node& to) {
-      Edge edge = Parent::addEdge(from, to);
-      notifier(Edge()).add(edge);
-      std::vector<Arc> arcs;
-      arcs.push_back(Parent::direct(edge, true));
-      arcs.push_back(Parent::direct(edge, false));
-      notifier(Arc()).add(arcs);
-      return edge;
-    }
-
-    void clear() {
-      notifier(Arc()).clear();
-      notifier(Edge()).clear();
-      Parent::clear();
-    }
-
-    void erase(const Edge& edge) {
-      std::vector<Arc> arcs;
-      arcs.push_back(Parent::direct(edge, true));
-      arcs.push_back(Parent::direct(edge, false));
-      notifier(Arc()).erase(arcs);
-      notifier(Edge()).erase(edge);
-      Parent::erase(edge);
-    }
-
-
-    EdgeSetExtender() {
-      arc_notifier.setContainer(*this);
-      edge_notifier.setContainer(*this);
-    }
-
-    ~EdgeSetExtender() {
-      edge_notifier.clear();
-      arc_notifier.clear();
-    }
-
-  };
-
-}
-
-#endif
Index: lemon/bits/enable_if.h
===================================================================
--- lemon/bits/enable_if.h	(revision 463)
+++ lemon/bits/enable_if.h	(revision 314)
@@ -3,5 +3,5 @@
  * This file is a part of LEMON, a generic C++ optimization library.
  *
- * Copyright (C) 2003-2009
+ * Copyright (C) 2003-2008
  * Egervary Jeno Kombinatorikus Optimalizalasi Kutatocsoport
  * (Egervary Research Group on Combinatorial Optimization, EGRES).
Index: mon/bits/graph_adaptor_extender.h
===================================================================
--- lemon/bits/graph_adaptor_extender.h	(revision 965)
+++ 	(revision )
@@ -1,401 +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_BITS_GRAPH_ADAPTOR_EXTENDER_H
-#define LEMON_BITS_GRAPH_ADAPTOR_EXTENDER_H
-
-#include <lemon/core.h>
-#include <lemon/error.h>
-
-namespace lemon {
-
-  template <typename _Digraph>
-  class DigraphAdaptorExtender : public _Digraph {
-    typedef _Digraph Parent;
-
-  public:
-
-    typedef _Digraph Digraph;
-    typedef DigraphAdaptorExtender Adaptor;
-
-    // Base extensions
-
-    typedef typename Parent::Node Node;
-    typedef typename Parent::Arc Arc;
-
-    int maxId(Node) const {
-      return Parent::maxNodeId();
-    }
-
-    int maxId(Arc) const {
-      return Parent::maxArcId();
-    }
-
-    Node fromId(int id, Node) const {
-      return Parent::nodeFromId(id);
-    }
-
-    Arc fromId(int id, Arc) const {
-      return Parent::arcFromId(id);
-    }
-
-    Node oppositeNode(const Node &n, const Arc &e) const {
-      if (n == Parent::source(e))
-        return Parent::target(e);
-      else if(n==Parent::target(e))
-        return Parent::source(e);
-      else
-        return INVALID;
-    }
-
-    class NodeIt : public Node {
-      const Adaptor* _adaptor;
-    public:
-
-      NodeIt() {}
-
-      NodeIt(Invalid i) : Node(i) { }
-
-      explicit NodeIt(const Adaptor& adaptor) : _adaptor(&adaptor) {
-        _adaptor->first(static_cast<Node&>(*this));
-      }
-
-      NodeIt(const Adaptor& adaptor, const Node& node)
-        : Node(node), _adaptor(&adaptor) {}
-
-      NodeIt& operator++() {
-        _adaptor->next(*this);
-        return *this;
-      }
-
-    };
-
-
-    class ArcIt : public Arc {
-      const Adaptor* _adaptor;
-    public:
-
-      ArcIt() { }
-
-      ArcIt(Invalid i) : Arc(i) { }
-
-      explicit ArcIt(const Adaptor& adaptor) : _adaptor(&adaptor) {
-        _adaptor->first(static_cast<Arc&>(*this));
-      }
-
-      ArcIt(const Adaptor& adaptor, const Arc& e) :
-        Arc(e), _adaptor(&adaptor) { }
-
-      ArcIt& operator++() {
-        _adaptor->next(*this);
-        return *this;
-      }
-
-    };
-
-
-    class OutArcIt : public Arc {
-      const Adaptor* _adaptor;
-    public:
-
-      OutArcIt() { }
-
-      OutArcIt(Invalid i) : Arc(i) { }
-
-      OutArcIt(const Adaptor& adaptor, const Node& node)
-        : _adaptor(&adaptor) {
-        _adaptor->firstOut(*this, node);
-      }
-
-      OutArcIt(const Adaptor& adaptor, const Arc& arc)
-        : Arc(arc), _adaptor(&adaptor) {}
-
-      OutArcIt& operator++() {
-        _adaptor->nextOut(*this);
-        return *this;
-      }
-
-    };
-
-
-    class InArcIt : public Arc {
-      const Adaptor* _adaptor;
-    public:
-
-      InArcIt() { }
-
-      InArcIt(Invalid i) : Arc(i) { }
-
-      InArcIt(const Adaptor& adaptor, const Node& node)
-        : _adaptor(&adaptor) {
-        _adaptor->firstIn(*this, node);
-      }
-
-      InArcIt(const Adaptor& adaptor, const Arc& arc) :
-        Arc(arc), _adaptor(&adaptor) {}
-
-      InArcIt& operator++() {
-        _adaptor->nextIn(*this);
-        return *this;
-      }
-
-    };
-
-    Node baseNode(const OutArcIt &e) const {
-      return Parent::source(e);
-    }
-    Node runningNode(const OutArcIt &e) const {
-      return Parent::target(e);
-    }
-
-    Node baseNode(const InArcIt &e) const {
-      return Parent::target(e);
-    }
-    Node runningNode(const InArcIt &e) const {
-      return Parent::source(e);
-    }
-
-  };
-
-  template <typename _Graph>
-  class GraphAdaptorExtender : public _Graph {
-    typedef _Graph Parent;
-
-  public:
-
-    typedef _Graph Graph;
-    typedef GraphAdaptorExtender Adaptor;
-
-    typedef True UndirectedTag;
-
-    typedef typename Parent::Node Node;
-    typedef typename Parent::Arc Arc;
-    typedef typename Parent::Edge Edge;
-
-    // Graph extension
-
-    int maxId(Node) const {
-      return Parent::maxNodeId();
-    }
-
-    int maxId(Arc) const {
-      return Parent::maxArcId();
-    }
-
-    int maxId(Edge) const {
-      return Parent::maxEdgeId();
-    }
-
-    Node fromId(int id, Node) const {
-      return Parent::nodeFromId(id);
-    }
-
-    Arc fromId(int id, Arc) const {
-      return Parent::arcFromId(id);
-    }
-
-    Edge fromId(int id, Edge) const {
-      return Parent::edgeFromId(id);
-    }
-
-    Node oppositeNode(const Node &n, const Edge &e) const {
-      if( n == Parent::u(e))
-        return Parent::v(e);
-      else if( n == Parent::v(e))
-        return Parent::u(e);
-      else
-        return INVALID;
-    }
-
-    Arc oppositeArc(const Arc &a) const {
-      return Parent::direct(a, !Parent::direction(a));
-    }
-
-    using Parent::direct;
-    Arc direct(const Edge &e, const Node &s) const {
-      return Parent::direct(e, Parent::u(e) == s);
-    }
-
-
-    class NodeIt : public Node {
-      const Adaptor* _adaptor;
-    public:
-
-      NodeIt() {}
-
-      NodeIt(Invalid i) : Node(i) { }
-
-      explicit NodeIt(const Adaptor& adaptor) : _adaptor(&adaptor) {
-        _adaptor->first(static_cast<Node&>(*this));
-      }
-
-      NodeIt(const Adaptor& adaptor, const Node& node)
-        : Node(node), _adaptor(&adaptor) {}
-
-      NodeIt& operator++() {
-        _adaptor->next(*this);
-        return *this;
-      }
-
-    };
-
-
-    class ArcIt : public Arc {
-      const Adaptor* _adaptor;
-    public:
-
-      ArcIt() { }
-
-      ArcIt(Invalid i) : Arc(i) { }
-
-      explicit ArcIt(const Adaptor& adaptor) : _adaptor(&adaptor) {
-        _adaptor->first(static_cast<Arc&>(*this));
-      }
-
-      ArcIt(const Adaptor& adaptor, const Arc& e) :
-        Arc(e), _adaptor(&adaptor) { }
-
-      ArcIt& operator++() {
-        _adaptor->next(*this);
-        return *this;
-      }
-
-    };
-
-
-    class OutArcIt : public Arc {
-      const Adaptor* _adaptor;
-    public:
-
-      OutArcIt() { }
-
-      OutArcIt(Invalid i) : Arc(i) { }
-
-      OutArcIt(const Adaptor& adaptor, const Node& node)
-        : _adaptor(&adaptor) {
-        _adaptor->firstOut(*this, node);
-      }
-
-      OutArcIt(const Adaptor& adaptor, const Arc& arc)
-        : Arc(arc), _adaptor(&adaptor) {}
-
-      OutArcIt& operator++() {
-        _adaptor->nextOut(*this);
-        return *this;
-      }
-
-    };
-
-
-    class InArcIt : public Arc {
-      const Adaptor* _adaptor;
-    public:
-
-      InArcIt() { }
-
-      InArcIt(Invalid i) : Arc(i) { }
-
-      InArcIt(const Adaptor& adaptor, const Node& node)
-        : _adaptor(&adaptor) {
-        _adaptor->firstIn(*this, node);
-      }
-
-      InArcIt(const Adaptor& adaptor, const Arc& arc) :
-        Arc(arc), _adaptor(&adaptor) {}
-
-      InArcIt& operator++() {
-        _adaptor->nextIn(*this);
-        return *this;
-      }
-
-    };
-
-    class EdgeIt : public Parent::Edge {
-      const Adaptor* _adaptor;
-    public:
-
-      EdgeIt() { }
-
-      EdgeIt(Invalid i) : Edge(i) { }
-
-      explicit EdgeIt(const Adaptor& adaptor) : _adaptor(&adaptor) {
-        _adaptor->first(static_cast<Edge&>(*this));
-      }
-
-      EdgeIt(const Adaptor& adaptor, const Edge& e) :
-        Edge(e), _adaptor(&adaptor) { }
-
-      EdgeIt& operator++() {
-        _adaptor->next(*this);
-        return *this;
-      }
-
-    };
-
-    class IncEdgeIt : public Edge {
-      friend class GraphAdaptorExtender;
-      const Adaptor* _adaptor;
-      bool direction;
-    public:
-
-      IncEdgeIt() { }
-
-      IncEdgeIt(Invalid i) : Edge(i), direction(false) { }
-
-      IncEdgeIt(const Adaptor& adaptor, const Node &n) : _adaptor(&adaptor) {
-        _adaptor->firstInc(static_cast<Edge&>(*this), direction, n);
-      }
-
-      IncEdgeIt(const Adaptor& adaptor, const Edge &e, const Node &n)
-        : _adaptor(&adaptor), Edge(e) {
-        direction = (_adaptor->u(e) == n);
-      }
-
-      IncEdgeIt& operator++() {
-        _adaptor->nextInc(*this, direction);
-        return *this;
-      }
-    };
-
-    Node baseNode(const OutArcIt &a) const {
-      return Parent::source(a);
-    }
-    Node runningNode(const OutArcIt &a) const {
-      return Parent::target(a);
-    }
-
-    Node baseNode(const InArcIt &a) const {
-      return Parent::target(a);
-    }
-    Node runningNode(const InArcIt &a) const {
-      return Parent::source(a);
-    }
-
-    Node baseNode(const IncEdgeIt &e) const {
-      return e.direction ? Parent::u(e) : Parent::v(e);
-    }
-    Node runningNode(const IncEdgeIt &e) const {
-      return e.direction ? Parent::v(e) : Parent::u(e);
-    }
-
-  };
-
-}
-
-
-#endif
Index: lemon/bits/graph_extender.h
===================================================================
--- lemon/bits/graph_extender.h	(revision 825)
+++ lemon/bits/graph_extender.h	(revision 314)
@@ -3,5 +3,5 @@
  * This file is a part of LEMON, a generic C++ optimization library.
  *
- * Copyright (C) 2003-2009
+ * Copyright (C) 2003-2008
  * Egervary Jeno Kombinatorikus Optimalizalasi Kutatocsoport
  * (Egervary Research Group on Combinatorial Optimization, EGRES).
@@ -30,16 +30,15 @@
 //\ingroup graphbits
 //\file
-//\brief Extenders for the graph types
+//\brief Extenders for the digraph types
 namespace lemon {
 
   // \ingroup graphbits
   //
-  // \brief Extender for the digraph implementations
+  // \brief Extender for the Digraphs
   template <typename Base>
   class DigraphExtender : public Base {
+  public:
+
     typedef Base Parent;
-
-  public:
-
     typedef DigraphExtender Digraph;
 
@@ -57,9 +56,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);
     }
@@ -220,7 +219,8 @@
     class NodeMap
       : public MapExtender<DefaultMap<Digraph, Node, _Value> > {
+    public:
+      typedef DigraphExtender Digraph;
       typedef MapExtender<DefaultMap<Digraph, Node, _Value> > Parent;
 
-    public:
       explicit NodeMap(const Digraph& digraph)
         : Parent(digraph) {}
@@ -244,7 +244,8 @@
     class ArcMap
       : public MapExtender<DefaultMap<Digraph, Arc, _Value> > {
+    public:
+      typedef DigraphExtender Digraph;
       typedef MapExtender<DefaultMap<Digraph, Arc, _Value> > Parent;
 
-    public:
       explicit ArcMap(const Digraph& digraph)
         : Parent(digraph) {}
@@ -330,8 +331,7 @@
   template <typename Base>
   class GraphExtender : public Base {
+  public:
+
     typedef Base Parent;
-
-  public:
-
     typedef GraphExtender Graph;
 
@@ -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);
     }
@@ -602,8 +602,9 @@
     class NodeMap
       : public MapExtender<DefaultMap<Graph, Node, _Value> > {
+    public:
+      typedef GraphExtender Graph;
       typedef MapExtender<DefaultMap<Graph, Node, _Value> > Parent;
 
-    public:
-      explicit NodeMap(const Graph& graph)
+      NodeMap(const Graph& graph)
         : Parent(graph) {}
       NodeMap(const Graph& graph, const _Value& value)
@@ -626,8 +627,9 @@
     class ArcMap
       : public MapExtender<DefaultMap<Graph, Arc, _Value> > {
+    public:
+      typedef GraphExtender Graph;
       typedef MapExtender<DefaultMap<Graph, Arc, _Value> > Parent;
 
-    public:
-      explicit ArcMap(const Graph& graph)
+      ArcMap(const Graph& graph)
         : Parent(graph) {}
       ArcMap(const Graph& graph, const _Value& value)
@@ -650,8 +652,9 @@
     class EdgeMap
       : public MapExtender<DefaultMap<Graph, Edge, _Value> > {
+    public:
+      typedef GraphExtender Graph;
       typedef MapExtender<DefaultMap<Graph, Edge, _Value> > Parent;
 
-    public:
-      explicit EdgeMap(const Graph& graph)
+      EdgeMap(const Graph& graph)
         : Parent(graph) {}
 
Index: lemon/bits/map_extender.h
===================================================================
--- lemon/bits/map_extender.h	(revision 867)
+++ lemon/bits/map_extender.h	(revision 865)
@@ -3,5 +3,5 @@
  * This file is a part of LEMON, a generic C++ optimization library.
  *
- * Copyright (C) 2003-2009
+ * Copyright (C) 2003-2008
  * Egervary Jeno Kombinatorikus Optimalizalasi Kutatocsoport
  * (Egervary Research Group on Combinatorial Optimization, EGRES).
@@ -37,18 +37,15 @@
   template <typename _Map>
   class MapExtender : public _Map {
+  public:
+
     typedef _Map Parent;
-    typedef typename Parent::GraphType GraphType;
-
-  public:
-
     typedef MapExtender Map;
+
+
+    typedef typename Parent::Graph Graph;
     typedef typename Parent::Key Item;
 
     typedef typename Parent::Key Key;
     typedef typename Parent::Value Value;
-    typedef typename Parent::Reference Reference;
-    typedef typename Parent::ConstReference ConstReference;
-
-    typedef typename Parent::ReferenceMapTag ReferenceMapTag;
 
     class MapIt;
@@ -60,8 +57,8 @@
   public:
 
-    MapExtender(const GraphType& graph)
+    MapExtender(const Graph& graph)
       : Parent(graph) {}
 
-    MapExtender(const GraphType& graph, const Value& value)
+    MapExtender(const Graph& graph, const Value& value)
       : Parent(graph, value) {}
 
@@ -79,8 +76,7 @@
   public:
     class MapIt : public Item {
-      typedef Item Parent;
-
-    public:
-
+    public:
+
+      typedef Item Parent;
       typedef typename Map::Value Value;
 
@@ -119,7 +115,7 @@
 
     class ConstMapIt : public Item {
-      typedef Item Parent;
-
-    public:
+    public:
+
+      typedef Item Parent;
 
       typedef typename Map::Value Value;
@@ -150,9 +146,9 @@
 
     class ItemIt : public Item {
-      typedef Item Parent;
-
-    public:
+    public:
+
+      typedef Item Parent;
+
       ItemIt() : map(NULL) {}
-
 
       ItemIt(Invalid i) : Parent(i), map(NULL) {}
@@ -181,18 +177,15 @@
   template <typename _Graph, typename _Map>
   class SubMapExtender : public _Map {
+  public:
+
     typedef _Map Parent;
-    typedef _Graph GraphType;
-
-  public:
-
     typedef SubMapExtender Map;
+
+    typedef _Graph Graph;
+
     typedef typename Parent::Key Item;
 
     typedef typename Parent::Key Key;
     typedef typename Parent::Value Value;
-    typedef typename Parent::Reference Reference;
-    typedef typename Parent::ConstReference ConstReference;
-
-    typedef typename Parent::ReferenceMapTag ReferenceMapTag;
 
     class MapIt;
@@ -204,8 +197,8 @@
   public:
 
-    SubMapExtender(const GraphType& _graph)
+    SubMapExtender(const Graph& _graph)
       : Parent(_graph), graph(_graph) {}
 
-    SubMapExtender(const GraphType& _graph, const Value& _value)
+    SubMapExtender(const Graph& _graph, const Value& _value)
       : Parent(_graph, _value), graph(_graph) {}
 
@@ -227,7 +220,7 @@
   public:
     class MapIt : public Item {
-      typedef Item Parent;
-
-    public:
+    public:
+
+      typedef Item Parent;
       typedef typename Map::Value Value;
 
@@ -266,7 +259,7 @@
 
     class ConstMapIt : public Item {
-      typedef Item Parent;
-
-    public:
+    public:
+
+      typedef Item Parent;
 
       typedef typename Map::Value Value;
@@ -297,9 +290,9 @@
 
     class ItemIt : public Item {
-      typedef Item Parent;
-
-    public:
+    public:
+
+      typedef Item Parent;
+
       ItemIt() : map(NULL) {}
-
 
       ItemIt(Invalid i) : Parent(i), map(NULL) { }
@@ -324,5 +317,5 @@
   private:
 
-    const GraphType& graph;
+    const Graph& graph;
 
   };
Index: lemon/bits/path_dump.h
===================================================================
--- lemon/bits/path_dump.h	(revision 973)
+++ lemon/bits/path_dump.h	(revision 971)
@@ -3,5 +3,5 @@
  * This file is a part of LEMON, a generic C++ optimization library.
  *
- * Copyright (C) 2003-2009
+ * Copyright (C) 2003-2008
  * Egervary Jeno Kombinatorikus Optimalizalasi Kutatocsoport
  * (Egervary Research Group on Combinatorial Optimization, EGRES).
@@ -17,9 +17,6 @@
  */
 
-#ifndef LEMON_BITS_PATH_DUMP_H
-#define LEMON_BITS_PATH_DUMP_H
-
-#include <lemon/core.h>
-#include <lemon/concept_check.h>
+#ifndef LEMON_BITS_PRED_MAP_PATH_H
+#define LEMON_BITS_PRED_MAP_PATH_H
 
 namespace lemon {
Index: mon/bits/solver_bits.h
===================================================================
--- lemon/bits/solver_bits.h	(revision 956)
+++ 	(revision )
@@ -1,193 +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_BITS_SOLVER_BITS_H
-#define LEMON_BITS_SOLVER_BITS_H
-
-#include <vector>
-
-namespace lemon {
-
-  namespace _solver_bits {
-
-    class VarIndex {
-    private:
-      struct ItemT {
-        int prev, next;
-        int index;
-      };
-      std::vector<ItemT> items;
-      int first_item, last_item, first_free_item;
-
-      std::vector<int> cross;
-
-    public:
-
-      VarIndex()
-        : first_item(-1), last_item(-1), first_free_item(-1) {
-      }
-
-      void clear() {
-        first_item = -1;
-        first_free_item = -1;
-        items.clear();
-        cross.clear();
-      }
-
-      int addIndex(int idx) {
-        int n;
-        if (first_free_item == -1) {
-          n = items.size();
-          items.push_back(ItemT());
-        } else {
-          n = first_free_item;
-          first_free_item = items[n].next;
-          if (first_free_item != -1) {
-            items[first_free_item].prev = -1;
-          }
-        }
-        items[n].index = idx;
-        if (static_cast<int>(cross.size()) <= idx) {
-          cross.resize(idx + 1, -1);
-        }
-        cross[idx] = n;
-
-        items[n].prev = last_item;
-        items[n].next = -1;
-        if (last_item != -1) {
-          items[last_item].next = n;
-        } else {
-          first_item = n;
-        }
-        last_item = n;
-
-        return n;
-      }
-
-      int addIndex(int idx, int n) {
-        while (n >= static_cast<int>(items.size())) {
-          items.push_back(ItemT());
-          items.back().prev = -1;
-          items.back().next = first_free_item;
-          if (first_free_item != -1) {
-            items[first_free_item].prev = items.size() - 1;
-          }
-          first_free_item = items.size() - 1;
-        }
-        if (items[n].next != -1) {
-          items[items[n].next].prev = items[n].prev;
-        }
-        if (items[n].prev != -1) {
-          items[items[n].prev].next = items[n].next;
-        } else {
-          first_free_item = items[n].next;
-        }
-
-        items[n].index = idx;
-        if (static_cast<int>(cross.size()) <= idx) {
-          cross.resize(idx + 1, -1);
-        }
-        cross[idx] = n;
-
-        items[n].prev = last_item;
-        items[n].next = -1;
-        if (last_item != -1) {
-          items[last_item].next = n;
-        } else {
-          first_item = n;
-        }
-        last_item = n;
-
-        return n;
-      }
-
-      void eraseIndex(int idx) {
-        int n = cross[idx];
-
-        if (items[n].prev != -1) {
-          items[items[n].prev].next = items[n].next;
-        } else {
-          first_item = items[n].next;
-        }
-        if (items[n].next != -1) {
-          items[items[n].next].prev = items[n].prev;
-        } else {
-          last_item = items[n].prev;
-        }
-
-        if (first_free_item != -1) {
-          items[first_free_item].prev = n;
-        }
-        items[n].next = first_free_item;
-        items[n].prev = -1;
-        first_free_item = n;
-
-        while (!cross.empty() && cross.back() == -1) {
-          cross.pop_back();
-        }
-      }
-
-      int maxIndex() const {
-        return cross.size() - 1;
-      }
-
-      void shiftIndices(int idx) {
-        for (int i = idx + 1; i < static_cast<int>(cross.size()); ++i) {
-          cross[i - 1] = cross[i];
-          if (cross[i] != -1) {
-            --items[cross[i]].index;
-          }
-        }
-        cross.back() = -1;
-        cross.pop_back();
-        while (!cross.empty() && cross.back() == -1) {
-          cross.pop_back();
-        }
-      }
-
-      void relocateIndex(int idx, int jdx) {
-        cross[idx] = cross[jdx];
-        items[cross[jdx]].index = idx;
-        cross[jdx] = -1;
-
-        while (!cross.empty() && cross.back() == -1) {
-          cross.pop_back();
-        }
-      }
-
-      int operator[](int idx) const {
-        return cross[idx];
-      }
-
-      int operator()(int fdx) const {
-        return items[fdx].index;
-      }
-
-      void firstItem(int& fdx) const {
-        fdx = first_item;
-      }
-
-      void nextItem(int& fdx) const {
-        fdx = items[fdx].next;
-      }
-
-    };
-  }
-}
-
-#endif
Index: lemon/bits/traits.h
===================================================================
--- lemon/bits/traits.h	(revision 663)
+++ lemon/bits/traits.h	(revision 314)
@@ -3,5 +3,5 @@
  * This file is a part of LEMON, a generic C++ optimization library.
  *
- * Copyright (C) 2003-2009
+ * Copyright (C) 2003-2008
  * Egervary Jeno Kombinatorikus Optimalizalasi Kutatocsoport
  * (Egervary Research Group on Combinatorial Optimization, EGRES).
@@ -30,42 +30,40 @@
   struct InvalidType {};
 
-  template <typename GR, typename _Item>
+  template <typename _Graph, typename _Item>
   class ItemSetTraits {};
 
 
-  template <typename GR, typename Enable = void>
+  template <typename Graph, typename Enable = void>
   struct NodeNotifierIndicator {
     typedef InvalidType Type;
   };
-  template <typename GR>
+  template <typename Graph>
   struct NodeNotifierIndicator<
-    GR,
-    typename enable_if<typename GR::NodeNotifier::Notifier, void>::type
-  > {
-    typedef typename GR::NodeNotifier Type;
-  };
-
-  template <typename GR>
-  class ItemSetTraits<GR, typename GR::Node> {
+    Graph,
+    typename enable_if<typename Graph::NodeNotifier::Notifier, void>::type
+  > {
+    typedef typename Graph::NodeNotifier Type;
+  };
+
+  template <typename _Graph>
+  class ItemSetTraits<_Graph, typename _Graph::Node> {
   public:
 
-    typedef GR Graph;
-    typedef GR Digraph;
-
-    typedef typename GR::Node Item;
-    typedef typename GR::NodeIt ItemIt;
-
-    typedef typename NodeNotifierIndicator<GR>::Type ItemNotifier;
-
-    template <typename V>
-    class Map : public GR::template NodeMap<V> {
-      typedef typename GR::template NodeMap<V> Parent;
-
+    typedef _Graph Graph;
+
+    typedef typename Graph::Node Item;
+    typedef typename Graph::NodeIt ItemIt;
+
+    typedef typename NodeNotifierIndicator<Graph>::Type ItemNotifier;
+
+    template <typename _Value>
+    class Map : public Graph::template NodeMap<_Value> {
     public:
-      typedef typename GR::template NodeMap<V> Type;
+      typedef typename Graph::template NodeMap<_Value> Parent;
+      typedef typename Graph::template NodeMap<_Value> Type;
       typedef typename Parent::Value Value;
 
-      Map(const GR& _digraph) : Parent(_digraph) {}
-      Map(const GR& _digraph, const Value& _value)
+      Map(const Graph& _digraph) : Parent(_digraph) {}
+      Map(const Graph& _digraph, const Value& _value)
         : Parent(_digraph, _value) {}
 
@@ -74,38 +72,36 @@
   };
 
-  template <typename GR, typename Enable = void>
+  template <typename Graph, typename Enable = void>
   struct ArcNotifierIndicator {
     typedef InvalidType Type;
   };
-  template <typename GR>
+  template <typename Graph>
   struct ArcNotifierIndicator<
-    GR,
-    typename enable_if<typename GR::ArcNotifier::Notifier, void>::type
-  > {
-    typedef typename GR::ArcNotifier Type;
-  };
-
-  template <typename GR>
-  class ItemSetTraits<GR, typename GR::Arc> {
+    Graph,
+    typename enable_if<typename Graph::ArcNotifier::Notifier, void>::type
+  > {
+    typedef typename Graph::ArcNotifier Type;
+  };
+
+  template <typename _Graph>
+  class ItemSetTraits<_Graph, typename _Graph::Arc> {
   public:
 
-    typedef GR Graph;
-    typedef GR Digraph;
-
-    typedef typename GR::Arc Item;
-    typedef typename GR::ArcIt ItemIt;
-
-    typedef typename ArcNotifierIndicator<GR>::Type ItemNotifier;
-
-    template <typename V>
-    class Map : public GR::template ArcMap<V> {
-      typedef typename GR::template ArcMap<V> Parent;
-
+    typedef _Graph Graph;
+
+    typedef typename Graph::Arc Item;
+    typedef typename Graph::ArcIt ItemIt;
+
+    typedef typename ArcNotifierIndicator<Graph>::Type ItemNotifier;
+
+    template <typename _Value>
+    class Map : public Graph::template ArcMap<_Value> {
     public:
-      typedef typename GR::template ArcMap<V> Type;
+      typedef typename Graph::template ArcMap<_Value> Parent;
+      typedef typename Graph::template ArcMap<_Value> Type;
       typedef typename Parent::Value Value;
 
-      Map(const GR& _digraph) : Parent(_digraph) {}
-      Map(const GR& _digraph, const Value& _value)
+      Map(const Graph& _digraph) : Parent(_digraph) {}
+      Map(const Graph& _digraph, const Value& _value)
         : Parent(_digraph, _value) {}
     };
@@ -113,38 +109,36 @@
   };
 
-  template <typename GR, typename Enable = void>
+  template <typename Graph, typename Enable = void>
   struct EdgeNotifierIndicator {
     typedef InvalidType Type;
   };
-  template <typename GR>
+  template <typename Graph>
   struct EdgeNotifierIndicator<
-    GR,
-    typename enable_if<typename GR::EdgeNotifier::Notifier, void>::type
-  > {
-    typedef typename GR::EdgeNotifier Type;
-  };
-
-  template <typename GR>
-  class ItemSetTraits<GR, typename GR::Edge> {
+    Graph,
+    typename enable_if<typename Graph::EdgeNotifier::Notifier, void>::type
+  > {
+    typedef typename Graph::EdgeNotifier Type;
+  };
+
+  template <typename _Graph>
+  class ItemSetTraits<_Graph, typename _Graph::Edge> {
   public:
 
-    typedef GR Graph;
-    typedef GR Digraph;
-
-    typedef typename GR::Edge Item;
-    typedef typename GR::EdgeIt ItemIt;
-
-    typedef typename EdgeNotifierIndicator<GR>::Type ItemNotifier;
-
-    template <typename V>
-    class Map : public GR::template EdgeMap<V> {
-      typedef typename GR::template EdgeMap<V> Parent;
-
+    typedef _Graph Graph;
+
+    typedef typename Graph::Edge Item;
+    typedef typename Graph::EdgeIt ItemIt;
+
+    typedef typename EdgeNotifierIndicator<Graph>::Type ItemNotifier;
+
+    template <typename _Value>
+    class Map : public Graph::template EdgeMap<_Value> {
     public:
-      typedef typename GR::template EdgeMap<V> Type;
+      typedef typename Graph::template EdgeMap<_Value> Parent;
+      typedef typename Graph::template EdgeMap<_Value> Type;
       typedef typename Parent::Value Value;
 
-      Map(const GR& _digraph) : Parent(_digraph) {}
-      Map(const GR& _digraph, const Value& _value)
+      Map(const Graph& _digraph) : Parent(_digraph) {}
+      Map(const Graph& _digraph, const Value& _value)
         : Parent(_digraph, _value) {}
     };
@@ -211,91 +205,65 @@
   // Indicators for the tags
 
-  template <typename GR, typename Enable = void>
+  template <typename Graph, typename Enable = void>
   struct NodeNumTagIndicator {
     static const bool value = false;
   };
 
-  template <typename GR>
+  template <typename Graph>
   struct NodeNumTagIndicator<
-    GR,
-    typename enable_if<typename GR::NodeNumTag, void>::type
-  > {
-    static const bool value = true;
-  };
-
-  template <typename GR, typename Enable = void>
-  struct ArcNumTagIndicator {
-    static const bool value = false;
-  };
-
-  template <typename GR>
-  struct ArcNumTagIndicator<
-    GR,
-    typename enable_if<typename GR::ArcNumTag, void>::type
-  > {
-    static const bool value = true;
-  };
-
-  template <typename GR, typename Enable = void>
+    Graph,
+    typename enable_if<typename Graph::NodeNumTag, void>::type
+  > {
+    static const bool value = true;
+  };
+
+  template <typename Graph, typename Enable = void>
   struct EdgeNumTagIndicator {
     static const bool value = false;
   };
 
-  template <typename GR>
+  template <typename Graph>
   struct EdgeNumTagIndicator<
-    GR,
-    typename enable_if<typename GR::EdgeNumTag, void>::type
-  > {
-    static const bool value = true;
-  };
-
-  template <typename GR, typename Enable = void>
-  struct FindArcTagIndicator {
-    static const bool value = false;
-  };
-
-  template <typename GR>
-  struct FindArcTagIndicator<
-    GR,
-    typename enable_if<typename GR::FindArcTag, void>::type
-  > {
-    static const bool value = true;
-  };
-
-  template <typename GR, typename Enable = void>
+    Graph,
+    typename enable_if<typename Graph::EdgeNumTag, void>::type
+  > {
+    static const bool value = true;
+  };
+
+  template <typename Graph, typename Enable = void>
   struct FindEdgeTagIndicator {
     static const bool value = false;
   };
 
-  template <typename GR>
+  template <typename Graph>
   struct FindEdgeTagIndicator<
-    GR,
-    typename enable_if<typename GR::FindEdgeTag, void>::type
-  > {
-    static const bool value = true;
-  };
-
-  template <typename GR, typename Enable = void>
+    Graph,
+    typename enable_if<typename Graph::FindEdgeTag, void>::type
+  > {
+    static const bool value = true;
+  };
+
+  template <typename Graph, typename Enable = void>
   struct UndirectedTagIndicator {
     static const bool value = false;
   };
 
-  template <typename GR>
+  template <typename Graph>
   struct UndirectedTagIndicator<
-    GR,
-    typename enable_if<typename GR::UndirectedTag, void>::type
-  > {
-    static const bool value = true;
-  };
-
-  template <typename GR, typename Enable = void>
+    Graph,
+    typename enable_if<typename Graph::UndirectedTag, void>::type
+  > {
+    static const bool value = true;
+  };
+
+  template <typename Graph, typename Enable = void>
   struct BuildTagIndicator {
     static const bool value = false;
   };
 
-  template <typename GR>
+  template <typename Graph>
   struct BuildTagIndicator<
-    GR,
-    typename enable_if<typename GR::BuildTag, void>::type
+    Graph,
+    typename enable_if<typename Graph::BuildTag, void>::type
   > {
     static const bool value = true;
Index: mon/bits/variant.h
===================================================================
--- lemon/bits/variant.h	(revision 463)
+++ 	(revision )
@@ -1,494 +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_BITS_VARIANT_H
-#define LEMON_BITS_VARIANT_H
-
-#include <lemon/assert.h>
-
-// \file
-// \brief Variant types
-
-namespace lemon {
-
-  namespace _variant_bits {
-
-    template <int left, int right>
-    struct CTMax {
-      static const int value = left < right ? right : left;
-    };
-
-  }
-
-
-  // \brief Simple Variant type for two types
-  //
-  // Simple Variant type for two types. The Variant type is a type-safe
-  // union. C++ has strong limitations for using unions, for
-  // example you cannot store a type with non-default constructor or
-  // destructor in a union. This class always knowns the current
-  // state of the variant and it cares for the proper construction
-  // and destruction.
-  template <typename _First, typename _Second>
-  class BiVariant {
-  public:
-
-    // \brief The \c First type.
-    typedef _First First;
-    // \brief The \c Second type.
-    typedef _Second Second;
-
-    // \brief Constructor
-    //
-    // This constructor initalizes to the default value of the \c First
-    // type.
-    BiVariant() {
-      flag = true;
-      new(reinterpret_cast<First*>(data)) First();
-    }
-
-    // \brief Constructor
-    //
-    // This constructor initalizes to the given value of the \c First
-    // type.
-    BiVariant(const First& f) {
-      flag = true;
-      new(reinterpret_cast<First*>(data)) First(f);
-    }
-
-    // \brief Constructor
-    //
-    // This constructor initalizes to the given value of the \c
-    // Second type.
-    BiVariant(const Second& s) {
-      flag = false;
-      new(reinterpret_cast<Second*>(data)) Second(s);
-    }
-
-    // \brief Copy constructor
-    //
-    // Copy constructor
-    BiVariant(const BiVariant& bivariant) {
-      flag = bivariant.flag;
-      if (flag) {
-        new(reinterpret_cast<First*>(data)) First(bivariant.first());
-      } else {
-        new(reinterpret_cast<Second*>(data)) Second(bivariant.second());
-      }
-    }
-
-    // \brief Destrcutor
-    //
-    // Destructor
-    ~BiVariant() {
-      destroy();
-    }
-
-    // \brief Set to the default value of the \c First type.
-    //
-    // This function sets the variant to the default value of the \c
-    // First type.
-    BiVariant& setFirst() {
-      destroy();
-      flag = true;
-      new(reinterpret_cast<First*>(data)) First();
-      return *this;
-    }
-
-    // \brief Set to the given value of the \c First type.
-    //
-    // This function sets the variant to the given value of the \c
-    // First type.
-    BiVariant& setFirst(const First& f) {
-      destroy();
-      flag = true;
-      new(reinterpret_cast<First*>(data)) First(f);
-      return *this;
-    }
-
-    // \brief Set to the default value of the \c Second type.
-    //
-    // This function sets the variant to the default value of the \c
-    // Second type.
-    BiVariant& setSecond() {
-      destroy();
-      flag = false;
-      new(reinterpret_cast<Second*>(data)) Second();
-      return *this;
-    }
-
-    // \brief Set to the given value of the \c Second type.
-    //
-    // This function sets the variant to the given value of the \c
-    // Second type.
-    BiVariant& setSecond(const Second& s) {
-      destroy();
-      flag = false;
-      new(reinterpret_cast<Second*>(data)) Second(s);
-      return *this;
-    }
-
-    // \brief Operator form of the \c setFirst()
-    BiVariant& operator=(const First& f) {
-      return setFirst(f);
-    }
-
-    // \brief Operator form of the \c setSecond()
-    BiVariant& operator=(const Second& s) {
-      return setSecond(s);
-    }
-
-    // \brief Assign operator
-    BiVariant& operator=(const BiVariant& bivariant) {
-      if (this == &bivariant) return *this;
-      destroy();
-      flag = bivariant.flag;
-      if (flag) {
-        new(reinterpret_cast<First*>(data)) First(bivariant.first());
-      } else {
-        new(reinterpret_cast<Second*>(data)) Second(bivariant.second());
-      }
-      return *this;
-    }
-
-    // \brief Reference to the value
-    //
-    // Reference to the value of the \c First type.
-    // \pre The BiVariant should store value of \c First type.
-    First& first() {
-      LEMON_DEBUG(flag, "Variant wrong state");
-      return *reinterpret_cast<First*>(data);
-    }
-
-    // \brief Const reference to the value
-    //
-    // Const reference to the value of the \c First type.
-    // \pre The BiVariant should store value of \c First type.
-    const First& first() const {
-      LEMON_DEBUG(flag, "Variant wrong state");
-      return *reinterpret_cast<const First*>(data);
-    }
-
-    // \brief Operator form of the \c first()
-    operator First&() { return first(); }
-    // \brief Operator form of the const \c first()
-    operator const First&() const { return first(); }
-
-    // \brief Reference to the value
-    //
-    // Reference to the value of the \c Second type.
-    // \pre The BiVariant should store value of \c Second type.
-    Second& second() {
-      LEMON_DEBUG(!flag, "Variant wrong state");
-      return *reinterpret_cast<Second*>(data);
-    }
-
-    // \brief Const reference to the value
-    //
-    // Const reference to the value of the \c Second type.
-    // \pre The BiVariant should store value of \c Second type.
-    const Second& second() const {
-      LEMON_DEBUG(!flag, "Variant wrong state");
-      return *reinterpret_cast<const Second*>(data);
-    }
-
-    // \brief Operator form of the \c second()
-    operator Second&() { return second(); }
-    // \brief Operator form of the const \c second()
-    operator const Second&() const { return second(); }
-
-    // \brief %True when the variant is in the first state
-    //
-    // %True when the variant stores value of the \c First type.
-    bool firstState() const { return flag; }
-
-    // \brief %True when the variant is in the second state
-    //
-    // %True when the variant stores value of the \c Second type.
-    bool secondState() const { return !flag; }
-
-  private:
-
-    void destroy() {
-      if (flag) {
-        reinterpret_cast<First*>(data)->~First();
-      } else {
-        reinterpret_cast<Second*>(data)->~Second();
-      }
-    }
-
-    char data[_variant_bits::CTMax<sizeof(First), sizeof(Second)>::value];
-    bool flag;
-  };
-
-  namespace _variant_bits {
-
-    template <int _idx, typename _TypeMap>
-    struct Memory {
-
-      typedef typename _TypeMap::template Map<_idx>::Type Current;
-
-      static void destroy(int index, char* place) {
-        if (index == _idx) {
-          reinterpret_cast<Current*>(place)->~Current();
-        } else {
-          Memory<_idx - 1, _TypeMap>::destroy(index, place);
-        }
-      }
-
-      static void copy(int index, char* to, const char* from) {
-        if (index == _idx) {
-          new (reinterpret_cast<Current*>(to))
-            Current(reinterpret_cast<const Current*>(from));
-        } else {
-          Memory<_idx - 1, _TypeMap>::copy(index, to, from);
-        }
-      }
-
-    };
-
-    template <typename _TypeMap>
-    struct Memory<-1, _TypeMap> {
-
-      static void destroy(int, char*) {
-        LEMON_DEBUG(false, "Variant wrong index.");
-      }
-
-      static void copy(int, char*, const char*) {
-        LEMON_DEBUG(false, "Variant wrong index.");
-      }
-    };
-
-    template <int _idx, typename _TypeMap>
-    struct Size {
-      static const int value =
-      CTMax<sizeof(typename _TypeMap::template Map<_idx>::Type),
-            Size<_idx - 1, _TypeMap>::value>::value;
-    };
-
-    template <typename _TypeMap>
-    struct Size<0, _TypeMap> {
-      static const int value =
-      sizeof(typename _TypeMap::template Map<0>::Type);
-    };
-
-  }
-
-  // \brief Variant type
-  //
-  // Simple Variant type. The Variant type is a type-safe union.
-  // C++ has strong limitations for using unions, for example you
-  // cannot store type with non-default constructor or destructor in
-  // a union. This class always knowns the current state of the
-  // variant and it cares for the proper construction and
-  // destruction.
-  //
-  // \param _num The number of the types which can be stored in the
-  // variant type.
-  // \param _TypeMap This class describes the types of the Variant. The
-  // _TypeMap::Map<index>::Type should be a valid type for each index
-  // in the range {0, 1, ..., _num - 1}. The \c VariantTypeMap is helper
-  // class to define such type mappings up to 10 types.
-  //
-  // And the usage of the class:
-  //\code
-  // typedef Variant<3, VariantTypeMap<int, std::string, double> > MyVariant;
-  // MyVariant var;
-  // var.set<0>(12);
-  // std::cout << var.get<0>() << std::endl;
-  // var.set<1>("alpha");
-  // std::cout << var.get<1>() << std::endl;
-  // var.set<2>(0.75);
-  // std::cout << var.get<2>() << std::endl;
-  //\endcode
-  //
-  // The result of course:
-  //\code
-  // 12
-  // alpha
-  // 0.75
-  //\endcode
-  template <int _num, typename _TypeMap>
-  class Variant {
-  public:
-
-    static const int num = _num;
-
-    typedef _TypeMap TypeMap;
-
-    // \brief Constructor
-    //
-    // This constructor initalizes to the default value of the \c type
-    // with 0 index.
-    Variant() {
-      flag = 0;
-      new(reinterpret_cast<typename TypeMap::template Map<0>::Type*>(data))
-        typename TypeMap::template Map<0>::Type();
-    }
-
-
-    // \brief Copy constructor
-    //
-    // Copy constructor
-    Variant(const Variant& variant) {
-      flag = variant.flag;
-      _variant_bits::Memory<num - 1, TypeMap>::copy(flag, data, variant.data);
-    }
-
-    // \brief Assign operator
-    //
-    // Assign operator
-    Variant& operator=(const Variant& variant) {
-      if (this == &variant) return *this;
-      _variant_bits::Memory<num - 1, TypeMap>::
-        destroy(flag, data);
-      flag = variant.flag;
-      _variant_bits::Memory<num - 1, TypeMap>::
-        copy(flag, data, variant.data);
-      return *this;
-    }
-
-    // \brief Destrcutor
-    //
-    // Destructor
-    ~Variant() {
-      _variant_bits::Memory<num - 1, TypeMap>::destroy(flag, data);
-    }
-
-    // \brief Set to the default value of the type with \c _idx index.
-    //
-    // This function sets the variant to the default value of the
-    // type with \c _idx index.
-    template <int _idx>
-    Variant& set() {
-      _variant_bits::Memory<num - 1, TypeMap>::destroy(flag, data);
-      flag = _idx;
-      new(reinterpret_cast<typename TypeMap::template Map<_idx>::Type*>(data))
-        typename TypeMap::template Map<_idx>::Type();
-      return *this;
-    }
-
-    // \brief Set to the given value of the type with \c _idx index.
-    //
-    // This function sets the variant to the given value of the type
-    // with \c _idx index.
-    template <int _idx>
-    Variant& set(const typename _TypeMap::template Map<_idx>::Type& init) {
-      _variant_bits::Memory<num - 1, TypeMap>::destroy(flag, data);
-      flag = _idx;
-      new(reinterpret_cast<typename TypeMap::template Map<_idx>::Type*>(data))
-        typename TypeMap::template Map<_idx>::Type(init);
-      return *this;
-    }
-
-    // \brief Gets the current value of the type with \c _idx index.
-    //
-    // Gets the current value of the type with \c _idx index.
-    template <int _idx>
-    const typename TypeMap::template Map<_idx>::Type& get() const {
-      LEMON_DEBUG(_idx == flag, "Variant wrong index");
-      return *reinterpret_cast<const typename TypeMap::
-        template Map<_idx>::Type*>(data);
-    }
-
-    // \brief Gets the current value of the type with \c _idx index.
-    //
-    // Gets the current value of the type with \c _idx index.
-    template <int _idx>
-    typename _TypeMap::template Map<_idx>::Type& get() {
-      LEMON_DEBUG(_idx == flag, "Variant wrong index");
-      return *reinterpret_cast<typename TypeMap::template Map<_idx>::Type*>
-        (data);
-    }
-
-    // \brief Returns the current state of the variant.
-    //
-    // Returns the current state of the variant.
-    int state() const {
-      return flag;
-    }
-
-  private:
-
-    char data[_variant_bits::Size<num - 1, TypeMap>::value];
-    int flag;
-  };
-
-  namespace _variant_bits {
-
-    template <int _index, typename _List>
-    struct Get {
-      typedef typename Get<_index - 1, typename _List::Next>::Type Type;
-    };
-
-    template <typename _List>
-    struct Get<0, _List> {
-      typedef typename _List::Type Type;
-    };
-
-    struct List {};
-
-    template <typename _Type, typename _List>
-    struct Insert {
-      typedef _List Next;
-      typedef _Type Type;
-    };
-
-    template <int _idx, typename _T0, typename _T1, typename _T2,
-              typename _T3, typename _T4, typename _T5, typename _T6,
-              typename _T7, typename _T8, typename _T9>
-    struct Mapper {
-      typedef List L10;
-      typedef Insert<_T9, L10> L9;
-      typedef Insert<_T8, L9> L8;
-      typedef Insert<_T7, L8> L7;
-      typedef Insert<_T6, L7> L6;
-      typedef Insert<_T5, L6> L5;
-      typedef Insert<_T4, L5> L4;
-      typedef Insert<_T3, L4> L3;
-      typedef Insert<_T2, L3> L2;
-      typedef Insert<_T1, L2> L1;
-      typedef Insert<_T0, L1> L0;
-      typedef typename Get<_idx, L0>::Type Type;
-    };
-
-  }
-
-  // \brief Helper class for Variant
-  //
-  // Helper class to define type mappings for Variant. This class
-  // converts the template parameters to be mappable by integer.
-  // \see Variant
-  template <
-    typename _T0,
-    typename _T1 = void, typename _T2 = void, typename _T3 = void,
-    typename _T4 = void, typename _T5 = void, typename _T6 = void,
-    typename _T7 = void, typename _T8 = void, typename _T9 = void>
-  struct VariantTypeMap {
-    template <int _idx>
-    struct Map {
-      typedef typename _variant_bits::
-      Mapper<_idx, _T0, _T1, _T2, _T3, _T4, _T5, _T6, _T7, _T8, _T9>::Type
-      Type;
-    };
-  };
-
-}
-
-
-#endif
Index: lemon/bits/vector_map.h
===================================================================
--- lemon/bits/vector_map.h	(revision 664)
+++ lemon/bits/vector_map.h	(revision 314)
@@ -3,5 +3,5 @@
  * This file is a part of LEMON, a generic C++ optimization library.
  *
- * Copyright (C) 2003-2009
+ * Copyright (C) 2003-2008
  * Egervary Jeno Kombinatorikus Optimalizalasi Kutatocsoport
  * (Egervary Research Group on Combinatorial Optimization, EGRES).
@@ -39,7 +39,7 @@
   // \brief Graph map based on the std::vector storage.
   //
-  // The VectorMap template class is graph map structure that automatically
-  // updates the map when a key is added to or erased from the graph.
-  // This map type uses std::vector to store the values.
+  // The VectorMap template class is graph map structure what
+  // automatically updates the map when a key is added to or erased from
+  // the map. This map type uses the std::vector to store the values.
   //
   // \tparam _Graph The graph this map is attached to.
@@ -57,5 +57,5 @@
 
     // The graph type of the map.
-    typedef _Graph GraphType;
+    typedef _Graph Graph;
     // The item type of the map.
     typedef _Item Item;
@@ -73,4 +73,6 @@
     // The map type.
     typedef VectorMap Map;
+    // The base class of the map.
+    typedef typename Notifier::ObserverBase Parent;
 
     // The reference type of the map;
@@ -79,10 +81,4 @@
     typedef typename Container::const_reference ConstReference;
 
-  private:
-
-    // The base class of the map.
-    typedef typename Notifier::ObserverBase Parent;
-
-  public:
 
     // \brief Constructor to attach the new map into the notifier.
@@ -90,5 +86,5 @@
     // It constructs a map and attachs it into the notifier.
     // It adds all the items of the graph to the map.
-    VectorMap(const GraphType& graph) {
+    VectorMap(const Graph& graph) {
       Parent::attach(graph.notifier(Item()));
       container.resize(Parent::notifier()->maxId() + 1);
@@ -99,5 +95,5 @@
     // It constructs a map uses a given value to initialize the map.
     // It adds all the items of the graph to the map.
-    VectorMap(const GraphType& graph, const Value& value) {
+    VectorMap(const Graph& graph, const Value& value) {
       Parent::attach(graph.notifier(Item()));
       container.resize(Parent::notifier()->maxId() + 1, value);
@@ -129,5 +125,5 @@
     // \brief Template assign operator.
     //
-    // The given parameter should conform to the ReadMap
+    // The given parameter should be conform to the ReadMap
     // concecpt and could be indiced by the current item set of
     // the NodeMap. In this case the value for each item
@@ -174,5 +170,5 @@
     // \brief Adds a new key to the map.
     //
-    // It adds a new key to the map. It is called by the observer notifier
+    // It adds a new key to the map. It called by the observer notifier
     // and it overrides the add() member function of the observer base.
     virtual void add(const Key& key) {
@@ -185,5 +181,5 @@
     // \brief Adds more new keys to the map.
     //
-    // It adds more new keys to the map. It is called by the observer notifier
+    // It adds more new keys to the map. It called by the observer notifier
     // and it overrides the add() member function of the observer base.
     virtual void add(const std::vector<Key>& keys) {
@@ -200,5 +196,5 @@
     // \brief Erase a key from the map.
     //
-    // Erase a key from the map. It is called by the observer notifier
+    // Erase a key from the map. It called by the observer notifier
     // and it overrides the erase() member function of the observer base.
     virtual void erase(const Key& key) {
@@ -208,5 +204,5 @@
     // \brief Erase more keys from the map.
     //
-    // It erases more keys from the map. It is called by the observer notifier
+    // Erase more keys from the map. It called by the observer notifier
     // and it overrides the erase() member function of the observer base.
     virtual void erase(const std::vector<Key>& keys) {
@@ -216,7 +212,7 @@
     }
 
-    // \brief Build the map.
-    //
-    // It builds the map. It is called by the observer notifier
+    // \brief Buildes the map.
+    //
+    // It buildes the map. It called by the observer notifier
     // and it overrides the build() member function of the observer base.
     virtual void build() {
@@ -228,5 +224,5 @@
     // \brief Clear the map.
     //
-    // It erases all items from the map. It is called by the observer notifier
+    // It erase all items from the map. It called by the observer notifier
     // and it overrides the clear() member function of the observer base.
     virtual void clear() {
Index: lemon/bits/windows.cc
===================================================================
--- lemon/bits/windows.cc	(revision 956)
+++ lemon/bits/windows.cc	(revision 513)
@@ -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).
@@ -97,5 +97,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,
Index: lemon/bits/windows.h
===================================================================
--- lemon/bits/windows.h	(revision 576)
+++ lemon/bits/windows.h	(revision 511)
@@ -17,6 +17,6 @@
  */
 
-#ifndef LEMON_BITS_WINDOWS_H
-#define LEMON_BITS_WINDOWS_H
+#ifndef LEMON_WINDOWS_H
+#define LEMON_WINDOWS_H
 
 #include <string>
Index: mon/bucket_heap.h
===================================================================
--- lemon/bucket_heap.h	(revision 956)
+++ 	(revision )
@@ -1,594 +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_BUCKET_HEAP_H
-#define LEMON_BUCKET_HEAP_H
-
-///\ingroup heaps
-///\file
-///\brief Bucket heap implementation.
-
-#include <vector>
-#include <utility>
-#include <functional>
-
-namespace lemon {
-
-  namespace _bucket_heap_bits {
-
-    template <bool MIN>
-    struct DirectionTraits {
-      static bool less(int left, int right) {
-        return left < right;
-      }
-      static void increase(int& value) {
-        ++value;
-      }
-    };
-
-    template <>
-    struct DirectionTraits<false> {
-      static bool less(int left, int right) {
-        return left > right;
-      }
-      static void increase(int& value) {
-        --value;
-      }
-    };
-
-  }
-
-  /// \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
-  template <typename IM, bool MIN = true>
-  class BucketHeap {
-
-  public:
-
-    /// Type of the item-int map.
-    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:
-
-    typedef _bucket_heap_bits::DirectionTraits<MIN> Direction;
-
-  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
-    /// 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.
-    };
-
-  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 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.
-    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(); _first.clear(); _minimum = 0;
-    }
-
-  private:
-
-    void relocateLast(int idx) {
-      if (idx + 1 < int(_data.size())) {
-        _data[idx] = _data.back();
-        if (_data[idx].prev != -1) {
-          _data[_data[idx].prev].next = idx;
-        } else {
-          _first[_data[idx].value] = idx;
-        }
-        if (_data[idx].next != -1) {
-          _data[_data[idx].next].prev = idx;
-        }
-        _iim[_data[idx].item] = idx;
-      }
-      _data.pop_back();
-    }
-
-    void unlace(int idx) {
-      if (_data[idx].prev != -1) {
-        _data[_data[idx].prev].next = _data[idx].next;
-      } else {
-        _first[_data[idx].value] = _data[idx].next;
-      }
-      if (_data[idx].next != -1) {
-        _data[_data[idx].next].prev = _data[idx].prev;
-      }
-    }
-
-    void lace(int idx) {
-      if (int(_first.size()) <= _data[idx].value) {
-        _first.resize(_data[idx].value + 1, -1);
-      }
-      _data[idx].next = _first[_data[idx].value];
-      if (_data[idx].next != -1) {
-        _data[_data[idx].next].prev = idx;
-      }
-      _first[_data[idx].value] = idx;
-      _data[idx].prev = -1;
-    }
-
-  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) {
-      push(p.first, p.second);
-    }
-
-    /// \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) {
-      int idx = _data.size();
-      _iim[i] = idx;
-      _data.push_back(BucketItem(i, p));
-      lace(idx);
-      if (Direction::less(p, _minimum)) {
-        _minimum = 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 {
-      while (_first[_minimum] == -1) {
-        Direction::increase(_minimum);
-      }
-      return _data[_first[_minimum]].item;
-    }
-
-    /// \brief The minimum priority.
-    ///
-    /// This function returns the minimum priority.
-    /// \pre The heap must be non-empty.
-    Prio prio() const {
-      while (_first[_minimum] == -1) {
-        Direction::increase(_minimum);
-      }
-      return _minimum;
-    }
-
-    /// \brief Remove the item having minimum priority.
-    ///
-    /// This function removes the item having minimum priority.
-    /// \pre The heap must be non-empty.
-    void pop() {
-      while (_first[_minimum] == -1) {
-        Direction::increase(_minimum);
-      }
-      int idx = _first[_minimum];
-      _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.
-    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.
-    Prio operator[](const Item &i) const {
-      int idx = _iim[i];
-      return _data[idx].value;
-    }
-
-    /// \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 (Direction::less(p, _data[idx].value)) {
-        decrease(i, p);
-      } else {
-        increase(i, p);
-      }
-    }
-
-    /// \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];
-      unlace(idx);
-      _data[idx].value = p;
-      if (Direction::less(p, _minimum)) {
-        _minimum = p;
-      }
-      lace(idx);
-    }
-
-    /// \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];
-      unlace(idx);
-      _data[idx].value = p;
-      lace(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.
-    /// \param i The item.
-    State state(const Item &i) const {
-      int idx = _iim[i];
-      if (idx >= 0) idx = 0;
-      return State(idx);
-    }
-
-    /// \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:
-
-    struct BucketItem {
-      BucketItem(const Item& _item, int _value)
-        : item(_item), value(_value) {}
-
-      Item item;
-      int value;
-
-      int prev, next;
-    };
-
-    ItemIntMap& _iim;
-    std::vector<int> _first;
-    std::vector<BucketItem> _data;
-    mutable int _minimum;
-
-  }; // class BucketHeap
-
-  /// \ingroup heaps
-  ///
-  /// \brief Simplified bucket heap data structure.
-  ///
-  /// 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.
-  ///
-  /// \sa BucketHeap
-  template <typename IM, bool MIN = true >
-  class SimpleBucketHeap {
-
-  public:
-
-    /// Type of the item-int map.
-    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:
-
-    typedef _bucket_heap_bits::DirectionTraits<MIN> Direction;
-
-  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
-    /// 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.
-    };
-
-  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 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.
-    int size() const { return _num; }
-
-    /// \brief Check if the heap is empty.
-    ///
-    /// This function returns \c true if the heap is empty.
-    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.
-    void clear() {
-      _data.clear(); _first.clear(); _free = -1; _num = 0; _minimum = 0;
-    }
-
-    /// \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) {
-      push(p.first, p.second);
-    }
-
-    /// \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) {
-      int idx;
-      if (_free == -1) {
-        idx = _data.size();
-        _data.push_back(BucketItem(i));
-      } else {
-        idx = _free;
-        _free = _data[idx].next;
-        _data[idx].item = i;
-      }
-      _iim[i] = idx;
-      if (p >= int(_first.size())) _first.resize(p + 1, -1);
-      _data[idx].next = _first[p];
-      _first[p] = idx;
-      if (Direction::less(p, _minimum)) {
-        _minimum = p;
-      }
-      ++_num;
-    }
-
-    /// \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 {
-      while (_first[_minimum] == -1) {
-        Direction::increase(_minimum);
-      }
-      return _data[_first[_minimum]].item;
-    }
-
-    /// \brief The minimum priority.
-    ///
-    /// This function returns the minimum priority.
-    /// \pre The heap must be non-empty.
-    Prio prio() const {
-      while (_first[_minimum] == -1) {
-        Direction::increase(_minimum);
-      }
-      return _minimum;
-    }
-
-    /// \brief Remove the item having minimum priority.
-    ///
-    /// This function removes the item having minimum priority.
-    /// \pre The heap must be non-empty.
-    void pop() {
-      while (_first[_minimum] == -1) {
-        Direction::increase(_minimum);
-      }
-      int idx = _first[_minimum];
-      _iim[_data[idx].item] = -2;
-      _first[_minimum] = _data[idx].next;
-      _data[idx].next = _free;
-      _free = idx;
-      --_num;
-    }
-
-    /// \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.
-    Prio operator[](const Item &i) const {
-      for (int k = 0; k < int(_first.size()); ++k) {
-        int idx = _first[k];
-        while (idx != -1) {
-          if (_data[idx].item == i) {
-            return k;
-          }
-          idx = _data[idx].next;
-        }
-      }
-      return -1;
-    }
-
-    /// \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 idx = _iim[i];
-      if (idx >= 0) idx = 0;
-      return State(idx);
-    }
-
-  private:
-
-    struct BucketItem {
-      BucketItem(const Item& _item)
-        : item(_item) {}
-
-      Item item;
-      int next;
-    };
-
-    ItemIntMap& _iim;
-    std::vector<int> _first;
-    std::vector<BucketItem> _data;
-    int _free, _num;
-    mutable int _minimum;
-
-  }; // class SimpleBucketHeap
-
-}
-
-#endif
Index: mon/capacity_scaling.h
===================================================================
--- lemon/capacity_scaling.h	(revision 956)
+++ 	(revision )
@@ -1,990 +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 number types must be signed and all input data must
-  /// be integer.
-  /// \warning This algorithm does not support negative costs for such
-  /// arcs that have 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 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.
-    ///
-    /// \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: mon/cbc.cc
===================================================================
--- lemon/cbc.cc	(revision 793)
+++ 	(revision )
@@ -1,475 +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.
- *
- */
-
-///\file
-///\brief Implementation of the CBC MIP solver interface.
-
-#include "cbc.h"
-
-#include <coin/CoinModel.hpp>
-#include <coin/CbcModel.hpp>
-#include <coin/OsiSolverInterface.hpp>
-
-#ifdef COIN_HAS_CLP
-#include "coin/OsiClpSolverInterface.hpp"
-#endif
-#ifdef COIN_HAS_OSL
-#include "coin/OsiOslSolverInterface.hpp"
-#endif
-
-#include "coin/CbcCutGenerator.hpp"
-#include "coin/CbcHeuristicLocal.hpp"
-#include "coin/CbcHeuristicGreedy.hpp"
-#include "coin/CbcHeuristicFPump.hpp"
-#include "coin/CbcHeuristicRINS.hpp"
-
-#include "coin/CglGomory.hpp"
-#include "coin/CglProbing.hpp"
-#include "coin/CglKnapsackCover.hpp"
-#include "coin/CglOddHole.hpp"
-#include "coin/CglClique.hpp"
-#include "coin/CglFlowCover.hpp"
-#include "coin/CglMixedIntegerRounding.hpp"
-
-#include "coin/CbcHeuristic.hpp"
-
-namespace lemon {
-
-  CbcMip::CbcMip() {
-    _prob = new CoinModel();
-    _prob->setProblemName("LEMON");
-    _osi_solver = 0;
-    _cbc_model = 0;
-    messageLevel(MESSAGE_NOTHING);
-  }
-
-  CbcMip::CbcMip(const CbcMip& other) {
-    _prob = new CoinModel(*other._prob);
-    _prob->setProblemName("LEMON");
-    _osi_solver = 0;
-    _cbc_model = 0;
-    messageLevel(MESSAGE_NOTHING);
-  }
-
-  CbcMip::~CbcMip() {
-    delete _prob;
-    if (_osi_solver) delete _osi_solver;
-    if (_cbc_model) delete _cbc_model;
-  }
-
-  const char* CbcMip::_solverName() const { return "CbcMip"; }
-
-  int CbcMip::_addCol() {
-    _prob->addColumn(0, 0, 0, -COIN_DBL_MAX, COIN_DBL_MAX, 0.0, 0, false);
-    return _prob->numberColumns() - 1;
-  }
-
-  CbcMip* CbcMip::newSolver() const {
-    CbcMip* newlp = new CbcMip;
-    return newlp;
-  }
-
-  CbcMip* CbcMip::cloneSolver() const {
-    CbcMip* copylp = new CbcMip(*this);
-    return copylp;
-  }
-
-  int CbcMip::_addRow() {
-    _prob->addRow(0, 0, 0, -COIN_DBL_MAX, COIN_DBL_MAX);
-    return _prob->numberRows() - 1;
-  }
-
-  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) {
-    _prob->deleteColumn(i);
-  }
-
-  void CbcMip::_eraseRow(int i) {
-    _prob->deleteRow(i);
-  }
-
-  void CbcMip::_eraseColId(int i) {
-    cols.eraseIndex(i);
-  }
-
-  void CbcMip::_eraseRowId(int i) {
-    rows.eraseIndex(i);
-  }
-
-  void CbcMip::_getColName(int c, std::string& name) const {
-    name = _prob->getColumnName(c);
-  }
-
-  void CbcMip::_setColName(int c, const std::string& name) {
-    _prob->setColumnName(c, name.c_str());
-  }
-
-  int CbcMip::_colByName(const std::string& name) const {
-    return _prob->column(name.c_str());
-  }
-
-  void CbcMip::_getRowName(int r, std::string& name) const {
-    name = _prob->getRowName(r);
-  }
-
-  void CbcMip::_setRowName(int r, const std::string& name) {
-    _prob->setRowName(r, name.c_str());
-  }
-
-  int CbcMip::_rowByName(const std::string& name) const {
-    return _prob->row(name.c_str());
-  }
-
-  void CbcMip::_setRowCoeffs(int i, ExprIterator b, ExprIterator e) {
-    for (ExprIterator it = b; it != e; ++it) {
-      _prob->setElement(i, it->first, it->second);
-    }
-  }
-
-  void CbcMip::_getRowCoeffs(int ix, InsertIterator b) const {
-    int length = _prob->numberRows();
-
-    std::vector<int> indices(length);
-    std::vector<Value> values(length);
-
-    length = _prob->getRow(ix, &indices[0], &values[0]);
-
-    for (int i = 0; i < length; ++i) {
-      *b = std::make_pair(indices[i], values[i]);
-      ++b;
-    }
-  }
-
-  void CbcMip::_setColCoeffs(int ix, ExprIterator b, ExprIterator e) {
-    for (ExprIterator it = b; it != e; ++it) {
-      _prob->setElement(it->first, ix, it->second);
-    }
-  }
-
-  void CbcMip::_getColCoeffs(int ix, InsertIterator b) const {
-    int length = _prob->numberColumns();
-
-    std::vector<int> indices(length);
-    std::vector<Value> values(length);
-
-    length = _prob->getColumn(ix, &indices[0], &values[0]);
-
-    for (int i = 0; i < length; ++i) {
-      *b = std::make_pair(indices[i], values[i]);
-      ++b;
-    }
-  }
-
-  void CbcMip::_setCoeff(int ix, int jx, Value value) {
-    _prob->setElement(ix, jx, value);
-  }
-
-  CbcMip::Value CbcMip::_getCoeff(int ix, int jx) const {
-    return _prob->getElement(ix, jx);
-  }
-
-
-  void CbcMip::_setColLowerBound(int i, Value lo) {
-    LEMON_ASSERT(lo != INF, "Invalid bound");
-    _prob->setColumnLower(i, lo == - INF ? - COIN_DBL_MAX : lo);
-  }
-
-  CbcMip::Value CbcMip::_getColLowerBound(int i) const {
-    double val = _prob->getColumnLower(i);
-    return val == - COIN_DBL_MAX ? - INF : val;
-  }
-
-  void CbcMip::_setColUpperBound(int i, Value up) {
-    LEMON_ASSERT(up != -INF, "Invalid bound");
-    _prob->setColumnUpper(i, up == INF ? COIN_DBL_MAX : up);
-  }
-
-  CbcMip::Value CbcMip::_getColUpperBound(int i) const {
-    double val = _prob->getColumnUpper(i);
-    return val == COIN_DBL_MAX ? INF : val;
-  }
-
-  void CbcMip::_setRowLowerBound(int i, Value lo) {
-    LEMON_ASSERT(lo != INF, "Invalid bound");
-    _prob->setRowLower(i, lo == - INF ? - COIN_DBL_MAX : lo);
-  }
-
-  CbcMip::Value CbcMip::_getRowLowerBound(int i) const {
-    double val = _prob->getRowLower(i);
-    return val == - COIN_DBL_MAX ? - INF : val;
-  }
-
-  void CbcMip::_setRowUpperBound(int i, Value up) {
-    LEMON_ASSERT(up != -INF, "Invalid bound");
-    _prob->setRowUpper(i, up == INF ? COIN_DBL_MAX : up);
-  }
-
-  CbcMip::Value CbcMip::_getRowUpperBound(int i) const {
-    double val = _prob->getRowUpper(i);
-    return val == COIN_DBL_MAX ? INF : val;
-  }
-
-  void CbcMip::_setObjCoeffs(ExprIterator b, ExprIterator e) {
-    int num = _prob->numberColumns();
-    for (int i = 0; i < num; ++i) {
-      _prob->setColumnObjective(i, 0.0);
-    }
-    for (ExprIterator it = b; it != e; ++it) {
-      _prob->setColumnObjective(it->first, it->second);
-    }
-  }
-
-  void CbcMip::_getObjCoeffs(InsertIterator b) const {
-    int num = _prob->numberColumns();
-    for (int i = 0; i < num; ++i) {
-      Value coef = _prob->getColumnObjective(i);
-      if (coef != 0.0) {
-        *b = std::make_pair(i, coef);
-        ++b;
-      }
-    }
-  }
-
-  void CbcMip::_setObjCoeff(int i, Value obj_coef) {
-    _prob->setColumnObjective(i, obj_coef);
-  }
-
-  CbcMip::Value CbcMip::_getObjCoeff(int i) const {
-    return _prob->getColumnObjective(i);
-  }
-
-  CbcMip::SolveExitStatus CbcMip::_solve() {
-
-    if (_osi_solver) {
-      delete _osi_solver;
-    }
-#ifdef COIN_HAS_CLP
-    _osi_solver = new OsiClpSolverInterface();
-#elif COIN_HAS_OSL
-    _osi_solver = new OsiOslSolverInterface();
-#else
-#error Cannot instantiate Osi solver
-#endif
-
-    _osi_solver->loadFromCoinModel(*_prob);
-
-    if (_cbc_model) {
-      delete _cbc_model;
-    }
-    _cbc_model= new CbcModel(*_osi_solver);
-
-    _osi_solver->messageHandler()->setLogLevel(_message_level);
-    _cbc_model->setLogLevel(_message_level);
-
-    _cbc_model->initialSolve();
-    _cbc_model->solver()->setHintParam(OsiDoReducePrint, true, OsiHintTry);
-
-    if (!_cbc_model->isInitialSolveAbandoned() &&
-        _cbc_model->isInitialSolveProvenOptimal() &&
-        !_cbc_model->isInitialSolveProvenPrimalInfeasible() &&
-        !_cbc_model->isInitialSolveProvenDualInfeasible()) {
-
-      CglProbing generator1;
-      generator1.setUsingObjective(true);
-      generator1.setMaxPass(3);
-      generator1.setMaxProbe(100);
-      generator1.setMaxLook(50);
-      generator1.setRowCuts(3);
-      _cbc_model->addCutGenerator(&generator1, -1, "Probing");
-
-      CglGomory generator2;
-      generator2.setLimit(300);
-      _cbc_model->addCutGenerator(&generator2, -1, "Gomory");
-
-      CglKnapsackCover generator3;
-      _cbc_model->addCutGenerator(&generator3, -1, "Knapsack");
-
-      CglOddHole generator4;
-      generator4.setMinimumViolation(0.005);
-      generator4.setMinimumViolationPer(0.00002);
-      generator4.setMaximumEntries(200);
-      _cbc_model->addCutGenerator(&generator4, -1, "OddHole");
-
-      CglClique generator5;
-      generator5.setStarCliqueReport(false);
-      generator5.setRowCliqueReport(false);
-      _cbc_model->addCutGenerator(&generator5, -1, "Clique");
-
-      CglMixedIntegerRounding mixedGen;
-      _cbc_model->addCutGenerator(&mixedGen, -1, "MixedIntegerRounding");
-
-      CglFlowCover flowGen;
-      _cbc_model->addCutGenerator(&flowGen, -1, "FlowCover");
-
-#ifdef COIN_HAS_CLP
-      OsiClpSolverInterface* osiclp =
-        dynamic_cast<OsiClpSolverInterface*>(_cbc_model->solver());
-      if (osiclp->getNumRows() < 300 && osiclp->getNumCols() < 500) {
-        osiclp->setupForRepeatedUse(2, 0);
-      }
-#endif
-
-      CbcRounding heuristic1(*_cbc_model);
-      heuristic1.setWhen(3);
-      _cbc_model->addHeuristic(&heuristic1);
-
-      CbcHeuristicLocal heuristic2(*_cbc_model);
-      heuristic2.setWhen(3);
-      _cbc_model->addHeuristic(&heuristic2);
-
-      CbcHeuristicGreedyCover heuristic3(*_cbc_model);
-      heuristic3.setAlgorithm(11);
-      heuristic3.setWhen(3);
-      _cbc_model->addHeuristic(&heuristic3);
-
-      CbcHeuristicFPump heuristic4(*_cbc_model);
-      heuristic4.setWhen(3);
-      _cbc_model->addHeuristic(&heuristic4);
-
-      CbcHeuristicRINS heuristic5(*_cbc_model);
-      heuristic5.setWhen(3);
-      _cbc_model->addHeuristic(&heuristic5);
-
-      if (_cbc_model->getNumCols() < 500) {
-        _cbc_model->setMaximumCutPassesAtRoot(-100);
-      } else if (_cbc_model->getNumCols() < 5000) {
-        _cbc_model->setMaximumCutPassesAtRoot(100);
-      } else {
-        _cbc_model->setMaximumCutPassesAtRoot(20);
-      }
-
-      if (_cbc_model->getNumCols() < 5000) {
-        _cbc_model->setNumberStrong(10);
-      }
-
-      _cbc_model->solver()->setIntParam(OsiMaxNumIterationHotStart, 100);
-      _cbc_model->branchAndBound();
-    }
-
-    if (_cbc_model->isAbandoned()) {
-      return UNSOLVED;
-    } else {
-      return SOLVED;
-    }
-  }
-
-  CbcMip::Value CbcMip::_getSol(int i) const {
-    return _cbc_model->getColSolution()[i];
-  }
-
-  CbcMip::Value CbcMip::_getSolValue() const {
-    return _cbc_model->getObjValue();
-  }
-
-  CbcMip::ProblemType CbcMip::_getType() const {
-    if (_cbc_model->isProvenOptimal()) {
-      return OPTIMAL;
-    } else if (_cbc_model->isContinuousUnbounded()) {
-      return UNBOUNDED;
-    }
-    return FEASIBLE;
-  }
-
-  void CbcMip::_setSense(Sense sense) {
-    switch (sense) {
-    case MIN:
-      _prob->setOptimizationDirection(1.0);
-      break;
-    case MAX:
-      _prob->setOptimizationDirection(- 1.0);
-      break;
-    }
-  }
-
-  CbcMip::Sense CbcMip::_getSense() const {
-    if (_prob->optimizationDirection() > 0.0) {
-      return MIN;
-    } else if (_prob->optimizationDirection() < 0.0) {
-      return MAX;
-    } else {
-      LEMON_ASSERT(false, "Wrong sense");
-      return CbcMip::Sense();
-    }
-  }
-
-  void CbcMip::_setColType(int i, CbcMip::ColTypes col_type) {
-    switch (col_type){
-    case INTEGER:
-      _prob->setInteger(i);
-      break;
-    case REAL:
-      _prob->setContinuous(i);
-      break;
-    default:;
-      LEMON_ASSERT(false, "Wrong sense");
-    }
-  }
-
-  CbcMip::ColTypes CbcMip::_getColType(int i) const {
-    return _prob->getColumnIsInteger(i) ? INTEGER : REAL;
-  }
-
-  void CbcMip::_clear() {
-    delete _prob;
-    if (_osi_solver) {
-      delete _osi_solver;
-      _osi_solver = 0;
-    }
-    if (_cbc_model) {
-      delete _cbc_model;
-      _cbc_model = 0;
-    }
-
-    _prob = new CoinModel();
-    rows.clear();
-    cols.clear();
-  }
-
-  void CbcMip::_messageLevel(MessageLevel level) {
-    switch (level) {
-    case MESSAGE_NOTHING:
-      _message_level = 0;
-      break;
-    case MESSAGE_ERROR:
-      _message_level = 1;
-      break;
-    case MESSAGE_WARNING:
-      _message_level = 1;
-      break;
-    case MESSAGE_NORMAL:
-      _message_level = 2;
-      break;
-    case MESSAGE_VERBOSE:
-      _message_level = 3;
-      break;
-    }
-  }
-
-} //END OF NAMESPACE LEMON
Index: mon/cbc.h
===================================================================
--- lemon/cbc.h	(revision 956)
+++ 	(revision )
@@ -1,130 +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.
- *
- */
-
-// -*- C++ -*-
-#ifndef LEMON_CBC_H
-#define LEMON_CBC_H
-
-///\file
-///\brief Header of the LEMON-CBC mip solver interface.
-///\ingroup lp_group
-
-#include <lemon/lp_base.h>
-
-class CoinModel;
-class OsiSolverInterface;
-class CbcModel;
-
-namespace lemon {
-
-  /// \brief Interface for the CBC MIP solver
-  ///
-  /// This class implements an interface for the CBC MIP solver.
-  ///\ingroup lp_group
-  class CbcMip : public MipSolver {
-  protected:
-
-    CoinModel *_prob;
-    OsiSolverInterface *_osi_solver;
-    CbcModel *_cbc_model;
-
-  public:
-
-    /// \e
-    CbcMip();
-    /// \e
-    CbcMip(const CbcMip&);
-    /// \e
-    ~CbcMip();
-    /// \e
-    virtual CbcMip* newSolver() const;
-    /// \e
-    virtual CbcMip* cloneSolver() const;
-
-  protected:
-
-    virtual const char* _solverName() const;
-
-    virtual int _addCol();
-    virtual int _addRow();
-    virtual int _addRow(Value l, ExprIterator b, ExprIterator e, Value u);
-
-    virtual void _eraseCol(int i);
-    virtual void _eraseRow(int i);
-
-    virtual void _eraseColId(int i);
-    virtual void _eraseRowId(int i);
-
-    virtual void _getColName(int col, std::string& name) const;
-    virtual void _setColName(int col, const std::string& name);
-    virtual int _colByName(const std::string& name) const;
-
-    virtual void _getRowName(int row, std::string& name) const;
-    virtual void _setRowName(int row, const std::string& name);
-    virtual int _rowByName(const std::string& name) const;
-
-    virtual void _setRowCoeffs(int i, ExprIterator b, ExprIterator e);
-    virtual void _getRowCoeffs(int i, InsertIterator b) const;
-
-    virtual void _setColCoeffs(int i, ExprIterator b, ExprIterator e);
-    virtual void _getColCoeffs(int i, InsertIterator b) const;
-
-    virtual void _setCoeff(int row, int col, Value value);
-    virtual Value _getCoeff(int row, int col) const;
-
-    virtual void _setColLowerBound(int i, Value value);
-    virtual Value _getColLowerBound(int i) const;
-    virtual void _setColUpperBound(int i, Value value);
-    virtual Value _getColUpperBound(int i) const;
-
-    virtual void _setRowLowerBound(int i, Value value);
-    virtual Value _getRowLowerBound(int i) const;
-    virtual void _setRowUpperBound(int i, Value value);
-    virtual Value _getRowUpperBound(int i) const;
-
-    virtual void _setObjCoeffs(ExprIterator b, ExprIterator e);
-    virtual void _getObjCoeffs(InsertIterator b) const;
-
-    virtual void _setObjCoeff(int i, Value obj_coef);
-    virtual Value _getObjCoeff(int i) const;
-
-    virtual void _setSense(Sense sense);
-    virtual Sense _getSense() const;
-
-    virtual ColTypes _getColType(int col) const;
-    virtual void _setColType(int col, ColTypes col_type);
-
-    virtual SolveExitStatus _solve();
-    virtual ProblemType _getType() const;
-    virtual Value _getSol(int i) const;
-    virtual Value _getSolValue() const;
-
-    virtual void _clear();
-
-    virtual void _messageLevel(MessageLevel level);
-    void _applyMessageLevel();
-
-    int _message_level;
-
-
-
-  };
-
-}
-
-#endif
Index: mon/circulation.h
===================================================================
--- lemon/circulation.h	(revision 956)
+++ 	(revision )
@@ -1,808 +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_CIRCULATION_H
-#define LEMON_CIRCULATION_H
-
-#include <lemon/tolerance.h>
-#include <lemon/elevator.h>
-#include <limits>
-
-///\ingroup max_flow
-///\file
-///\brief Push-relabel algorithm for finding a feasible circulation.
-///
-namespace lemon {
-
-  /// \brief Default traits class of Circulation class.
-  ///
-  /// Default traits class of Circulation class.
-  ///
-  /// \tparam GR Type of the digraph the algorithm runs on.
-  /// \tparam LM The type of the lower bound map.
-  /// \tparam UM The type of the upper bound (capacity) map.
-  /// \tparam SM The type of the supply map.
-  template <typename GR, typename LM,
-            typename UM, typename SM>
-  struct CirculationDefaultTraits {
-
-    /// \brief The type of the digraph the algorithm runs on.
-    typedef GR Digraph;
-
-    /// \brief The type of the lower bound map.
-    ///
-    /// The type of the map that stores the lower bounds on the arcs.
-    /// It must conform to the \ref concepts::ReadMap "ReadMap" concept.
-    typedef LM LowerMap;
-
-    /// \brief The type of the upper bound (capacity) map.
-    ///
-    /// The type of the map that stores the upper bounds (capacities)
-    /// on the arcs.
-    /// It must conform to the \ref concepts::ReadMap "ReadMap" concept.
-    typedef UM UpperMap;
-
-    /// \brief The type of supply map.
-    ///
-    /// 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;
-
-    /// \brief The type of the flow and supply values.
-    typedef typename SupplyMap::Value Value;
-
-    /// \brief The type of the map that stores the flow values.
-    ///
-    /// The type of the map that stores the flow values.
-    /// 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.
-    ///
-    /// This function instantiates a \ref FlowMap.
-    /// \param digraph The digraph for which we would like to define
-    /// the flow map.
-    static FlowMap* createFlowMap(const Digraph& digraph) {
-      return new FlowMap(digraph);
-    }
-
-    /// \brief The elevator type used by the algorithm.
-    ///
-    /// The elevator type used by the algorithm.
-    ///
-    /// \sa Elevator, LinkedElevator
-#ifdef DOXYGEN
-    typedef lemon::Elevator<GR, GR::Node> Elevator;
-#else
-    typedef lemon::Elevator<Digraph, typename Digraph::Node> Elevator;
-#endif
-
-    /// \brief Instantiates an Elevator.
-    ///
-    /// This function instantiates an \ref Elevator.
-    /// \param digraph The digraph for which we would like to define
-    /// the elevator.
-    /// \param max_level The maximum level of the elevator.
-    static Elevator* createElevator(const Digraph& digraph, int max_level) {
-      return new Elevator(digraph, max_level);
-    }
-
-    /// \brief The tolerance used by the algorithm
-    ///
-    /// The tolerance used by the algorithm to handle inexact computation.
-    typedef lemon::Tolerance<Value> Tolerance;
-
-  };
-
-  /**
-     \brief Push-relabel algorithm for the network circulation problem.
-
-     \ingroup max_flow
-     This class implements a push-relabel algorithm for the \e network
-     \e circulation problem.
-     It is to find a feasible circulation when lower and upper bounds
-     are given for the flow values on the arcs and lower bounds are
-     given for the difference between the outgoing and incoming flow
-     at the nodes.
-
-     The exact formulation of this problem is the following.
-     Let \f$G=(V,A)\f$ be a digraph, \f$lower: A\rightarrow\mathbf{R}\f$
-     \f$upper: A\rightarrow\mathbf{R}\cup\{\infty\}\f$ denote the lower and
-     upper bounds on the arcs, for which \f$lower(uv) \leq upper(uv)\f$
-     holds for all \f$uv\in A\f$, and \f$sup: V\rightarrow\mathbf{R}\f$
-     denotes the signed supply values of the nodes.
-     If \f$sup(u)>0\f$, then \f$u\f$ is a supply node with \f$sup(u)\f$
-     supply, if \f$sup(u)<0\f$, then \f$u\f$ is a demand node with
-     \f$-sup(u)\f$ demand.
-     A feasible circulation is an \f$f: A\rightarrow\mathbf{R}\f$
-     solution of the following problem.
-
-     \f[ \sum_{uv\in A} f(uv) - \sum_{vu\in A} f(vu)
-     \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
-     of the expressions on the left-hand side of the inequalities is zero).
-     It means that the total demand must be greater or equal to the total
-     supply and all the supplies have to be carried out from the supply nodes,
-     but there could be demands that are not satisfied.
-     If \f$\sum_{u\in V} sup(u)\f$ is zero, then all the supply/demand
-     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
-     have to be satisfied while there could be supplies that are not used),
-     then you could easily transform the problem to the above form by reversing
-     the direction of the arcs and taking the negative of the supply values
-     (e.g. using \ref ReverseDigraph and \ref NegMap adaptors).
-
-     This algorithm either calculates a feasible circulation, or provides
-     a \ref barrier() "barrier", which prooves that a feasible soultion
-     cannot exist.
-
-     Note that this algorithm also provides a feasible solution for the
-     \ref min_cost_flow "minimum cost flow problem".
-
-     \tparam GR The type of the digraph the algorithm runs on.
-     \tparam LM The type of the lower bound map. The default
-     map type is \ref concepts::Digraph::ArcMap "GR::ArcMap<int>".
-     \tparam UM The type of the upper bound (capacity) map.
-     The default map type is \c LM.
-     \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
-template< typename GR,
-          typename LM,
-          typename UM,
-          typename SM,
-          typename TR >
-#else
-template< typename GR,
-          typename LM = typename GR::template ArcMap<int>,
-          typename UM = LM,
-          typename SM = typename GR::template NodeMap<typename UM::Value>,
-          typename TR = CirculationDefaultTraits<GR, LM, UM, SM> >
-#endif
-  class Circulation {
-  public:
-
-    ///The \ref CirculationDefaultTraits "traits class" of the algorithm.
-    typedef TR Traits;
-    ///The type of the digraph the algorithm runs on.
-    typedef typename Traits::Digraph Digraph;
-    ///The type of the flow and supply values.
-    typedef typename Traits::Value Value;
-
-    ///The type of the lower bound map.
-    typedef typename Traits::LowerMap LowerMap;
-    ///The type of the upper bound (capacity) map.
-    typedef typename Traits::UpperMap UpperMap;
-    ///The type of the supply map.
-    typedef typename Traits::SupplyMap SupplyMap;
-    ///The type of the flow map.
-    typedef typename Traits::FlowMap FlowMap;
-
-    ///The type of the elevator.
-    typedef typename Traits::Elevator Elevator;
-    ///The type of the tolerance.
-    typedef typename Traits::Tolerance Tolerance;
-
-  private:
-
-    TEMPLATE_DIGRAPH_TYPEDEFS(Digraph);
-
-    const Digraph &_g;
-    int _node_num;
-
-    const LowerMap *_lo;
-    const UpperMap *_up;
-    const SupplyMap *_supply;
-
-    FlowMap *_flow;
-    bool _local_flow;
-
-    Elevator* _level;
-    bool _local_level;
-
-    typedef typename Digraph::template NodeMap<Value> ExcessMap;
-    ExcessMap* _excess;
-
-    Tolerance _tol;
-    int _el;
-
-  public:
-
-    typedef Circulation Create;
-
-    ///\name Named Template Parameters
-
-    ///@{
-
-    template <typename T>
-    struct SetFlowMapTraits : public Traits {
-      typedef T FlowMap;
-      static FlowMap *createFlowMap(const Digraph&) {
-        LEMON_ASSERT(false, "FlowMap is not initialized");
-        return 0; // ignore warnings
-      }
-    };
-
-    /// \brief \ref named-templ-param "Named parameter" for setting
-    /// FlowMap type
-    ///
-    /// \ref named-templ-param "Named parameter" for setting FlowMap
-    /// type.
-    template <typename T>
-    struct SetFlowMap
-      : public Circulation<Digraph, LowerMap, UpperMap, SupplyMap,
-                           SetFlowMapTraits<T> > {
-      typedef Circulation<Digraph, LowerMap, UpperMap, SupplyMap,
-                          SetFlowMapTraits<T> > Create;
-    };
-
-    template <typename T>
-    struct SetElevatorTraits : public Traits {
-      typedef T Elevator;
-      static Elevator *createElevator(const Digraph&, 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 Circulation<Digraph, LowerMap, UpperMap, SupplyMap,
-                           SetElevatorTraits<T> > {
-      typedef Circulation<Digraph, LowerMap, UpperMap, SupplyMap,
-                          SetElevatorTraits<T> > Create;
-    };
-
-    template <typename T>
-    struct SetStandardElevatorTraits : public Traits {
-      typedef T Elevator;
-      static Elevator *createElevator(const Digraph& digraph, int max_level) {
-        return new Elevator(digraph, 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
-    /// digraph 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 Circulation<Digraph, LowerMap, UpperMap, SupplyMap,
-                       SetStandardElevatorTraits<T> > {
-      typedef Circulation<Digraph, LowerMap, UpperMap, SupplyMap,
-                      SetStandardElevatorTraits<T> > Create;
-    };
-
-    /// @}
-
-  protected:
-
-    Circulation() {}
-
-  public:
-
-    /// Constructor.
-
-    /// The constructor of the class.
-    ///
-    /// \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
-    /// on the arcs.
-    /// \param supply The signed supply values of the nodes.
-    Circulation(const Digraph &graph, const LowerMap &lower,
-                const UpperMap &upper, const SupplyMap &supply)
-      : _g(graph), _lo(&lower), _up(&upper), _supply(&supply),
-        _flow(NULL), _local_flow(false), _level(NULL), _local_level(false),
-        _excess(NULL) {}
-
-    /// Destructor.
-    ~Circulation() {
-      destroyStructures();
-    }
-
-
-  private:
-
-    bool checkBoundMaps() {
-      for (ArcIt e(_g);e!=INVALID;++e) {
-        if (_tol.less((*_up)[e], (*_lo)[e])) return false;
-      }
-      return true;
-    }
-
-    void createStructures() {
-      _node_num = _el = countNodes(_g);
-
-      if (!_flow) {
-        _flow = Traits::createFlowMap(_g);
-        _local_flow = true;
-      }
-      if (!_level) {
-        _level = Traits::createElevator(_g, _node_num);
-        _local_level = true;
-      }
-      if (!_excess) {
-        _excess = new ExcessMap(_g);
-      }
-    }
-
-    void destroyStructures() {
-      if (_local_flow) {
-        delete _flow;
-      }
-      if (_local_level) {
-        delete _level;
-      }
-      if (_excess) {
-        delete _excess;
-      }
-    }
-
-  public:
-
-    /// Sets the lower bound map.
-
-    /// Sets the lower bound map.
-    /// \return <tt>(*this)</tt>
-    Circulation& lowerMap(const LowerMap& map) {
-      _lo = &map;
-      return *this;
-    }
-
-    /// Sets the upper bound (capacity) map.
-
-    /// Sets the upper bound (capacity) map.
-    /// \return <tt>(*this)</tt>
-    Circulation& upperMap(const UpperMap& map) {
-      _up = &map;
-      return *this;
-    }
-
-    /// Sets the supply map.
-
-    /// Sets the supply map.
-    /// \return <tt>(*this)</tt>
-    Circulation& supplyMap(const SupplyMap& map) {
-      _supply = &map;
-      return *this;
-    }
-
-    /// \brief Sets the flow map.
-    ///
-    /// Sets the flow 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>
-    Circulation& flowMap(FlowMap& map) {
-      if (_local_flow) {
-        delete _flow;
-        _local_flow = false;
-      }
-      _flow = &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>
-    Circulation& 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;
-    }
-
-    /// \brief Sets the tolerance used by the algorithm.
-    ///
-    /// Sets the tolerance object used by the algorithm.
-    /// \return <tt>(*this)</tt>
-    Circulation& tolerance(const Tolerance& tolerance) {
-      _tol = tolerance;
-      return *this;
-    }
-
-    /// \brief Returns a const reference to the tolerance.
-    ///
-    /// Returns a const reference to the tolerance object used by
-    /// the algorithm.
-    const Tolerance& tolerance() const {
-      return _tol;
-    }
-
-    /// \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
-    /// the \ref start() function.
-
-    ///@{
-
-    /// Initializes the internal data structures.
-
-    /// Initializes the internal data structures and sets all flow values
-    /// to the lower bound.
-    void init()
-    {
-      LEMON_DEBUG(checkBoundMaps(),
-        "Upper bounds must be greater or equal to the lower bounds");
-
-      createStructures();
-
-      for(NodeIt n(_g);n!=INVALID;++n) {
-        (*_excess)[n] = (*_supply)[n];
-      }
-
-      for (ArcIt e(_g);e!=INVALID;++e) {
-        _flow->set(e, (*_lo)[e]);
-        (*_excess)[_g.target(e)] += (*_flow)[e];
-        (*_excess)[_g.source(e)] -= (*_flow)[e];
-      }
-
-      // global relabeling tested, but in general case it provides
-      // worse performance for random digraphs
-      _level->initStart();
-      for(NodeIt n(_g);n!=INVALID;++n)
-        _level->initAddItem(n);
-      _level->initFinish();
-      for(NodeIt n(_g);n!=INVALID;++n)
-        if(_tol.positive((*_excess)[n]))
-          _level->activate(n);
-    }
-
-    /// Initializes the internal data structures using a greedy approach.
-
-    /// Initializes the internal data structures using a greedy approach
-    /// to construct the initial solution.
-    void greedyInit()
-    {
-      LEMON_DEBUG(checkBoundMaps(),
-        "Upper bounds must be greater or equal to the lower bounds");
-
-      createStructures();
-
-      for(NodeIt n(_g);n!=INVALID;++n) {
-        (*_excess)[n] = (*_supply)[n];
-      }
-
-      for (ArcIt e(_g);e!=INVALID;++e) {
-        if (!_tol.less(-(*_excess)[_g.target(e)], (*_up)[e])) {
-          _flow->set(e, (*_up)[e]);
-          (*_excess)[_g.target(e)] += (*_up)[e];
-          (*_excess)[_g.source(e)] -= (*_up)[e];
-        } else if (_tol.less(-(*_excess)[_g.target(e)], (*_lo)[e])) {
-          _flow->set(e, (*_lo)[e]);
-          (*_excess)[_g.target(e)] += (*_lo)[e];
-          (*_excess)[_g.source(e)] -= (*_lo)[e];
-        } else {
-          Value fc = -(*_excess)[_g.target(e)];
-          _flow->set(e, fc);
-          (*_excess)[_g.target(e)] = 0;
-          (*_excess)[_g.source(e)] -= fc;
-        }
-      }
-
-      _level->initStart();
-      for(NodeIt n(_g);n!=INVALID;++n)
-        _level->initAddItem(n);
-      _level->initFinish();
-      for(NodeIt n(_g);n!=INVALID;++n)
-        if(_tol.positive((*_excess)[n]))
-          _level->activate(n);
-    }
-
-    ///Executes the algorithm
-
-    ///This function executes the algorithm.
-    ///
-    ///\return \c true if a feasible circulation is found.
-    ///
-    ///\sa barrier()
-    ///\sa barrierMap()
-    bool start()
-    {
-
-      Node act;
-      Node bact=INVALID;
-      Node last_activated=INVALID;
-      while((act=_level->highestActive())!=INVALID) {
-        int actlevel=(*_level)[act];
-        int mlevel=_node_num;
-        Value exc=(*_excess)[act];
-
-        for(OutArcIt e(_g,act);e!=INVALID; ++e) {
-          Node v = _g.target(e);
-          Value fc=(*_up)[e]-(*_flow)[e];
-          if(!_tol.positive(fc)) continue;
-          if((*_level)[v]<actlevel) {
-            if(!_tol.less(fc, exc)) {
-              _flow->set(e, (*_flow)[e] + exc);
-              (*_excess)[v] += exc;
-              if(!_level->active(v) && _tol.positive((*_excess)[v]))
-                _level->activate(v);
-              (*_excess)[act] = 0;
-              _level->deactivate(act);
-              goto next_l;
-            }
-            else {
-              _flow->set(e, (*_up)[e]);
-              (*_excess)[v] += fc;
-              if(!_level->active(v) && _tol.positive((*_excess)[v]))
-                _level->activate(v);
-              exc-=fc;
-            }
-          }
-          else if((*_level)[v]<mlevel) mlevel=(*_level)[v];
-        }
-        for(InArcIt e(_g,act);e!=INVALID; ++e) {
-          Node v = _g.source(e);
-          Value fc=(*_flow)[e]-(*_lo)[e];
-          if(!_tol.positive(fc)) continue;
-          if((*_level)[v]<actlevel) {
-            if(!_tol.less(fc, exc)) {
-              _flow->set(e, (*_flow)[e] - exc);
-              (*_excess)[v] += exc;
-              if(!_level->active(v) && _tol.positive((*_excess)[v]))
-                _level->activate(v);
-              (*_excess)[act] = 0;
-              _level->deactivate(act);
-              goto next_l;
-            }
-            else {
-              _flow->set(e, (*_lo)[e]);
-              (*_excess)[v] += fc;
-              if(!_level->active(v) && _tol.positive((*_excess)[v]))
-                _level->activate(v);
-              exc-=fc;
-            }
-          }
-          else if((*_level)[v]<mlevel) mlevel=(*_level)[v];
-        }
-
-        (*_excess)[act] = exc;
-        if(!_tol.positive(exc)) _level->deactivate(act);
-        else if(mlevel==_node_num) {
-          _level->liftHighestActiveToTop();
-          _el = _node_num;
-          return false;
-        }
-        else {
-          _level->liftHighestActive(mlevel+1);
-          if(_level->onLevel(actlevel)==0) {
-            _el = actlevel;
-            return false;
-          }
-        }
-      next_l:
-        ;
-      }
-      return true;
-    }
-
-    /// Runs the algorithm.
-
-    /// This function runs the algorithm.
-    ///
-    /// \return \c true if a feasible circulation is found.
-    ///
-    /// \note Apart from the return value, c.run() is just a shortcut of
-    /// the following code.
-    /// \code
-    ///   c.greedyInit();
-    ///   c.start();
-    /// \endcode
-    bool run() {
-      greedyInit();
-      return start();
-    }
-
-    /// @}
-
-    /// \name Query Functions
-    /// The results of the circulation algorithm can be obtained using
-    /// these functions.\n
-    /// Either \ref run() or \ref start() should be called before
-    /// using them.
-
-    ///@{
-
-    /// \brief Returns the flow value on the given arc.
-    ///
-    /// Returns the flow value on the given arc.
-    ///
-    /// \pre Either \ref run() or \ref init() must be called before
-    /// using this function.
-    Value flow(const Arc& arc) const {
-      return (*_flow)[arc];
-    }
-
-    /// \brief Returns a const reference to the flow map.
-    ///
-    /// Returns a const reference to the arc map storing the found flow.
-    ///
-    /// \pre Either \ref run() or \ref init() must be called before
-    /// using this function.
-    const FlowMap& flowMap() const {
-      return *_flow;
-    }
-
-    /**
-       \brief Returns \c true if the given node is in a barrier.
-
-       Barrier is a set \e B of nodes for which
-
-       \f[ \sum_{uv\in A: u\in B} upper(uv) -
-           \sum_{uv\in A: v\in B} lower(uv) < \sum_{v\in B} sup(v) \f]
-
-       holds. The existence of a set with this property prooves that a
-       feasible circualtion cannot exist.
-
-       This function returns \c true if the given node is in the found
-       barrier. If a feasible circulation is found, the function
-       gives back \c false for every node.
-
-       \pre Either \ref run() or \ref init() must be called before
-       using this function.
-
-       \sa barrierMap()
-       \sa checkBarrier()
-    */
-    bool barrier(const Node& node) const
-    {
-      return (*_level)[node] >= _el;
-    }
-
-    /// \brief Gives back a barrier.
-    ///
-    /// This function sets \c bar to the characteristic vector of the
-    /// found barrier. \c bar should be a \ref concepts::WriteMap "writable"
-    /// node map with \c bool (or convertible) value type.
-    ///
-    /// If a feasible circulation is found, the function gives back an
-    /// empty set, so \c bar[v] will be \c false for all nodes \c v.
-    ///
-    /// \note This function calls \ref barrier() for each node,
-    /// so it runs in O(n) time.
-    ///
-    /// \pre Either \ref run() or \ref init() must be called before
-    /// using this function.
-    ///
-    /// \sa barrier()
-    /// \sa checkBarrier()
-    template<class BarrierMap>
-    void barrierMap(BarrierMap &bar) const
-    {
-      for(NodeIt n(_g);n!=INVALID;++n)
-        bar.set(n, (*_level)[n] >= _el);
-    }
-
-    /// @}
-
-    /// \name Checker Functions
-    /// The feasibility of the results can be checked using
-    /// these functions.\n
-    /// Either \ref run() or \ref start() should be called before
-    /// using them.
-
-    ///@{
-
-    ///Check if the found flow is a feasible circulation
-
-    ///Check if the found flow is a feasible circulation,
-    ///
-    bool checkFlow() const {
-      for(ArcIt e(_g);e!=INVALID;++e)
-        if((*_flow)[e]<(*_lo)[e]||(*_flow)[e]>(*_up)[e]) return false;
-      for(NodeIt n(_g);n!=INVALID;++n)
-        {
-          Value dif=-(*_supply)[n];
-          for(InArcIt e(_g,n);e!=INVALID;++e) dif-=(*_flow)[e];
-          for(OutArcIt e(_g,n);e!=INVALID;++e) dif+=(*_flow)[e];
-          if(_tol.negative(dif)) return false;
-        }
-      return true;
-    }
-
-    ///Check whether or not the last execution provides a barrier
-
-    ///Check whether or not the last execution provides a barrier.
-    ///\sa barrier()
-    ///\sa barrierMap()
-    bool checkBarrier() const
-    {
-      Value delta=0;
-      Value inf_cap = std::numeric_limits<Value>::has_infinity ?
-        std::numeric_limits<Value>::infinity() :
-        std::numeric_limits<Value>::max();
-      for(NodeIt n(_g);n!=INVALID;++n)
-        if(barrier(n))
-          delta-=(*_supply)[n];
-      for(ArcIt e(_g);e!=INVALID;++e)
-        {
-          Node s=_g.source(e);
-          Node t=_g.target(e);
-          if(barrier(s)&&!barrier(t)) {
-            if (_tol.less(inf_cap - (*_up)[e], delta)) return false;
-            delta+=(*_up)[e];
-          }
-          else if(barrier(t)&&!barrier(s)) delta-=(*_lo)[e];
-        }
-      return _tol.negative(delta);
-    }
-
-    /// @}
-
-  };
-
-}
-
-#endif
Index: mon/clp.cc
===================================================================
--- lemon/clp.cc	(revision 956)
+++ 	(revision )
@@ -1,466 +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/clp.h>
-#include <coin/ClpSimplex.hpp>
-
-namespace lemon {
-
-  ClpLp::ClpLp() {
-    _prob = new ClpSimplex();
-    _init_temporals();
-    messageLevel(MESSAGE_NOTHING);
-  }
-
-  ClpLp::ClpLp(const ClpLp& other) {
-    _prob = new ClpSimplex(*other._prob);
-    rows = other.rows;
-    cols = other.cols;
-    _init_temporals();
-    messageLevel(MESSAGE_NOTHING);
-  }
-
-  ClpLp::~ClpLp() {
-    delete _prob;
-    _clear_temporals();
-  }
-
-  void ClpLp::_init_temporals() {
-    _primal_ray = 0;
-    _dual_ray = 0;
-  }
-
-  void ClpLp::_clear_temporals() {
-    if (_primal_ray) {
-      delete[] _primal_ray;
-      _primal_ray = 0;
-    }
-    if (_dual_ray) {
-      delete[] _dual_ray;
-      _dual_ray = 0;
-    }
-  }
-
-  ClpLp* ClpLp::newSolver() const {
-    ClpLp* newlp = new ClpLp;
-    return newlp;
-  }
-
-  ClpLp* ClpLp::cloneSolver() const {
-    ClpLp* copylp = new ClpLp(*this);
-    return copylp;
-  }
-
-  const char* ClpLp::_solverName() const { return "ClpLp"; }
-
-  int ClpLp::_addCol() {
-    _prob->addColumn(0, 0, 0, -COIN_DBL_MAX, COIN_DBL_MAX, 0.0);
-    return _prob->numberColumns() - 1;
-  }
-
-  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;
-  }
-
-
-  void ClpLp::_eraseCol(int c) {
-    _col_names_ref.erase(_prob->getColumnName(c));
-    _prob->deleteColumns(1, &c);
-  }
-
-  void ClpLp::_eraseRow(int r) {
-    _row_names_ref.erase(_prob->getRowName(r));
-    _prob->deleteRows(1, &r);
-  }
-
-  void ClpLp::_eraseColId(int i) {
-    cols.eraseIndex(i);
-    cols.shiftIndices(i);
-  }
-
-  void ClpLp::_eraseRowId(int i) {
-    rows.eraseIndex(i);
-    rows.shiftIndices(i);
-  }
-
-  void ClpLp::_getColName(int c, std::string& name) const {
-    name = _prob->getColumnName(c);
-  }
-
-  void ClpLp::_setColName(int c, const std::string& name) {
-    _prob->setColumnName(c, const_cast<std::string&>(name));
-    _col_names_ref[name] = c;
-  }
-
-  int ClpLp::_colByName(const std::string& name) const {
-    std::map<std::string, int>::const_iterator it = _col_names_ref.find(name);
-    return it != _col_names_ref.end() ? it->second : -1;
-  }
-
-  void ClpLp::_getRowName(int r, std::string& name) const {
-    name = _prob->getRowName(r);
-  }
-
-  void ClpLp::_setRowName(int r, const std::string& name) {
-    _prob->setRowName(r, const_cast<std::string&>(name));
-    _row_names_ref[name] = r;
-  }
-
-  int ClpLp::_rowByName(const std::string& name) const {
-    std::map<std::string, int>::const_iterator it = _row_names_ref.find(name);
-    return it != _row_names_ref.end() ? it->second : -1;
-  }
-
-
-  void ClpLp::_setRowCoeffs(int ix, ExprIterator b, ExprIterator e) {
-    std::map<int, Value> coeffs;
-
-    int n = _prob->clpMatrix()->getNumCols();
-
-    const int* indices = _prob->clpMatrix()->getIndices();
-    const double* elements = _prob->clpMatrix()->getElements();
-
-    for (int i = 0; i < n; ++i) {
-      CoinBigIndex begin = _prob->clpMatrix()->getVectorStarts()[i];
-      CoinBigIndex end = begin + _prob->clpMatrix()->getVectorLengths()[i];
-
-      const int* it = std::lower_bound(indices + begin, indices + end, ix);
-      if (it != indices + end && *it == ix && elements[it - indices] != 0.0) {
-        coeffs[i] = 0.0;
-      }
-    }
-
-    for (ExprIterator it = b; it != e; ++it) {
-      coeffs[it->first] = it->second;
-    }
-
-    for (std::map<int, Value>::iterator it = coeffs.begin();
-         it != coeffs.end(); ++it) {
-      _prob->modifyCoefficient(ix, it->first, it->second);
-    }
-  }
-
-  void ClpLp::_getRowCoeffs(int ix, InsertIterator b) const {
-    int n = _prob->clpMatrix()->getNumCols();
-
-    const int* indices = _prob->clpMatrix()->getIndices();
-    const double* elements = _prob->clpMatrix()->getElements();
-
-    for (int i = 0; i < n; ++i) {
-      CoinBigIndex begin = _prob->clpMatrix()->getVectorStarts()[i];
-      CoinBigIndex end = begin + _prob->clpMatrix()->getVectorLengths()[i];
-
-      const int* it = std::lower_bound(indices + begin, indices + end, ix);
-      if (it != indices + end && *it == ix) {
-        *b = std::make_pair(i, elements[it - indices]);
-      }
-    }
-  }
-
-  void ClpLp::_setColCoeffs(int ix, ExprIterator b, ExprIterator e) {
-    std::map<int, Value> coeffs;
-
-    CoinBigIndex begin = _prob->clpMatrix()->getVectorStarts()[ix];
-    CoinBigIndex end = begin + _prob->clpMatrix()->getVectorLengths()[ix];
-
-    const int* indices = _prob->clpMatrix()->getIndices();
-    const double* elements = _prob->clpMatrix()->getElements();
-
-    for (CoinBigIndex i = begin; i != end; ++i) {
-      if (elements[i] != 0.0) {
-        coeffs[indices[i]] = 0.0;
-      }
-    }
-    for (ExprIterator it = b; it != e; ++it) {
-      coeffs[it->first] = it->second;
-    }
-    for (std::map<int, Value>::iterator it = coeffs.begin();
-         it != coeffs.end(); ++it) {
-      _prob->modifyCoefficient(it->first, ix, it->second);
-    }
-  }
-
-  void ClpLp::_getColCoeffs(int ix, InsertIterator b) const {
-    CoinBigIndex begin = _prob->clpMatrix()->getVectorStarts()[ix];
-    CoinBigIndex end = begin + _prob->clpMatrix()->getVectorLengths()[ix];
-
-    const int* indices = _prob->clpMatrix()->getIndices();
-    const double* elements = _prob->clpMatrix()->getElements();
-
-    for (CoinBigIndex i = begin; i != end; ++i) {
-      *b = std::make_pair(indices[i], elements[i]);
-      ++b;
-    }
-  }
-
-  void ClpLp::_setCoeff(int ix, int jx, Value value) {
-    _prob->modifyCoefficient(ix, jx, value);
-  }
-
-  ClpLp::Value ClpLp::_getCoeff(int ix, int jx) const {
-    CoinBigIndex begin = _prob->clpMatrix()->getVectorStarts()[ix];
-    CoinBigIndex end = begin + _prob->clpMatrix()->getVectorLengths()[ix];
-
-    const int* indices = _prob->clpMatrix()->getIndices();
-    const double* elements = _prob->clpMatrix()->getElements();
-
-    const int* it = std::lower_bound(indices + begin, indices + end, jx);
-    if (it != indices + end && *it == jx) {
-      return elements[it - indices];
-    } else {
-      return 0.0;
-    }
-  }
-
-  void ClpLp::_setColLowerBound(int i, Value lo) {
-    _prob->setColumnLower(i, lo == - INF ? - COIN_DBL_MAX : lo);
-  }
-
-  ClpLp::Value ClpLp::_getColLowerBound(int i) const {
-    double val = _prob->getColLower()[i];
-    return val == - COIN_DBL_MAX ? - INF : val;
-  }
-
-  void ClpLp::_setColUpperBound(int i, Value up) {
-    _prob->setColumnUpper(i, up == INF ? COIN_DBL_MAX : up);
-  }
-
-  ClpLp::Value ClpLp::_getColUpperBound(int i) const {
-    double val = _prob->getColUpper()[i];
-    return val == COIN_DBL_MAX ? INF : val;
-  }
-
-  void ClpLp::_setRowLowerBound(int i, Value lo) {
-    _prob->setRowLower(i, lo == - INF ? - COIN_DBL_MAX : lo);
-  }
-
-  ClpLp::Value ClpLp::_getRowLowerBound(int i) const {
-    double val = _prob->getRowLower()[i];
-    return val == - COIN_DBL_MAX ? - INF : val;
-  }
-
-  void ClpLp::_setRowUpperBound(int i, Value up) {
-    _prob->setRowUpper(i, up == INF ? COIN_DBL_MAX : up);
-  }
-
-  ClpLp::Value ClpLp::_getRowUpperBound(int i) const {
-    double val = _prob->getRowUpper()[i];
-    return val == COIN_DBL_MAX ? INF : val;
-  }
-
-  void ClpLp::_setObjCoeffs(ExprIterator b, ExprIterator e) {
-    int num = _prob->clpMatrix()->getNumCols();
-    for (int i = 0; i < num; ++i) {
-      _prob->setObjectiveCoefficient(i, 0.0);
-    }
-    for (ExprIterator it = b; it != e; ++it) {
-      _prob->setObjectiveCoefficient(it->first, it->second);
-    }
-  }
-
-  void ClpLp::_getObjCoeffs(InsertIterator b) const {
-    int num = _prob->clpMatrix()->getNumCols();
-    for (int i = 0; i < num; ++i) {
-      Value coef = _prob->getObjCoefficients()[i];
-      if (coef != 0.0) {
-        *b = std::make_pair(i, coef);
-        ++b;
-      }
-    }
-  }
-
-  void ClpLp::_setObjCoeff(int i, Value obj_coef) {
-    _prob->setObjectiveCoefficient(i, obj_coef);
-  }
-
-  ClpLp::Value ClpLp::_getObjCoeff(int i) const {
-    return _prob->getObjCoefficients()[i];
-  }
-
-  ClpLp::SolveExitStatus ClpLp::_solve() {
-    return _prob->primal() >= 0 ? SOLVED : UNSOLVED;
-  }
-
-  ClpLp::SolveExitStatus ClpLp::solvePrimal() {
-    return _prob->primal() >= 0 ? SOLVED : UNSOLVED;
-  }
-
-  ClpLp::SolveExitStatus ClpLp::solveDual() {
-    return _prob->dual() >= 0 ? SOLVED : UNSOLVED;
-  }
-
-  ClpLp::SolveExitStatus ClpLp::solveBarrier() {
-    return _prob->barrier() >= 0 ? SOLVED : UNSOLVED;
-  }
-
-  ClpLp::Value ClpLp::_getPrimal(int i) const {
-    return _prob->primalColumnSolution()[i];
-  }
-  ClpLp::Value ClpLp::_getPrimalValue() const {
-    return _prob->objectiveValue();
-  }
-
-  ClpLp::Value ClpLp::_getDual(int i) const {
-    return _prob->dualRowSolution()[i];
-  }
-
-  ClpLp::Value ClpLp::_getPrimalRay(int i) const {
-    if (!_primal_ray) {
-      _primal_ray = _prob->unboundedRay();
-      LEMON_ASSERT(_primal_ray != 0, "Primal ray is not provided");
-    }
-    return _primal_ray[i];
-  }
-
-  ClpLp::Value ClpLp::_getDualRay(int i) const {
-    if (!_dual_ray) {
-      _dual_ray = _prob->infeasibilityRay();
-      LEMON_ASSERT(_dual_ray != 0, "Dual ray is not provided");
-    }
-    return _dual_ray[i];
-  }
-
-  ClpLp::VarStatus ClpLp::_getColStatus(int i) const {
-    switch (_prob->getColumnStatus(i)) {
-    case ClpSimplex::basic:
-      return BASIC;
-    case ClpSimplex::isFree:
-      return FREE;
-    case ClpSimplex::atUpperBound:
-      return UPPER;
-    case ClpSimplex::atLowerBound:
-      return LOWER;
-    case ClpSimplex::isFixed:
-      return FIXED;
-    case ClpSimplex::superBasic:
-      return FREE;
-    default:
-      LEMON_ASSERT(false, "Wrong column status");
-      return VarStatus();
-    }
-  }
-
-  ClpLp::VarStatus ClpLp::_getRowStatus(int i) const {
-    switch (_prob->getColumnStatus(i)) {
-    case ClpSimplex::basic:
-      return BASIC;
-    case ClpSimplex::isFree:
-      return FREE;
-    case ClpSimplex::atUpperBound:
-      return UPPER;
-    case ClpSimplex::atLowerBound:
-      return LOWER;
-    case ClpSimplex::isFixed:
-      return FIXED;
-    case ClpSimplex::superBasic:
-      return FREE;
-    default:
-      LEMON_ASSERT(false, "Wrong row status");
-      return VarStatus();
-    }
-  }
-
-
-  ClpLp::ProblemType ClpLp::_getPrimalType() const {
-    if (_prob->isProvenOptimal()) {
-      return OPTIMAL;
-    } else if (_prob->isProvenPrimalInfeasible()) {
-      return INFEASIBLE;
-    } else if (_prob->isProvenDualInfeasible()) {
-      return UNBOUNDED;
-    } else {
-      return UNDEFINED;
-    }
-  }
-
-  ClpLp::ProblemType ClpLp::_getDualType() const {
-    if (_prob->isProvenOptimal()) {
-      return OPTIMAL;
-    } else if (_prob->isProvenDualInfeasible()) {
-      return INFEASIBLE;
-    } else if (_prob->isProvenPrimalInfeasible()) {
-      return INFEASIBLE;
-    } else {
-      return UNDEFINED;
-    }
-  }
-
-  void ClpLp::_setSense(ClpLp::Sense sense) {
-    switch (sense) {
-    case MIN:
-      _prob->setOptimizationDirection(1);
-      break;
-    case MAX:
-      _prob->setOptimizationDirection(-1);
-      break;
-    }
-  }
-
-  ClpLp::Sense ClpLp::_getSense() const {
-    double dir = _prob->optimizationDirection();
-    if (dir > 0.0) {
-      return MIN;
-    } else {
-      return MAX;
-    }
-  }
-
-  void ClpLp::_clear() {
-    delete _prob;
-    _prob = new ClpSimplex();
-    rows.clear();
-    cols.clear();
-    _col_names_ref.clear();
-    _clear_temporals();
-  }
-
-  void ClpLp::_messageLevel(MessageLevel level) {
-    switch (level) {
-    case MESSAGE_NOTHING:
-      _prob->setLogLevel(0);
-      break;
-    case MESSAGE_ERROR:
-      _prob->setLogLevel(1);
-      break;
-    case MESSAGE_WARNING:
-      _prob->setLogLevel(2);
-      break;
-    case MESSAGE_NORMAL:
-      _prob->setLogLevel(3);
-      break;
-    case MESSAGE_VERBOSE:
-      _prob->setLogLevel(4);
-      break;
-    }
-  }
-
-} //END OF NAMESPACE LEMON
Index: mon/clp.h
===================================================================
--- lemon/clp.h	(revision 956)
+++ 	(revision )
@@ -1,164 +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_CLP_H
-#define LEMON_CLP_H
-
-///\file
-///\brief Header of the LEMON-CLP lp solver interface.
-
-#include <vector>
-#include <string>
-
-#include <lemon/lp_base.h>
-
-class ClpSimplex;
-
-namespace lemon {
-
-  /// \ingroup lp_group
-  ///
-  /// \brief Interface for the CLP solver
-  ///
-  /// This class implements an interface for the Clp LP solver.  The
-  /// Clp library is an object oriented lp solver library developed at
-  /// the IBM. The CLP is part of the COIN-OR package and it can be
-  /// used with Common Public License.
-  class ClpLp : public LpSolver {
-  protected:
-
-    ClpSimplex* _prob;
-
-    std::map<std::string, int> _col_names_ref;
-    std::map<std::string, int> _row_names_ref;
-
-  public:
-
-    /// \e
-    ClpLp();
-    /// \e
-    ClpLp(const ClpLp&);
-    /// \e
-    ~ClpLp();
-
-    /// \e
-    virtual ClpLp* newSolver() const;
-    /// \e
-    virtual ClpLp* cloneSolver() const;
-
-  protected:
-
-    mutable double* _primal_ray;
-    mutable double* _dual_ray;
-
-    void _init_temporals();
-    void _clear_temporals();
-
-  protected:
-
-    virtual const char* _solverName() const;
-
-    virtual int _addCol();
-    virtual int _addRow();
-    virtual int _addRow(Value l, ExprIterator b, ExprIterator e, Value u);
-
-    virtual void _eraseCol(int i);
-    virtual void _eraseRow(int i);
-
-    virtual void _eraseColId(int i);
-    virtual void _eraseRowId(int i);
-
-    virtual void _getColName(int col, std::string& name) const;
-    virtual void _setColName(int col, const std::string& name);
-    virtual int _colByName(const std::string& name) const;
-
-    virtual void _getRowName(int row, std::string& name) const;
-    virtual void _setRowName(int row, const std::string& name);
-    virtual int _rowByName(const std::string& name) const;
-
-    virtual void _setRowCoeffs(int i, ExprIterator b, ExprIterator e);
-    virtual void _getRowCoeffs(int i, InsertIterator b) const;
-
-    virtual void _setColCoeffs(int i, ExprIterator b, ExprIterator e);
-    virtual void _getColCoeffs(int i, InsertIterator b) const;
-
-    virtual void _setCoeff(int row, int col, Value value);
-    virtual Value _getCoeff(int row, int col) const;
-
-    virtual void _setColLowerBound(int i, Value value);
-    virtual Value _getColLowerBound(int i) const;
-    virtual void _setColUpperBound(int i, Value value);
-    virtual Value _getColUpperBound(int i) const;
-
-    virtual void _setRowLowerBound(int i, Value value);
-    virtual Value _getRowLowerBound(int i) const;
-    virtual void _setRowUpperBound(int i, Value value);
-    virtual Value _getRowUpperBound(int i) const;
-
-    virtual void _setObjCoeffs(ExprIterator, ExprIterator);
-    virtual void _getObjCoeffs(InsertIterator) const;
-
-    virtual void _setObjCoeff(int i, Value obj_coef);
-    virtual Value _getObjCoeff(int i) const;
-
-    virtual void _setSense(Sense sense);
-    virtual Sense _getSense() const;
-
-    virtual SolveExitStatus _solve();
-
-    virtual Value _getPrimal(int i) const;
-    virtual Value _getDual(int i) const;
-
-    virtual Value _getPrimalValue() const;
-
-    virtual Value _getPrimalRay(int i) const;
-    virtual Value _getDualRay(int i) const;
-
-    virtual VarStatus _getColStatus(int i) const;
-    virtual VarStatus _getRowStatus(int i) const;
-
-    virtual ProblemType _getPrimalType() const;
-    virtual ProblemType _getDualType() const;
-
-    virtual void _clear();
-
-    virtual void _messageLevel(MessageLevel);
-
-  public:
-
-    ///Solves LP with primal simplex method.
-    SolveExitStatus solvePrimal();
-
-    ///Solves LP with dual simplex method.
-    SolveExitStatus solveDual();
-
-    ///Solves LP with barrier method.
-    SolveExitStatus solveBarrier();
-
-    ///Returns the constraint identifier understood by CLP.
-    int clpRow(Row r) const { return rows(id(r)); }
-
-    ///Returns the variable identifier understood by CLP.
-    int clpCol(Col c) const { return cols(id(c)); }
-
-  };
-
-} //END OF NAMESPACE LEMON
-
-#endif //LEMON_CLP_H
-
Index: lemon/color.cc
===================================================================
--- lemon/color.cc	(revision 463)
+++ lemon/color.cc	(revision 209)
@@ -3,5 +3,5 @@
  * This file is a part of LEMON, a generic C++ optimization library.
  *
- * Copyright (C) 2003-2009
+ * Copyright (C) 2003-2008
  * Egervary Jeno Kombinatorikus Optimalizalasi Kutatocsoport
  * (Egervary Research Group on Combinatorial Optimization, EGRES).
Index: lemon/color.h
===================================================================
--- lemon/color.h	(revision 463)
+++ lemon/color.h	(revision 313)
@@ -3,5 +3,5 @@
  * This file is a part of LEMON, a generic C++ optimization library.
  *
- * Copyright (C) 2003-2009
+ * Copyright (C) 2003-2008
  * Egervary Jeno Kombinatorikus Optimalizalasi Kutatocsoport
  * (Egervary Research Group on Combinatorial Optimization, EGRES).
Index: lemon/concept_check.h
===================================================================
--- lemon/concept_check.h	(revision 463)
+++ lemon/concept_check.h	(revision 285)
@@ -3,5 +3,5 @@
  * This file is a part of LEMON, a generic C++ optimization library.
  *
- * Copyright (C) 2003-2009
+ * Copyright (C) 2003-2008
  * Egervary Jeno Kombinatorikus Optimalizalasi Kutatocsoport
  * (Egervary Research Group on Combinatorial Optimization, EGRES).
Index: lemon/concepts/digraph.h
===================================================================
--- lemon/concepts/digraph.h	(revision 956)
+++ lemon/concepts/digraph.h	(revision 263)
@@ -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).
@@ -17,6 +17,6 @@
  */
 
-#ifndef LEMON_CONCEPTS_DIGRAPH_H
-#define LEMON_CONCEPTS_DIGRAPH_H
+#ifndef LEMON_CONCEPT_DIGRAPH_H
+#define LEMON_CONCEPT_DIGRAPH_H
 
 ///\ingroup graph_concepts
@@ -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,50 +393,49 @@
       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 Read write map of the nodes to type \c T.
+      ///
+      /// ReadWrite map of the nodes to type \c T.
+      /// \sa Reference
       template<class T>
-      class NodeMap : public ReferenceMap<Node, T, T&, const T&> {
-      public:
-
-        /// Constructor
-        explicit NodeMap(const Digraph&) { }
-        /// Constructor with given initial value
+      class NodeMap : public ReadWriteMap< Node, T > {
+      public:
+
+        ///\e
+        NodeMap(const Digraph&) { }
+        ///\e
         NodeMap(const Digraph&, T) { }
 
       private:
         ///Copy constructor
-        NodeMap(const NodeMap& nm) :
-          ReferenceMap<Node, T, T&, const T&>(nm) { }
+        NodeMap(const NodeMap& nm) : ReadWriteMap< Node, T >(nm) { }
         ///Assignment operator
         template <typename CMap>
@@ -445,21 +446,19 @@
       };
 
-      /// \brief Standard graph map type for the arcs.
-      ///
-      /// Standard graph map type for the arcs.
-      /// It conforms to the ReferenceMap concept.
+      /// \brief Read write map of the arcs to type \c T.
+      ///
+      /// Reference map of the arcs to type \c T.
+      /// \sa Reference
       template<class T>
-      class ArcMap : public ReferenceMap<Arc, T, T&, const T&> {
-      public:
-
-        /// Constructor
-        explicit ArcMap(const Digraph&) { }
-        /// Constructor with given initial value
+      class ArcMap : public ReadWriteMap<Arc,T> {
+      public:
+
+        ///\e
+        ArcMap(const Digraph&) { }
+        ///\e
         ArcMap(const Digraph&, T) { }
-
       private:
         ///Copy constructor
-        ArcMap(const ArcMap& em) :
-          ReferenceMap<Arc, T, T&, const T&>(em) { }
+        ArcMap(const ArcMap& em) : ReadWriteMap<Arc,T>(em) { }
         ///Assignment operator
         template <typename CMap>
@@ -473,5 +472,4 @@
       struct Constraints {
         void constraints() {
-          checkConcept<BaseDigraphComponent, _Digraph>();
           checkConcept<IterableDigraphComponent<>, _Digraph>();
           checkConcept<IDableDigraphComponent<>, _Digraph>();
@@ -487,3 +485,3 @@
 
 
-#endif
+#endif // LEMON_CONCEPT_DIGRAPH_H
Index: lemon/concepts/graph.h
===================================================================
--- lemon/concepts/graph.h	(revision 956)
+++ lemon/concepts/graph.h	(revision 263)
@@ -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).
@@ -19,12 +19,11 @@
 ///\ingroup graph_concepts
 ///\file
-///\brief The concept of undirected graphs.
-
-#ifndef LEMON_CONCEPTS_GRAPH_H
-#define LEMON_CONCEPTS_GRAPH_H
+///\brief The concept of Undirected Graphs.
+
+#ifndef LEMON_CONCEPT_GRAPH_H
+#define LEMON_CONCEPT_GRAPH_H
 
 #include <lemon/concepts/graph_components.h>
-#include <lemon/concepts/maps.h>
-#include <lemon/concept_check.h>
+#include <lemon/concepts/graph.h>
 #include <lemon/core.h>
 
@@ -34,72 +33,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 +97,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 +126,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 +139,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 +147,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 +172,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 +188,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 +228,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 +236,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 +273,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 +285,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.
-      class Arc {
-      public:
-        /// Default constructor
-
-        /// Default constructor.
-        /// \warning It sets the object to an undefined value.
+      /// The directed arc type.
+
+      /// The directed arc type. It can be converted to the
+      /// edge or it should be inherited from the undirected
+      /// arc.
+      class Arc : public Edge {
+      public:
+        /// Default constructor
+
+        /// @warning The default constructor sets the iterator
+        /// to an undefined value.
         Arc() { }
         /// Copy constructor.
@@ -333,46 +324,40 @@
         /// Copy constructor.
         ///
-        Arc(const Arc&) { }
-        /// %Invalid constructor \& conversion.
-
-        /// Initializes the object to be invalid.
-        /// \sa Invalid for more details.
+        Arc(const Arc& e) : Edge(e) { }
+        /// 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.
-        ///
-        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 +365,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 +373,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 +419,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 +447,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,47 +471,49 @@
         ///
         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 Read write map of the nodes to type \c T.
+      ///
+      /// ReadWrite map of the nodes to type \c T.
+      /// \sa Reference
       template<class T>
-      class NodeMap : public ReferenceMap<Node, T, T&, const T&>
+      class NodeMap : public ReadWriteMap< Node, T >
       {
       public:
 
-        /// Constructor
-        explicit NodeMap(const Graph&) { }
-        /// Constructor with given initial value
+        ///\e
+        NodeMap(const Graph&) { }
+        ///\e
         NodeMap(const Graph&, T) { }
 
       private:
         ///Copy constructor
-        NodeMap(const NodeMap& nm) :
-          ReferenceMap<Node, T, T&, const T&>(nm) { }
+        NodeMap(const NodeMap& nm) : ReadWriteMap< Node, T >(nm) { }
         ///Assignment operator
         template <typename CMap>
@@ -532,22 +524,20 @@
       };
 
-      /// \brief Standard graph map type for the arcs.
-      ///
-      /// Standard graph map type for the arcs.
-      /// It conforms to the ReferenceMap concept.
+      /// \brief Read write map of the directed arcs to type \c T.
+      ///
+      /// Reference map of the directed arcs to type \c T.
+      /// \sa Reference
       template<class T>
-      class ArcMap : public ReferenceMap<Arc, T, T&, const T&>
+      class ArcMap : public ReadWriteMap<Arc,T>
       {
       public:
 
-        /// Constructor
-        explicit ArcMap(const Graph&) { }
-        /// Constructor with given initial value
+        ///\e
+        ArcMap(const Graph&) { }
+        ///\e
         ArcMap(const Graph&, T) { }
-
       private:
         ///Copy constructor
-        ArcMap(const ArcMap& em) :
-          ReferenceMap<Arc, T, T&, const T&>(em) { }
+        ArcMap(const ArcMap& em) : ReadWriteMap<Arc,T>(em) { }
         ///Assignment operator
         template <typename CMap>
@@ -558,22 +548,20 @@
       };
 
-      /// \brief Standard graph map type for the edges.
-      ///
-      /// Standard graph map type for the edges.
-      /// It conforms to the ReferenceMap concept.
+      /// Read write map of the edges to type \c T.
+
+      /// Reference map of the arcs to type \c T.
+      /// \sa Reference
       template<class T>
-      class EdgeMap : public ReferenceMap<Edge, T, T&, const T&>
+      class EdgeMap : public ReadWriteMap<Edge,T>
       {
       public:
 
-        /// Constructor
-        explicit EdgeMap(const Graph&) { }
-        /// Constructor with given initial value
+        ///\e
+        EdgeMap(const Graph&) { }
+        ///\e
         EdgeMap(const Graph&, T) { }
-
       private:
         ///Copy constructor
-        EdgeMap(const EdgeMap& em) :
-          ReferenceMap<Edge, T, T&, const T&>(em) {}
+        EdgeMap(const EdgeMap& em) : ReadWriteMap<Edge,T>(em) {}
         ///Assignment operator
         template <typename CMap>
@@ -584,121 +572,92 @@
       };
 
-      /// \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.
-      /// \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.
-      /// \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.
-      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.
-      int id(Node) const { return -1; }
-
-      /// \brief The ID of the edge.
-      ///
-      /// Returns the ID of the given edge.
-      int id(Edge) const { return -1; }
-
-      /// \brief The ID of the arc.
-      ///
-      /// Returns the ID of the given 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.
-      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.
-      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.
-      Arc arcFromId(int) const { return INVALID; }
-
-      /// \brief An upper bound on the node IDs.
-      ///
-      /// 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.
-      int maxEdgeId() const { return -1; }
-
-      /// \brief An upper bound on the arc IDs.
-      ///
-      /// 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 {
+      /// \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 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 {
+      /// \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 The oppositely directed arc.
-      ///
-      /// Returns the oppositely directed arc representing the same edge.
+      /// \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 The opposite node on the edge.
-      ///
-      /// Returns the opposite node on the given edge.
+      /// \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. But we use these two methods
+      /// to query the two nodes of the arc. The direction of the arc
+      /// which arises this way is called the inherent direction of the
+      /// edge, and is used to define the "default" direction
+      /// of the directed versions of the arcs.
+      /// \sa direction
+      Node u(Edge) const { return INVALID; }
+
+      /// \brief Second node of the edge.
+      Node v(Edge) const { return INVALID; }
+
+      /// \brief Source node of the directed arc.
+      Node source(Arc) const { return INVALID; }
+
+      /// \brief Target node of the directed arc.
+      Node target(Arc) const { return INVALID; }
+
+      /// \brief Returns the id of the node.
+      int id(Node) const { return -1; }
+
+      /// \brief Returns the id of the edge.
+      int id(Edge) const { return -1; }
+
+      /// \brief Returns the id of the arc.
+      int id(Arc) const { return -1; }
+
+      /// \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 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 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 Returns an upper bound on the node IDs.
+      int maxNodeId() const { return -1; }
+
+      /// \brief Returns an upper bound on the edge IDs.
+      int maxEdgeId() const { return -1; }
+
+      /// \brief Returns an upper bound on the arc IDs.
+      int maxArcId() const { return -1; }
 
       void first(Node&) const {}
@@ -734,42 +693,49 @@
       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>
       struct Constraints {
         void constraints() {
-          checkConcept<BaseGraphComponent, _Graph>();
           checkConcept<IterableGraphComponent<>, _Graph>();
           checkConcept<IDableGraphComponent<>, _Graph>();
Index: lemon/concepts/graph_components.h
===================================================================
--- lemon/concepts/graph_components.h	(revision 956)
+++ lemon/concepts/graph_components.h	(revision 313)
@@ -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).
@@ -19,8 +19,9 @@
 ///\ingroup graph_concepts
 ///\file
-///\brief The concepts of graph components.
-
-#ifndef LEMON_CONCEPTS_GRAPH_COMPONENTS_H
-#define LEMON_CONCEPTS_GRAPH_COMPONENTS_H
+///\brief The concept of graph components.
+
+
+#ifndef LEMON_CONCEPT_GRAPH_COMPONENTS_H
+#define LEMON_CONCEPT_GRAPH_COMPONENTS_H
 
 #include <lemon/core.h>
@@ -32,16 +33,17 @@
   namespace concepts {
 
-    /// \brief Concept class for \c Node, \c Arc and \c Edge types.
-    ///
-    /// This class describes the concept of \c Node, \c Arc and \c Edge
-    /// subtypes of digraph and graph types.
+    /// \brief Skeleton class for graph Node and Arc types
+    ///
+    /// This class describes the interface of Node and Arc (and Edge
+    /// in undirected graphs) subtypes of graph types.
     ///
     /// \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
-    /// 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'.
+    /// create graph skeleton classes. The reason for this is than Node
+    /// and Arc types should \em not derive from the same base class.
+    /// For Node you should instantiate it with character 'n' and for Arc
+    /// with 'a'.
+
 #ifndef DOXYGEN
-    template <char sel = '0'>
+    template <char _selector = '0'>
 #endif
     class GraphItem {
@@ -49,52 +51,43 @@
       /// \brief Default constructor.
       ///
-      /// Default constructor.
       /// \warning The default constructor is not required to set
       /// the item to some well-defined value. So you should consider it
       /// as uninitialized.
       GraphItem() {}
-
       /// \brief Copy constructor.
       ///
       /// Copy constructor.
+      ///
       GraphItem(const GraphItem &) {}
-
-      /// \brief Constructor for conversion from \c INVALID.
-      ///
-      /// Constructor for conversion from \c INVALID.
-      /// It initializes the item to be invalid.
+      /// \brief Invalid constructor \& conversion.
+      ///
+      /// This constructor initializes the item to be invalid.
       /// \sa Invalid for more details.
       GraphItem(Invalid) {}
-
-      /// \brief Assignment operator.
-      ///
-      /// Assignment operator for the item.
-      GraphItem& operator=(const GraphItem&) { return *this; }
-
-      /// \brief Assignment operator for INVALID.
-      ///
-      /// This operator makes the item invalid.
-      GraphItem& operator=(Invalid) { return *this; }
-
+      /// \brief Assign operator for nodes.
+      ///
+      /// The nodes are assignable.
+      ///
+      GraphItem& operator=(GraphItem const&) { return *this; }
       /// \brief Equality operator.
       ///
-      /// Equality operator.
-      bool operator==(const GraphItem&) const { return false; }
-
+      /// Two iterators are equal if and only if they represents the
+      /// same node in the graph or both are invalid.
+      bool operator==(GraphItem) const { return false; }
       /// \brief Inequality operator.
       ///
-      /// Inequality operator.
-      bool operator!=(const GraphItem&) const { return false; }
-
-      /// \brief Ordering operator.
-      ///
-      /// This operator defines an ordering of the items.
-      /// 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
+      /// \sa operator==(const Node& n)
+      ///
+      bool operator!=(GraphItem) const { return false; }
+
+      /// \brief Artificial ordering operator.
+      ///
+      /// 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<(const GraphItem&) const { return false; }
+      bool operator<(GraphItem) const { return false; }
 
       template<typename _GraphItem>
@@ -102,5 +95,4 @@
         void constraints() {
           _GraphItem i1;
-          i1=INVALID;
           _GraphItem i2 = i1;
           _GraphItem i3 = INVALID;
@@ -109,4 +101,5 @@
 
           bool b;
+          //          b = (ia == ib) && (ia != ib) && (ia < ib);
           b = (ia == ib) && (ia != ib);
           b = (ia == INVALID) && (ib != INVALID);
@@ -119,10 +112,11 @@
     };
 
-    /// \brief Base skeleton class for directed graphs.
-    ///
-    /// 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
-    /// to get the source and the target nodes of arcs.
+    /// \brief An empty base directed graph class.
+    ///
+    /// This class provides the minimal set of features needed for a
+    /// directed graph structure. All digraph concepts have to be
+    /// conform to this base directed graph. It just provides types
+    /// for nodes and arcs and functions to get the source and the
+    /// target of the arcs.
     class BaseDigraphComponent {
     public:
@@ -132,25 +126,29 @@
       /// \brief Node class of the digraph.
       ///
-      /// This class represents the nodes of the digraph.
+      /// This class represents the Nodes of the digraph.
+      ///
       typedef GraphItem<'n'> Node;
 
       /// \brief Arc class of the digraph.
       ///
-      /// This class represents the arcs of the digraph.
-      typedef GraphItem<'a'> Arc;
-
-      /// \brief Return the source node of an arc.
-      ///
-      /// This function returns the source node of an arc.
-      Node source(const Arc&) const { return INVALID; }
-
-      /// \brief Return the target node of an arc.
-      ///
-      /// This function returns the target node of an arc.
-      Node target(const Arc&) const { return INVALID; }
-
-      /// \brief Return the opposite node on the given arc.
-      ///
-      /// This function returns the opposite node on the given arc.
+      /// This class represents the Arcs of the digraph.
+      ///
+      typedef GraphItem<'e'> Arc;
+
+      /// \brief Gives back the target node of an arc.
+      ///
+      /// Gives back the target node of an arc.
+      ///
+      Node target(const Arc&) const { return INVALID;}
+
+      /// \brief Gives back the source node of an arc.
+      ///
+      /// Gives back the source node of an arc.
+      ///
+      Node source(const Arc&) const { return INVALID;}
+
+      /// \brief Gives back 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;
@@ -178,79 +176,56 @@
     };
 
-    /// \brief Base skeleton class for undirected graphs.
-    ///
-    /// This class describes the base interface of undirected graph types.
-    /// All graph %concepts have to conform to this class.
-    /// It extends the interface of \ref BaseDigraphComponent with an
-    /// \c Edge type and functions to get the end nodes of edges,
-    /// to convert from arcs to edges and to get both direction of edges.
+    /// \brief An empty base undirected graph class.
+    ///
+    /// This class provides the minimal set of features needed for an
+    /// undirected graph structure. All undirected graph concepts have
+    /// to be conform to this base graph. It just provides types for
+    /// nodes, arcs and edges and functions to get the
+    /// source and the target of the arcs and edges,
+    /// conversion from arcs to edges and function to get
+    /// both direction of the edges.
     class BaseGraphComponent : public BaseDigraphComponent {
     public:
-
-      typedef BaseGraphComponent Graph;
-
       typedef BaseDigraphComponent::Node Node;
       typedef BaseDigraphComponent::Arc Arc;
-
-      /// \brief Undirected edge class of the graph.
-      ///
-      /// This class represents the undirected edges of the graph.
-      /// Undirected graphs can be used as directed graphs, each edge is
-      /// represented by two opposite directed arcs.
-      class Edge : public GraphItem<'e'> {
-        typedef GraphItem<'e'> Parent;
-
+      /// \brief Undirected arc class of the graph.
+      ///
+      /// This class represents the edges of the graph.
+      /// The undirected graphs can be used as a directed graph which
+      /// for each arc contains the opposite arc too so the graph is
+      /// bidirected. The edge represents two opposite
+      /// directed arcs.
+      class Edge : public GraphItem<'u'> {
       public:
+        typedef GraphItem<'u'> Parent;
         /// \brief Default constructor.
         ///
-        /// Default constructor.
         /// \warning The default constructor is not required to set
         /// the item to some well-defined value. So you should consider it
         /// as uninitialized.
         Edge() {}
-
         /// \brief Copy constructor.
         ///
         /// Copy constructor.
+        ///
         Edge(const Edge &) : Parent() {}
-
-        /// \brief Constructor for conversion from \c INVALID.
-        ///
-        /// Constructor for conversion from \c INVALID.
-        /// It initializes the item to be invalid.
+        /// \brief Invalid constructor \& conversion.
+        ///
+        /// This constructor initializes the item to be invalid.
         /// \sa Invalid for more details.
         Edge(Invalid) {}
-
-        /// \brief Constructor for conversion from an arc.
-        ///
-        /// Constructor for conversion from an arc.
+        /// \brief Converter from arc to edge.
+        ///
         /// Besides the core graph item functionality each arc should
         /// be convertible to the represented edge.
         Edge(const Arc&) {}
-     };
-
-      /// \brief Return one end node of an edge.
-      ///
-      /// This function returns one end node of an edge.
-      Node u(const Edge&) const { return INVALID; }
-
-      /// \brief Return the other end node of an edge.
-      ///
-      /// This function returns the other end node of an edge.
-      Node v(const Edge&) const { return INVALID; }
-
-      /// \brief Return a directed arc related to an edge.
-      ///
-      /// This function returns a directed arc from its direction and the
-      /// represented edge.
-      Arc direct(const Edge&, bool) const { return INVALID; }
-
-      /// \brief Return a directed arc related to an edge.
-      ///
-      /// This function returns a directed arc from its source node and the
-      /// represented edge.
-      Arc direct(const Edge&, const Node&) const { return INVALID; }
-
-      /// \brief Return the direction of the arc.
+        /// \brief Assign arc to edge.
+        ///
+        /// Besides the core graph item functionality each arc should
+        /// be convertible to the represented edge.
+        Edge& operator=(const Arc&) { return *this; }
+      };
+
+      /// \brief Returns the direction of the arc.
       ///
       /// Returns the direction of the arc. Each arc represents an
@@ -259,9 +234,31 @@
       bool direction(const Arc&) const { return true; }
 
-      /// \brief Return the opposite arc.
-      ///
-      /// This function returns the opposite arc, i.e. the arc representing
-      /// the same edge and has opposite direction.
-      Arc oppositeArc(const Arc&) const { return INVALID; }
+      /// \brief Returns the directed arc.
+      ///
+      /// Returns the directed arc from its direction and the
+      /// represented edge.
+      Arc direct(const Edge&, bool) const { return INVALID;}
+
+      /// \brief Returns the directed arc.
+      ///
+      /// Returns the directed arc from its source and the
+      /// represented edge.
+      Arc direct(const Edge&, const Node&) const { return INVALID;}
+
+      /// \brief Returns the opposite arc.
+      ///
+      /// Returns the opposite arc. It is the arc representing the
+      /// same edge and has opposite direction.
+      Arc oppositeArc(const Arc&) const { return INVALID;}
+
+      /// \brief Gives back one ending of an edge.
+      ///
+      /// Gives back one ending of an edge.
+      Node u(const Edge&) const { return INVALID;}
+
+      /// \brief Gives back the other ending of an edge.
+      ///
+      /// Gives back the other ending of an edge.
+      Node v(const Edge&) const { return INVALID;}
 
       template <typename _Graph>
@@ -273,5 +270,5 @@
         void constraints() {
           checkConcept<BaseDigraphComponent, _Graph>();
-          checkConcept<GraphItem<'e'>, Edge>();
+          checkConcept<GraphItem<'u'>, Edge>();
           {
             Node n;
@@ -281,5 +278,4 @@
             n = graph.v(ue);
             e = graph.direct(ue, true);
-            e = graph.direct(ue, false);
             e = graph.direct(ue, n);
             e = graph.oppositeArc(e);
@@ -295,55 +291,57 @@
     };
 
-    /// \brief Skeleton class for \e idable directed graphs.
-    ///
-    /// This class describes the interface of \e idable directed graphs.
-    /// It extends \ref BaseDigraphComponent with the core ID functions.
-    /// The ids of the items must be unique and immutable.
-    /// This concept is part of the Digraph concept.
-    template <typename BAS = BaseDigraphComponent>
-    class IDableDigraphComponent : public BAS {
-    public:
-
-      typedef BAS Base;
+    /// \brief An empty idable base digraph class.
+    ///
+    /// This class provides beside the core digraph features
+    /// core id functions for the digraph structure.
+    /// The most of the base digraphs should be conform to this concept.
+    /// The id's are unique and immutable.
+    template <typename _Base = BaseDigraphComponent>
+    class IDableDigraphComponent : public _Base {
+    public:
+
+      typedef _Base Base;
       typedef typename Base::Node Node;
       typedef typename Base::Arc Arc;
 
-      /// \brief Return a unique integer id for the given node.
-      ///
-      /// This function returns a unique integer id for the given node.
-      int id(const Node&) const { return -1; }
-
-      /// \brief Return the node by its unique id.
-      ///
-      /// This function returns the node by its unique id.
-      /// If the digraph does not contain a node with the given id,
-      /// then the result of the function is undefined.
-      Node nodeFromId(int) const { return INVALID; }
-
-      /// \brief Return a unique integer id for the given arc.
-      ///
-      /// This function returns a unique integer id for the given arc.
-      int id(const Arc&) const { return -1; }
-
-      /// \brief Return the arc by its unique id.
-      ///
-      /// This function returns the arc by its unique id.
-      /// If the digraph does not contain an arc with the given id,
-      /// then the result of the function is undefined.
-      Arc arcFromId(int) const { return INVALID; }
-
-      /// \brief Return an integer greater or equal to the maximum
-      /// node id.
-      ///
-      /// This function returns an integer greater or equal to the
-      /// maximum node id.
-      int maxNodeId() const { return -1; }
-
-      /// \brief Return an integer greater or equal to the maximum
-      /// arc id.
-      ///
-      /// This function returns an integer greater or equal to the
-      /// maximum arc id.
-      int maxArcId() const { return -1; }
+      /// \brief Gives back an unique integer id for the Node.
+      ///
+      /// Gives back an unique integer id for the Node.
+      ///
+      int id(const Node&) const { return -1;}
+
+      /// \brief Gives back the node by the unique id.
+      ///
+      /// Gives back the node by the unique id.
+      /// If the digraph does not contain node with the given id
+      /// then the result of the function is undetermined.
+      Node nodeFromId(int) const { return INVALID;}
+
+      /// \brief Gives back an unique integer id for the Arc.
+      ///
+      /// Gives back an unique integer id for the Arc.
+      ///
+      int id(const Arc&) const { return -1;}
+
+      /// \brief Gives back the arc by the unique id.
+      ///
+      /// Gives back the arc by the unique id.
+      /// If the digraph does not contain arc with the given id
+      /// then the result of the function is undetermined.
+      Arc arcFromId(int) const { return INVALID;}
+
+      /// \brief Gives back an integer greater or equal to the maximum
+      /// Node id.
+      ///
+      /// Gives back an integer greater or equal to the maximum Node
+      /// id.
+      int maxNodeId() const { return -1;}
+
+      /// \brief Gives back an integer greater or equal to the maximum
+      /// Arc id.
+      ///
+      /// Gives back an integer greater or equal to the maximum Arc
+      /// id.
+      int maxArcId() const { return -1;}
 
       template <typename _Digraph>
@@ -353,10 +351,8 @@
           checkConcept<Base, _Digraph >();
           typename _Digraph::Node node;
-          node=INVALID;
           int nid = digraph.id(node);
           nid = digraph.id(node);
           node = digraph.nodeFromId(nid);
           typename _Digraph::Arc arc;
-          arc=INVALID;
           int eid = digraph.id(arc);
           eid = digraph.id(arc);
@@ -373,38 +369,38 @@
     };
 
-    /// \brief Skeleton class for \e idable undirected graphs.
-    ///
-    /// This class describes the interface of \e idable undirected
-    /// graphs. It extends \ref IDableDigraphComponent with the core ID
-    /// functions of undirected graphs.
-    /// The ids of the items must be unique and immutable.
-    /// This concept is part of the Graph concept.
-    template <typename BAS = BaseGraphComponent>
-    class IDableGraphComponent : public IDableDigraphComponent<BAS> {
-    public:
-
-      typedef BAS Base;
+    /// \brief An empty idable base undirected graph class.
+    ///
+    /// This class provides beside the core undirected graph features
+    /// core id functions for the undirected graph structure.  The
+    /// most of the base undirected graphs should be conform to this
+    /// concept.  The id's are unique and immutable.
+    template <typename _Base = BaseGraphComponent>
+    class IDableGraphComponent : public IDableDigraphComponent<_Base> {
+    public:
+
+      typedef _Base Base;
       typedef typename Base::Edge Edge;
 
-      using IDableDigraphComponent<Base>::id;
-
-      /// \brief Return a unique integer id for the given edge.
-      ///
-      /// This function returns a unique integer id for the given edge.
-      int id(const Edge&) const { return -1; }
-
-      /// \brief Return the edge by its unique id.
-      ///
-      /// This function returns the edge by its unique id.
-      /// If the graph does not contain an edge with the given id,
-      /// then the result of the function is undefined.
-      Edge edgeFromId(int) const { return INVALID; }
-
-      /// \brief Return an integer greater or equal to the maximum
-      /// edge id.
-      ///
-      /// This function returns an integer greater or equal to the
-      /// maximum edge id.
-      int maxEdgeId() const { return -1; }
+      using IDableDigraphComponent<_Base>::id;
+
+      /// \brief Gives back an unique integer id for the Edge.
+      ///
+      /// Gives back an unique integer id for the Edge.
+      ///
+      int id(const Edge&) const { return -1;}
+
+      /// \brief Gives back the edge by the unique id.
+      ///
+      /// Gives back the edge by the unique id.  If the
+      /// graph does not contain arc with the given id then the
+      /// result of the function is undetermined.
+      Edge edgeFromId(int) const { return INVALID;}
+
+      /// \brief Gives back an integer greater or equal to the maximum
+      /// Edge id.
+      ///
+      /// Gives back an integer greater or equal to the maximum Edge
+      /// id.
+      int maxEdgeId() const { return -1;}
 
       template <typename _Graph>
@@ -412,4 +408,5 @@
 
         void constraints() {
+          checkConcept<Base, _Graph >();
           checkConcept<IDableDigraphComponent<Base>, _Graph >();
           typename _Graph::Edge edge;
@@ -425,59 +422,50 @@
     };
 
-    /// \brief Concept class for \c NodeIt, \c ArcIt and \c EdgeIt types.
-    ///
-    /// This class describes the concept of \c NodeIt, \c ArcIt and
-    /// \c EdgeIt subtypes of digraph and graph types.
-    template <typename GR, typename Item>
-    class GraphItemIt : public Item {
+    /// \brief Skeleton class for graph NodeIt and ArcIt
+    ///
+    /// Skeleton class for graph NodeIt and ArcIt.
+    ///
+    template <typename _Graph, typename _Item>
+    class GraphItemIt : public _Item {
     public:
       /// \brief Default constructor.
       ///
-      /// Default constructor.
-      /// \warning The default constructor is not required to set
-      /// the iterator to some well-defined value. So you should consider it
-      /// as uninitialized.
+      /// @warning The default constructor sets the iterator
+      /// to an undefined value.
       GraphItemIt() {}
-
       /// \brief Copy constructor.
       ///
       /// Copy constructor.
-      GraphItemIt(const GraphItemIt& it) : Item(it) {}
-
-      /// \brief Constructor that sets the iterator to the first item.
-      ///
-      /// Constructor that sets the iterator to the first item.
-      explicit GraphItemIt(const GR&) {}
-
-      /// \brief Constructor for conversion from \c INVALID.
-      ///
-      /// Constructor for conversion from \c INVALID.
-      /// It initializes the iterator to be invalid.
+      ///
+      GraphItemIt(const GraphItemIt& ) {}
+      /// \brief Sets the iterator to the first item.
+      ///
+      /// Sets the iterator to the first item of \c the graph.
+      ///
+      explicit GraphItemIt(const _Graph&) {}
+      /// \brief Invalid constructor \& conversion.
+      ///
+      /// This constructor initializes the item to be invalid.
       /// \sa Invalid for more details.
       GraphItemIt(Invalid) {}
-
-      /// \brief Assignment operator.
-      ///
-      /// Assignment operator for the iterator.
+      /// \brief Assign operator for items.
+      ///
+      /// The items are assignable.
+      ///
       GraphItemIt& operator=(const GraphItemIt&) { return *this; }
-
-      /// \brief Increment the iterator.
-      ///
-      /// This operator increments the iterator, i.e. assigns it to the
-      /// next item.
+      /// \brief Next item.
+      ///
+      /// Assign the iterator to the next item.
+      ///
       GraphItemIt& operator++() { return *this; }
-
       /// \brief Equality operator
       ///
-      /// Equality operator.
       /// Two iterators are equal if and only if they point to the
       /// same object or both are invalid.
       bool operator==(const GraphItemIt&) const { return true;}
-
       /// \brief Inequality operator
       ///
-      /// Inequality operator.
-      /// Two iterators are equal if and only if they point to the
-      /// same object or both are invalid.
+      /// \sa operator==(Node n)
+      ///
       bool operator!=(const GraphItemIt&) const { return true;}
 
@@ -485,9 +473,6 @@
       struct Constraints {
         void constraints() {
-          checkConcept<GraphItem<>, _GraphItemIt>();
           _GraphItemIt it1(g);
           _GraphItemIt it2;
-          _GraphItemIt it3 = it1;
-          _GraphItemIt it4 = INVALID;
 
           it2 = ++it1;
@@ -495,68 +480,58 @@
           ++(++it1);
 
-          Item bi = it1;
+          _Item bi = it1;
           bi = it2;
         }
-        const GR& g;
-      };
-    };
-
-    /// \brief Concept class for \c InArcIt, \c OutArcIt and
-    /// \c IncEdgeIt types.
-    ///
-    /// 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 'i', for \c OutArcIt with \c 'o' and for \c IncEdgeIt with \c 'e'.
-    template <typename GR,
-              typename Item = typename GR::Arc,
-              typename Base = typename GR::Node,
-              char sel = '0'>
-    class GraphIncIt : public Item {
+        _Graph& g;
+      };
+    };
+
+    /// \brief Skeleton class for graph InArcIt and OutArcIt
+    ///
+    /// \note Because InArcIt and OutArcIt may not inherit from the same
+    /// base class, the _selector is a additional template parameter. For
+    /// InArcIt you should instantiate it with character 'i' and for
+    /// OutArcIt with 'o'.
+    template <typename _Graph,
+              typename _Item = typename _Graph::Arc,
+              typename _Base = typename _Graph::Node,
+              char _selector = '0'>
+    class GraphIncIt : public _Item {
     public:
       /// \brief Default constructor.
       ///
-      /// Default constructor.
-      /// \warning The default constructor is not required to set
-      /// the iterator to some well-defined value. So you should consider it
-      /// as uninitialized.
+      /// @warning The default constructor sets the iterator
+      /// to an undefined value.
       GraphIncIt() {}
-
       /// \brief Copy constructor.
       ///
       /// Copy constructor.
-      GraphIncIt(const GraphIncIt& it) : Item(it) {}
-
-      /// \brief Constructor that sets the iterator to the first
-      /// incoming or outgoing arc.
-      ///
-      /// Constructor that sets the iterator to the first arc
-      /// incoming to or outgoing from the given node.
-      explicit GraphIncIt(const GR&, const Base&) {}
-
-      /// \brief Constructor for conversion from \c INVALID.
-      ///
-      /// Constructor for conversion from \c INVALID.
-      /// It initializes the iterator to be invalid.
+      ///
+      GraphIncIt(GraphIncIt const& gi) : _Item(gi) {}
+      /// \brief Sets the iterator to the first arc incoming into or outgoing
+      /// from the node.
+      ///
+      /// Sets the iterator to the first arc incoming into or outgoing
+      /// from the node.
+      ///
+      explicit GraphIncIt(const _Graph&, const _Base&) {}
+      /// \brief Invalid constructor \& conversion.
+      ///
+      /// This constructor initializes the item to be invalid.
       /// \sa Invalid for more details.
       GraphIncIt(Invalid) {}
-
-      /// \brief Assignment operator.
-      ///
-      /// Assignment operator for the iterator.
-      GraphIncIt& operator=(const GraphIncIt&) { return *this; }
-
-      /// \brief Increment the iterator.
-      ///
-      /// This operator increments the iterator, i.e. assigns it to the
-      /// next arc incoming to or outgoing from the given node.
+      /// \brief Assign operator for iterators.
+      ///
+      /// The iterators are assignable.
+      ///
+      GraphIncIt& operator=(GraphIncIt const&) { return *this; }
+      /// \brief Next item.
+      ///
+      /// Assign the iterator to the next item.
+      ///
       GraphIncIt& operator++() { return *this; }
 
       /// \brief Equality operator
       ///
-      /// Equality operator.
       /// Two iterators are equal if and only if they point to the
       /// same object or both are invalid.
@@ -565,7 +540,6 @@
       /// \brief Inequality operator
       ///
-      /// Inequality operator.
-      /// Two iterators are equal if and only if they point to the
-      /// same object or both are invalid.
+      /// \sa operator==(Node n)
+      ///
       bool operator!=(const GraphIncIt&) const { return true;}
 
@@ -573,33 +547,35 @@
       struct Constraints {
         void constraints() {
-          checkConcept<GraphItem<sel>, _GraphIncIt>();
+          checkConcept<GraphItem<_selector>, _GraphIncIt>();
           _GraphIncIt it1(graph, node);
           _GraphIncIt it2;
-          _GraphIncIt it3 = it1;
-          _GraphIncIt it4 = INVALID;
 
           it2 = ++it1;
           ++it2 = it1;
           ++(++it1);
-          Item e = it1;
+          _Item e = it1;
           e = it2;
-        }
-        const Base& node;
-        const GR& graph;
-      };
-    };
-
-    /// \brief Skeleton class for iterable directed graphs.
-    ///
-    /// This class describes the interface of iterable directed
-    /// graphs. It extends \ref BaseDigraphComponent with the core
-    /// iterable interface.
+
+        }
+
+        _Item arc;
+        _Base node;
+        _Graph graph;
+        _GraphIncIt it;
+      };
+    };
+
+
+    /// \brief An empty iterable digraph class.
+    ///
+    /// This class provides beside the core digraph features
+    /// iterator based iterable interface for the digraph structure.
     /// This concept is part of the Digraph concept.
-    template <typename BAS = BaseDigraphComponent>
-    class IterableDigraphComponent : public BAS {
-
-    public:
-
-      typedef BAS Base;
+    template <typename _Base = BaseDigraphComponent>
+    class IterableDigraphComponent : public _Base {
+
+    public:
+
+      typedef _Base Base;
       typedef typename Base::Node Node;
       typedef typename Base::Arc Arc;
@@ -607,59 +583,68 @@
       typedef IterableDigraphComponent Digraph;
 
-      /// \name Base Iteration
-      ///
-      /// This interface provides functions for iteration on digraph items.
+      /// \name Base iteration
+      ///
+      /// This interface provides functions for iteration on digraph items
       ///
       /// @{
 
-      /// \brief Return the first node.
-      ///
-      /// This function gives back the first node in the iteration order.
+      /// \brief Gives back the first node in the iterating order.
+      ///
+      /// Gives back the first node in the iterating order.
+      ///
       void first(Node&) const {}
 
-      /// \brief Return the next node.
-      ///
-      /// This function gives back the next node in the iteration order.
+      /// \brief Gives back the next node in the iterating order.
+      ///
+      /// Gives back the next node in the iterating order.
+      ///
       void next(Node&) const {}
 
-      /// \brief Return the first arc.
-      ///
-      /// This function gives back the first arc in the iteration order.
+      /// \brief Gives back the first arc in the iterating order.
+      ///
+      /// Gives back the first arc in the iterating order.
+      ///
       void first(Arc&) const {}
 
-      /// \brief Return the next arc.
-      ///
-      /// This function gives back the next arc in the iteration order.
+      /// \brief Gives back the next arc in the iterating order.
+      ///
+      /// Gives back the next arc in the iterating order.
+      ///
       void next(Arc&) const {}
 
-      /// \brief Return the first arc incomming to the given node.
-      ///
-      /// This function gives back the first arc incomming to the
+
+      /// \brief Gives back the first of the arcs point to the given
+      /// node.
+      ///
+      /// Gives back the first of the arcs point to the given node.
+      ///
+      void firstIn(Arc&, const Node&) const {}
+
+      /// \brief Gives back the next of the arcs points to the given
+      /// node.
+      ///
+      /// Gives back the next of the arcs points to the given node.
+      ///
+      void nextIn(Arc&) const {}
+
+      /// \brief Gives back the first of the arcs start from the
       /// given node.
-      void firstIn(Arc&, const Node&) const {}
-
-      /// \brief Return the next arc incomming to the given node.
-      ///
-      /// This function gives back the next arc incomming to the
-      /// given node.
-      void nextIn(Arc&) const {}
-
-      /// \brief Return the first arc outgoing form the given node.
-      ///
-      /// This function gives back the first arc outgoing form the
-      /// given node.
+      ///
+      /// Gives back the first of the arcs start from the given node.
+      ///
       void firstOut(Arc&, const Node&) const {}
 
-      /// \brief Return the next arc outgoing form the given node.
-      ///
-      /// This function gives back the next arc outgoing form the
-      /// given node.
+      /// \brief Gives back the next of the arcs start from the given
+      /// node.
+      ///
+      /// Gives back the next of the arcs start from the given node.
+      ///
       void nextOut(Arc&) const {}
 
       /// @}
 
-      /// \name Class Based Iteration
-      ///
-      /// This interface provides iterator classes for digraph items.
+      /// \name Class based iteration
+      ///
+      /// This interface provides functions for iteration on digraph items
       ///
       /// @{
@@ -671,7 +656,7 @@
       typedef GraphItemIt<Digraph, Node> NodeIt;
 
-      /// \brief This iterator goes through each arc.
-      ///
-      /// This iterator goes through each arc.
+      /// \brief This iterator goes through each node.
+      ///
+      /// This iterator goes through each node.
       ///
       typedef GraphItemIt<Digraph, Arc> ArcIt;
@@ -679,5 +664,5 @@
       /// \brief This iterator goes trough the incoming arcs of a node.
       ///
-      /// This iterator goes trough the \e incoming arcs of a certain node
+      /// This iterator goes trough the \e inccoming arcs of a certain node
       /// of a digraph.
       typedef GraphIncIt<Digraph, Arc, Node, 'i'> InArcIt;
@@ -691,24 +676,24 @@
       /// \brief The base node of the iterator.
       ///
-      /// This function gives back the base node of the iterator.
-      /// It is always the target node of the pointed arc.
+      /// 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.
       ///
-      /// This function gives back the running node of the iterator.
-      /// It is always the source node of the pointed arc.
+      /// 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.
       ///
-      /// This function gives back the base node of the iterator.
-      /// It is always the source node of the pointed arc.
+      /// 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.
       ///
-      /// This function gives back the running node of the iterator.
-      /// It is always the target node of the pointed arc.
+      /// Gives back the running node of the iterator.
+      /// It is always the target of the pointed arc.
       Node runningNode(const OutArcIt&) const { return INVALID; }
 
@@ -752,10 +737,10 @@
 
             typename _Digraph::Node n;
-            const typename _Digraph::InArcIt iait(INVALID);
-            const typename _Digraph::OutArcIt oait(INVALID);
-            n = digraph.baseNode(iait);
-            n = digraph.runningNode(iait);
-            n = digraph.baseNode(oait);
-            n = digraph.runningNode(oait);
+            typename _Digraph::InArcIt ieit(INVALID);
+            typename _Digraph::OutArcIt oeit(INVALID);
+            n = digraph.baseNode(ieit);
+            n = digraph.runningNode(ieit);
+            n = digraph.baseNode(oeit);
+            n = digraph.runningNode(oeit);
             ignore_unused_variable_warning(n);
           }
@@ -763,18 +748,18 @@
 
         const _Digraph& digraph;
-      };
-    };
-
-    /// \brief Skeleton class for iterable undirected graphs.
-    ///
-    /// This class describes the interface of iterable undirected
-    /// graphs. It extends \ref IterableDigraphComponent with the core
-    /// iterable interface of undirected graphs.
+
+      };
+    };
+
+    /// \brief An empty iterable undirected graph class.
+    ///
+    /// This class provides beside the core graph features iterator
+    /// based iterable interface for the undirected graph structure.
     /// This concept is part of the Graph concept.
-    template <typename BAS = BaseGraphComponent>
-    class IterableGraphComponent : public IterableDigraphComponent<BAS> {
-    public:
-
-      typedef BAS Base;
+    template <typename _Base = BaseGraphComponent>
+    class IterableGraphComponent : public IterableDigraphComponent<_Base> {
+    public:
+
+      typedef _Base Base;
       typedef typename Base::Node Node;
       typedef typename Base::Arc Arc;
@@ -784,29 +769,34 @@
       typedef IterableGraphComponent Graph;
 
-      /// \name Base Iteration
-      ///
-      /// This interface provides functions for iteration on edges.
-      ///
+      /// \name Base iteration
+      ///
+      /// This interface provides functions for iteration on graph items
       /// @{
 
-      using IterableDigraphComponent<Base>::first;
-      using IterableDigraphComponent<Base>::next;
-
-      /// \brief Return the first edge.
-      ///
-      /// This function gives back the first edge in the iteration order.
+      using IterableDigraphComponent<_Base>::first;
+      using IterableDigraphComponent<_Base>::next;
+
+      /// \brief Gives back the first edge in the iterating
+      /// order.
+      ///
+      /// Gives back the first edge in the iterating order.
+      ///
       void first(Edge&) const {}
 
-      /// \brief Return the next edge.
-      ///
-      /// This function gives back the next edge in the iteration order.
+      /// \brief Gives back the next edge in the iterating
+      /// order.
+      ///
+      /// Gives back the next edge in the iterating order.
+      ///
       void next(Edge&) const {}
 
-      /// \brief Return the first edge incident to the given node.
-      ///
-      /// 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
+
+      /// \brief Gives back the first of the edges from the
       /// given node.
+      ///
+      /// Gives back the first of the edges from the given
+      /// node. The bool parameter gives back that direction which
+      /// gives a good direction of the edge so the source of the
+      /// directed arc is the given node.
       void firstInc(Edge&, bool&, const Node&) const {}
 
@@ -814,39 +804,38 @@
       /// given node.
       ///
-      /// This function gives back the next edge incident to the given
-      /// node. The bool parameter should be used as \c firstInc() use it.
+      /// Gives back the next of the edges from the given
+      /// node. The bool parameter should be used as the \c firstInc()
+      /// use it.
       void nextInc(Edge&, bool&) const {}
 
-      using IterableDigraphComponent<Base>::baseNode;
-      using IterableDigraphComponent<Base>::runningNode;
+      using IterableDigraphComponent<_Base>::baseNode;
+      using IterableDigraphComponent<_Base>::runningNode;
 
       /// @}
 
-      /// \name Class Based Iteration
-      ///
-      /// This interface provides iterator classes for edges.
+      /// \name Class based iteration
+      ///
+      /// This interface provides functions for iteration on graph items
       ///
       /// @{
 
-      /// \brief This iterator goes through each edge.
-      ///
-      /// This iterator goes through each edge.
+      /// \brief This iterator goes through each node.
+      ///
+      /// This iterator goes through each node.
       typedef GraphItemIt<Graph, Edge> EdgeIt;
-
-      /// \brief This iterator goes trough the incident edges of a
+      /// \brief This iterator goes trough the incident arcs of a
       /// node.
       ///
-      /// This iterator goes trough the incident edges of a certain
+      /// This iterator goes trough the incident arcs of a certain
       /// node of a graph.
-      typedef GraphIncIt<Graph, Edge, Node, 'e'> IncEdgeIt;
-
+      typedef GraphIncIt<Graph, Edge, Node, 'u'> IncEdgeIt;
       /// \brief The base node of the iterator.
       ///
-      /// This function gives back the base node of the iterator.
+      /// Gives back the base node of the iterator.
       Node baseNode(const IncEdgeIt&) const { return INVALID; }
 
       /// \brief The running node of the iterator.
       ///
-      /// This function gives back the running node of the iterator.
+      /// Gives back the running node of the iterator.
       Node runningNode(const IncEdgeIt&) const { return INVALID; }
 
@@ -877,52 +866,52 @@
               typename _Graph::EdgeIt >();
             checkConcept<GraphIncIt<_Graph, typename _Graph::Edge,
-              typename _Graph::Node, 'e'>, typename _Graph::IncEdgeIt>();
+              typename _Graph::Node, 'u'>, typename _Graph::IncEdgeIt>();
 
             typename _Graph::Node n;
-            const typename _Graph::IncEdgeIt ieit(INVALID);
-            n = graph.baseNode(ieit);
-            n = graph.runningNode(ieit);
+            typename _Graph::IncEdgeIt ueit(INVALID);
+            n = graph.baseNode(ueit);
+            n = graph.runningNode(ueit);
           }
         }
 
         const _Graph& graph;
-      };
-    };
-
-    /// \brief Skeleton class for alterable directed graphs.
-    ///
-    /// This class describes the interface of alterable directed
-    /// graphs. It extends \ref BaseDigraphComponent with the alteration
-    /// notifier interface. It implements
+
+      };
+    };
+
+    /// \brief An empty alteration notifier digraph class.
+    ///
+    /// This class provides beside the core digraph features alteration
+    /// notifier interface for the digraph structure.  This implements
     /// an observer-notifier pattern for each digraph item. More
     /// obsevers can be registered into the notifier and whenever an
-    /// alteration occured in the digraph all the observers will be
+    /// alteration occured in the digraph all the observers will
     /// notified about it.
-    template <typename BAS = BaseDigraphComponent>
-    class AlterableDigraphComponent : public BAS {
-    public:
-
-      typedef BAS Base;
+    template <typename _Base = BaseDigraphComponent>
+    class AlterableDigraphComponent : public _Base {
+    public:
+
+      typedef _Base Base;
       typedef typename Base::Node Node;
       typedef typename Base::Arc Arc;
 
 
-      /// Node alteration notifier class.
+      /// The node observer registry.
       typedef AlterationNotifier<AlterableDigraphComponent, Node>
       NodeNotifier;
-      /// Arc alteration notifier class.
+      /// The arc observer registry.
       typedef AlterationNotifier<AlterableDigraphComponent, Arc>
       ArcNotifier;
 
-      /// \brief Return the node alteration notifier.
-      ///
-      /// This function gives back the node alteration notifier.
+      /// \brief Gives back the node alteration notifier.
+      ///
+      /// Gives back the node alteration notifier.
       NodeNotifier& notifier(Node) const {
-         return NodeNotifier();
+        return NodeNotifier();
       }
 
-      /// \brief Return the arc alteration notifier.
-      ///
-      /// This function gives back the arc alteration notifier.
+      /// \brief Gives back the arc alteration notifier.
+      ///
+      /// Gives back the arc alteration notifier.
       ArcNotifier& notifier(Arc) const {
         return ArcNotifier();
@@ -944,31 +933,32 @@
 
         const _Digraph& digraph;
-      };
-    };
-
-    /// \brief Skeleton class for alterable undirected graphs.
-    ///
-    /// This class describes the interface of alterable undirected
-    /// graphs. It extends \ref AlterableDigraphComponent with the alteration
-    /// notifier interface of undirected graphs. It implements
-    /// an observer-notifier pattern for the edges. More
+
+      };
+
+    };
+
+    /// \brief An empty alteration notifier undirected graph class.
+    ///
+    /// This class provides beside the core graph features alteration
+    /// notifier interface for the graph structure.  This implements
+    /// an observer-notifier pattern for each graph item. More
     /// obsevers can be registered into the notifier and whenever an
-    /// alteration occured in the graph all the observers will be
+    /// alteration occured in the graph all the observers will
     /// notified about it.
-    template <typename BAS = BaseGraphComponent>
-    class AlterableGraphComponent : public AlterableDigraphComponent<BAS> {
-    public:
-
-      typedef BAS Base;
+    template <typename _Base = BaseGraphComponent>
+    class AlterableGraphComponent : public AlterableDigraphComponent<_Base> {
+    public:
+
+      typedef _Base Base;
       typedef typename Base::Edge Edge;
 
 
-      /// Edge alteration notifier class.
+      /// The arc observer registry.
       typedef AlterationNotifier<AlterableGraphComponent, Edge>
       EdgeNotifier;
 
-      /// \brief Return the edge alteration notifier.
-      ///
-      /// This function gives back the edge alteration notifier.
+      /// \brief Gives back the arc alteration notifier.
+      ///
+      /// Gives back the arc alteration notifier.
       EdgeNotifier& notifier(Edge) const {
         return EdgeNotifier();
@@ -978,5 +968,5 @@
       struct Constraints {
         void constraints() {
-          checkConcept<AlterableDigraphComponent<Base>, _Graph>();
+          checkConcept<AlterableGraphComponent<Base>, _Graph>();
           typename _Graph::EdgeNotifier& uen
             = graph.notifier(typename _Graph::Edge());
@@ -985,39 +975,35 @@
 
         const _Graph& graph;
-      };
-    };
-
-    /// \brief Concept class for standard graph maps.
-    ///
-    /// This class describes the concept of standard graph maps, i.e.
-    /// 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.
-    template <typename GR, typename K, typename V>
-    class GraphMap : public ReferenceMap<K, V, V&, const V&> {
-      typedef ReferenceMap<K, V, V&, const V&> Parent;
-
-    public:
-
+
+      };
+
+    };
+
+    /// \brief Class describing the concept of graph maps
+    ///
+    /// This class describes the common interface of the graph maps
+    /// (NodeMap, ArcMap), that is maps that can be used to
+    /// associate data to graph descriptors (nodes or arcs).
+    template <typename _Graph, typename _Item, typename _Value>
+    class GraphMap : public ReadWriteMap<_Item, _Value> {
+    public:
+
+      typedef ReadWriteMap<_Item, _Value> Parent;
+
+      /// The graph type of the map.
+      typedef _Graph Graph;
       /// The key type of the map.
-      typedef K Key;
+      typedef _Item Key;
       /// The value type of the map.
-      typedef V Value;
-      /// The reference type of the map.
-      typedef Value& Reference;
-      /// The const reference type of the map.
-      typedef const Value& ConstReference;
-
-      // The reference map tag.
-      typedef True ReferenceMapTag;
+      typedef _Value Value;
 
       /// \brief Construct a new map.
       ///
       /// Construct a new map for the graph.
-      explicit GraphMap(const GR&) {}
+      explicit GraphMap(const Graph&) {}
       /// \brief Construct a new map with default value.
       ///
-      /// Construct a new map for the graph and initalize the values.
-      GraphMap(const GR&, const Value&) {}
+      /// Construct a new map for the graph and initalise the values.
+      GraphMap(const Graph&, const Value&) {}
 
     private:
@@ -1027,7 +1013,7 @@
       GraphMap(const GraphMap&) : Parent() {}
 
-      /// \brief Assignment operator.
-      ///
-      /// Assignment operator. It does not mofify the underlying graph,
+      /// \brief Assign operator.
+      ///
+      /// Assign operator. It does not mofify the underlying graph,
       /// it just iterates on the current item set and set the  map
       /// with the value returned by the assigned map.
@@ -1042,23 +1028,22 @@
       struct Constraints {
         void constraints() {
-          checkConcept
-            <ReferenceMap<Key, Value, Value&, const Value&>, _Map>();
-          _Map m1(g);
-          _Map m2(g,t);
-
-          // Copy constructor
-          // _Map m3(m);
-
-          // Assignment operator
+          checkConcept<ReadWriteMap<Key, Value>, _Map >();
+          // Construction with a graph parameter
+          _Map a(g);
+          // Constructor with a graph and a default value parameter
+          _Map a2(g,t);
+          // Copy constructor.
+          // _Map b(c);
+
           // ReadMap<Key, Value> cmap;
-          // m3 = cmap;
-
-          ignore_unused_variable_warning(m1);
-          ignore_unused_variable_warning(m2);
-          // ignore_unused_variable_warning(m3);
-        }
-
-        const _Map &m;
-        const GR &g;
+          // b = cmap;
+
+          ignore_unused_variable_warning(a);
+          ignore_unused_variable_warning(a2);
+          // ignore_unused_variable_warning(b);
+        }
+
+        const _Map &c;
+        const Graph &g;
         const typename GraphMap::Value &t;
       };
@@ -1066,15 +1051,14 @@
     };
 
-    /// \brief Skeleton class for mappable directed graphs.
-    ///
-    /// This class describes the interface of mappable directed graphs.
-    /// It extends \ref BaseDigraphComponent with the standard digraph
-    /// map classes, namely \c NodeMap and \c ArcMap.
+    /// \brief An empty mappable digraph class.
+    ///
+    /// This class provides beside the core digraph features
+    /// map interface for the digraph structure.
     /// This concept is part of the Digraph concept.
-    template <typename BAS = BaseDigraphComponent>
-    class MappableDigraphComponent : public BAS  {
-    public:
-
-      typedef BAS Base;
+    template <typename _Base = BaseDigraphComponent>
+    class MappableDigraphComponent : public _Base  {
+    public:
+
+      typedef _Base Base;
       typedef typename Base::Node Node;
       typedef typename Base::Arc Arc;
@@ -1082,13 +1066,13 @@
       typedef MappableDigraphComponent Digraph;
 
-      /// \brief Standard graph map for the nodes.
-      ///
-      /// Standard graph map for the nodes.
-      /// It conforms to the ReferenceMap concept.
-      template <typename V>
-      class NodeMap : public GraphMap<MappableDigraphComponent, Node, V> {
-        typedef GraphMap<MappableDigraphComponent, Node, V> Parent;
-
+      /// \brief ReadWrite map of the nodes.
+      ///
+      /// ReadWrite map of the nodes.
+      ///
+      template <typename _Value>
+      class NodeMap : public GraphMap<Digraph, Node, _Value> {
       public:
+        typedef GraphMap<MappableDigraphComponent, Node, _Value> Parent;
+
         /// \brief Construct a new map.
         ///
@@ -1099,6 +1083,6 @@
         /// \brief Construct a new map with default value.
         ///
-        /// Construct a new map for the digraph and initalize the values.
-        NodeMap(const MappableDigraphComponent& digraph, const V& value)
+        /// Construct a new map for the digraph and initalise the values.
+        NodeMap(const MappableDigraphComponent& digraph, const _Value& value)
           : Parent(digraph, value) {}
 
@@ -1109,10 +1093,10 @@
         NodeMap(const NodeMap& nm) : Parent(nm) {}
 
-        /// \brief Assignment operator.
-        ///
-        /// Assignment operator.
+        /// \brief Assign operator.
+        ///
+        /// Assign operator.
         template <typename CMap>
         NodeMap& operator=(const CMap&) {
-          checkConcept<ReadMap<Node, V>, CMap>();
+          checkConcept<ReadMap<Node, _Value>, CMap>();
           return *this;
         }
@@ -1120,13 +1104,13 @@
       };
 
-      /// \brief Standard graph map for the arcs.
-      ///
-      /// Standard graph map for the arcs.
-      /// It conforms to the ReferenceMap concept.
-      template <typename V>
-      class ArcMap : public GraphMap<MappableDigraphComponent, Arc, V> {
-        typedef GraphMap<MappableDigraphComponent, Arc, V> Parent;
-
+      /// \brief ReadWrite map of the arcs.
+      ///
+      /// ReadWrite map of the arcs.
+      ///
+      template <typename _Value>
+      class ArcMap : public GraphMap<Digraph, Arc, _Value> {
       public:
+        typedef GraphMap<MappableDigraphComponent, Arc, _Value> Parent;
+
         /// \brief Construct a new map.
         ///
@@ -1137,6 +1121,6 @@
         /// \brief Construct a new map with default value.
         ///
-        /// Construct a new map for the digraph and initalize the values.
-        ArcMap(const MappableDigraphComponent& digraph, const V& value)
+        /// Construct a new map for the digraph and initalise the values.
+        ArcMap(const MappableDigraphComponent& digraph, const _Value& value)
           : Parent(digraph, value) {}
 
@@ -1147,10 +1131,10 @@
         ArcMap(const ArcMap& nm) : Parent(nm) {}
 
-        /// \brief Assignment operator.
-        ///
-        /// Assignment operator.
+        /// \brief Assign operator.
+        ///
+        /// Assign operator.
         template <typename CMap>
         ArcMap& operator=(const CMap&) {
-          checkConcept<ReadMap<Arc, V>, CMap>();
+          checkConcept<ReadMap<Arc, _Value>, CMap>();
           return *this;
         }
@@ -1199,32 +1183,31 @@
         }
 
-        const _Digraph& digraph;
-      };
-    };
-
-    /// \brief Skeleton class for mappable undirected graphs.
-    ///
-    /// This class describes the interface of mappable undirected graphs.
-    /// It extends \ref MappableDigraphComponent with the standard graph
-    /// map class for edges (\c EdgeMap).
+        _Digraph& digraph;
+      };
+    };
+
+    /// \brief An empty mappable base bipartite graph class.
+    ///
+    /// This class provides beside the core graph features
+    /// map interface for the graph structure.
     /// This concept is part of the Graph concept.
-    template <typename BAS = BaseGraphComponent>
-    class MappableGraphComponent : public MappableDigraphComponent<BAS>  {
-    public:
-
-      typedef BAS Base;
+    template <typename _Base = BaseGraphComponent>
+    class MappableGraphComponent : public MappableDigraphComponent<_Base>  {
+    public:
+
+      typedef _Base Base;
       typedef typename Base::Edge Edge;
 
       typedef MappableGraphComponent Graph;
 
-      /// \brief Standard graph map for the edges.
-      ///
-      /// Standard graph map for the edges.
-      /// It conforms to the ReferenceMap concept.
-      template <typename V>
-      class EdgeMap : public GraphMap<MappableGraphComponent, Edge, V> {
-        typedef GraphMap<MappableGraphComponent, Edge, V> Parent;
-
+      /// \brief ReadWrite map of the edges.
+      ///
+      /// ReadWrite map of the edges.
+      ///
+      template <typename _Value>
+      class EdgeMap : public GraphMap<Graph, Edge, _Value> {
       public:
+        typedef GraphMap<MappableGraphComponent, Edge, _Value> Parent;
+
         /// \brief Construct a new map.
         ///
@@ -1235,6 +1218,6 @@
         /// \brief Construct a new map with default value.
         ///
-        /// Construct a new map for the graph and initalize the values.
-        EdgeMap(const MappableGraphComponent& graph, const V& value)
+        /// Construct a new map for the graph and initalise the values.
+        EdgeMap(const MappableGraphComponent& graph, const _Value& value)
           : Parent(graph, value) {}
 
@@ -1245,10 +1228,10 @@
         EdgeMap(const EdgeMap& nm) : Parent(nm) {}
 
-        /// \brief Assignment operator.
-        ///
-        /// Assignment operator.
+        /// \brief Assign operator.
+        ///
+        /// Assign operator.
         template <typename CMap>
         EdgeMap& operator=(const CMap&) {
-          checkConcept<ReadMap<Edge, V>, CMap>();
+          checkConcept<ReadMap<Edge, _Value>, CMap>();
           return *this;
         }
@@ -1267,5 +1250,5 @@
 
         void constraints() {
-          checkConcept<MappableDigraphComponent<Base>, _Graph>();
+          checkConcept<MappableGraphComponent<Base>, _Graph>();
 
           { // int map test
@@ -1284,33 +1267,33 @@
         }
 
-        const _Graph& graph;
-      };
-    };
-
-    /// \brief Skeleton class for extendable directed graphs.
-    ///
-    /// This class describes the interface of extendable directed graphs.
-    /// It extends \ref BaseDigraphComponent with functions for adding
-    /// nodes and arcs to the digraph.
-    /// This concept requires \ref AlterableDigraphComponent.
-    template <typename BAS = BaseDigraphComponent>
-    class ExtendableDigraphComponent : public BAS {
-    public:
-      typedef BAS Base;
-
-      typedef typename Base::Node Node;
-      typedef typename Base::Arc Arc;
-
-      /// \brief Add a new node to the digraph.
-      ///
-      /// This function adds a new node to the digraph.
+        _Graph& graph;
+      };
+    };
+
+    /// \brief An empty extendable digraph class.
+    ///
+    /// This class provides beside the core digraph features digraph
+    /// extendable interface for the digraph structure.  The main
+    /// difference between the base and this interface is that the
+    /// digraph alterations should handled already on this level.
+    template <typename _Base = BaseDigraphComponent>
+    class ExtendableDigraphComponent : public _Base {
+    public:
+      typedef _Base Base;
+
+      typedef typename _Base::Node Node;
+      typedef typename _Base::Arc Arc;
+
+      /// \brief Adds a new node to the digraph.
+      ///
+      /// Adds a new node to the digraph.
+      ///
       Node addNode() {
         return INVALID;
       }
 
-      /// \brief Add a new arc connecting the given two nodes.
-      ///
-      /// This function adds a new arc connecting the given two nodes
-      /// of the digraph.
+      /// \brief Adds a new arc connects the given two nodes.
+      ///
+      /// Adds a new arc connects the the given two nodes.
       Arc addArc(const Node&, const Node&) {
         return INVALID;
@@ -1332,30 +1315,31 @@
     };
 
-    /// \brief Skeleton class for extendable undirected graphs.
-    ///
-    /// This class describes the interface of extendable undirected graphs.
-    /// It extends \ref BaseGraphComponent with functions for adding
-    /// nodes and edges to the graph.
-    /// This concept requires \ref AlterableGraphComponent.
-    template <typename BAS = BaseGraphComponent>
-    class ExtendableGraphComponent : public BAS {
-    public:
-
-      typedef BAS Base;
-      typedef typename Base::Node Node;
-      typedef typename Base::Edge Edge;
-
-      /// \brief Add a new node to the digraph.
-      ///
-      /// This function adds a new node to the digraph.
+    /// \brief An empty extendable base undirected graph class.
+    ///
+    /// This class provides beside the core undirected graph features
+    /// core undircted graph extend interface for the graph structure.
+    /// The main difference between the base and this interface is
+    /// that the graph alterations should handled already on this
+    /// level.
+    template <typename _Base = BaseGraphComponent>
+    class ExtendableGraphComponent : public _Base {
+    public:
+
+      typedef _Base Base;
+      typedef typename _Base::Node Node;
+      typedef typename _Base::Edge Edge;
+
+      /// \brief Adds a new node to the graph.
+      ///
+      /// Adds a new node to the graph.
+      ///
       Node addNode() {
         return INVALID;
       }
 
-      /// \brief Add a new edge connecting the given two nodes.
-      ///
-      /// This function adds a new edge connecting the given two nodes
-      /// of the graph.
-      Edge addEdge(const Node&, const Node&) {
+      /// \brief Adds a new arc connects the given two nodes.
+      ///
+      /// Adds a new arc connects the the given two nodes.
+      Edge addArc(const Node&, const Node&) {
         return INVALID;
       }
@@ -1376,15 +1360,15 @@
     };
 
-    /// \brief Skeleton class for erasable directed graphs.
-    ///
-    /// This class describes the interface of erasable directed graphs.
-    /// It extends \ref BaseDigraphComponent with functions for removing
-    /// nodes and arcs from the digraph.
-    /// This concept requires \ref AlterableDigraphComponent.
-    template <typename BAS = BaseDigraphComponent>
-    class ErasableDigraphComponent : public BAS {
-    public:
-
-      typedef BAS Base;
+    /// \brief An empty erasable digraph class.
+    ///
+    /// This class provides beside the core digraph features core erase
+    /// functions for the digraph structure. The main difference between
+    /// the base and this interface is that the digraph alterations
+    /// should handled already on this level.
+    template <typename _Base = BaseDigraphComponent>
+    class ErasableDigraphComponent : public _Base {
+    public:
+
+      typedef _Base Base;
       typedef typename Base::Node Node;
       typedef typename Base::Arc Arc;
@@ -1392,11 +1376,12 @@
       /// \brief Erase a node from the digraph.
       ///
-      /// This function erases the given node from the digraph and all arcs
-      /// connected to the node.
+      /// Erase a node from the digraph. This function should
+      /// erase all arcs connecting to the node.
       void erase(const Node&) {}
 
       /// \brief Erase an arc from the digraph.
       ///
-      /// This function erases the given arc from the digraph.
+      /// Erase an arc from the digraph.
+      ///
       void erase(const Arc&) {}
 
@@ -1405,7 +1390,7 @@
         void constraints() {
           checkConcept<Base, _Digraph>();
-          const typename _Digraph::Node node(INVALID);
+          typename _Digraph::Node node;
           digraph.erase(node);
-          const typename _Digraph::Arc arc(INVALID);
+          typename _Digraph::Arc arc;
           digraph.erase(arc);
         }
@@ -1415,15 +1400,15 @@
     };
 
-    /// \brief Skeleton class for erasable undirected graphs.
-    ///
-    /// This class describes the interface of erasable undirected graphs.
-    /// It extends \ref BaseGraphComponent with functions for removing
-    /// nodes and edges from the graph.
-    /// This concept requires \ref AlterableGraphComponent.
-    template <typename BAS = BaseGraphComponent>
-    class ErasableGraphComponent : public BAS {
-    public:
-
-      typedef BAS Base;
+    /// \brief An empty erasable base undirected graph class.
+    ///
+    /// This class provides beside the core undirected graph features
+    /// core erase functions for the undirceted graph structure. The
+    /// main difference between the base and this interface is that
+    /// the graph alterations should handled already on this level.
+    template <typename _Base = BaseGraphComponent>
+    class ErasableGraphComponent : public _Base {
+    public:
+
+      typedef _Base Base;
       typedef typename Base::Node Node;
       typedef typename Base::Edge Edge;
@@ -1431,11 +1416,12 @@
       /// \brief Erase a node from the graph.
       ///
-      /// This function erases the given node from the graph and all edges
-      /// connected to the node.
+      /// Erase a node from the graph. This function should erase
+      /// arcs connecting to the node.
       void erase(const Node&) {}
 
-      /// \brief Erase an edge from the digraph.
-      ///
-      /// This function erases the given edge from the digraph.
+      /// \brief Erase an arc from the graph.
+      ///
+      /// Erase an arc from the graph.
+      ///
       void erase(const Edge&) {}
 
@@ -1444,7 +1430,7 @@
         void constraints() {
           checkConcept<Base, _Graph>();
-          const typename _Graph::Node node(INVALID);
+          typename _Graph::Node node;
           graph.erase(node);
-          const typename _Graph::Edge edge(INVALID);
+          typename _Graph::Edge edge;
           graph.erase(edge);
         }
@@ -1454,19 +1440,20 @@
     };
 
-    /// \brief Skeleton class for clearable directed graphs.
-    ///
-    /// This class describes the interface of clearable directed graphs.
-    /// It extends \ref BaseDigraphComponent with a function for clearing
-    /// the digraph.
-    /// This concept requires \ref AlterableDigraphComponent.
-    template <typename BAS = BaseDigraphComponent>
-    class ClearableDigraphComponent : public BAS {
-    public:
-
-      typedef BAS Base;
+    /// \brief An empty clearable base digraph class.
+    ///
+    /// This class provides beside the core digraph features core clear
+    /// functions for the digraph structure. The main difference between
+    /// the base and this interface is that the digraph alterations
+    /// should handled already on this level.
+    template <typename _Base = BaseDigraphComponent>
+    class ClearableDigraphComponent : public _Base {
+    public:
+
+      typedef _Base Base;
 
       /// \brief Erase all nodes and arcs from the digraph.
       ///
-      /// This function erases all nodes and arcs from the digraph.
+      /// Erase all nodes and arcs from the digraph.
+      ///
       void clear() {}
 
@@ -1478,33 +1465,27 @@
         }
 
-        _Digraph& digraph;
-      };
-    };
-
-    /// \brief Skeleton class for clearable undirected graphs.
-    ///
-    /// This class describes the interface of clearable undirected graphs.
-    /// It extends \ref BaseGraphComponent with a function for clearing
-    /// the graph.
-    /// This concept requires \ref AlterableGraphComponent.
-    template <typename BAS = BaseGraphComponent>
-    class ClearableGraphComponent : public ClearableDigraphComponent<BAS> {
-    public:
-
-      typedef BAS Base;
-
-      /// \brief Erase all nodes and edges from the graph.
-      ///
-      /// This function erases all nodes and edges from the graph.
-      void clear() {}
+        _Digraph digraph;
+      };
+    };
+
+    /// \brief An empty clearable base undirected graph class.
+    ///
+    /// This class provides beside the core undirected graph features
+    /// core clear functions for the undirected graph structure. The
+    /// main difference between the base and this interface is that
+    /// the graph alterations should handled already on this level.
+    template <typename _Base = BaseGraphComponent>
+    class ClearableGraphComponent : public ClearableDigraphComponent<_Base> {
+    public:
+
+      typedef _Base Base;
 
       template <typename _Graph>
       struct Constraints {
         void constraints() {
-          checkConcept<Base, _Graph>();
-          graph.clear();
-        }
-
-        _Graph& graph;
+          checkConcept<ClearableGraphComponent<Base>, _Graph>();
+        }
+
+        _Graph graph;
       };
     };
Index: lemon/concepts/heap.h
===================================================================
--- lemon/concepts/heap.h	(revision 956)
+++ lemon/concepts/heap.h	(revision 290)
@@ -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).
@@ -17,13 +17,12 @@
  */
 
-#ifndef LEMON_CONCEPTS_HEAP_H
-#define LEMON_CONCEPTS_HEAP_H
-
 ///\ingroup concept
 ///\file
 ///\brief The concept of heaps.
 
+#ifndef LEMON_CONCEPT_HEAP_H
+#define LEMON_CONCEPT_HEAP_H
+
 #include <lemon/core.h>
-#include <lemon/concept_check.h>
 
 namespace lemon {
@@ -36,190 +35,121 @@
     /// \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.
-    ///
-    /// 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
-    /// 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
+    /// Concept class describing the main interface of heaps.
+    template <typename Priority, typename ItemIntMap>
     class Heap {
     public:
 
-      /// Type of the item-int map.
-      typedef IM ItemIntMap;
-      /// Type of the priorities.
-      typedef PR Prio;
       /// Type of the items stored in the heap.
       typedef typename ItemIntMap::Key Item;
 
+      /// Type of the priorities.
+      typedef Priority Prio;
+
       /// \brief Type to represent the states of the items.
       ///
       /// 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.
+      /// "pre heap" or "post heap". The later two are indifferent
+      /// from the point of view of the heap, but may be useful for
+      /// the user.
+      ///
+      /// The \c ItemIntMap must be initialized in such a way, that it
+      /// assigns \c PRE_HEAP (<tt>-1</tt>) to every item.
       enum State {
-        IN_HEAP = 0,    ///< = 0. The "in heap" state constant.
-        PRE_HEAP = -1,  ///< = -1. The "pre-heap" state constant.
-        POST_HEAP = -2  ///< = -2. The "post-heap" state constant.
+        IN_HEAP = 0,
+        PRE_HEAP = -1,
+        POST_HEAP = -2
       };
 
-      /// \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.
+      /// \pre \c i must be in the heap.
+      /// \param i The item.
       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.
+      /// \pre \c i must be stored in the heap with priority at least \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.
-#ifdef DOXYGEN
       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.
+      /// \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.
-#ifdef DOXYGEN
       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 +159,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
 
 
@@ -321,3 +243,3 @@
   } // namespace lemon
 }
-#endif
+#endif // LEMON_CONCEPT_PATH_H
Index: lemon/concepts/maps.h
===================================================================
--- lemon/concepts/maps.h	(revision 765)
+++ lemon/concepts/maps.h	(revision 314)
@@ -3,5 +3,5 @@
  * This file is a part of LEMON, a generic C++ optimization library.
  *
- * Copyright (C) 2003-2009
+ * Copyright (C) 2003-2008
  * Egervary Jeno Kombinatorikus Optimalizalasi Kutatocsoport
  * (Egervary Research Group on Combinatorial Optimization, EGRES).
@@ -17,6 +17,6 @@
  */
 
-#ifndef LEMON_CONCEPTS_MAPS_H
-#define LEMON_CONCEPTS_MAPS_H
+#ifndef LEMON_CONCEPT_MAPS_H
+#define LEMON_CONCEPT_MAPS_H
 
 #include <lemon/core.h>
@@ -183,6 +183,5 @@
       template<typename _ReferenceMap>
       struct Constraints {
-        typename enable_if<typename _ReferenceMap::ReferenceMapTag, void>::type
-        constraints() {
+        void constraints() {
           checkConcept<ReadWriteMap<K, T>, _ReferenceMap >();
           ref = m[key];
@@ -215,3 +214,3 @@
 } //namespace lemon
 
-#endif
+#endif // LEMON_CONCEPT_MAPS_H
Index: lemon/concepts/path.h
===================================================================
--- lemon/concepts/path.h	(revision 832)
+++ lemon/concepts/path.h	(revision 281)
@@ -3,5 +3,5 @@
  * This file is a part of LEMON, a generic C++ optimization library.
  *
- * Copyright (C) 2003-2009
+ * Copyright (C) 2003-2008
  * Egervary Jeno Kombinatorikus Optimalizalasi Kutatocsoport
  * (Egervary Research Group on Combinatorial Optimization, EGRES).
@@ -19,9 +19,9 @@
 ///\ingroup concept
 ///\file
-///\brief The concept of paths
+///\brief Classes for representing paths in digraphs.
 ///
 
-#ifndef LEMON_CONCEPTS_PATH_H
-#define LEMON_CONCEPTS_PATH_H
+#ifndef LEMON_CONCEPT_PATH_H
+#define LEMON_CONCEPT_PATH_H
 
 #include <lemon/core.h>
@@ -39,26 +39,17 @@
     /// 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.
-    template <typename GR>
+    /// \tparam _Digraph 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 _Digraph>
     class Path {
     public:
 
       /// Type of the underlying digraph.
-      typedef GR Digraph;
+      typedef _Digraph Digraph;
       /// Arc type of the underlying digraph.
       typedef typename Digraph::Arc Arc;
@@ -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; }
 
@@ -202,26 +193,33 @@
     ///
     /// 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.
-    template <typename GR>
+
+    /// \tparam _Digraph  The digraph type in which the path is.
+    ///
+    /// The paths can be constructed from any path type by a
+    /// template constructor or a template assignment operator.
+    ///
+    template <typename _Digraph>
     class PathDumper {
     public:
 
       /// Type of the underlying digraph.
-      typedef GR Digraph;
+      typedef _Digraph Digraph;
       /// Arc type of the underlying digraph.
       typedef typename Digraph::Arc Arc;
 
-      /// 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;}
 
@@ -231,12 +229,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:
@@ -245,8 +244,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; }
 
@@ -263,9 +262,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:
@@ -274,8 +272,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; }
 
@@ -308,3 +306,3 @@
 } // namespace lemon
 
-#endif
+#endif // LEMON_CONCEPT_PATH_H
Index: lemon/config.h.cmake
===================================================================
--- lemon/config.h.cmake	(revision 725)
+++ lemon/config.h.cmake	(revision 540)
@@ -1,8 +1,1 @@
-#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 725)
+++ lemon/config.h.in	(revision 540)
@@ -1,14 +1,2 @@
-/* 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
@@ -17,10 +5,4 @@
 #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
+/* Define to 1 if you have long long */
+#undef LEMON_HAVE_LONG_LONG
Index: mon/connectivity.h
===================================================================
--- lemon/connectivity.h	(revision 956)
+++ 	(revision )
@@ -1,1665 +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_CONNECTIVITY_H
-#define LEMON_CONNECTIVITY_H
-
-#include <lemon/dfs.h>
-#include <lemon/bfs.h>
-#include <lemon/core.h>
-#include <lemon/maps.h>
-#include <lemon/adaptors.h>
-
-#include <lemon/concepts/digraph.h>
-#include <lemon/concepts/graph.h>
-#include <lemon/concept_check.h>
-
-#include <stack>
-#include <functional>
-
-/// \ingroup graph_properties
-/// \file
-/// \brief Connectivity algorithms
-///
-/// Connectivity algorithms
-
-namespace lemon {
-
-  /// \ingroup graph_properties
-  ///
-  /// \brief Check whether an undirected graph is connected.
-  ///
-  /// This function checks whether the given undirected graph is connected,
-  /// i.e. there is a path between any two nodes in the graph.
-  ///
-  /// \return \c true if the graph is connected.
-  /// \note By definition, the empty graph is connected.
-  ///
-  /// \see countConnectedComponents(), connectedComponents()
-  /// \see stronglyConnected()
-  template <typename Graph>
-  bool connected(const Graph& graph) {
-    checkConcept<concepts::Graph, Graph>();
-    typedef typename Graph::NodeIt NodeIt;
-    if (NodeIt(graph) == INVALID) return true;
-    Dfs<Graph> dfs(graph);
-    dfs.run(NodeIt(graph));
-    for (NodeIt it(graph); it != INVALID; ++it) {
-      if (!dfs.reached(it)) {
-        return false;
-      }
-    }
-    return true;
-  }
-
-  /// \ingroup graph_properties
-  ///
-  /// \brief Count the number of connected components of an undirected graph
-  ///
-  /// This function counts the number of connected components of the given
-  /// undirected graph.
-  ///
-  /// The connected components are the classes of an equivalence relation
-  /// on the nodes of an undirected graph. Two nodes are in the same class
-  /// if they are connected with a path.
-  ///
-  /// \return The number of connected components.
-  /// \note By definition, the empty graph consists
-  /// of zero connected components.
-  ///
-  /// \see connected(), connectedComponents()
-  template <typename Graph>
-  int countConnectedComponents(const Graph &graph) {
-    checkConcept<concepts::Graph, Graph>();
-    typedef typename Graph::Node Node;
-    typedef typename Graph::Arc Arc;
-
-    typedef NullMap<Node, Arc> PredMap;
-    typedef NullMap<Node, int> DistMap;
-
-    int compNum = 0;
-    typename Bfs<Graph>::
-      template SetPredMap<PredMap>::
-      template SetDistMap<DistMap>::
-      Create bfs(graph);
-
-    PredMap predMap;
-    bfs.predMap(predMap);
-
-    DistMap distMap;
-    bfs.distMap(distMap);
-
-    bfs.init();
-    for(typename Graph::NodeIt n(graph); n != INVALID; ++n) {
-      if (!bfs.reached(n)) {
-        bfs.addSource(n);
-        bfs.start();
-        ++compNum;
-      }
-    }
-    return compNum;
-  }
-
-  /// \ingroup graph_properties
-  ///
-  /// \brief Find the connected components of an undirected graph
-  ///
-  /// This function finds the connected components of the given undirected
-  /// graph.
-  ///
-  /// The connected components are the classes of an equivalence relation
-  /// on the nodes of an undirected graph. Two nodes are in the same class
-  /// if they are connected with a path.
-  ///
-  /// \image html connected_components.png
-  /// \image latex connected_components.eps "Connected components" width=\textwidth
-  ///
-  /// \param graph The undirected graph.
-  /// \retval compMap A writable node map. The values will be set from 0 to
-  /// the number of the connected components minus one. Each value of the map
-  /// will be set exactly once, and the values of a certain component will be
-  /// set continuously.
-  /// \return The number of connected components.
-  /// \note By definition, the empty graph consists
-  /// of zero connected components.
-  ///
-  /// \see connected(), countConnectedComponents()
-  template <class Graph, class NodeMap>
-  int connectedComponents(const Graph &graph, NodeMap &compMap) {
-    checkConcept<concepts::Graph, Graph>();
-    typedef typename Graph::Node Node;
-    typedef typename Graph::Arc Arc;
-    checkConcept<concepts::WriteMap<Node, int>, NodeMap>();
-
-    typedef NullMap<Node, Arc> PredMap;
-    typedef NullMap<Node, int> DistMap;
-
-    int compNum = 0;
-    typename Bfs<Graph>::
-      template SetPredMap<PredMap>::
-      template SetDistMap<DistMap>::
-      Create bfs(graph);
-
-    PredMap predMap;
-    bfs.predMap(predMap);
-
-    DistMap distMap;
-    bfs.distMap(distMap);
-
-    bfs.init();
-    for(typename Graph::NodeIt n(graph); n != INVALID; ++n) {
-      if(!bfs.reached(n)) {
-        bfs.addSource(n);
-        while (!bfs.emptyQueue()) {
-          compMap.set(bfs.nextNode(), compNum);
-          bfs.processNextNode();
-        }
-        ++compNum;
-      }
-    }
-    return compNum;
-  }
-
-  namespace _connectivity_bits {
-
-    template <typename Digraph, typename Iterator >
-    struct LeaveOrderVisitor : public DfsVisitor<Digraph> {
-    public:
-      typedef typename Digraph::Node Node;
-      LeaveOrderVisitor(Iterator it) : _it(it) {}
-
-      void leave(const Node& node) {
-        *(_it++) = node;
-      }
-
-    private:
-      Iterator _it;
-    };
-
-    template <typename Digraph, typename Map>
-    struct FillMapVisitor : public DfsVisitor<Digraph> {
-    public:
-      typedef typename Digraph::Node Node;
-      typedef typename Map::Value Value;
-
-      FillMapVisitor(Map& map, Value& value)
-        : _map(map), _value(value) {}
-
-      void reach(const Node& node) {
-        _map.set(node, _value);
-      }
-    private:
-      Map& _map;
-      Value& _value;
-    };
-
-    template <typename Digraph, typename ArcMap>
-    struct StronglyConnectedCutArcsVisitor : public DfsVisitor<Digraph> {
-    public:
-      typedef typename Digraph::Node Node;
-      typedef typename Digraph::Arc Arc;
-
-      StronglyConnectedCutArcsVisitor(const Digraph& digraph,
-                                      ArcMap& cutMap,
-                                      int& cutNum)
-        : _digraph(digraph), _cutMap(cutMap), _cutNum(cutNum),
-          _compMap(digraph, -1), _num(-1) {
-      }
-
-      void start(const Node&) {
-        ++_num;
-      }
-
-      void reach(const Node& node) {
-        _compMap.set(node, _num);
-      }
-
-      void examine(const Arc& arc) {
-         if (_compMap[_digraph.source(arc)] !=
-             _compMap[_digraph.target(arc)]) {
-           _cutMap.set(arc, true);
-           ++_cutNum;
-         }
-      }
-    private:
-      const Digraph& _digraph;
-      ArcMap& _cutMap;
-      int& _cutNum;
-
-      typename Digraph::template NodeMap<int> _compMap;
-      int _num;
-    };
-
-  }
-
-
-  /// \ingroup graph_properties
-  ///
-  /// \brief Check whether a directed graph is strongly connected.
-  ///
-  /// This function checks whether the given directed graph is strongly
-  /// connected, i.e. any two nodes of the digraph are
-  /// connected with directed paths in both direction.
-  ///
-  /// \return \c true if the digraph is strongly connected.
-  /// \note By definition, the empty digraph is strongly connected.
-  ///
-  /// \see countStronglyConnectedComponents(), stronglyConnectedComponents()
-  /// \see connected()
-  template <typename Digraph>
-  bool stronglyConnected(const Digraph& digraph) {
-    checkConcept<concepts::Digraph, Digraph>();
-
-    typedef typename Digraph::Node Node;
-    typedef typename Digraph::NodeIt NodeIt;
-
-    typename Digraph::Node source = NodeIt(digraph);
-    if (source == INVALID) return true;
-
-    using namespace _connectivity_bits;
-
-    typedef DfsVisitor<Digraph> Visitor;
-    Visitor visitor;
-
-    DfsVisit<Digraph, Visitor> dfs(digraph, visitor);
-    dfs.init();
-    dfs.addSource(source);
-    dfs.start();
-
-    for (NodeIt it(digraph); it != INVALID; ++it) {
-      if (!dfs.reached(it)) {
-        return false;
-      }
-    }
-
-    typedef ReverseDigraph<const Digraph> RDigraph;
-    typedef typename RDigraph::NodeIt RNodeIt;
-    RDigraph rdigraph(digraph);
-
-    typedef DfsVisitor<RDigraph> RVisitor;
-    RVisitor rvisitor;
-
-    DfsVisit<RDigraph, RVisitor> rdfs(rdigraph, rvisitor);
-    rdfs.init();
-    rdfs.addSource(source);
-    rdfs.start();
-
-    for (RNodeIt it(rdigraph); it != INVALID; ++it) {
-      if (!rdfs.reached(it)) {
-        return false;
-      }
-    }
-
-    return true;
-  }
-
-  /// \ingroup graph_properties
-  ///
-  /// \brief Count the number of strongly connected components of a
-  /// directed graph
-  ///
-  /// This function counts the number of strongly connected components of
-  /// the given directed graph.
-  ///
-  /// The strongly connected components are the classes of an
-  /// equivalence relation on the nodes of a digraph. Two nodes are in
-  /// the same class if they are connected with directed paths in both
-  /// direction.
-  ///
-  /// \return The number of strongly connected components.
-  /// \note By definition, the empty digraph has zero
-  /// strongly connected components.
-  ///
-  /// \see stronglyConnected(), stronglyConnectedComponents()
-  template <typename Digraph>
-  int countStronglyConnectedComponents(const Digraph& digraph) {
-    checkConcept<concepts::Digraph, Digraph>();
-
-    using namespace _connectivity_bits;
-
-    typedef typename Digraph::Node Node;
-    typedef typename Digraph::Arc Arc;
-    typedef typename Digraph::NodeIt NodeIt;
-    typedef typename Digraph::ArcIt ArcIt;
-
-    typedef std::vector<Node> Container;
-    typedef typename Container::iterator Iterator;
-
-    Container nodes(countNodes(digraph));
-    typedef LeaveOrderVisitor<Digraph, Iterator> Visitor;
-    Visitor visitor(nodes.begin());
-
-    DfsVisit<Digraph, Visitor> dfs(digraph, visitor);
-    dfs.init();
-    for (NodeIt it(digraph); it != INVALID; ++it) {
-      if (!dfs.reached(it)) {
-        dfs.addSource(it);
-        dfs.start();
-      }
-    }
-
-    typedef typename Container::reverse_iterator RIterator;
-    typedef ReverseDigraph<const Digraph> RDigraph;
-
-    RDigraph rdigraph(digraph);
-
-    typedef DfsVisitor<Digraph> RVisitor;
-    RVisitor rvisitor;
-
-    DfsVisit<RDigraph, RVisitor> rdfs(rdigraph, rvisitor);
-
-    int compNum = 0;
-
-    rdfs.init();
-    for (RIterator it = nodes.rbegin(); it != nodes.rend(); ++it) {
-      if (!rdfs.reached(*it)) {
-        rdfs.addSource(*it);
-        rdfs.start();
-        ++compNum;
-      }
-    }
-    return compNum;
-  }
-
-  /// \ingroup graph_properties
-  ///
-  /// \brief Find the strongly connected components of a directed graph
-  ///
-  /// This function finds the strongly connected components of the given
-  /// directed graph. In addition, the numbering of the components will
-  /// satisfy that there is no arc going from a higher numbered component
-  /// to a lower one (i.e. it provides a topological order of the components).
-  ///
-  /// The strongly connected components are the classes of an
-  /// equivalence relation on the nodes of a digraph. Two nodes are in
-  /// the same class if they are connected with directed paths in both
-  /// direction.
-  ///
-  /// \image html strongly_connected_components.png
-  /// \image latex strongly_connected_components.eps "Strongly connected components" width=\textwidth
-  ///
-  /// \param digraph The digraph.
-  /// \retval compMap A writable node map. The values will be set from 0 to
-  /// the number of the strongly connected components minus one. Each value
-  /// of the map will be set exactly once, and the values of a certain
-  /// component will be set continuously.
-  /// \return The number of strongly connected components.
-  /// \note By definition, the empty digraph has zero
-  /// strongly connected components.
-  ///
-  /// \see stronglyConnected(), countStronglyConnectedComponents()
-  template <typename Digraph, typename NodeMap>
-  int stronglyConnectedComponents(const Digraph& digraph, NodeMap& compMap) {
-    checkConcept<concepts::Digraph, Digraph>();
-    typedef typename Digraph::Node Node;
-    typedef typename Digraph::NodeIt NodeIt;
-    checkConcept<concepts::WriteMap<Node, int>, NodeMap>();
-
-    using namespace _connectivity_bits;
-
-    typedef std::vector<Node> Container;
-    typedef typename Container::iterator Iterator;
-
-    Container nodes(countNodes(digraph));
-    typedef LeaveOrderVisitor<Digraph, Iterator> Visitor;
-    Visitor visitor(nodes.begin());
-
-    DfsVisit<Digraph, Visitor> dfs(digraph, visitor);
-    dfs.init();
-    for (NodeIt it(digraph); it != INVALID; ++it) {
-      if (!dfs.reached(it)) {
-        dfs.addSource(it);
-        dfs.start();
-      }
-    }
-
-    typedef typename Container::reverse_iterator RIterator;
-    typedef ReverseDigraph<const Digraph> RDigraph;
-
-    RDigraph rdigraph(digraph);
-
-    int compNum = 0;
-
-    typedef FillMapVisitor<RDigraph, NodeMap> RVisitor;
-    RVisitor rvisitor(compMap, compNum);
-
-    DfsVisit<RDigraph, RVisitor> rdfs(rdigraph, rvisitor);
-
-    rdfs.init();
-    for (RIterator it = nodes.rbegin(); it != nodes.rend(); ++it) {
-      if (!rdfs.reached(*it)) {
-        rdfs.addSource(*it);
-        rdfs.start();
-        ++compNum;
-      }
-    }
-    return compNum;
-  }
-
-  /// \ingroup graph_properties
-  ///
-  /// \brief Find the cut arcs of the strongly connected components.
-  ///
-  /// This function finds the cut arcs of the strongly connected components
-  /// of the given digraph.
-  ///
-  /// The strongly connected components are the classes of an
-  /// equivalence relation on the nodes of a digraph. Two nodes are in
-  /// the same class if they are connected with directed paths in both
-  /// direction.
-  /// The strongly connected components are separated by the cut arcs.
-  ///
-  /// \param digraph The digraph.
-  /// \retval cutMap A writable arc map. The values will be set to \c true
-  /// for the cut arcs (exactly once for each cut arc), and will not be
-  /// changed for other arcs.
-  /// \return The number of cut arcs.
-  ///
-  /// \see stronglyConnected(), stronglyConnectedComponents()
-  template <typename Digraph, typename ArcMap>
-  int stronglyConnectedCutArcs(const Digraph& digraph, ArcMap& cutMap) {
-    checkConcept<concepts::Digraph, Digraph>();
-    typedef typename Digraph::Node Node;
-    typedef typename Digraph::Arc Arc;
-    typedef typename Digraph::NodeIt NodeIt;
-    checkConcept<concepts::WriteMap<Arc, bool>, ArcMap>();
-
-    using namespace _connectivity_bits;
-
-    typedef std::vector<Node> Container;
-    typedef typename Container::iterator Iterator;
-
-    Container nodes(countNodes(digraph));
-    typedef LeaveOrderVisitor<Digraph, Iterator> Visitor;
-    Visitor visitor(nodes.begin());
-
-    DfsVisit<Digraph, Visitor> dfs(digraph, visitor);
-    dfs.init();
-    for (NodeIt it(digraph); it != INVALID; ++it) {
-      if (!dfs.reached(it)) {
-        dfs.addSource(it);
-        dfs.start();
-      }
-    }
-
-    typedef typename Container::reverse_iterator RIterator;
-    typedef ReverseDigraph<const Digraph> RDigraph;
-
-    RDigraph rdigraph(digraph);
-
-    int cutNum = 0;
-
-    typedef StronglyConnectedCutArcsVisitor<RDigraph, ArcMap> RVisitor;
-    RVisitor rvisitor(rdigraph, cutMap, cutNum);
-
-    DfsVisit<RDigraph, RVisitor> rdfs(rdigraph, rvisitor);
-
-    rdfs.init();
-    for (RIterator it = nodes.rbegin(); it != nodes.rend(); ++it) {
-      if (!rdfs.reached(*it)) {
-        rdfs.addSource(*it);
-        rdfs.start();
-      }
-    }
-    return cutNum;
-  }
-
-  namespace _connectivity_bits {
-
-    template <typename Digraph>
-    class CountBiNodeConnectedComponentsVisitor : public DfsVisitor<Digraph> {
-    public:
-      typedef typename Digraph::Node Node;
-      typedef typename Digraph::Arc Arc;
-      typedef typename Digraph::Edge Edge;
-
-      CountBiNodeConnectedComponentsVisitor(const Digraph& graph, int &compNum)
-        : _graph(graph), _compNum(compNum),
-          _numMap(graph), _retMap(graph), _predMap(graph), _num(0) {}
-
-      void start(const Node& node) {
-        _predMap.set(node, INVALID);
-      }
-
-      void reach(const Node& node) {
-        _numMap.set(node, _num);
-        _retMap.set(node, _num);
-        ++_num;
-      }
-
-      void discover(const Arc& edge) {
-        _predMap.set(_graph.target(edge), _graph.source(edge));
-      }
-
-      void examine(const Arc& edge) {
-        if (_graph.source(edge) == _graph.target(edge) &&
-            _graph.direction(edge)) {
-          ++_compNum;
-          return;
-        }
-        if (_predMap[_graph.source(edge)] == _graph.target(edge)) {
-          return;
-        }
-        if (_retMap[_graph.source(edge)] > _numMap[_graph.target(edge)]) {
-          _retMap.set(_graph.source(edge), _numMap[_graph.target(edge)]);
-        }
-      }
-
-      void backtrack(const Arc& edge) {
-        if (_retMap[_graph.source(edge)] > _retMap[_graph.target(edge)]) {
-          _retMap.set(_graph.source(edge), _retMap[_graph.target(edge)]);
-        }
-        if (_numMap[_graph.source(edge)] <= _retMap[_graph.target(edge)]) {
-          ++_compNum;
-        }
-      }
-
-    private:
-      const Digraph& _graph;
-      int& _compNum;
-
-      typename Digraph::template NodeMap<int> _numMap;
-      typename Digraph::template NodeMap<int> _retMap;
-      typename Digraph::template NodeMap<Node> _predMap;
-      int _num;
-    };
-
-    template <typename Digraph, typename ArcMap>
-    class BiNodeConnectedComponentsVisitor : public DfsVisitor<Digraph> {
-    public:
-      typedef typename Digraph::Node Node;
-      typedef typename Digraph::Arc Arc;
-      typedef typename Digraph::Edge Edge;
-
-      BiNodeConnectedComponentsVisitor(const Digraph& graph,
-                                       ArcMap& compMap, int &compNum)
-        : _graph(graph), _compMap(compMap), _compNum(compNum),
-          _numMap(graph), _retMap(graph), _predMap(graph), _num(0) {}
-
-      void start(const Node& node) {
-        _predMap.set(node, INVALID);
-      }
-
-      void reach(const Node& node) {
-        _numMap.set(node, _num);
-        _retMap.set(node, _num);
-        ++_num;
-      }
-
-      void discover(const Arc& edge) {
-        Node target = _graph.target(edge);
-        _predMap.set(target, edge);
-        _edgeStack.push(edge);
-      }
-
-      void examine(const Arc& edge) {
-        Node source = _graph.source(edge);
-        Node target = _graph.target(edge);
-        if (source == target && _graph.direction(edge)) {
-          _compMap.set(edge, _compNum);
-          ++_compNum;
-          return;
-        }
-        if (_numMap[target] < _numMap[source]) {
-          if (_predMap[source] != _graph.oppositeArc(edge)) {
-            _edgeStack.push(edge);
-          }
-        }
-        if (_predMap[source] != INVALID &&
-            target == _graph.source(_predMap[source])) {
-          return;
-        }
-        if (_retMap[source] > _numMap[target]) {
-          _retMap.set(source, _numMap[target]);
-        }
-      }
-
-      void backtrack(const Arc& edge) {
-        Node source = _graph.source(edge);
-        Node target = _graph.target(edge);
-        if (_retMap[source] > _retMap[target]) {
-          _retMap.set(source, _retMap[target]);
-        }
-        if (_numMap[source] <= _retMap[target]) {
-          while (_edgeStack.top() != edge) {
-            _compMap.set(_edgeStack.top(), _compNum);
-            _edgeStack.pop();
-          }
-          _compMap.set(edge, _compNum);
-          _edgeStack.pop();
-          ++_compNum;
-        }
-      }
-
-    private:
-      const Digraph& _graph;
-      ArcMap& _compMap;
-      int& _compNum;
-
-      typename Digraph::template NodeMap<int> _numMap;
-      typename Digraph::template NodeMap<int> _retMap;
-      typename Digraph::template NodeMap<Arc> _predMap;
-      std::stack<Edge> _edgeStack;
-      int _num;
-    };
-
-
-    template <typename Digraph, typename NodeMap>
-    class BiNodeConnectedCutNodesVisitor : public DfsVisitor<Digraph> {
-    public:
-      typedef typename Digraph::Node Node;
-      typedef typename Digraph::Arc Arc;
-      typedef typename Digraph::Edge Edge;
-
-      BiNodeConnectedCutNodesVisitor(const Digraph& graph, NodeMap& cutMap,
-                                     int& cutNum)
-        : _graph(graph), _cutMap(cutMap), _cutNum(cutNum),
-          _numMap(graph), _retMap(graph), _predMap(graph), _num(0) {}
-
-      void start(const Node& node) {
-        _predMap.set(node, INVALID);
-        rootCut = false;
-      }
-
-      void reach(const Node& node) {
-        _numMap.set(node, _num);
-        _retMap.set(node, _num);
-        ++_num;
-      }
-
-      void discover(const Arc& edge) {
-        _predMap.set(_graph.target(edge), _graph.source(edge));
-      }
-
-      void examine(const Arc& edge) {
-        if (_graph.source(edge) == _graph.target(edge) &&
-            _graph.direction(edge)) {
-          if (!_cutMap[_graph.source(edge)]) {
-            _cutMap.set(_graph.source(edge), true);
-            ++_cutNum;
-          }
-          return;
-        }
-        if (_predMap[_graph.source(edge)] == _graph.target(edge)) return;
-        if (_retMap[_graph.source(edge)] > _numMap[_graph.target(edge)]) {
-          _retMap.set(_graph.source(edge), _numMap[_graph.target(edge)]);
-        }
-      }
-
-      void backtrack(const Arc& edge) {
-        if (_retMap[_graph.source(edge)] > _retMap[_graph.target(edge)]) {
-          _retMap.set(_graph.source(edge), _retMap[_graph.target(edge)]);
-        }
-        if (_numMap[_graph.source(edge)] <= _retMap[_graph.target(edge)]) {
-          if (_predMap[_graph.source(edge)] != INVALID) {
-            if (!_cutMap[_graph.source(edge)]) {
-              _cutMap.set(_graph.source(edge), true);
-              ++_cutNum;
-            }
-          } else if (rootCut) {
-            if (!_cutMap[_graph.source(edge)]) {
-              _cutMap.set(_graph.source(edge), true);
-              ++_cutNum;
-            }
-          } else {
-            rootCut = true;
-          }
-        }
-      }
-
-    private:
-      const Digraph& _graph;
-      NodeMap& _cutMap;
-      int& _cutNum;
-
-      typename Digraph::template NodeMap<int> _numMap;
-      typename Digraph::template NodeMap<int> _retMap;
-      typename Digraph::template NodeMap<Node> _predMap;
-      std::stack<Edge> _edgeStack;
-      int _num;
-      bool rootCut;
-    };
-
-  }
-
-  template <typename Graph>
-  int countBiNodeConnectedComponents(const Graph& graph);
-
-  /// \ingroup graph_properties
-  ///
-  /// \brief Check whether an undirected graph is bi-node-connected.
-  ///
-  /// This function checks whether the given undirected graph is
-  /// bi-node-connected, i.e. any two edges are on same circle.
-  ///
-  /// \return \c true if the graph bi-node-connected.
-  /// \note By definition, the empty graph is bi-node-connected.
-  ///
-  /// \see countBiNodeConnectedComponents(), biNodeConnectedComponents()
-  template <typename Graph>
-  bool biNodeConnected(const Graph& graph) {
-    return countBiNodeConnectedComponents(graph) <= 1;
-  }
-
-  /// \ingroup graph_properties
-  ///
-  /// \brief Count the number of bi-node-connected components of an
-  /// undirected graph.
-  ///
-  /// This function counts the number of bi-node-connected components of
-  /// the given undirected graph.
-  ///
-  /// The bi-node-connected components are the classes of an equivalence
-  /// relation on the edges of a undirected graph. Two edges are in the
-  /// same class if they are on same circle.
-  ///
-  /// \return The number of bi-node-connected components.
-  ///
-  /// \see biNodeConnected(), biNodeConnectedComponents()
-  template <typename Graph>
-  int countBiNodeConnectedComponents(const Graph& graph) {
-    checkConcept<concepts::Graph, Graph>();
-    typedef typename Graph::NodeIt NodeIt;
-
-    using namespace _connectivity_bits;
-
-    typedef CountBiNodeConnectedComponentsVisitor<Graph> Visitor;
-
-    int compNum = 0;
-    Visitor visitor(graph, compNum);
-
-    DfsVisit<Graph, Visitor> dfs(graph, visitor);
-    dfs.init();
-
-    for (NodeIt it(graph); it != INVALID; ++it) {
-      if (!dfs.reached(it)) {
-        dfs.addSource(it);
-        dfs.start();
-      }
-    }
-    return compNum;
-  }
-
-  /// \ingroup graph_properties
-  ///
-  /// \brief Find the bi-node-connected components of an undirected graph.
-  ///
-  /// This function finds the bi-node-connected components of the given
-  /// undirected graph.
-  ///
-  /// The bi-node-connected components are the classes of an equivalence
-  /// relation on the edges of a undirected graph. Two edges are in the
-  /// same class if they are on same circle.
-  ///
-  /// \image html node_biconnected_components.png
-  /// \image latex node_biconnected_components.eps "bi-node-connected components" width=\textwidth
-  ///
-  /// \param graph The undirected graph.
-  /// \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
-  /// certain component will be set continuously.
-  /// \return The number of bi-node-connected components.
-  ///
-  /// \see biNodeConnected(), countBiNodeConnectedComponents()
-  template <typename Graph, typename EdgeMap>
-  int biNodeConnectedComponents(const Graph& graph,
-                                EdgeMap& compMap) {
-    checkConcept<concepts::Graph, Graph>();
-    typedef typename Graph::NodeIt NodeIt;
-    typedef typename Graph::Edge Edge;
-    checkConcept<concepts::WriteMap<Edge, int>, EdgeMap>();
-
-    using namespace _connectivity_bits;
-
-    typedef BiNodeConnectedComponentsVisitor<Graph, EdgeMap> Visitor;
-
-    int compNum = 0;
-    Visitor visitor(graph, compMap, compNum);
-
-    DfsVisit<Graph, Visitor> dfs(graph, visitor);
-    dfs.init();
-
-    for (NodeIt it(graph); it != INVALID; ++it) {
-      if (!dfs.reached(it)) {
-        dfs.addSource(it);
-        dfs.start();
-      }
-    }
-    return compNum;
-  }
-
-  /// \ingroup graph_properties
-  ///
-  /// \brief Find the bi-node-connected cut nodes in an undirected graph.
-  ///
-  /// This function finds the bi-node-connected cut nodes in the given
-  /// undirected graph.
-  ///
-  /// The bi-node-connected components are the classes of an equivalence
-  /// relation on the edges of a undirected graph. Two edges are in the
-  /// same class if they are on same circle.
-  /// The bi-node-connected components are separted by the cut nodes of
-  /// the components.
-  ///
-  /// \param graph The undirected graph.
-  /// \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
-  /// other nodes.
-  /// \return The number of the cut nodes.
-  ///
-  /// \see biNodeConnected(), biNodeConnectedComponents()
-  template <typename Graph, typename NodeMap>
-  int biNodeConnectedCutNodes(const Graph& graph, NodeMap& cutMap) {
-    checkConcept<concepts::Graph, Graph>();
-    typedef typename Graph::Node Node;
-    typedef typename Graph::NodeIt NodeIt;
-    checkConcept<concepts::WriteMap<Node, bool>, NodeMap>();
-
-    using namespace _connectivity_bits;
-
-    typedef BiNodeConnectedCutNodesVisitor<Graph, NodeMap> Visitor;
-
-    int cutNum = 0;
-    Visitor visitor(graph, cutMap, cutNum);
-
-    DfsVisit<Graph, Visitor> dfs(graph, visitor);
-    dfs.init();
-
-    for (NodeIt it(graph); it != INVALID; ++it) {
-      if (!dfs.reached(it)) {
-        dfs.addSource(it);
-        dfs.start();
-      }
-    }
-    return cutNum;
-  }
-
-  namespace _connectivity_bits {
-
-    template <typename Digraph>
-    class CountBiEdgeConnectedComponentsVisitor : public DfsVisitor<Digraph> {
-    public:
-      typedef typename Digraph::Node Node;
-      typedef typename Digraph::Arc Arc;
-      typedef typename Digraph::Edge Edge;
-
-      CountBiEdgeConnectedComponentsVisitor(const Digraph& graph, int &compNum)
-        : _graph(graph), _compNum(compNum),
-          _numMap(graph), _retMap(graph), _predMap(graph), _num(0) {}
-
-      void start(const Node& node) {
-        _predMap.set(node, INVALID);
-      }
-
-      void reach(const Node& node) {
-        _numMap.set(node, _num);
-        _retMap.set(node, _num);
-        ++_num;
-      }
-
-      void leave(const Node& node) {
-        if (_numMap[node] <= _retMap[node]) {
-          ++_compNum;
-        }
-      }
-
-      void discover(const Arc& edge) {
-        _predMap.set(_graph.target(edge), edge);
-      }
-
-      void examine(const Arc& edge) {
-        if (_predMap[_graph.source(edge)] == _graph.oppositeArc(edge)) {
-          return;
-        }
-        if (_retMap[_graph.source(edge)] > _retMap[_graph.target(edge)]) {
-          _retMap.set(_graph.source(edge), _retMap[_graph.target(edge)]);
-        }
-      }
-
-      void backtrack(const Arc& edge) {
-        if (_retMap[_graph.source(edge)] > _retMap[_graph.target(edge)]) {
-          _retMap.set(_graph.source(edge), _retMap[_graph.target(edge)]);
-        }
-      }
-
-    private:
-      const Digraph& _graph;
-      int& _compNum;
-
-      typename Digraph::template NodeMap<int> _numMap;
-      typename Digraph::template NodeMap<int> _retMap;
-      typename Digraph::template NodeMap<Arc> _predMap;
-      int _num;
-    };
-
-    template <typename Digraph, typename NodeMap>
-    class BiEdgeConnectedComponentsVisitor : public DfsVisitor<Digraph> {
-    public:
-      typedef typename Digraph::Node Node;
-      typedef typename Digraph::Arc Arc;
-      typedef typename Digraph::Edge Edge;
-
-      BiEdgeConnectedComponentsVisitor(const Digraph& graph,
-                                       NodeMap& compMap, int &compNum)
-        : _graph(graph), _compMap(compMap), _compNum(compNum),
-          _numMap(graph), _retMap(graph), _predMap(graph), _num(0) {}
-
-      void start(const Node& node) {
-        _predMap.set(node, INVALID);
-      }
-
-      void reach(const Node& node) {
-        _numMap.set(node, _num);
-        _retMap.set(node, _num);
-        _nodeStack.push(node);
-        ++_num;
-      }
-
-      void leave(const Node& node) {
-        if (_numMap[node] <= _retMap[node]) {
-          while (_nodeStack.top() != node) {
-            _compMap.set(_nodeStack.top(), _compNum);
-            _nodeStack.pop();
-          }
-          _compMap.set(node, _compNum);
-          _nodeStack.pop();
-          ++_compNum;
-        }
-      }
-
-      void discover(const Arc& edge) {
-        _predMap.set(_graph.target(edge), edge);
-      }
-
-      void examine(const Arc& edge) {
-        if (_predMap[_graph.source(edge)] == _graph.oppositeArc(edge)) {
-          return;
-        }
-        if (_retMap[_graph.source(edge)] > _retMap[_graph.target(edge)]) {
-          _retMap.set(_graph.source(edge), _retMap[_graph.target(edge)]);
-        }
-      }
-
-      void backtrack(const Arc& edge) {
-        if (_retMap[_graph.source(edge)] > _retMap[_graph.target(edge)]) {
-          _retMap.set(_graph.source(edge), _retMap[_graph.target(edge)]);
-        }
-      }
-
-    private:
-      const Digraph& _graph;
-      NodeMap& _compMap;
-      int& _compNum;
-
-      typename Digraph::template NodeMap<int> _numMap;
-      typename Digraph::template NodeMap<int> _retMap;
-      typename Digraph::template NodeMap<Arc> _predMap;
-      std::stack<Node> _nodeStack;
-      int _num;
-    };
-
-
-    template <typename Digraph, typename ArcMap>
-    class BiEdgeConnectedCutEdgesVisitor : public DfsVisitor<Digraph> {
-    public:
-      typedef typename Digraph::Node Node;
-      typedef typename Digraph::Arc Arc;
-      typedef typename Digraph::Edge Edge;
-
-      BiEdgeConnectedCutEdgesVisitor(const Digraph& graph,
-                                     ArcMap& cutMap, int &cutNum)
-        : _graph(graph), _cutMap(cutMap), _cutNum(cutNum),
-          _numMap(graph), _retMap(graph), _predMap(graph), _num(0) {}
-
-      void start(const Node& node) {
-        _predMap[node] = INVALID;
-      }
-
-      void reach(const Node& node) {
-        _numMap.set(node, _num);
-        _retMap.set(node, _num);
-        ++_num;
-      }
-
-      void leave(const Node& node) {
-        if (_numMap[node] <= _retMap[node]) {
-          if (_predMap[node] != INVALID) {
-            _cutMap.set(_predMap[node], true);
-            ++_cutNum;
-          }
-        }
-      }
-
-      void discover(const Arc& edge) {
-        _predMap.set(_graph.target(edge), edge);
-      }
-
-      void examine(const Arc& edge) {
-        if (_predMap[_graph.source(edge)] == _graph.oppositeArc(edge)) {
-          return;
-        }
-        if (_retMap[_graph.source(edge)] > _retMap[_graph.target(edge)]) {
-          _retMap.set(_graph.source(edge), _retMap[_graph.target(edge)]);
-        }
-      }
-
-      void backtrack(const Arc& edge) {
-        if (_retMap[_graph.source(edge)] > _retMap[_graph.target(edge)]) {
-          _retMap.set(_graph.source(edge), _retMap[_graph.target(edge)]);
-        }
-      }
-
-    private:
-      const Digraph& _graph;
-      ArcMap& _cutMap;
-      int& _cutNum;
-
-      typename Digraph::template NodeMap<int> _numMap;
-      typename Digraph::template NodeMap<int> _retMap;
-      typename Digraph::template NodeMap<Arc> _predMap;
-      int _num;
-    };
-  }
-
-  template <typename Graph>
-  int countBiEdgeConnectedComponents(const Graph& graph);
-
-  /// \ingroup graph_properties
-  ///
-  /// \brief Check whether an undirected graph is bi-edge-connected.
-  ///
-  /// 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.
-  ///
-  /// \return \c true if the graph is bi-edge-connected.
-  /// \note By definition, the empty graph is bi-edge-connected.
-  ///
-  /// \see countBiEdgeConnectedComponents(), biEdgeConnectedComponents()
-  template <typename Graph>
-  bool biEdgeConnected(const Graph& graph) {
-    return countBiEdgeConnectedComponents(graph) <= 1;
-  }
-
-  /// \ingroup graph_properties
-  ///
-  /// \brief Count the number of bi-edge-connected components of an
-  /// undirected graph.
-  ///
-  /// This function counts the number of bi-edge-connected components of
-  /// the given undirected graph.
-  ///
-  /// The bi-edge-connected components are the classes of an equivalence
-  /// relation on the nodes of an undirected graph. Two nodes are in the
-  /// same class if they are connected with at least two edge-disjoint
-  /// paths.
-  ///
-  /// \return The number of bi-edge-connected components.
-  ///
-  /// \see biEdgeConnected(), biEdgeConnectedComponents()
-  template <typename Graph>
-  int countBiEdgeConnectedComponents(const Graph& graph) {
-    checkConcept<concepts::Graph, Graph>();
-    typedef typename Graph::NodeIt NodeIt;
-
-    using namespace _connectivity_bits;
-
-    typedef CountBiEdgeConnectedComponentsVisitor<Graph> Visitor;
-
-    int compNum = 0;
-    Visitor visitor(graph, compNum);
-
-    DfsVisit<Graph, Visitor> dfs(graph, visitor);
-    dfs.init();
-
-    for (NodeIt it(graph); it != INVALID; ++it) {
-      if (!dfs.reached(it)) {
-        dfs.addSource(it);
-        dfs.start();
-      }
-    }
-    return compNum;
-  }
-
-  /// \ingroup graph_properties
-  ///
-  /// \brief Find the bi-edge-connected components of an undirected graph.
-  ///
-  /// This function finds the bi-edge-connected components of the given
-  /// undirected graph.
-  ///
-  /// The bi-edge-connected components are the classes of an equivalence
-  /// relation on the nodes of an undirected graph. Two nodes are in the
-  /// same class if they are connected with at least two edge-disjoint
-  /// paths.
-  ///
-  /// \image html edge_biconnected_components.png
-  /// \image latex edge_biconnected_components.eps "bi-edge-connected components" width=\textwidth
-  ///
-  /// \param graph The undirected graph.
-  /// \retval compMap A writable node map. The values will be set from 0 to
-  /// the number of the bi-edge-connected components minus one. Each 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-edge-connected components.
-  ///
-  /// \see biEdgeConnected(), countBiEdgeConnectedComponents()
-  template <typename Graph, typename NodeMap>
-  int biEdgeConnectedComponents(const Graph& graph, NodeMap& compMap) {
-    checkConcept<concepts::Graph, Graph>();
-    typedef typename Graph::NodeIt NodeIt;
-    typedef typename Graph::Node Node;
-    checkConcept<concepts::WriteMap<Node, int>, NodeMap>();
-
-    using namespace _connectivity_bits;
-
-    typedef BiEdgeConnectedComponentsVisitor<Graph, NodeMap> Visitor;
-
-    int compNum = 0;
-    Visitor visitor(graph, compMap, compNum);
-
-    DfsVisit<Graph, Visitor> dfs(graph, visitor);
-    dfs.init();
-
-    for (NodeIt it(graph); it != INVALID; ++it) {
-      if (!dfs.reached(it)) {
-        dfs.addSource(it);
-        dfs.start();
-      }
-    }
-    return compNum;
-  }
-
-  /// \ingroup graph_properties
-  ///
-  /// \brief Find the bi-edge-connected cut edges in an undirected graph.
-  ///
-  /// This function finds the bi-edge-connected cut edges in the given
-  /// undirected graph.
-  ///
-  /// The bi-edge-connected components are the classes of an equivalence
-  /// relation on the nodes of an undirected graph. Two nodes are in the
-  /// same class if they are connected with at least two edge-disjoint
-  /// paths.
-  /// The bi-edge-connected components are separted by the cut edges of
-  /// the components.
-  ///
-  /// \param graph The undirected graph.
-  /// \retval cutMap A writable edge map. The values will be set to \c true
-  /// for the cut edges (exactly once for each cut edge), and will not be
-  /// changed for other edges.
-  /// \return The number of cut edges.
-  ///
-  /// \see biEdgeConnected(), biEdgeConnectedComponents()
-  template <typename Graph, typename EdgeMap>
-  int biEdgeConnectedCutEdges(const Graph& graph, EdgeMap& cutMap) {
-    checkConcept<concepts::Graph, Graph>();
-    typedef typename Graph::NodeIt NodeIt;
-    typedef typename Graph::Edge Edge;
-    checkConcept<concepts::WriteMap<Edge, bool>, EdgeMap>();
-
-    using namespace _connectivity_bits;
-
-    typedef BiEdgeConnectedCutEdgesVisitor<Graph, EdgeMap> Visitor;
-
-    int cutNum = 0;
-    Visitor visitor(graph, cutMap, cutNum);
-
-    DfsVisit<Graph, Visitor> dfs(graph, visitor);
-    dfs.init();
-
-    for (NodeIt it(graph); it != INVALID; ++it) {
-      if (!dfs.reached(it)) {
-        dfs.addSource(it);
-        dfs.start();
-      }
-    }
-    return cutNum;
-  }
-
-
-  namespace _connectivity_bits {
-
-    template <typename Digraph, typename IntNodeMap>
-    class TopologicalSortVisitor : public DfsVisitor<Digraph> {
-    public:
-      typedef typename Digraph::Node Node;
-      typedef typename Digraph::Arc edge;
-
-      TopologicalSortVisitor(IntNodeMap& order, int num)
-        : _order(order), _num(num) {}
-
-      void leave(const Node& node) {
-        _order.set(node, --_num);
-      }
-
-    private:
-      IntNodeMap& _order;
-      int _num;
-    };
-
-  }
-
-  /// \ingroup graph_properties
-  ///
-  /// \brief Check whether a digraph is DAG.
-  ///
-  /// This function checks whether the given digraph is DAG, i.e.
-  /// \e Directed \e Acyclic \e Graph.
-  /// \return \c true if there is no directed cycle in the digraph.
-  /// \see acyclic()
-  template <typename Digraph>
-  bool dag(const Digraph& digraph) {
-
-    checkConcept<concepts::Digraph, Digraph>();
-
-    typedef typename Digraph::Node Node;
-    typedef typename Digraph::NodeIt NodeIt;
-    typedef typename Digraph::Arc Arc;
-
-    typedef typename Digraph::template NodeMap<bool> ProcessedMap;
-
-    typename Dfs<Digraph>::template SetProcessedMap<ProcessedMap>::
-      Create dfs(digraph);
-
-    ProcessedMap processed(digraph);
-    dfs.processedMap(processed);
-
-    dfs.init();
-    for (NodeIt it(digraph); it != INVALID; ++it) {
-      if (!dfs.reached(it)) {
-        dfs.addSource(it);
-        while (!dfs.emptyQueue()) {
-          Arc arc = dfs.nextArc();
-          Node target = digraph.target(arc);
-          if (dfs.reached(target) && !processed[target]) {
-            return false;
-          }
-          dfs.processNextArc();
-        }
-      }
-    }
-    return true;
-  }
-
-  /// \ingroup graph_properties
-  ///
-  /// \brief Sort the nodes of a DAG into topolgical order.
-  ///
-  /// This function sorts the nodes of the given acyclic digraph (DAG)
-  /// into topolgical order.
-  ///
-  /// \param digraph The digraph, which must be DAG.
-  /// \retval order A writable node map. The values will be 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.
-  ///
-  /// \see dag(), checkedTopologicalSort()
-  template <typename Digraph, typename NodeMap>
-  void topologicalSort(const Digraph& digraph, NodeMap& order) {
-    using namespace _connectivity_bits;
-
-    checkConcept<concepts::Digraph, Digraph>();
-    checkConcept<concepts::WriteMap<typename Digraph::Node, int>, NodeMap>();
-
-    typedef typename Digraph::Node Node;
-    typedef typename Digraph::NodeIt NodeIt;
-    typedef typename Digraph::Arc Arc;
-
-    TopologicalSortVisitor<Digraph, NodeMap>
-      visitor(order, countNodes(digraph));
-
-    DfsVisit<Digraph, TopologicalSortVisitor<Digraph, NodeMap> >
-      dfs(digraph, visitor);
-
-    dfs.init();
-    for (NodeIt it(digraph); it != INVALID; ++it) {
-      if (!dfs.reached(it)) {
-        dfs.addSource(it);
-        dfs.start();
-      }
-    }
-  }
-
-  /// \ingroup graph_properties
-  ///
-  /// \brief Sort the nodes of a DAG into topolgical order.
-  ///
-  /// This function sorts the nodes of the given acyclic digraph (DAG)
-  /// into topolgical order and also checks whether the given digraph
-  /// is DAG.
-  ///
-  /// \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.
-  /// Each value of the map will be set exactly once, and the values will
-  /// be set descending order.
-  /// \return \c false if the digraph is not DAG.
-  ///
-  /// \see dag(), topologicalSort()
-  template <typename Digraph, typename NodeMap>
-  bool checkedTopologicalSort(const Digraph& digraph, NodeMap& order) {
-    using namespace _connectivity_bits;
-
-    checkConcept<concepts::Digraph, Digraph>();
-    checkConcept<concepts::ReadWriteMap<typename Digraph::Node, int>,
-      NodeMap>();
-
-    typedef typename Digraph::Node Node;
-    typedef typename Digraph::NodeIt NodeIt;
-    typedef typename Digraph::Arc Arc;
-
-    for (NodeIt it(digraph); it != INVALID; ++it) {
-      order.set(it, -1);
-    }
-
-    TopologicalSortVisitor<Digraph, NodeMap>
-      visitor(order, countNodes(digraph));
-
-    DfsVisit<Digraph, TopologicalSortVisitor<Digraph, NodeMap> >
-      dfs(digraph, visitor);
-
-    dfs.init();
-    for (NodeIt it(digraph); it != INVALID; ++it) {
-      if (!dfs.reached(it)) {
-        dfs.addSource(it);
-        while (!dfs.emptyQueue()) {
-           Arc arc = dfs.nextArc();
-           Node target = digraph.target(arc);
-           if (dfs.reached(target) && order[target] == -1) {
-             return false;
-           }
-           dfs.processNextArc();
-         }
-      }
-    }
-    return true;
-  }
-
-  /// \ingroup graph_properties
-  ///
-  /// \brief Check whether an undirected graph is acyclic.
-  ///
-  /// This function checks whether the given undirected graph is acyclic.
-  /// \return \c true if there is no cycle in the graph.
-  /// \see dag()
-  template <typename Graph>
-  bool acyclic(const Graph& graph) {
-    checkConcept<concepts::Graph, Graph>();
-    typedef typename Graph::Node Node;
-    typedef typename Graph::NodeIt NodeIt;
-    typedef typename Graph::Arc Arc;
-    Dfs<Graph> dfs(graph);
-    dfs.init();
-    for (NodeIt it(graph); it != INVALID; ++it) {
-      if (!dfs.reached(it)) {
-        dfs.addSource(it);
-        while (!dfs.emptyQueue()) {
-          Arc arc = dfs.nextArc();
-          Node source = graph.source(arc);
-          Node target = graph.target(arc);
-          if (dfs.reached(target) &&
-              dfs.predArc(source) != graph.oppositeArc(arc)) {
-            return false;
-          }
-          dfs.processNextArc();
-        }
-      }
-    }
-    return true;
-  }
-
-  /// \ingroup graph_properties
-  ///
-  /// \brief Check whether an undirected graph is tree.
-  ///
-  /// This function checks whether the given undirected graph is tree.
-  /// \return \c true if the graph is acyclic and connected.
-  /// \see acyclic(), connected()
-  template <typename Graph>
-  bool tree(const Graph& graph) {
-    checkConcept<concepts::Graph, Graph>();
-    typedef typename Graph::Node Node;
-    typedef typename Graph::NodeIt NodeIt;
-    typedef typename Graph::Arc Arc;
-    if (NodeIt(graph) == INVALID) return true;
-    Dfs<Graph> dfs(graph);
-    dfs.init();
-    dfs.addSource(NodeIt(graph));
-    while (!dfs.emptyQueue()) {
-      Arc arc = dfs.nextArc();
-      Node source = graph.source(arc);
-      Node target = graph.target(arc);
-      if (dfs.reached(target) &&
-          dfs.predArc(source) != graph.oppositeArc(arc)) {
-        return false;
-      }
-      dfs.processNextArc();
-    }
-    for (NodeIt it(graph); it != INVALID; ++it) {
-      if (!dfs.reached(it)) {
-        return false;
-      }
-    }
-    return true;
-  }
-
-  namespace _connectivity_bits {
-
-    template <typename Digraph>
-    class BipartiteVisitor : public BfsVisitor<Digraph> {
-    public:
-      typedef typename Digraph::Arc Arc;
-      typedef typename Digraph::Node Node;
-
-      BipartiteVisitor(const Digraph& graph, bool& bipartite)
-        : _graph(graph), _part(graph), _bipartite(bipartite) {}
-
-      void start(const Node& node) {
-        _part[node] = true;
-      }
-      void discover(const Arc& edge) {
-        _part.set(_graph.target(edge), !_part[_graph.source(edge)]);
-      }
-      void examine(const Arc& edge) {
-        _bipartite = _bipartite &&
-          _part[_graph.target(edge)] != _part[_graph.source(edge)];
-      }
-
-    private:
-
-      const Digraph& _graph;
-      typename Digraph::template NodeMap<bool> _part;
-      bool& _bipartite;
-    };
-
-    template <typename Digraph, typename PartMap>
-    class BipartitePartitionsVisitor : public BfsVisitor<Digraph> {
-    public:
-      typedef typename Digraph::Arc Arc;
-      typedef typename Digraph::Node Node;
-
-      BipartitePartitionsVisitor(const Digraph& graph,
-                                 PartMap& part, bool& bipartite)
-        : _graph(graph), _part(part), _bipartite(bipartite) {}
-
-      void start(const Node& node) {
-        _part.set(node, true);
-      }
-      void discover(const Arc& edge) {
-        _part.set(_graph.target(edge), !_part[_graph.source(edge)]);
-      }
-      void examine(const Arc& edge) {
-        _bipartite = _bipartite &&
-          _part[_graph.target(edge)] != _part[_graph.source(edge)];
-      }
-
-    private:
-
-      const Digraph& _graph;
-      PartMap& _part;
-      bool& _bipartite;
-    };
-  }
-
-  /// \ingroup graph_properties
-  ///
-  /// \brief Check whether an undirected graph is bipartite.
-  ///
-  /// The function checks whether the given undirected graph is bipartite.
-  /// \return \c true if the graph is bipartite.
-  ///
-  /// \see bipartitePartitions()
-  template<typename Graph>
-  bool bipartite(const Graph &graph){
-    using namespace _connectivity_bits;
-
-    checkConcept<concepts::Graph, Graph>();
-
-    typedef typename Graph::NodeIt NodeIt;
-    typedef typename Graph::ArcIt ArcIt;
-
-    bool bipartite = true;
-
-    BipartiteVisitor<Graph>
-      visitor(graph, bipartite);
-    BfsVisit<Graph, BipartiteVisitor<Graph> >
-      bfs(graph, visitor);
-    bfs.init();
-    for(NodeIt it(graph); it != INVALID; ++it) {
-      if(!bfs.reached(it)){
-        bfs.addSource(it);
-        while (!bfs.emptyQueue()) {
-          bfs.processNextNode();
-          if (!bipartite) return false;
-        }
-      }
-    }
-    return true;
-  }
-
-  /// \ingroup graph_properties
-  ///
-  /// \brief Find the bipartite partitions of an undirected graph.
-  ///
-  /// This function checks whether the given undirected graph is bipartite
-  /// and gives back the bipartite partitions.
-  ///
-  /// \image html bipartite_partitions.png
-  /// \image latex bipartite_partitions.eps "Bipartite partititions" width=\textwidth
-  ///
-  /// \param graph The undirected graph.
-  /// \retval partMap A writable node map of \c bool (or convertible) value
-  /// type. The values will be set to \c true for one component and
-  /// \c false for the other one.
-  /// \return \c true if the graph is bipartite, \c false otherwise.
-  ///
-  /// \see bipartite()
-  template<typename Graph, typename NodeMap>
-  bool bipartitePartitions(const Graph &graph, NodeMap &partMap){
-    using namespace _connectivity_bits;
-
-    checkConcept<concepts::Graph, Graph>();
-    checkConcept<concepts::WriteMap<typename Graph::Node, bool>, NodeMap>();
-
-    typedef typename Graph::Node Node;
-    typedef typename Graph::NodeIt NodeIt;
-    typedef typename Graph::ArcIt ArcIt;
-
-    bool bipartite = true;
-
-    BipartitePartitionsVisitor<Graph, NodeMap>
-      visitor(graph, partMap, bipartite);
-    BfsVisit<Graph, BipartitePartitionsVisitor<Graph, NodeMap> >
-      bfs(graph, visitor);
-    bfs.init();
-    for(NodeIt it(graph); it != INVALID; ++it) {
-      if(!bfs.reached(it)){
-        bfs.addSource(it);
-        while (!bfs.emptyQueue()) {
-          bfs.processNextNode();
-          if (!bipartite) return false;
-        }
-      }
-    }
-    return true;
-  }
-
-  /// \ingroup graph_properties
-  ///
-  /// \brief Check whether the given graph contains no loop arcs/edges.
-  ///
-  /// This function returns \c true if there are no loop arcs/edges in
-  /// the given graph. It works for both directed and undirected graphs.
-  template <typename Graph>
-  bool loopFree(const Graph& graph) {
-    for (typename Graph::ArcIt it(graph); it != INVALID; ++it) {
-      if (graph.source(it) == graph.target(it)) return false;
-    }
-    return true;
-  }
-
-  /// \ingroup graph_properties
-  ///
-  /// \brief Check whether the given graph contains no parallel arcs/edges.
-  ///
-  /// This function returns \c true if there are no parallel arcs/edges in
-  /// the given graph. It works for both directed and undirected graphs.
-  template <typename Graph>
-  bool parallelFree(const Graph& graph) {
-    typename Graph::template NodeMap<int> reached(graph, 0);
-    int cnt = 1;
-    for (typename Graph::NodeIt n(graph); n != INVALID; ++n) {
-      for (typename Graph::OutArcIt a(graph, n); a != INVALID; ++a) {
-        if (reached[graph.target(a)] == cnt) return false;
-        reached[graph.target(a)] = cnt;
-      }
-      ++cnt;
-    }
-    return true;
-  }
-
-  /// \ingroup graph_properties
-  ///
-  /// \brief Check whether the given graph is simple.
-  ///
-  /// This function returns \c true if the given graph is simple, i.e.
-  /// it contains no loop arcs/edges and no parallel arcs/edges.
-  /// The function works for both directed and undirected graphs.
-  /// \see loopFree(), parallelFree()
-  template <typename Graph>
-  bool simpleGraph(const Graph& graph) {
-    typename Graph::template NodeMap<int> reached(graph, 0);
-    int cnt = 1;
-    for (typename Graph::NodeIt n(graph); n != INVALID; ++n) {
-      reached[n] = cnt;
-      for (typename Graph::OutArcIt a(graph, n); a != INVALID; ++a) {
-        if (reached[graph.target(a)] == cnt) return false;
-        reached[graph.target(a)] = cnt;
-      }
-      ++cnt;
-    }
-    return true;
-  }
-
-} //namespace lemon
-
-#endif //LEMON_CONNECTIVITY_H
Index: lemon/core.h
===================================================================
--- lemon/core.h	(revision 986)
+++ lemon/core.h	(revision 980)
@@ -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).
@@ -27,14 +27,4 @@
 #include <lemon/bits/traits.h>
 #include <lemon/assert.h>
-
-// Disable the following warnings when compiling with MSVC:
-// C4250: 'class1' : inherits 'class2::member' via dominance
-// C4355: 'this' : used in base member initializer list
-// C4503: 'function' : decorated name length exceeded, name was truncated
-// C4800: 'type' : forcing value to bool 'true' or 'false' (performance warning)
-// C4996: 'function': was declared deprecated
-#ifdef _MSC_VER
-#pragma warning( disable : 4250 4355 4503 4800 4996 )
-#endif
 
 ///\file
@@ -1047,12 +1037,13 @@
   ///\sa findArc()
   ///\sa ArcLookUp, AllArcLookUp, DynArcLookUp
-  template <typename GR>
-  class ConArcIt : public GR::Arc {
-    typedef typename GR::Arc Parent;
-
+  template <typename _Graph>
+  class ConArcIt : public _Graph::Arc {
   public:
 
-    typedef typename GR::Arc Arc;
-    typedef typename GR::Node Node;
+    typedef _Graph Graph;
+    typedef typename Graph::Arc Parent;
+
+    typedef typename Graph::Arc Arc;
+    typedef typename Graph::Node Node;
 
     /// \brief Constructor.
@@ -1060,5 +1051,5 @@
     /// Construct a new ConArcIt iterating on the arcs that
     /// connects nodes \c u and \c v.
-    ConArcIt(const GR& g, Node u, Node v) : _graph(g) {
+    ConArcIt(const Graph& g, Node u, Node v) : _graph(g) {
       Parent::operator=(findArc(_graph, u, v));
     }
@@ -1067,5 +1058,5 @@
     ///
     /// Construct a new ConArcIt that continues the iterating from arc \c a.
-    ConArcIt(const GR& g, Arc a) : Parent(a), _graph(g) {}
+    ConArcIt(const Graph& g, Arc a) : Parent(a), _graph(g) {}
 
     /// \brief Increment operator.
@@ -1078,5 +1069,5 @@
     }
   private:
-    const GR& _graph;
+    const Graph& _graph;
   };
 
@@ -1169,12 +1160,13 @@
   ///
   ///\sa findEdge()
-  template <typename GR>
-  class ConEdgeIt : public GR::Edge {
-    typedef typename GR::Edge Parent;
-
+  template <typename _Graph>
+  class ConEdgeIt : public _Graph::Edge {
   public:
 
-    typedef typename GR::Edge Edge;
-    typedef typename GR::Node Node;
+    typedef _Graph Graph;
+    typedef typename Graph::Edge Parent;
+
+    typedef typename Graph::Edge Edge;
+    typedef typename Graph::Node Node;
 
     /// \brief Constructor.
@@ -1182,5 +1174,5 @@
     /// Construct a new ConEdgeIt iterating on the edges that
     /// connects nodes \c u and \c v.
-    ConEdgeIt(const GR& g, Node u, Node v) : _graph(g), _u(u), _v(v) {
+    ConEdgeIt(const Graph& g, Node u, Node v) : _graph(g), _u(u), _v(v) {
       Parent::operator=(findEdge(_graph, _u, _v));
     }
@@ -1189,5 +1181,5 @@
     ///
     /// Construct a new ConEdgeIt that continues iterating from edge \c e.
-    ConEdgeIt(const GR& g, Edge e) : Parent(e), _graph(g) {}
+    ConEdgeIt(const Graph& g, Edge e) : Parent(e), _graph(g) {}
 
     /// \brief Increment operator.
@@ -1199,5 +1191,5 @@
     }
   private:
-    const GR& _graph;
+    const Graph& _graph;
     Node _u, _v;
   };
@@ -1222,31 +1214,27 @@
   ///queries.
   ///
-  ///\tparam GR The type of the underlying digraph.
+  ///\tparam G The type of the underlying digraph.
   ///
   ///\sa ArcLookUp
   ///\sa AllArcLookUp
-  template <typename GR>
+  template<class G>
   class DynArcLookUp
-    : protected ItemSetTraits<GR, typename GR::Arc>::ItemNotifier::ObserverBase
+    : protected ItemSetTraits<G, typename G::Arc>::ItemNotifier::ObserverBase
   {
-    typedef typename ItemSetTraits<GR, typename GR::Arc>
+  public:
+    typedef typename ItemSetTraits<G, typename G::Arc>
     ::ItemNotifier::ObserverBase Parent;
 
-    TEMPLATE_DIGRAPH_TYPEDEFS(GR);
-
-  public:
-
-    /// The Digraph type
-    typedef GR Digraph;
+    TEMPLATE_DIGRAPH_TYPEDEFS(G);
+    typedef G Digraph;
 
   protected:
 
-    class AutoNodeMap : public ItemSetTraits<GR, Node>::template Map<Arc>::Type
-    {
-      typedef typename ItemSetTraits<GR, Node>::template Map<Arc>::Type Parent;
-
+    class AutoNodeMap : public ItemSetTraits<G, Node>::template Map<Arc>::Type {
     public:
 
-      AutoNodeMap(const GR& digraph) : Parent(digraph, INVALID) {}
+      typedef typename ItemSetTraits<G, Node>::template Map<Arc>::Type Parent;
+
+      AutoNodeMap(const G& digraph) : Parent(digraph, INVALID) {}
 
       virtual void add(const Node& node) {
@@ -1271,4 +1259,10 @@
       }
     };
+
+    const Digraph &_g;
+    AutoNodeMap _head;
+    typename Digraph::template ArcMap<Arc> _parent;
+    typename Digraph::template ArcMap<Arc> _left;
+    typename Digraph::template ArcMap<Arc> _right;
 
     class ArcLess {
@@ -1282,12 +1276,4 @@
     };
 
-  protected:
-
-    const Digraph &_g;
-    AutoNodeMap _head;
-    typename Digraph::template ArcMap<Arc> _parent;
-    typename Digraph::template ArcMap<Arc> _left;
-    typename Digraph::template ArcMap<Arc> _right;
-
   public:
 
@@ -1332,5 +1318,5 @@
     virtual void clear() {
       for(NodeIt n(_g);n!=INVALID;++n) {
-        _head[n] = INVALID;
+        _head.set(n, INVALID);
       }
     }
@@ -1339,11 +1325,11 @@
       Node s = _g.source(arc);
       Node t = _g.target(arc);
-      _left[arc] = INVALID;
-      _right[arc] = INVALID;
+      _left.set(arc, INVALID);
+      _right.set(arc, INVALID);
 
       Arc e = _head[s];
       if (e == INVALID) {
-        _head[s] = arc;
-        _parent[arc] = INVALID;
+        _head.set(s, arc);
+        _parent.set(arc, INVALID);
         return;
       }
@@ -1351,6 +1337,6 @@
         if (t < _g.target(e)) {
           if (_left[e] == INVALID) {
-            _left[e] = arc;
-            _parent[arc] = e;
+            _left.set(e, arc);
+            _parent.set(arc, e);
             splay(arc);
             return;
@@ -1360,6 +1346,6 @@
         } else {
           if (_right[e] == INVALID) {
-            _right[e] = arc;
-            _parent[arc] = e;
+            _right.set(e, arc);
+            _parent.set(arc, e);
             splay(arc);
             return;
@@ -1374,25 +1360,25 @@
       if (_left[arc] == INVALID) {
         if (_right[arc] != INVALID) {
-          _parent[_right[arc]] = _parent[arc];
+          _parent.set(_right[arc], _parent[arc]);
         }
         if (_parent[arc] != INVALID) {
           if (_left[_parent[arc]] == arc) {
-            _left[_parent[arc]] = _right[arc];
+            _left.set(_parent[arc], _right[arc]);
           } else {
-            _right[_parent[arc]] = _right[arc];
+            _right.set(_parent[arc], _right[arc]);
           }
         } else {
-          _head[_g.source(arc)] = _right[arc];
+          _head.set(_g.source(arc), _right[arc]);
         }
       } else if (_right[arc] == INVALID) {
-        _parent[_left[arc]] = _parent[arc];
+        _parent.set(_left[arc], _parent[arc]);
         if (_parent[arc] != INVALID) {
           if (_left[_parent[arc]] == arc) {
-            _left[_parent[arc]] = _left[arc];
+            _left.set(_parent[arc], _left[arc]);
           } else {
-            _right[_parent[arc]] = _left[arc];
+            _right.set(_parent[arc], _left[arc]);
           }
         } else {
-          _head[_g.source(arc)] = _left[arc];
+          _head.set(_g.source(arc), _left[arc]);
         }
       } else {
@@ -1404,36 +1390,36 @@
           }
           Arc s = _parent[e];
-          _right[_parent[e]] = _left[e];
+          _right.set(_parent[e], _left[e]);
           if (_left[e] != INVALID) {
-            _parent[_left[e]] = _parent[e];
+            _parent.set(_left[e], _parent[e]);
           }
 
-          _left[e] = _left[arc];
-          _parent[_left[arc]] = e;
-          _right[e] = _right[arc];
-          _parent[_right[arc]] = e;
-
-          _parent[e] = _parent[arc];
+          _left.set(e, _left[arc]);
+          _parent.set(_left[arc], e);
+          _right.set(e, _right[arc]);
+          _parent.set(_right[arc], e);
+
+          _parent.set(e, _parent[arc]);
           if (_parent[arc] != INVALID) {
             if (_left[_parent[arc]] == arc) {
-              _left[_parent[arc]] = e;
+              _left.set(_parent[arc], e);
             } else {
-              _right[_parent[arc]] = e;
+              _right.set(_parent[arc], e);
             }
           }
           splay(s);
         } else {
-          _right[e] = _right[arc];
-          _parent[_right[arc]] = e;
-          _parent[e] = _parent[arc];
+          _right.set(e, _right[arc]);
+          _parent.set(_right[arc], e);
+          _parent.set(e, _parent[arc]);
 
           if (_parent[arc] != INVALID) {
             if (_left[_parent[arc]] == arc) {
-              _left[_parent[arc]] = e;
+              _left.set(_parent[arc], e);
             } else {
-              _right[_parent[arc]] = e;
+              _right.set(_parent[arc], e);
             }
           } else {
-            _head[_g.source(arc)] = e;
+            _head.set(_g.source(arc), e);
           }
         }
@@ -1447,15 +1433,15 @@
       if (a < m) {
         Arc left = refreshRec(v,a,m-1);
-        _left[me] = left;
-        _parent[left] = me;
+        _left.set(me, left);
+        _parent.set(left, me);
       } else {
-        _left[me] = INVALID;
+        _left.set(me, INVALID);
       }
       if (m < b) {
         Arc right = refreshRec(v,m+1,b);
-        _right[me] = right;
-        _parent[right] = me;
+        _right.set(me, right);
+        _parent.set(right, me);
       } else {
-        _right[me] = INVALID;
+        _right.set(me, INVALID);
       }
       return me;
@@ -1469,8 +1455,8 @@
           std::sort(v.begin(),v.end(),ArcLess(_g));
           Arc head = refreshRec(v,0,v.size()-1);
-          _head[n] = head;
-          _parent[head] = INVALID;
-        }
-        else _head[n] = INVALID;
+          _head.set(n, head);
+          _parent.set(head, INVALID);
+        }
+        else _head.set(n, INVALID);
       }
     }
@@ -1478,17 +1464,17 @@
     void zig(Arc v) {
       Arc w = _parent[v];
-      _parent[v] = _parent[w];
-      _parent[w] = v;
-      _left[w] = _right[v];
-      _right[v] = w;
+      _parent.set(v, _parent[w]);
+      _parent.set(w, v);
+      _left.set(w, _right[v]);
+      _right.set(v, w);
       if (_parent[v] != INVALID) {
         if (_right[_parent[v]] == w) {
-          _right[_parent[v]] = v;
+          _right.set(_parent[v], v);
         } else {
-          _left[_parent[v]] = v;
+          _left.set(_parent[v], v);
         }
       }
       if (_left[w] != INVALID){
-        _parent[_left[w]] = w;
+        _parent.set(_left[w], w);
       }
     }
@@ -1496,17 +1482,17 @@
     void zag(Arc v) {
       Arc w = _parent[v];
-      _parent[v] = _parent[w];
-      _parent[w] = v;
-      _right[w] = _left[v];
-      _left[v] = w;
+      _parent.set(v, _parent[w]);
+      _parent.set(w, v);
+      _right.set(w, _left[v]);
+      _left.set(v, w);
       if (_parent[v] != INVALID){
         if (_left[_parent[v]] == w) {
-          _left[_parent[v]] = v;
+          _left.set(_parent[v], v);
         } else {
-          _right[_parent[v]] = v;
+          _right.set(_parent[v], v);
         }
       }
       if (_right[w] != INVALID){
-        _parent[_right[w]] = w;
+        _parent.set(_right[w], w);
       }
     }
@@ -1640,17 +1626,14 @@
   ///(<em>O</em>(<em>m</em> log<em>m</em>)) to the number of arcs).
   ///
-  ///\tparam GR The type of the underlying digraph.
+  ///\tparam G The type of the underlying digraph.
   ///
   ///\sa DynArcLookUp
   ///\sa AllArcLookUp
-  template<class GR>
+  template<class G>
   class ArcLookUp
   {
-    TEMPLATE_DIGRAPH_TYPEDEFS(GR);
-
   public:
-
-    /// The Digraph type
-    typedef GR Digraph;
+    TEMPLATE_DIGRAPH_TYPEDEFS(G);
+    typedef G Digraph;
 
   protected:
@@ -1753,19 +1736,20 @@
   ///(<em>O</em>(<em>m</em> log<em>m</em>)) to the number of arcs).
   ///
-  ///\tparam GR The type of the underlying digraph.
+  ///\tparam G The type of the underlying digraph.
   ///
   ///\sa DynArcLookUp
   ///\sa ArcLookUp
-  template<class GR>
-  class AllArcLookUp : public ArcLookUp<GR>
+  template<class G>
+  class AllArcLookUp : public ArcLookUp<G>
   {
-    using ArcLookUp<GR>::_g;
-    using ArcLookUp<GR>::_right;
-    using ArcLookUp<GR>::_left;
-    using ArcLookUp<GR>::_head;
-
-    TEMPLATE_DIGRAPH_TYPEDEFS(GR);
-
-    typename GR::template ArcMap<Arc> _next;
+    using ArcLookUp<G>::_g;
+    using ArcLookUp<G>::_right;
+    using ArcLookUp<G>::_left;
+    using ArcLookUp<G>::_head;
+
+    TEMPLATE_DIGRAPH_TYPEDEFS(G);
+    typedef G Digraph;
+
+    typename Digraph::template ArcMap<Arc> _next;
 
     Arc refreshNext(Arc head,Arc next=INVALID)
@@ -1786,8 +1770,4 @@
 
   public:
-
-    /// The Digraph type
-    typedef GR Digraph;
-
     ///Constructor
 
@@ -1796,5 +1776,5 @@
     ///It builds up the search database, which remains valid until the digraph
     ///changes.
-    AllArcLookUp(const Digraph &g) : ArcLookUp<GR>(g), _next(g) {refreshNext();}
+    AllArcLookUp(const Digraph &g) : ArcLookUp<G>(g), _next(g) {refreshNext();}
 
     ///Refresh the data structure at a node.
@@ -1806,5 +1786,5 @@
     void refresh(Node n)
     {
-      ArcLookUp<GR>::refresh(n);
+      ArcLookUp<G>::refresh(n);
       refreshNext(_head[n]);
     }
@@ -1853,5 +1833,5 @@
     Arc operator()(Node s, Node t, Arc prev=INVALID) const {}
 #else
-    using ArcLookUp<GR>::operator() ;
+    using ArcLookUp<G>::operator() ;
     Arc operator()(Node s, Node t, Arc prev) const
     {
Index: mon/cost_scaling.h
===================================================================
--- lemon/cost_scaling.h	(revision 956)
+++ 	(revision )
@@ -1,1316 +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.
-  ///
-  /// 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 number types must be signed and all input data must
-  /// be integer.
-  /// \warning This algorithm does not support negative costs for such
-  /// arcs that have 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 proved 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::Node, LargeCost> LargeCostNodeMap;
-    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;
-
-    // Data for a StaticDigraph structure
-    typedef std::pair<int, int> IntPair;
-    StaticDigraph _sgr;
-    std::vector<IntPair> _arc_vec;
-    std::vector<LargeCost> _cost_vec;
-    LargeCostArcMap _cost_map;
-    LargeCostNodeMap _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:
-
-    /// \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),
-      _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 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 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.
-    ///
-    /// \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 larger than one.
-    ///
-    /// \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 = 8) {
-      _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 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 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.
-    /// \return <tt>(*this)</tt>
-    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);
-
-      _arc_vec.reserve(_res_arc_num);
-      _cost_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
-    ///   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;
-        }
-      }
-
-      return OPTIMAL;
-    }
-
-    // Execute the algorithm and transform the results
-    void start(Method method) {
-      // Maximum path length for partial augment
-      const int MAX_PATH_LENGTH = 4;
-
-      // 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);
-
-      // Execute the algorithm
-      switch (method) {
-        case PUSH:
-          startPush();
-          break;
-        case AUGMENT:
-          startAugment();
-          break;
-        case PARTIAL_AUGMENT:
-          startAugment(MAX_PATH_LENGTH);
-          break;
-      }
-
-      // Compute node potentials for the original costs
-      _arc_vec.clear();
-      _cost_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(_scost[j]);
-        }
-      }
-      _sgr.build(_res_node_num, _arc_vec.begin(), _arc_vec.end());
-
-      typename BellmanFord<StaticDigraph, LargeCostArcMap>
-        ::template SetDistMap<LargeCostNodeMap>::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];
-        }
-      }
-    }
-
-    // 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) {
-          int v = _target[a];
-          if (_res_cap[a] > 0 && _cost[a] + pi_u - _pi[v] < 0) {
-            Value delta = _res_cap[a];
-            _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];
-      }
-    }
-
-    // Early termination heuristic
-    bool earlyTermination() {
-      const double EARLY_TERM_FACTOR = 3.0;
-
-      // Build a static residual graph
-      _arc_vec.clear();
-      _cost_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] + 1);
-        }
-      }
-      _sgr.build(_res_node_num, _arc_vec.begin(), _arc_vec.end());
-
-      // Run Bellman-Ford algorithm to check if the current flow is optimal
-      BellmanFord<StaticDigraph, LargeCostArcMap> bf(_sgr, _cost_map);
-      bf.init(0);
-      bool done = false;
-      int K = int(EARLY_TERM_FACTOR * std::sqrt(double(_res_node_num)));
-      for (int i = 0; i < K && !done; ++i) {
-        done = bf.processNextWeakRound();
-      }
-      return done;
-    }
-
-    // Global potential update heuristic
-    void globalUpdate() {
-      int bucket_end = _root + 1;
-
-      // Initialize buckets
-      for (int r = 0; r != _max_rank; ++r) {
-        _buckets[r] = bucket_end;
-      }
-      Value total_excess = 0;
-      for (int i = 0; i != _res_node_num; ++i) {
-        if (_excess[i] < 0) {
-          _rank[i] = 0;
-          _bucket_next[i] = _buckets[0];
-          _bucket_prev[_buckets[0]] = i;
-          _buckets[0] = i;
-        } else {
-          total_excess += _excess[i];
-          _rank[i] = _max_rank;
-        }
-      }
-      if (total_excess == 0) return;
-
-      // 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 + 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 {
-                      _bucket_next[_bucket_prev[v]] = _bucket_next[v];
-                      _bucket_prev[_bucket_next[v]] = _bucket_prev[v];
-                    }
-                  }
-
-                  // Insert v to its new bucket
-                  _bucket_next[v] = _buckets[new_rank_v];
-                  _bucket_prev[_buckets[new_rank_v]] = 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 = std::numeric_limits<int>::max()) {
-      // Paramters for heuristics
-      const int EARLY_TERM_EPSILON_LIMIT = 1000;
-      const double GLOBAL_UPDATE_FACTOR = 3.0;
-
-      const int global_update_freq = int(GLOBAL_UPDATE_FACTOR *
-        (_res_node_num + _sup_node_num * _sup_node_num));
-      int next_update_limit = global_update_freq;
-
-      int relabel_cnt = 0;
-
-      // Perform cost scaling phases
-      std::vector<int> path;
-      for ( ; _epsilon >= 1; _epsilon = _epsilon < _alpha && _epsilon > 1 ?
-                                        1 : _epsilon / _alpha )
-      {
-        // Early termination heuristic
-        if (_epsilon <= EARLY_TERM_EPSILON_LIMIT) {
-          if (earlyTermination()) break;
-        }
-
-        // 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
-          path.clear();
-          int tip = start;
-          while (_excess[tip] >= 0 && int(path.size()) < max_length) {
-            int u;
-            LargeCost min_red_cost, rc, pi_tip = _pi[tip];
-            int last_out = _first_out[tip+1];
-            for (int a = _next_out[tip]; a != last_out; ++a) {
-              u = _target[a];
-              if (_res_cap[a] > 0 && _cost[a] + pi_tip - _pi[u] < 0) {
-                path.push_back(a);
-                _next_out[tip] = a;
-                tip = u;
-                goto next_step;
-              }
-            }
-
-            // Relabel tip node
-            min_red_cost = std::numeric_limits<LargeCost>::max();
-            if (tip != start) {
-              int ra = _reverse[path.back()];
-              min_red_cost = _cost[ra] + pi_tip - _pi[_target[ra]];
-            }
-            for (int a = _first_out[tip]; a != last_out; ++a) {
-              rc = _cost[a] + pi_tip - _pi[_target[a]];
-              if (_res_cap[a] > 0 && 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) {
-              tip = _source[path.back()];
-              path.pop_back();
-            }
-
-          next_step: ;
-          }
-
-          // Augment along the found path (as much flow as possible)
-          Value delta;
-          int pa, u, v = start;
-          for (int i = 0; i != int(path.size()); ++i) {
-            pa = path[i];
-            u = v;
-            v = _target[pa];
-            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);
-          }
-
-          // Global update heuristic
-          if (relabel_cnt >= next_update_limit) {
-            globalUpdate();
-            next_update_limit += global_update_freq;
-          }
-        }
-      }
-    }
-
-    /// Execute the algorithm performing push and relabel operations
-    void startPush() {
-      // Paramters for heuristics
-      const int EARLY_TERM_EPSILON_LIMIT = 1000;
-      const double GLOBAL_UPDATE_FACTOR = 2.0;
-
-      const int global_update_freq = int(GLOBAL_UPDATE_FACTOR *
-        (_res_node_num + _sup_node_num * _sup_node_num));
-      int next_update_limit = global_update_freq;
-
-      int relabel_cnt = 0;
-
-      // Perform cost scaling phases
-      BoolVector hyper(_res_node_num, false);
-      LargeCostVector hyper_cost(_res_node_num);
-      for ( ; _epsilon >= 1; _epsilon = _epsilon < _alpha && _epsilon > 1 ?
-                                        1 : _epsilon / _alpha )
-      {
-        // Early termination heuristic
-        if (_epsilon <= EARLY_TERM_EPSILON_LIMIT) {
-          if (earlyTermination()) break;
-        }
-
-        // 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) {
-              rc = _cost[a] + pi_n - _pi[_target[a]];
-              if (_res_cap[a] > 0 && 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_update_limit) {
-            globalUpdate();
-            for (int u = 0; u != _res_node_num; ++u)
-              hyper[u] = false;
-            next_update_limit += global_update_freq;
-          }
-        }
-      }
-    }
-
-  }; //class CostScaling
-
-  ///@}
-
-} //namespace lemon
-
-#endif //LEMON_COST_SCALING_H
Index: lemon/counter.h
===================================================================
--- lemon/counter.h	(revision 833)
+++ lemon/counter.h	(revision 209)
@@ -3,5 +3,5 @@
  * This file is a part of LEMON, a generic C++ optimization library.
  *
- * Copyright (C) 2003-2009
+ * Copyright (C) 2003-2008
  * Egervary Jeno Kombinatorikus Optimalizalasi Kutatocsoport
  * (Egervary Research Group on Combinatorial Optimization, EGRES).
@@ -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: mon/cplex.cc
===================================================================
--- lemon/cplex.cc	(revision 956)
+++ 	(revision )
@@ -1,984 +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 <vector>
-#include <cstring>
-
-#include <lemon/cplex.h>
-
-extern "C" {
-#include <ilcplex/cplex.h>
-}
-
-
-///\file
-///\brief Implementation of the LEMON-CPLEX lp solver interface.
-namespace lemon {
-
-  CplexEnv::LicenseError::LicenseError(int status) {
-    if (!CPXgeterrorstring(0, status, _message)) {
-      std::strcpy(_message, "Cplex unknown error");
-    }
-  }
-
-  CplexEnv::CplexEnv() {
-    int status;
-    _cnt = new int;
-    _env = CPXopenCPLEX(&status);
-    if (_env == 0) {
-      delete _cnt;
-      _cnt = 0;
-      throw LicenseError(status);
-    }
-  }
-
-  CplexEnv::CplexEnv(const CplexEnv& other) {
-    _env = other._env;
-    _cnt = other._cnt;
-    ++(*_cnt);
-  }
-
-  CplexEnv& CplexEnv::operator=(const CplexEnv& other) {
-    _env = other._env;
-    _cnt = other._cnt;
-    ++(*_cnt);
-    return *this;
-  }
-
-  CplexEnv::~CplexEnv() {
-    --(*_cnt);
-    if (*_cnt == 0) {
-      delete _cnt;
-      CPXcloseCPLEX(&_env);
-    }
-  }
-
-  CplexBase::CplexBase() : LpBase() {
-    int status;
-    _prob = CPXcreateprob(cplexEnv(), &status, "Cplex problem");
-    messageLevel(MESSAGE_NOTHING);
-  }
-
-  CplexBase::CplexBase(const CplexEnv& env)
-    : LpBase(), _env(env) {
-    int status;
-    _prob = CPXcreateprob(cplexEnv(), &status, "Cplex problem");
-    messageLevel(MESSAGE_NOTHING);
-  }
-
-  CplexBase::CplexBase(const CplexBase& cplex)
-    : LpBase() {
-    int status;
-    _prob = CPXcloneprob(cplexEnv(), cplex._prob, &status);
-    rows = cplex.rows;
-    cols = cplex.cols;
-    messageLevel(MESSAGE_NOTHING);
-  }
-
-  CplexBase::~CplexBase() {
-    CPXfreeprob(cplexEnv(),&_prob);
-  }
-
-  int CplexBase::_addCol() {
-    int i = CPXgetnumcols(cplexEnv(), _prob);
-    double lb = -INF, ub = INF;
-    CPXnewcols(cplexEnv(), _prob, 1, 0, &lb, &ub, 0, 0);
-    return i;
-  }
-
-
-  int CplexBase::_addRow() {
-    int i = CPXgetnumrows(cplexEnv(), _prob);
-    const double ub = INF;
-    const char s = 'L';
-    CPXnewrows(cplexEnv(), _prob, 1, &ub, &s, 0, 0);
-    return i;
-  }
-
-  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) {
-    CPXdelcols(cplexEnv(), _prob, i, i);
-  }
-
-  void CplexBase::_eraseRow(int i) {
-    CPXdelrows(cplexEnv(), _prob, i, i);
-  }
-
-  void CplexBase::_eraseColId(int i) {
-    cols.eraseIndex(i);
-    cols.shiftIndices(i);
-  }
-  void CplexBase::_eraseRowId(int i) {
-    rows.eraseIndex(i);
-    rows.shiftIndices(i);
-  }
-
-  void CplexBase::_getColName(int col, std::string &name) const {
-    int size;
-    CPXgetcolname(cplexEnv(), _prob, 0, 0, 0, &size, col, col);
-    if (size == 0) {
-      name.clear();
-      return;
-    }
-
-    size *= -1;
-    std::vector<char> buf(size);
-    char *cname;
-    int tmp;
-    CPXgetcolname(cplexEnv(), _prob, &cname, &buf.front(), size,
-                  &tmp, col, col);
-    name = cname;
-  }
-
-  void CplexBase::_setColName(int col, const std::string &name) {
-    char *cname;
-    cname = const_cast<char*>(name.c_str());
-    CPXchgcolname(cplexEnv(), _prob, 1, &col, &cname);
-  }
-
-  int CplexBase::_colByName(const std::string& name) const {
-    int index;
-    if (CPXgetcolindex(cplexEnv(), _prob,
-                       const_cast<char*>(name.c_str()), &index) == 0) {
-      return index;
-    }
-    return -1;
-  }
-
-  void CplexBase::_getRowName(int row, std::string &name) const {
-    int size;
-    CPXgetrowname(cplexEnv(), _prob, 0, 0, 0, &size, row, row);
-    if (size == 0) {
-      name.clear();
-      return;
-    }
-
-    size *= -1;
-    std::vector<char> buf(size);
-    char *cname;
-    int tmp;
-    CPXgetrowname(cplexEnv(), _prob, &cname, &buf.front(), size,
-                  &tmp, row, row);
-    name = cname;
-  }
-
-  void CplexBase::_setRowName(int row, const std::string &name) {
-    char *cname;
-    cname = const_cast<char*>(name.c_str());
-    CPXchgrowname(cplexEnv(), _prob, 1, &row, &cname);
-  }
-
-  int CplexBase::_rowByName(const std::string& name) const {
-    int index;
-    if (CPXgetrowindex(cplexEnv(), _prob,
-                       const_cast<char*>(name.c_str()), &index) == 0) {
-      return index;
-    }
-    return -1;
-  }
-
-  void CplexBase::_setRowCoeffs(int i, ExprIterator b,
-                                      ExprIterator e)
-  {
-    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());
-  }
-
-  void CplexBase::_getRowCoeffs(int i, InsertIterator b) const {
-    int tmp1, tmp2, tmp3, length;
-    CPXgetrows(cplexEnv(), _prob, &tmp1, &tmp2, 0, 0, 0, &length, i, i);
-
-    length = -length;
-    std::vector<int> indices(length);
-    std::vector<double> values(length);
-
-    CPXgetrows(cplexEnv(), _prob, &tmp1, &tmp2,
-               &indices.front(), &values.front(),
-               length, &tmp3, i, i);
-
-    for (int i = 0; i < length; ++i) {
-      *b = std::make_pair(indices[i], values[i]);
-      ++b;
-    }
-  }
-
-  void CplexBase::_setColCoeffs(int i, ExprIterator b, ExprIterator e) {
-    std::vector<int> indices;
-    std::vector<int> collist;
-    std::vector<Value> values;
-
-    for(ExprIterator it=b; it!=e; ++it) {
-      indices.push_back(it->first);
-      values.push_back(it->second);
-      collist.push_back(i);
-    }
-
-    CPXchgcoeflist(cplexEnv(), _prob, values.size(),
-                   &indices.front(), &collist.front(), &values.front());
-  }
-
-  void CplexBase::_getColCoeffs(int i, InsertIterator b) const {
-
-    int tmp1, tmp2, tmp3, length;
-    CPXgetcols(cplexEnv(), _prob, &tmp1, &tmp2, 0, 0, 0, &length, i, i);
-
-    length = -length;
-    std::vector<int> indices(length);
-    std::vector<double> values(length);
-
-    CPXgetcols(cplexEnv(), _prob, &tmp1, &tmp2,
-               &indices.front(), &values.front(),
-               length, &tmp3, i, i);
-
-    for (int i = 0; i < length; ++i) {
-      *b = std::make_pair(indices[i], values[i]);
-      ++b;
-    }
-
-  }
-
-  void CplexBase::_setCoeff(int row, int col, Value value) {
-    CPXchgcoef(cplexEnv(), _prob, row, col, value);
-  }
-
-  CplexBase::Value CplexBase::_getCoeff(int row, int col) const {
-    CplexBase::Value value;
-    CPXgetcoef(cplexEnv(), _prob, row, col, &value);
-    return value;
-  }
-
-  void CplexBase::_setColLowerBound(int i, Value value) {
-    const char s = 'L';
-    CPXchgbds(cplexEnv(), _prob, 1, &i, &s, &value);
-  }
-
-  CplexBase::Value CplexBase::_getColLowerBound(int i) const {
-    CplexBase::Value res;
-    CPXgetlb(cplexEnv(), _prob, &res, i, i);
-    return res <= -CPX_INFBOUND ? -INF : res;
-  }
-
-  void CplexBase::_setColUpperBound(int i, Value value)
-  {
-    const char s = 'U';
-    CPXchgbds(cplexEnv(), _prob, 1, &i, &s, &value);
-  }
-
-  CplexBase::Value CplexBase::_getColUpperBound(int i) const {
-    CplexBase::Value res;
-    CPXgetub(cplexEnv(), _prob, &res, i, i);
-    return res >= CPX_INFBOUND ? INF : res;
-  }
-
-  CplexBase::Value CplexBase::_getRowLowerBound(int i) const {
-    char s;
-    CPXgetsense(cplexEnv(), _prob, &s, i, i);
-    CplexBase::Value res;
-
-    switch (s) {
-    case 'G':
-    case 'R':
-    case 'E':
-      CPXgetrhs(cplexEnv(), _prob, &res, i, i);
-      return res <= -CPX_INFBOUND ? -INF : res;
-    default:
-      return -INF;
-    }
-  }
-
-  CplexBase::Value CplexBase::_getRowUpperBound(int i) const {
-    char s;
-    CPXgetsense(cplexEnv(), _prob, &s, i, i);
-    CplexBase::Value res;
-
-    switch (s) {
-    case 'L':
-    case 'E':
-      CPXgetrhs(cplexEnv(), _prob, &res, i, i);
-      return res >= CPX_INFBOUND ? INF : res;
-    case 'R':
-      CPXgetrhs(cplexEnv(), _prob, &res, i, i);
-      {
-        double rng;
-        CPXgetrngval(cplexEnv(), _prob, &rng, i, i);
-        res += rng;
-      }
-      return res >= CPX_INFBOUND ? INF : res;
-    default:
-      return INF;
-    }
-  }
-
-  //This is easier to implement
-  void CplexBase::_set_row_bounds(int i, Value lb, Value ub) {
-    if (lb == -INF) {
-      const char s = 'L';
-      CPXchgsense(cplexEnv(), _prob, 1, &i, &s);
-      CPXchgrhs(cplexEnv(), _prob, 1, &i, &ub);
-    } else if (ub == INF) {
-      const char s = 'G';
-      CPXchgsense(cplexEnv(), _prob, 1, &i, &s);
-      CPXchgrhs(cplexEnv(), _prob, 1, &i, &lb);
-    } else if (lb == ub){
-      const char s = 'E';
-      CPXchgsense(cplexEnv(), _prob, 1, &i, &s);
-      CPXchgrhs(cplexEnv(), _prob, 1, &i, &lb);
-    } else {
-      const char s = 'R';
-      CPXchgsense(cplexEnv(), _prob, 1, &i, &s);
-      CPXchgrhs(cplexEnv(), _prob, 1, &i, &lb);
-      double len = ub - lb;
-      CPXchgrngval(cplexEnv(), _prob, 1, &i, &len);
-    }
-  }
-
-  void CplexBase::_setRowLowerBound(int i, Value lb)
-  {
-    LEMON_ASSERT(lb != INF, "Invalid bound");
-    _set_row_bounds(i, lb, CplexBase::_getRowUpperBound(i));
-  }
-
-  void CplexBase::_setRowUpperBound(int i, Value ub)
-  {
-
-    LEMON_ASSERT(ub != -INF, "Invalid bound");
-    _set_row_bounds(i, CplexBase::_getRowLowerBound(i), ub);
-  }
-
-  void CplexBase::_setObjCoeffs(ExprIterator b, ExprIterator e)
-  {
-    std::vector<int> indices;
-    std::vector<Value> values;
-    for(ExprIterator it=b; it!=e; ++it) {
-      indices.push_back(it->first);
-      values.push_back(it->second);
-    }
-    CPXchgobj(cplexEnv(), _prob, values.size(),
-              &indices.front(), &values.front());
-
-  }
-
-  void CplexBase::_getObjCoeffs(InsertIterator b) const
-  {
-    int num = CPXgetnumcols(cplexEnv(), _prob);
-    std::vector<Value> x(num);
-
-    CPXgetobj(cplexEnv(), _prob, &x.front(), 0, num - 1);
-    for (int i = 0; i < num; ++i) {
-      if (x[i] != 0.0) {
-        *b = std::make_pair(i, x[i]);
-        ++b;
-      }
-    }
-  }
-
-  void CplexBase::_setObjCoeff(int i, Value obj_coef)
-  {
-    CPXchgobj(cplexEnv(), _prob, 1, &i, &obj_coef);
-  }
-
-  CplexBase::Value CplexBase::_getObjCoeff(int i) const
-  {
-    Value x;
-    CPXgetobj(cplexEnv(), _prob, &x, i, i);
-    return x;
-  }
-
-  void CplexBase::_setSense(CplexBase::Sense sense) {
-    switch (sense) {
-    case MIN:
-      CPXchgobjsen(cplexEnv(), _prob, CPX_MIN);
-      break;
-    case MAX:
-      CPXchgobjsen(cplexEnv(), _prob, CPX_MAX);
-      break;
-    }
-  }
-
-  CplexBase::Sense CplexBase::_getSense() const {
-    switch (CPXgetobjsen(cplexEnv(), _prob)) {
-    case CPX_MIN:
-      return MIN;
-    case CPX_MAX:
-      return MAX;
-    default:
-      LEMON_ASSERT(false, "Invalid sense");
-      return CplexBase::Sense();
-    }
-  }
-
-  void CplexBase::_clear() {
-    CPXfreeprob(cplexEnv(),&_prob);
-    int status;
-    _prob = CPXcreateprob(cplexEnv(), &status, "Cplex problem");
-    rows.clear();
-    cols.clear();
-  }
-
-  void CplexBase::_messageLevel(MessageLevel level) {
-    switch (level) {
-    case MESSAGE_NOTHING:
-      _message_enabled = false;
-      break;
-    case MESSAGE_ERROR:
-    case MESSAGE_WARNING:
-    case MESSAGE_NORMAL:
-    case MESSAGE_VERBOSE:
-      _message_enabled = true;
-      break;
-    }
-  }
-
-  void CplexBase::_applyMessageLevel() {
-    CPXsetintparam(cplexEnv(), CPX_PARAM_SCRIND,
-                   _message_enabled ? CPX_ON : CPX_OFF);
-  }
-
-  // CplexLp members
-
-  CplexLp::CplexLp()
-    : LpBase(), LpSolver(), CplexBase() {}
-
-  CplexLp::CplexLp(const CplexEnv& env)
-    : LpBase(), LpSolver(), CplexBase(env) {}
-
-  CplexLp::CplexLp(const CplexLp& other)
-    : LpBase(), LpSolver(), CplexBase(other) {}
-
-  CplexLp::~CplexLp() {}
-
-  CplexLp* CplexLp::newSolver() const { return new CplexLp; }
-  CplexLp* CplexLp::cloneSolver() const {return new CplexLp(*this); }
-
-  const char* CplexLp::_solverName() const { return "CplexLp"; }
-
-  void CplexLp::_clear_temporals() {
-    _col_status.clear();
-    _row_status.clear();
-    _primal_ray.clear();
-    _dual_ray.clear();
-  }
-
-  // The routine returns zero unless an error occurred during the
-  // optimization. Examples of errors include exhausting available
-  // memory (CPXERR_NO_MEMORY) or encountering invalid data in the
-  // CPLEX problem object (CPXERR_NO_PROBLEM). Exceeding a
-  // user-specified CPLEX limit, or proving the model infeasible or
-  // unbounded, are not considered errors. Note that a zero return
-  // value does not necessarily mean that a solution exists. Use query
-  // routines CPXsolninfo, CPXgetstat, and CPXsolution to obtain
-  // further information about the status of the optimization.
-  CplexLp::SolveExitStatus CplexLp::convertStatus(int status) {
-#if CPX_VERSION >= 800
-    if (status == 0) {
-      switch (CPXgetstat(cplexEnv(), _prob)) {
-      case CPX_STAT_OPTIMAL:
-      case CPX_STAT_INFEASIBLE:
-      case CPX_STAT_UNBOUNDED:
-        return SOLVED;
-      default:
-        return UNSOLVED;
-      }
-    } else {
-      return UNSOLVED;
-    }
-#else
-    if (status == 0) {
-      //We want to exclude some cases
-      switch (CPXgetstat(cplexEnv(), _prob)) {
-      case CPX_OBJ_LIM:
-      case CPX_IT_LIM_FEAS:
-      case CPX_IT_LIM_INFEAS:
-      case CPX_TIME_LIM_FEAS:
-      case CPX_TIME_LIM_INFEAS:
-        return UNSOLVED;
-      default:
-        return SOLVED;
-      }
-    } else {
-      return UNSOLVED;
-    }
-#endif
-  }
-
-  CplexLp::SolveExitStatus CplexLp::_solve() {
-    _clear_temporals();
-    _applyMessageLevel();
-    return convertStatus(CPXlpopt(cplexEnv(), _prob));
-  }
-
-  CplexLp::SolveExitStatus CplexLp::solvePrimal() {
-    _clear_temporals();
-    _applyMessageLevel();
-    return convertStatus(CPXprimopt(cplexEnv(), _prob));
-  }
-
-  CplexLp::SolveExitStatus CplexLp::solveDual() {
-    _clear_temporals();
-    _applyMessageLevel();
-    return convertStatus(CPXdualopt(cplexEnv(), _prob));
-  }
-
-  CplexLp::SolveExitStatus CplexLp::solveBarrier() {
-    _clear_temporals();
-    _applyMessageLevel();
-    return convertStatus(CPXbaropt(cplexEnv(), _prob));
-  }
-
-  CplexLp::Value CplexLp::_getPrimal(int i) const {
-    Value x;
-    CPXgetx(cplexEnv(), _prob, &x, i, i);
-    return x;
-  }
-
-  CplexLp::Value CplexLp::_getDual(int i) const {
-    Value y;
-    CPXgetpi(cplexEnv(), _prob, &y, i, i);
-    return y;
-  }
-
-  CplexLp::Value CplexLp::_getPrimalValue() const {
-    Value objval;
-    CPXgetobjval(cplexEnv(), _prob, &objval);
-    return objval;
-  }
-
-  CplexLp::VarStatus CplexLp::_getColStatus(int i) const {
-    if (_col_status.empty()) {
-      _col_status.resize(CPXgetnumcols(cplexEnv(), _prob));
-      CPXgetbase(cplexEnv(), _prob, &_col_status.front(), 0);
-    }
-    switch (_col_status[i]) {
-    case CPX_BASIC:
-      return BASIC;
-    case CPX_FREE_SUPER:
-      return FREE;
-    case CPX_AT_LOWER:
-      return LOWER;
-    case CPX_AT_UPPER:
-      return UPPER;
-    default:
-      LEMON_ASSERT(false, "Wrong column status");
-      return CplexLp::VarStatus();
-    }
-  }
-
-  CplexLp::VarStatus CplexLp::_getRowStatus(int i) const {
-    if (_row_status.empty()) {
-      _row_status.resize(CPXgetnumrows(cplexEnv(), _prob));
-      CPXgetbase(cplexEnv(), _prob, 0, &_row_status.front());
-    }
-    switch (_row_status[i]) {
-    case CPX_BASIC:
-      return BASIC;
-    case CPX_AT_LOWER:
-      {
-        char s;
-        CPXgetsense(cplexEnv(), _prob, &s, i, i);
-        return s != 'L' ? LOWER : UPPER;
-      }
-    case CPX_AT_UPPER:
-      return UPPER;
-    default:
-      LEMON_ASSERT(false, "Wrong row status");
-      return CplexLp::VarStatus();
-    }
-  }
-
-  CplexLp::Value CplexLp::_getPrimalRay(int i) const {
-    if (_primal_ray.empty()) {
-      _primal_ray.resize(CPXgetnumcols(cplexEnv(), _prob));
-      CPXgetray(cplexEnv(), _prob, &_primal_ray.front());
-    }
-    return _primal_ray[i];
-  }
-
-  CplexLp::Value CplexLp::_getDualRay(int i) const {
-    if (_dual_ray.empty()) {
-
-    }
-    return _dual_ray[i];
-  }
-
-  // Cplex 7.0 status values
-  // This table lists the statuses, returned by the CPXgetstat()
-  // routine, for solutions to LP problems or mixed integer problems. If
-  // no solution exists, the return value is zero.
-
-  // For Simplex, Barrier
-  // 1          CPX_OPTIMAL
-  //          Optimal solution found
-  // 2          CPX_INFEASIBLE
-  //          Problem infeasible
-  // 3    CPX_UNBOUNDED
-  //          Problem unbounded
-  // 4          CPX_OBJ_LIM
-  //          Objective limit exceeded in Phase II
-  // 5          CPX_IT_LIM_FEAS
-  //          Iteration limit exceeded in Phase II
-  // 6          CPX_IT_LIM_INFEAS
-  //          Iteration limit exceeded in Phase I
-  // 7          CPX_TIME_LIM_FEAS
-  //          Time limit exceeded in Phase II
-  // 8          CPX_TIME_LIM_INFEAS
-  //          Time limit exceeded in Phase I
-  // 9          CPX_NUM_BEST_FEAS
-  //          Problem non-optimal, singularities in Phase II
-  // 10         CPX_NUM_BEST_INFEAS
-  //          Problem non-optimal, singularities in Phase I
-  // 11         CPX_OPTIMAL_INFEAS
-  //          Optimal solution found, unscaled infeasibilities
-  // 12         CPX_ABORT_FEAS
-  //          Aborted in Phase II
-  // 13         CPX_ABORT_INFEAS
-  //          Aborted in Phase I
-  // 14          CPX_ABORT_DUAL_INFEAS
-  //          Aborted in barrier, dual infeasible
-  // 15          CPX_ABORT_PRIM_INFEAS
-  //          Aborted in barrier, primal infeasible
-  // 16          CPX_ABORT_PRIM_DUAL_INFEAS
-  //          Aborted in barrier, primal and dual infeasible
-  // 17          CPX_ABORT_PRIM_DUAL_FEAS
-  //          Aborted in barrier, primal and dual feasible
-  // 18          CPX_ABORT_CROSSOVER
-  //          Aborted in crossover
-  // 19          CPX_INForUNBD
-  //          Infeasible or unbounded
-  // 20   CPX_PIVOT
-  //       User pivot used
-  //
-  // Pending return values
-  // ??case CPX_ABORT_DUAL_INFEAS
-  // ??case CPX_ABORT_CROSSOVER
-  // ??case CPX_INForUNBD
-  // ??case CPX_PIVOT
-
-  //Some more interesting stuff:
-
-  // CPX_PARAM_PROBMETHOD  1062  int  LPMETHOD
-  // 0 Automatic
-  // 1 Primal Simplex
-  // 2 Dual Simplex
-  // 3 Network Simplex
-  // 4 Standard Barrier
-  // Default: 0
-  // Description: Method for linear optimization.
-  // Determines which algorithm is used when CPXlpopt() (or "optimize"
-  // in the Interactive Optimizer) is called. Currently the behavior of
-  // the "Automatic" setting is that CPLEX simply invokes the dual
-  // simplex method, but this capability may be expanded in the future
-  // so that CPLEX chooses the method based on problem characteristics
-#if CPX_VERSION < 900
-  void statusSwitch(CPXENVptr cplexEnv(),int& stat){
-    int lpmethod;
-    CPXgetintparam (cplexEnv(),CPX_PARAM_PROBMETHOD,&lpmethod);
-    if (lpmethod==2){
-      if (stat==CPX_UNBOUNDED){
-        stat=CPX_INFEASIBLE;
-      }
-      else{
-        if (stat==CPX_INFEASIBLE)
-          stat=CPX_UNBOUNDED;
-      }
-    }
-  }
-#else
-  void statusSwitch(CPXENVptr,int&){}
-#endif
-
-  CplexLp::ProblemType CplexLp::_getPrimalType() const {
-    // Unboundedness not treated well: the following is from cplex 9.0 doc
-    // About Unboundedness
-
-    // The treatment of models that are unbounded involves a few
-    // subtleties. Specifically, a declaration of unboundedness means that
-    // ILOG CPLEX has determined that the model has an unbounded
-    // ray. Given any feasible solution x with objective z, a multiple of
-    // the unbounded ray can be added to x to give a feasible solution
-    // with objective z-1 (or z+1 for maximization models). Thus, if a
-    // feasible solution exists, then the optimal objective is
-    // unbounded. Note that ILOG CPLEX has not necessarily concluded that
-    // a feasible solution exists. Users can call the routine CPXsolninfo
-    // to determine whether ILOG CPLEX has also concluded that the model
-    // has a feasible solution.
-
-    int stat = CPXgetstat(cplexEnv(), _prob);
-#if CPX_VERSION >= 800
-    switch (stat)
-      {
-      case CPX_STAT_OPTIMAL:
-        return OPTIMAL;
-      case CPX_STAT_UNBOUNDED:
-        return UNBOUNDED;
-      case CPX_STAT_INFEASIBLE:
-        return INFEASIBLE;
-      default:
-        return UNDEFINED;
-      }
-#else
-    statusSwitch(cplexEnv(),stat);
-    //CPXgetstat(cplexEnv(), _prob);
-    switch (stat) {
-    case 0:
-      return UNDEFINED; //Undefined
-    case CPX_OPTIMAL://Optimal
-      return OPTIMAL;
-    case CPX_UNBOUNDED://Unbounded
-      return INFEASIBLE;//In case of dual simplex
-      //return UNBOUNDED;
-    case CPX_INFEASIBLE://Infeasible
-      //    case CPX_IT_LIM_INFEAS:
-      //     case CPX_TIME_LIM_INFEAS:
-      //     case CPX_NUM_BEST_INFEAS:
-      //     case CPX_OPTIMAL_INFEAS:
-      //     case CPX_ABORT_INFEAS:
-      //     case CPX_ABORT_PRIM_INFEAS:
-      //     case CPX_ABORT_PRIM_DUAL_INFEAS:
-      return UNBOUNDED;//In case of dual simplex
-      //return INFEASIBLE;
-      //     case CPX_OBJ_LIM:
-      //     case CPX_IT_LIM_FEAS:
-      //     case CPX_TIME_LIM_FEAS:
-      //     case CPX_NUM_BEST_FEAS:
-      //     case CPX_ABORT_FEAS:
-      //     case CPX_ABORT_PRIM_DUAL_FEAS:
-      //       return FEASIBLE;
-    default:
-      return UNDEFINED; //Everything else comes here
-      //FIXME error
-    }
-#endif
-  }
-
-  // Cplex 9.0 status values
-  // CPX_STAT_ABORT_DUAL_OBJ_LIM
-  // CPX_STAT_ABORT_IT_LIM
-  // CPX_STAT_ABORT_OBJ_LIM
-  // CPX_STAT_ABORT_PRIM_OBJ_LIM
-  // CPX_STAT_ABORT_TIME_LIM
-  // CPX_STAT_ABORT_USER
-  // CPX_STAT_FEASIBLE_RELAXED
-  // CPX_STAT_INFEASIBLE
-  // CPX_STAT_INForUNBD
-  // CPX_STAT_NUM_BEST
-  // CPX_STAT_OPTIMAL
-  // CPX_STAT_OPTIMAL_FACE_UNBOUNDED
-  // CPX_STAT_OPTIMAL_INFEAS
-  // CPX_STAT_OPTIMAL_RELAXED
-  // CPX_STAT_UNBOUNDED
-
-  CplexLp::ProblemType CplexLp::_getDualType() const {
-    int stat = CPXgetstat(cplexEnv(), _prob);
-#if CPX_VERSION >= 800
-    switch (stat) {
-    case CPX_STAT_OPTIMAL:
-      return OPTIMAL;
-    case CPX_STAT_UNBOUNDED:
-      return INFEASIBLE;
-    default:
-      return UNDEFINED;
-    }
-#else
-    statusSwitch(cplexEnv(),stat);
-    switch (stat) {
-    case 0:
-      return UNDEFINED; //Undefined
-    case CPX_OPTIMAL://Optimal
-      return OPTIMAL;
-    case CPX_UNBOUNDED:
-      return INFEASIBLE;
-    default:
-      return UNDEFINED; //Everything else comes here
-      //FIXME error
-    }
-#endif
-  }
-
-  // CplexMip members
-
-  CplexMip::CplexMip()
-    : LpBase(), MipSolver(), CplexBase() {
-
-#if CPX_VERSION < 800
-    CPXchgprobtype(cplexEnv(),  _prob, CPXPROB_MIP);
-#else
-    CPXchgprobtype(cplexEnv(),  _prob, CPXPROB_MILP);
-#endif
-  }
-
-  CplexMip::CplexMip(const CplexEnv& env)
-    : LpBase(), MipSolver(), CplexBase(env) {
-
-#if CPX_VERSION < 800
-    CPXchgprobtype(cplexEnv(),  _prob, CPXPROB_MIP);
-#else
-    CPXchgprobtype(cplexEnv(),  _prob, CPXPROB_MILP);
-#endif
-
-  }
-
-  CplexMip::CplexMip(const CplexMip& other)
-    : LpBase(), MipSolver(), CplexBase(other) {}
-
-  CplexMip::~CplexMip() {}
-
-  CplexMip* CplexMip::newSolver() const { return new CplexMip; }
-  CplexMip* CplexMip::cloneSolver() const {return new CplexMip(*this); }
-
-  const char* CplexMip::_solverName() const { return "CplexMip"; }
-
-  void CplexMip::_setColType(int i, CplexMip::ColTypes col_type) {
-
-    // Note If a variable is to be changed to binary, a call to CPXchgbds
-    // should also be made to change the bounds to 0 and 1.
-
-    switch (col_type){
-    case INTEGER: {
-      const char t = 'I';
-      CPXchgctype (cplexEnv(), _prob, 1, &i, &t);
-    } break;
-    case REAL: {
-      const char t = 'C';
-      CPXchgctype (cplexEnv(), _prob, 1, &i, &t);
-    } break;
-    default:
-      break;
-    }
-  }
-
-  CplexMip::ColTypes CplexMip::_getColType(int i) const {
-    char t;
-    CPXgetctype (cplexEnv(), _prob, &t, i, i);
-    switch (t) {
-    case 'I':
-      return INTEGER;
-    case 'C':
-      return REAL;
-    default:
-      LEMON_ASSERT(false, "Invalid column type");
-      return ColTypes();
-    }
-
-  }
-
-  CplexMip::SolveExitStatus CplexMip::_solve() {
-    int status;
-    _applyMessageLevel();
-    status = CPXmipopt (cplexEnv(), _prob);
-    if (status==0)
-      return SOLVED;
-    else
-      return UNSOLVED;
-
-  }
-
-
-  CplexMip::ProblemType CplexMip::_getType() const {
-
-    int stat = CPXgetstat(cplexEnv(), _prob);
-
-    //Fortunately, MIP statuses did not change for cplex 8.0
-    switch (stat) {
-    case CPXMIP_OPTIMAL:
-      // Optimal integer solution has been found.
-    case CPXMIP_OPTIMAL_TOL:
-      // Optimal soluton with the tolerance defined by epgap or epagap has
-      // been found.
-      return OPTIMAL;
-      //This also exists in later issues
-      //    case CPXMIP_UNBOUNDED:
-      //return UNBOUNDED;
-      case CPXMIP_INFEASIBLE:
-        return INFEASIBLE;
-    default:
-      return UNDEFINED;
-    }
-    //Unboundedness not treated well: the following is from cplex 9.0 doc
-    // About Unboundedness
-
-    // The treatment of models that are unbounded involves a few
-    // subtleties. Specifically, a declaration of unboundedness means that
-    // ILOG CPLEX has determined that the model has an unbounded
-    // ray. Given any feasible solution x with objective z, a multiple of
-    // the unbounded ray can be added to x to give a feasible solution
-    // with objective z-1 (or z+1 for maximization models). Thus, if a
-    // feasible solution exists, then the optimal objective is
-    // unbounded. Note that ILOG CPLEX has not necessarily concluded that
-    // a feasible solution exists. Users can call the routine CPXsolninfo
-    // to determine whether ILOG CPLEX has also concluded that the model
-    // has a feasible solution.
-  }
-
-  CplexMip::Value CplexMip::_getSol(int i) const {
-    Value x;
-    CPXgetmipx(cplexEnv(), _prob, &x, i, i);
-    return x;
-  }
-
-  CplexMip::Value CplexMip::_getSolValue() const {
-    Value objval;
-    CPXgetmipobjval(cplexEnv(), _prob, &objval);
-    return objval;
-  }
-
-} //namespace lemon
-
Index: mon/cplex.h
===================================================================
--- lemon/cplex.h	(revision 793)
+++ 	(revision )
@@ -1,277 +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_CPLEX_H
-#define LEMON_CPLEX_H
-
-///\file
-///\brief Header of the LEMON-CPLEX lp solver interface.
-
-#include <lemon/lp_base.h>
-
-struct cpxenv;
-struct cpxlp;
-
-namespace lemon {
-
-  /// \brief Reference counted wrapper around cpxenv pointer
-  ///
-  /// The cplex uses environment object which is responsible for
-  /// checking the proper license usage. This class provides a simple
-  /// interface for share the environment object between different
-  /// problems.
-  class CplexEnv {
-    friend class CplexBase;
-  private:
-    cpxenv* _env;
-    mutable int* _cnt;
-
-  public:
-
-    /// \brief This exception is thrown when the license check is not
-    /// sufficient
-    class LicenseError : public Exception {
-      friend class CplexEnv;
-    private:
-
-      LicenseError(int status);
-      char _message[510];
-
-    public:
-
-      /// The short error message
-      virtual const char* what() const throw() {
-        return _message;
-      }
-    };
-
-    /// Constructor
-    CplexEnv();
-    /// Shallow copy constructor
-    CplexEnv(const CplexEnv&);
-    /// Shallow assignement
-    CplexEnv& operator=(const CplexEnv&);
-    /// Destructor
-    virtual ~CplexEnv();
-
-  protected:
-
-    cpxenv* cplexEnv() { return _env; }
-    const cpxenv* cplexEnv() const { return _env; }
-  };
-
-  /// \brief Base interface for the CPLEX LP and MIP solver
-  ///
-  /// This class implements the common interface of the CPLEX LP and
-  /// MIP solvers.
-  /// \ingroup lp_group
-  class CplexBase : virtual public LpBase {
-  protected:
-
-    CplexEnv _env;
-    cpxlp* _prob;
-
-    CplexBase();
-    CplexBase(const CplexEnv&);
-    CplexBase(const CplexBase &);
-    virtual ~CplexBase();
-
-    virtual int _addCol();
-    virtual int _addRow();
-    virtual int _addRow(Value l, ExprIterator b, ExprIterator e, Value u);
-
-    virtual void _eraseCol(int i);
-    virtual void _eraseRow(int i);
-
-    virtual void _eraseColId(int i);
-    virtual void _eraseRowId(int i);
-
-    virtual void _getColName(int col, std::string& name) const;
-    virtual void _setColName(int col, const std::string& name);
-    virtual int _colByName(const std::string& name) const;
-
-    virtual void _getRowName(int row, std::string& name) const;
-    virtual void _setRowName(int row, const std::string& name);
-    virtual int _rowByName(const std::string& name) const;
-
-    virtual void _setRowCoeffs(int i, ExprIterator b, ExprIterator e);
-    virtual void _getRowCoeffs(int i, InsertIterator b) const;
-
-    virtual void _setColCoeffs(int i, ExprIterator b, ExprIterator e);
-    virtual void _getColCoeffs(int i, InsertIterator b) const;
-
-    virtual void _setCoeff(int row, int col, Value value);
-    virtual Value _getCoeff(int row, int col) const;
-
-    virtual void _setColLowerBound(int i, Value value);
-    virtual Value _getColLowerBound(int i) const;
-
-    virtual void _setColUpperBound(int i, Value value);
-    virtual Value _getColUpperBound(int i) const;
-
-  private:
-    void _set_row_bounds(int i, Value lb, Value ub);
-  protected:
-
-    virtual void _setRowLowerBound(int i, Value value);
-    virtual Value _getRowLowerBound(int i) const;
-
-    virtual void _setRowUpperBound(int i, Value value);
-    virtual Value _getRowUpperBound(int i) const;
-
-    virtual void _setObjCoeffs(ExprIterator b, ExprIterator e);
-    virtual void _getObjCoeffs(InsertIterator b) const;
-
-    virtual void _setObjCoeff(int i, Value obj_coef);
-    virtual Value _getObjCoeff(int i) const;
-
-    virtual void _setSense(Sense sense);
-    virtual Sense _getSense() const;
-
-    virtual void _clear();
-
-    virtual void _messageLevel(MessageLevel level);
-    void _applyMessageLevel();
-
-    bool _message_enabled;
-
-  public:
-
-    /// Returns the used \c CplexEnv instance
-    const CplexEnv& env() const { return _env; }
-
-    /// \brief Returns the const cpxenv pointer
-    ///
-    /// \note The cpxenv might be destructed with the solver.
-    const cpxenv* cplexEnv() const { return _env.cplexEnv(); }
-
-    /// \brief Returns the const cpxenv pointer
-    ///
-    /// \note The cpxenv might be destructed with the solver.
-    cpxenv* cplexEnv() { return _env.cplexEnv(); }
-
-    /// Returns the cplex problem object
-    cpxlp* cplexLp() { return _prob; }
-    /// Returns the cplex problem object
-    const cpxlp* cplexLp() const { return _prob; }
-
-  };
-
-  /// \brief Interface for the CPLEX LP solver
-  ///
-  /// This class implements an interface for the CPLEX LP solver.
-  ///\ingroup lp_group
-  class CplexLp : public LpSolver, public CplexBase {
-  public:
-    /// \e
-    CplexLp();
-    /// \e
-    CplexLp(const CplexEnv&);
-    /// \e
-    CplexLp(const CplexLp&);
-    /// \e
-    virtual ~CplexLp();
-
-    /// \e
-    virtual CplexLp* cloneSolver() const;
-    /// \e
-    virtual CplexLp* newSolver() const;
-
-  private:
-
-    // these values cannot retrieved element by element
-    mutable std::vector<int> _col_status;
-    mutable std::vector<int> _row_status;
-
-    mutable std::vector<Value> _primal_ray;
-    mutable std::vector<Value> _dual_ray;
-
-    void _clear_temporals();
-
-    SolveExitStatus convertStatus(int status);
-
-  protected:
-
-    virtual const char* _solverName() const;
-
-    virtual SolveExitStatus _solve();
-    virtual Value _getPrimal(int i) const;
-    virtual Value _getDual(int i) const;
-    virtual Value _getPrimalValue() const;
-
-    virtual VarStatus _getColStatus(int i) const;
-    virtual VarStatus _getRowStatus(int i) const;
-
-    virtual Value _getPrimalRay(int i) const;
-    virtual Value _getDualRay(int i) const;
-
-    virtual ProblemType _getPrimalType() const;
-    virtual ProblemType _getDualType() const;
-
-  public:
-
-    /// Solve with primal simplex method
-    SolveExitStatus solvePrimal();
-
-    /// Solve with dual simplex method
-    SolveExitStatus solveDual();
-
-    /// Solve with barrier method
-    SolveExitStatus solveBarrier();
-
-  };
-
-  /// \brief Interface for the CPLEX MIP solver
-  ///
-  /// This class implements an interface for the CPLEX MIP solver.
-  ///\ingroup lp_group
-  class CplexMip : public MipSolver, public CplexBase {
-  public:
-    /// \e
-    CplexMip();
-    /// \e
-    CplexMip(const CplexEnv&);
-    /// \e
-    CplexMip(const CplexMip&);
-    /// \e
-    virtual ~CplexMip();
-
-    /// \e
-    virtual CplexMip* cloneSolver() const;
-    /// \e
-    virtual CplexMip* newSolver() const;
-
-  protected:
-
-
-    virtual const char* _solverName() const;
-
-    virtual ColTypes _getColType(int col) const;
-    virtual void _setColType(int col, ColTypes col_type);
-
-    virtual SolveExitStatus _solve();
-    virtual ProblemType _getType() const;
-    virtual Value _getSol(int i) const;
-    virtual Value _getSolValue() const;
-
-  };
-
-} //END OF NAMESPACE LEMON
-
-#endif //LEMON_CPLEX_H
-
Index: mon/cycle_canceling.h
===================================================================
--- lemon/cycle_canceling.h	(revision 956)
+++ 	(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 number types must be signed and all input data must
-  /// be integer.
-  /// \warning This algorithm does not support negative costs for such
-  /// arcs that have 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 proved 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 {
-      /// 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 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.
-    ///
-    /// \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 956)
+++ lemon/dfs.h	(revision 1007)
@@ -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).
@@ -48,11 +48,11 @@
     ///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.
-
-    ///This function instantiates a \ref PredMap.
+    ///Instantiates a PredMap.
+
+    ///This function instantiates a PredMap.
     ///\param g is the digraph, to which we would like to define the
-    ///\ref PredMap.
+    ///PredMap.
     static PredMap *createPredMap(const Digraph &g)
     {
@@ -63,12 +63,11 @@
 
     ///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.
-
-    ///This function instantiates a \ref ProcessedMap.
+    ///Instantiates a ProcessedMap.
+
+    ///This function instantiates a ProcessedMap.
     ///\param g is the digraph, to which
-    ///we would like to define the \ref ProcessedMap.
+    ///we would like to define the ProcessedMap
 #ifdef DOXYGEN
     static ProcessedMap *createProcessedMap(const Digraph &g)
@@ -83,12 +82,11 @@
 
     ///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.
-
-    ///This function instantiates a \ref ReachedMap.
+    ///Instantiates a ReachedMap.
+
+    ///This function instantiates a ReachedMap.
     ///\param g is the digraph, to which
-    ///we would like to define the \ref ReachedMap.
+    ///we would like to define the ReachedMap.
     static ReachedMap *createReachedMap(const Digraph &g)
     {
@@ -99,11 +97,11 @@
 
     ///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.
-
-    ///This function instantiates a \ref DistMap.
+    ///Instantiates a DistMap.
+
+    ///This function instantiates a DistMap.
     ///\param g is the digraph, to which we would like to define the
-    ///\ref DistMap.
+    ///DistMap.
     static DistMap *createDistMap(const Digraph &g)
     {
@@ -122,10 +120,11 @@
   ///
   ///\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.
+  ///The default value is \ref ListDigraph. The value of GR is not used
+  ///directly by \ref Dfs, it is only passed to \ref DfsDefaultTraits.
+  ///\tparam TR Traits class to set various data types used by the algorithm.
+  ///The default traits class is
+  ///\ref DfsDefaultTraits "DfsDefaultTraits<GR>".
+  ///See \ref DfsDefaultTraits for the documentation of
+  ///a Dfs traits class.
 #ifdef DOXYGEN
   template <typename GR,
@@ -153,5 +152,5 @@
     typedef PredMapPath<Digraph, PredMap> Path;
 
-    ///The \ref DfsDefaultTraits "traits class" of the algorithm.
+    ///The traits class.
     typedef TR Traits;
 
@@ -214,5 +213,5 @@
     typedef Dfs Create;
 
-    ///\name Named Template Parameters
+    ///\name Named template parameters
 
     ///@{
@@ -228,9 +227,8 @@
     };
     ///\brief \ref named-templ-param "Named parameter" for setting
-    ///\c PredMap type.
+    ///PredMap type.
     ///
     ///\ref named-templ-param "Named parameter" for setting
-    ///\c PredMap type.
-    ///It must conform to the \ref concepts::WriteMap "WriteMap" concept.
+    ///PredMap type.
     template <class T>
     struct SetPredMap : public Dfs<Digraph, SetPredMapTraits<T> > {
@@ -248,9 +246,8 @@
     };
     ///\brief \ref named-templ-param "Named parameter" for setting
-    ///\c DistMap type.
+    ///DistMap type.
     ///
     ///\ref named-templ-param "Named parameter" for setting
-    ///\c DistMap type.
-    ///It must conform to the \ref concepts::WriteMap "WriteMap" concept.
+    ///DistMap type.
     template <class T>
     struct SetDistMap : public Dfs< Digraph, SetDistMapTraits<T> > {
@@ -268,10 +265,8 @@
     };
     ///\brief \ref named-templ-param "Named parameter" for setting
-    ///\c ReachedMap type.
+    ///ReachedMap type.
     ///
     ///\ref named-templ-param "Named parameter" for setting
-    ///\c ReachedMap type.
-    ///It must conform to
-    ///the \ref concepts::ReadWriteMap "ReadWriteMap" concept.
+    ///ReachedMap type.
     template <class T>
     struct SetReachedMap : public Dfs< Digraph, SetReachedMapTraits<T> > {
@@ -289,9 +284,8 @@
     };
     ///\brief \ref named-templ-param "Named parameter" for setting
-    ///\c ProcessedMap type.
+    ///ProcessedMap type.
     ///
     ///\ref named-templ-param "Named parameter" for setting
-    ///\c ProcessedMap type.
-    ///It must conform to the \ref concepts::WriteMap "WriteMap" concept.
+    ///ProcessedMap type.
     template <class T>
     struct SetProcessedMap : public Dfs< Digraph, SetProcessedMapTraits<T> > {
@@ -307,8 +301,8 @@
     };
     ///\brief \ref named-templ-param "Named parameter" for setting
-    ///\c ProcessedMap type to be <tt>Digraph::NodeMap<bool></tt>.
+    ///ProcessedMap type to be <tt>Digraph::NodeMap<bool></tt>.
     ///
     ///\ref named-templ-param "Named parameter" for setting
-    ///\c ProcessedMap type to be <tt>Digraph::NodeMap<bool></tt>.
+    ///ProcessedMap type to be <tt>Digraph::NodeMap<bool></tt>.
     ///If you don't set it explicitly, it will be automatically allocated.
     struct SetStandardProcessedMap :
@@ -345,8 +339,7 @@
 
     ///Sets the map that stores the predecessor arcs.
-    ///If you don't use this function before calling \ref run(Node) "run()"
-    ///or \ref init(), an instance will be allocated automatically.
-    ///The destructor deallocates this automatically allocated map,
-    ///of course.
+    ///If you don't use this function before calling \ref run(),
+    ///it will allocate one. The destructor deallocates this
+    ///automatically allocated map, of course.
     ///\return <tt> (*this) </tt>
     Dfs &predMap(PredMap &m)
@@ -363,8 +356,7 @@
 
     ///Sets the map that indicates which nodes are reached.
-    ///If you don't use this function before calling \ref run(Node) "run()"
-    ///or \ref init(), an instance will be allocated automatically.
-    ///The destructor deallocates this automatically allocated map,
-    ///of course.
+    ///If you don't use this function before calling \ref run(),
+    ///it will allocate one. The destructor deallocates this
+    ///automatically allocated map, of course.
     ///\return <tt> (*this) </tt>
     Dfs &reachedMap(ReachedMap &m)
@@ -381,8 +373,7 @@
 
     ///Sets the map that indicates which nodes are processed.
-    ///If you don't use this function before calling \ref run(Node) "run()"
-    ///or \ref init(), an instance will be allocated automatically.
-    ///The destructor deallocates this automatically allocated map,
-    ///of course.
+    ///If you don't use this function before calling \ref run(),
+    ///it will allocate one. The destructor deallocates this
+    ///automatically allocated map, of course.
     ///\return <tt> (*this) </tt>
     Dfs &processedMap(ProcessedMap &m)
@@ -400,8 +391,7 @@
     ///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(Node) "run()"
-    ///or \ref init(), an instance will be allocated automatically.
-    ///The destructor deallocates this automatically allocated map,
-    ///of course.
+    ///If you don't use this function before calling \ref run(),
+    ///it will allocate one. The destructor deallocates this
+    ///automatically allocated map, of course.
     ///\return <tt> (*this) </tt>
     Dfs &distMap(DistMap &m)
@@ -417,18 +407,20 @@
   public:
 
-    ///\name Execution Control
-    ///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()
-    ///and perform the actual computation with \ref start().
-    ///This procedure can be repeated if there are nodes that have not
-    ///been reached.
+    ///\name Execution control
+    ///The simplest way to execute the algorithm is to use
+    ///one of the member functions called \ref lemon::Dfs::run() "run()".
+    ///\n
+    ///If you need more control on the execution, first you must call
+    ///\ref lemon::Dfs::init() "init()", then you can add a source node
+    ///with \ref lemon::Dfs::addSource() "addSource()".
+    ///Finally \ref lemon::Dfs::start() "start()" will perform the
+    ///actual path computation.
 
     ///@{
 
-    ///\brief Initializes the internal data structures.
-    ///
     ///Initializes the internal data structures.
+
+    ///Initializes the internal data structures.
+    ///
     void init()
     {
@@ -447,8 +439,9 @@
     ///Adds a new source node to the set of nodes to be processed.
     ///
-    ///\pre The stack must be empty. Otherwise the algorithm gives
-    ///wrong results. (One of the outgoing arcs of all the source nodes
-    ///except for the last one will not be visited and distances will
-    ///also be wrong.)
+    ///\pre The stack must be empty. (Otherwise the algorithm gives
+    ///false results.)
+    ///
+    ///\warning Distances will be wrong (or at least strange) in case of
+    ///multiple sources.
     void addSource(Node s)
     {
@@ -514,14 +507,14 @@
     }
 
-    ///Returns \c false if there are nodes to be processed.
-
-    ///Returns \c false if there are nodes to be processed
-    ///in the queue (stack).
+    ///\brief Returns \c false if there are nodes
+    ///to be processed.
+    ///
+    ///Returns \c false if there are nodes
+    ///to be processed in the queue (stack).
     bool emptyQueue() const { return _stack_head<0; }
 
     ///Returns the number of the nodes to be processed.
 
-    ///Returns the number of the nodes to be processed
-    ///in the queue (stack).
+    ///Returns the number of the nodes to be processed in the queue (stack).
     int queueSize() const { return _stack_head+1; }
 
@@ -566,5 +559,5 @@
     void start(Node t)
     {
-      while ( !emptyQueue() && G->target(_stack[_stack_head])!=t )
+      while ( !emptyQueue() && !(*_reached)[t] )
         processNextArc();
     }
@@ -641,6 +634,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,
+    ///- the distance of each node from the root in the %DFS tree.
     ///
     ///\note <tt>d.run()</tt> is just a shortcut of the following code.
@@ -667,58 +664,58 @@
 
     ///\name Query Functions
-    ///The results of the DFS algorithm can be obtained using these
+    ///The result of the %DFS algorithm can be obtained using these
     ///functions.\n
-    ///Either \ref run(Node) "run()" or \ref start() should be called
-    ///before using them.
+    ///Either \ref lemon::Dfs::run() "run()" or \ref lemon::Dfs::start()
+    ///"start()" must be called before using them.
 
     ///@{
 
-    ///The DFS path to the given node.
-
-    ///Returns the DFS path to the given node from the root(s).
-    ///
-    ///\warning \c t should be reached from the root(s).
-    ///
-    ///\pre Either \ref run(Node) "run()" or \ref init()
-    ///must be called before using this function.
+    ///The DFS path to a node.
+
+    ///Returns the DFS path to a node.
+    ///
+    ///\warning \c t should be reachable from the root.
+    ///
+    ///\pre Either \ref run() or \ref start() must be called before
+    ///using this function.
     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).
-    ///
-    ///\warning If node \c v is not reached from the root(s), then
+    ///The distance of a node from the root.
+
+    ///Returns the distance of a node from the root.
+    ///
+    ///\warning If node \c v is not reachable from the root, then
     ///the return value of this function is undefined.
     ///
-    ///\pre Either \ref run(Node) "run()" or \ref init()
-    ///must be called before using this function.
+    ///\pre Either \ref run() or \ref start() must be called before
+    ///using this function.
     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
-    ///node \c v, i.e. it returns the last arc of 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.
+    ///node \c v, i.e. it returns the last arc of a %DFS path from the
+    ///root to \c v. It is \c INVALID
+    ///if \c v is not reachable 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 predNode() and \ref predMap().
-    ///
-    ///\pre Either \ref run(Node) "run()" or \ref init()
-    ///must be called before using this function.
+    ///\ref predNode().
+    ///
+    ///\pre Either \ref run() or \ref start() must be called before using
+    ///this function.
     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
-    ///if \c v is not reached from the root(s) or if \c v is a root.
+    ///from a %DFS path from the root to \c v. It is \c INVALID
+    ///if \c v is not reachable 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().
-    ///
-    ///\pre Either \ref run(Node) "run()" or \ref init()
-    ///must be called before using this function.
+    ///\ref predArc().
+    ///
+    ///\pre Either \ref run() or \ref start() must be called before
+    ///using this function.
     Node predNode(Node v) const { return (*_pred)[v]==INVALID ? INVALID:
                                   G->source((*_pred)[v]); }
@@ -730,5 +727,5 @@
     ///distances of the nodes calculated by the algorithm.
     ///
-    ///\pre Either \ref run(Node) "run()" or \ref init()
+    ///\pre Either \ref run() or \ref init()
     ///must be called before using this function.
     const DistMap &distMap() const { return *_dist;}
@@ -738,15 +735,14 @@
     ///
     ///Returns a const reference to the node map that stores the predecessor
-    ///arcs, which form the DFS tree (forest).
-    ///
-    ///\pre Either \ref run(Node) "run()" or \ref init()
+    ///arcs, which form the DFS tree.
+    ///
+    ///\pre Either \ref run() or \ref init()
     ///must be called before using this function.
     const PredMap &predMap() const { return *_pred;}
 
-    ///Checks if the given node. node is reached from the root(s).
-
-    ///Returns \c true if \c v is reached from the root(s).
-    ///
-    ///\pre Either \ref run(Node) "run()" or \ref init()
+    ///Checks if a node is reachable from the root(s).
+
+    ///Returns \c true if \c v is reachable from the root(s).
+    ///\pre Either \ref run() or \ref start()
     ///must be called before using this function.
     bool reached(Node v) const { return (*_reached)[v]; }
@@ -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),
@@ -891,12 +890,9 @@
   /// This auxiliary class is created to implement the
   /// \ref dfs() "function-type interface" of \ref Dfs algorithm.
-  /// It does not have own \ref run(Node) "run()" method, it uses the
-  /// functions and features of the plain \ref Dfs.
+  /// It does not have own \ref run() method, it uses the functions
+  /// and features of the plain \ref Dfs.
   ///
   /// 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)
@@ -1113,5 +1111,6 @@
   ///  bool reached = dfs(g).path(p).dist(d).run(s,t);
   ///\endcode
-  ///\warning Don't forget to put the \ref DfsWizard::run(Node) "run()"
+
+  ///\warning Don't forget to put the \ref DfsWizard::run() "run()"
   ///to the end of the parameter list.
   ///\sa DfsWizard
@@ -1129,7 +1128,7 @@
   /// This class defines the interface of the DfsVisit events, and
   /// it could be the base of a real visitor class.
-  template <typename GR>
+  template <typename _Digraph>
   struct DfsVisitor {
-    typedef GR Digraph;
+    typedef _Digraph Digraph;
     typedef typename Digraph::Arc Arc;
     typedef typename Digraph::Node Node;
@@ -1167,7 +1166,7 @@
   };
 #else
-  template <typename GR>
+  template <typename _Digraph>
   struct DfsVisitor {
-    typedef GR Digraph;
+    typedef _Digraph Digraph;
     typedef typename Digraph::Arc Arc;
     typedef typename Digraph::Node Node;
@@ -1202,15 +1201,14 @@
   /// Default traits class of DfsVisit class.
   /// \tparam _Digraph The type of the digraph the algorithm runs on.
-  template<class GR>
+  template<class _Digraph>
   struct DfsVisitDefaultTraits {
 
     /// \brief The type of the digraph the algorithm runs on.
-    typedef GR Digraph;
+    typedef _Digraph Digraph;
 
     /// \brief The type of the map that indicates which nodes are reached.
     ///
     /// 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;
 
@@ -1228,10 +1226,10 @@
   /// \ingroup search
   ///
-  /// \brief DFS algorithm class with visitor interface.
+  /// \brief %DFS algorithm class with visitor interface.
   ///
-  /// This class provides an efficient implementation of the DFS algorithm
+  /// This class provides an efficient implementation of the %DFS algorithm
   /// with visitor interface.
   ///
-  /// The DfsVisit class provides an alternative interface to the Dfs
+  /// The %DfsVisit class provides an alternative interface to the Dfs
   /// class. It works with callback mechanism, the DfsVisit object calls
   /// the member functions of the \c Visitor class on every DFS event.
@@ -1242,23 +1240,23 @@
   /// instead.
   ///
-  /// \tparam GR The type of the digraph the algorithm runs on.
-  /// The default type is \ref ListDigraph.
-  /// The value of GR is not used directly by \ref DfsVisit,
-  /// it is only passed to \ref DfsVisitDefaultTraits.
-  /// \tparam VS The Visitor type that is used by the algorithm.
-  /// \ref DfsVisitor "DfsVisitor<GR>" is an empty visitor, which
+  /// \tparam _Digraph The type of the digraph the algorithm runs on.
+  /// The default value is
+  /// \ref ListDigraph. The value of _Digraph is not used directly by
+  /// \ref DfsVisit, it is only passed to \ref DfsVisitDefaultTraits.
+  /// \tparam _Visitor The Visitor type that is used by the algorithm.
+  /// \ref DfsVisitor "DfsVisitor<_Digraph>" is an empty visitor, which
   /// 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 _Traits Traits class to set various data types used by the
+  /// algorithm. The default traits class is
+  /// \ref DfsVisitDefaultTraits "DfsVisitDefaultTraits<_Digraph>".
+  /// See \ref DfsVisitDefaultTraits for the documentation of
+  /// a DFS visit traits class.
 #ifdef DOXYGEN
-  template <typename GR, typename VS, typename TR>
+  template <typename _Digraph, typename _Visitor, typename _Traits>
 #else
-  template <typename GR = ListDigraph,
-            typename VS = DfsVisitor<GR>,
-            typename TR = DfsVisitDefaultTraits<GR> >
+  template <typename _Digraph = ListDigraph,
+            typename _Visitor = DfsVisitor<_Digraph>,
+            typename _Traits = DfsVisitDefaultTraits<_Digraph> >
 #endif
   class DfsVisit {
@@ -1266,5 +1264,5 @@
 
     ///The traits class.
-    typedef TR Traits;
+    typedef _Traits Traits;
 
     ///The type of the digraph the algorithm runs on.
@@ -1272,5 +1270,5 @@
 
     ///The visitor type used by the algorithm.
-    typedef VS Visitor;
+    typedef _Visitor Visitor;
 
     ///The type of the map that indicates which nodes are reached.
@@ -1312,5 +1310,5 @@
     typedef DfsVisit Create;
 
-    /// \name Named Template Parameters
+    /// \name Named template parameters
 
     ///@{
@@ -1354,8 +1352,7 @@
     ///
     /// Sets the map that indicates which nodes are reached.
-    /// If you don't use this function before calling \ref run(Node) "run()"
-    /// or \ref init(), an instance will be allocated automatically.
-    /// The destructor deallocates this automatically allocated map,
-    /// of course.
+    /// If you don't use this function before calling \ref run(),
+    /// it will allocate one. The destructor deallocates this
+    /// automatically allocated map, of course.
     /// \return <tt> (*this) </tt>
     DfsVisit &reachedMap(ReachedMap &m) {
@@ -1370,12 +1367,14 @@
   public:
 
-    /// \name Execution Control
-    /// 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()
-    /// and perform the actual computation with \ref start().
-    /// This procedure can be repeated if there are nodes that have not
-    /// been reached.
+    /// \name Execution control
+    /// The simplest way to execute the algorithm is to use
+    /// one of the member functions called \ref lemon::DfsVisit::run()
+    /// "run()".
+    /// \n
+    /// If you need more control on the execution, first you must call
+    /// \ref lemon::DfsVisit::init() "init()", then you can add several
+    /// source nodes with \ref lemon::DfsVisit::addSource() "addSource()".
+    /// Finally \ref lemon::DfsVisit::start() "start()" will perform the
+    /// actual path computation.
 
     /// @{
@@ -1393,12 +1392,13 @@
     }
 
-    /// \brief Adds a new source node.
-    ///
-    /// Adds a new source node to the set of nodes to be processed.
-    ///
-    /// \pre The stack must be empty. Otherwise the algorithm gives
-    /// wrong results. (One of the outgoing arcs of all the source nodes
-    /// except for the last one will not be visited and distances will
-    /// also be wrong.)
+    ///Adds a new source node.
+
+    ///Adds a new source node to the set of nodes to be processed.
+    ///
+    ///\pre The stack must be empty. (Otherwise the algorithm gives
+    ///false results.)
+    ///
+    ///\warning Distances will be wrong (or at least strange) in case of
+    ///multiple sources.
     void addSource(Node s)
     {
@@ -1414,5 +1414,4 @@
           } else {
             _visitor->leave(s);
-            _visitor->stop(s);
           }
         }
@@ -1513,5 +1512,5 @@
     /// with addSource() before using this function.
     void start(Node t) {
-      while ( !emptyQueue() && _digraph->target(_stack[_stack_head]) != t )
+      while ( !emptyQueue() && !(*_reached)[t] )
         processNextArc();
     }
@@ -1587,6 +1586,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,
+    /// - the distance of each node from the root in the %DFS tree.
     ///
     /// \note <tt>d.run()</tt> is just a shortcut of the following code.
@@ -1613,18 +1616,17 @@
 
     /// \name Query Functions
-    /// The results of the DFS algorithm can be obtained using these
+    /// The result of the %DFS algorithm can be obtained using these
     /// functions.\n
-    /// Either \ref run(Node) "run()" or \ref start() should be called
-    /// before using them.
-
+    /// Either \ref lemon::DfsVisit::run() "run()" or
+    /// \ref lemon::DfsVisit::start() "start()" must be called before
+    /// using them.
     ///@{
 
-    /// \brief Checks if the given node is reached from the root(s).
-    ///
-    /// Returns \c true if \c v is reached from the root(s).
-    ///
-    /// \pre Either \ref run(Node) "run()" or \ref init()
+    /// \brief Checks if a node is reachable from the root(s).
+    ///
+    /// Returns \c true if \c v is reachable from the root(s).
+    /// \pre Either \ref run() or \ref start()
     /// must be called before using this function.
-    bool reached(Node v) const { return (*_reached)[v]; }
+    bool reached(Node v) { return (*_reached)[v]; }
 
     ///@}
Index: mon/dheap.h
===================================================================
--- lemon/dheap.h	(revision 929)
+++ 	(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 956)
+++ lemon/dijkstra.h	(revision 412)
@@ -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).
@@ -39,8 +39,6 @@
   /// This operation traits class defines all computational operations and
   /// constants which are used in the Dijkstra algorithm.
-  template <typename V>
+  template <typename Value>
   struct DijkstraDefaultOperationTraits {
-    /// \e
-    typedef V Value;
     /// \brief Gives back the zero value of the type.
     static Value zero() {
@@ -61,6 +59,6 @@
   ///Default traits class of Dijkstra class.
   ///\tparam GR The type of the digraph.
-  ///\tparam LEN The type of the length map.
-  template<typename GR, typename LEN>
+  ///\tparam LM The type of the length map.
+  template<class GR, class LM>
   struct DijkstraDefaultTraits
   {
@@ -71,10 +69,10 @@
 
     ///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;
-
-    /// Operation traits for %Dijkstra algorithm.
+    ///It must meet the \ref concepts::ReadMap "ReadMap" concept.
+    typedef LM LengthMap;
+    ///The type of the length of the arcs.
+    typedef typename LM::Value Value;
+
+    /// Operation traits for Dijkstra algorithm.
 
     /// This class defines the operations that are used in the algorithm.
@@ -87,5 +85,5 @@
     /// Usually it is \c Digraph::NodeMap<int>.
     typedef typename Digraph::template NodeMap<int> HeapCrossRef;
-    ///Instantiates a \c HeapCrossRef.
+    ///Instantiates a \ref HeapCrossRef.
 
     ///This function instantiates a \ref HeapCrossRef.
@@ -97,5 +95,5 @@
     }
 
-    ///The heap type used by the %Dijkstra algorithm.
+    ///The heap type used by the Dijkstra algorithm.
 
     ///The heap type used by the Dijkstra algorithm.
@@ -103,6 +101,6 @@
     ///\sa BinHeap
     ///\sa Dijkstra
-    typedef BinHeap<typename LEN::Value, HeapCrossRef, std::less<Value> > Heap;
-    ///Instantiates a \c Heap.
+    typedef BinHeap<typename LM::Value, HeapCrossRef, std::less<Value> > Heap;
+    ///Instantiates a \ref Heap.
 
     ///This function instantiates a \ref Heap.
@@ -117,11 +115,11 @@
     ///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.
-
-    ///This function instantiates a \ref PredMap.
+    ///Instantiates a PredMap.
+
+    ///This function instantiates a PredMap.
     ///\param g is the digraph, to which we would like to define the
-    ///\ref PredMap.
+    ///PredMap.
     static PredMap *createPredMap(const Digraph &g)
     {
@@ -132,12 +130,12 @@
 
     ///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.
-
-    ///This function instantiates a \ref ProcessedMap.
+    ///Instantiates a ProcessedMap.
+
+    ///This function instantiates a ProcessedMap.
     ///\param g is the digraph, to which
-    ///we would like to define the \ref ProcessedMap.
+    ///we would like to define the ProcessedMap
 #ifdef DOXYGEN
     static ProcessedMap *createProcessedMap(const Digraph &g)
@@ -152,11 +150,11 @@
 
     ///The type of the map that stores the distances of the nodes.
-    ///It must conform to the \ref concepts::WriteMap "WriteMap" concept.
-    typedef typename Digraph::template NodeMap<typename LEN::Value> DistMap;
-    ///Instantiates a \c DistMap.
-
-    ///This function instantiates a \ref DistMap.
+    ///It must meet the \ref concepts::WriteMap "WriteMap" concept.
+    typedef typename Digraph::template NodeMap<typename LM::Value> DistMap;
+    ///Instantiates a DistMap.
+
+    ///This function instantiates a DistMap.
     ///\param g is the digraph, to which we would like to define
-    ///the \ref DistMap.
+    ///the DistMap
     static DistMap *createDistMap(const Digraph &g)
     {
@@ -169,8 +167,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
@@ -186,22 +180,24 @@
   ///
   ///\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.
-  ///It is read once for each arc, so the map may involve in
+  ///The default value is \ref ListDigraph.
+  ///The value of GR is not used directly by \ref Dijkstra, it is only
+  ///passed to \ref DijkstraDefaultTraits.
+  ///\tparam LM A readable arc map that determines the lengths of the
+  ///arcs. It is read once for each arc, so the map may involve in
   ///relatively time consuming process to compute the arc lengths if
   ///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.
+  ///concepts::Digraph::ArcMap "Digraph::ArcMap<int>".
+  ///The value of LM is not used directly by \ref Dijkstra, it is only
+  ///passed to \ref DijkstraDefaultTraits.
+  ///\tparam TR Traits class to set various data types used by the algorithm.
+  ///The default traits class is \ref DijkstraDefaultTraits
+  ///"DijkstraDefaultTraits<GR,LM>". See \ref DijkstraDefaultTraits
+  ///for the documentation of a Dijkstra traits class.
 #ifdef DOXYGEN
-  template <typename GR, typename LEN, typename TR>
+  template <typename GR, typename LM, typename TR>
 #else
   template <typename GR=ListDigraph,
-            typename LEN=typename GR::template ArcMap<int>,
-            typename TR=DijkstraDefaultTraits<GR,LEN> >
+            typename LM=typename GR::template ArcMap<int>,
+            typename TR=DijkstraDefaultTraits<GR,LM> >
 #endif
   class Dijkstra {
@@ -211,6 +207,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;
@@ -228,9 +224,8 @@
     ///The heap type used by the algorithm.
     typedef typename TR::Heap Heap;
-    ///\brief The \ref DijkstraDefaultOperationTraits "operation traits class"
-    ///of the algorithm.
+    ///The operation traits class.
     typedef typename TR::OperationTraits OperationTraits;
 
-    ///The \ref DijkstraDefaultTraits "traits class" of the algorithm.
+    ///The traits class.
     typedef TR Traits;
 
@@ -245,5 +240,5 @@
     const Digraph *G;
     //Pointer to the length map.
-    const LengthMap *_length;
+    const LengthMap *length;
     //Pointer to the map of predecessors arcs.
     PredMap *_pred;
@@ -296,5 +291,5 @@
     typedef Dijkstra Create;
 
-    ///\name Named Template Parameters
+    ///\name Named template parameters
 
     ///@{
@@ -310,9 +305,8 @@
     };
     ///\brief \ref named-templ-param "Named parameter" for setting
-    ///\c PredMap type.
+    ///PredMap type.
     ///
     ///\ref named-templ-param "Named parameter" for setting
-    ///\c PredMap type.
-    ///It must conform to the \ref concepts::WriteMap "WriteMap" concept.
+    ///PredMap type.
     template <class T>
     struct SetPredMap
@@ -331,9 +325,8 @@
     };
     ///\brief \ref named-templ-param "Named parameter" for setting
-    ///\c DistMap type.
+    ///DistMap type.
     ///
     ///\ref named-templ-param "Named parameter" for setting
-    ///\c DistMap type.
-    ///It must conform to the \ref concepts::WriteMap "WriteMap" concept.
+    ///DistMap type.
     template <class T>
     struct SetDistMap
@@ -352,9 +345,8 @@
     };
     ///\brief \ref named-templ-param "Named parameter" for setting
-    ///\c ProcessedMap type.
+    ///ProcessedMap type.
     ///
     ///\ref named-templ-param "Named parameter" for setting
-    ///\c ProcessedMap type.
-    ///It must conform to the \ref concepts::WriteMap "WriteMap" concept.
+    ///ProcessedMap type.
     template <class T>
     struct SetProcessedMap
@@ -371,8 +363,8 @@
     };
     ///\brief \ref named-templ-param "Named parameter" for setting
-    ///\c ProcessedMap type to be <tt>Digraph::NodeMap<bool></tt>.
+    ///ProcessedMap type to be <tt>Digraph::NodeMap<bool></tt>.
     ///
     ///\ref named-templ-param "Named parameter" for setting
-    ///\c ProcessedMap type to be <tt>Digraph::NodeMap<bool></tt>.
+    ///ProcessedMap type to be <tt>Digraph::NodeMap<bool></tt>.
     ///If you don't set it explicitly, it will be automatically allocated.
     struct SetStandardProcessedMap
@@ -397,12 +389,8 @@
     };
     ///\brief \ref named-templ-param "Named parameter" for setting
-    ///heap and cross reference types
+    ///heap and cross reference type
     ///
     ///\ref named-templ-param "Named parameter" for setting heap and cross
-    ///reference types. If this named parameter is used, then external
-    ///heap and cross reference objects must be passed to the algorithm
-    ///using the \ref heap() function before calling \ref run(Node) "run()"
-    ///or \ref init().
-    ///\sa SetStandardHeap
+    ///reference type.
     template <class H, class CR = typename Digraph::template NodeMap<int> >
     struct SetHeap
@@ -424,16 +412,10 @@
     };
     ///\brief \ref named-templ-param "Named parameter" for setting
-    ///heap and cross reference types with automatic allocation
+    ///heap and cross reference type with automatic allocation
     ///
     ///\ref named-templ-param "Named parameter" for setting heap and cross
-    ///reference types with automatic allocation.
-    ///They should have standard constructor interfaces to be able to
-    ///automatically created by the algorithm (i.e. the digraph 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(Node) "run()" or \ref init().
-    ///\sa SetHeap
+    ///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
@@ -452,6 +434,5 @@
     ///
     ///\ref named-templ-param "Named parameter" for setting
-    ///\c OperationTraits type.
-    /// For more information, see \ref DijkstraDefaultOperationTraits.
+    ///\ref OperationTraits type.
     template <class T>
     struct SetOperationTraits
@@ -472,8 +453,8 @@
 
     ///Constructor.
-    ///\param g The digraph the algorithm runs on.
-    ///\param length The length map used by the algorithm.
-    Dijkstra(const Digraph& g, const LengthMap& length) :
-      G(&g), _length(&length),
+    ///\param _g The digraph the algorithm runs on.
+    ///\param _length The length map used by the algorithm.
+    Dijkstra(const Digraph& _g, const LengthMap& _length) :
+      G(&_g), length(&_length),
       _pred(NULL), local_pred(false),
       _dist(NULL), local_dist(false),
@@ -499,5 +480,5 @@
     Dijkstra &lengthMap(const LengthMap &m)
     {
-      _length = &m;
+      length = &m;
       return *this;
     }
@@ -506,8 +487,7 @@
 
     ///Sets the map that stores the predecessor arcs.
-    ///If you don't use this function before calling \ref run(Node) "run()"
-    ///or \ref init(), an instance will be allocated automatically.
-    ///The destructor deallocates this automatically allocated map,
-    ///of course.
+    ///If you don't use this function before calling \ref run(),
+    ///it will allocate one. The destructor deallocates this
+    ///automatically allocated map, of course.
     ///\return <tt> (*this) </tt>
     Dijkstra &predMap(PredMap &m)
@@ -524,8 +504,7 @@
 
     ///Sets the map that indicates which nodes are processed.
-    ///If you don't use this function before calling \ref run(Node) "run()"
-    ///or \ref init(), an instance will be allocated automatically.
-    ///The destructor deallocates this automatically allocated map,
-    ///of course.
+    ///If you don't use this function before calling \ref run(),
+    ///it will allocate one. The destructor deallocates this
+    ///automatically allocated map, of course.
     ///\return <tt> (*this) </tt>
     Dijkstra &processedMap(ProcessedMap &m)
@@ -543,8 +522,7 @@
     ///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(Node) "run()"
-    ///or \ref init(), an instance will be allocated automatically.
-    ///The destructor deallocates this automatically allocated map,
-    ///of course.
+    ///If you don't use this function before calling \ref run(),
+    ///it will allocate one. The destructor deallocates this
+    ///automatically allocated map, of course.
     ///\return <tt> (*this) </tt>
     Dijkstra &distMap(DistMap &m)
@@ -561,9 +539,7 @@
 
     ///Sets the heap and the cross reference used by algorithm.
-    ///If you don't use this function before calling \ref run(Node) "run()"
-    ///or \ref init(), heap and cross reference instances will be
-    ///allocated automatically.
-    ///The destructor deallocates these automatically allocated objects,
-    ///of course.
+    ///If you don't use this function before calling \ref run(),
+    ///it will allocate one. The destructor deallocates this
+    ///automatically allocated heap and cross reference, of course.
     ///\return <tt> (*this) </tt>
     Dijkstra &heap(Heap& hp, HeapCrossRef &cr)
@@ -592,17 +568,20 @@
   public:
 
-    ///\name Execution Control
-    ///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
-    ///\ref addSource(). Finally the actual path computation can be
-    ///performed with one of the \ref start() functions.
+    ///\name Execution control
+    ///The simplest way to execute the algorithm is to use one of the
+    ///member functions called \ref lemon::Dijkstra::run() "run()".
+    ///\n
+    ///If you need more control on the execution, first you must call
+    ///\ref lemon::Dijkstra::init() "init()", then you can add several
+    ///source nodes with \ref lemon::Dijkstra::addSource() "addSource()".
+    ///Finally \ref lemon::Dijkstra::start() "start()" will perform the
+    ///actual path computation.
 
     ///@{
 
-    ///\brief Initializes the internal data structures.
-    ///
     ///Initializes the internal data structures.
+
+    ///Initializes the internal data structures.
+    ///
     void init()
     {
@@ -652,10 +631,10 @@
         switch(_heap->state(w)) {
         case Heap::PRE_HEAP:
-          _heap->push(w,OperationTraits::plus(oldvalue, (*_length)[e]));
+          _heap->push(w,OperationTraits::plus(oldvalue, (*length)[e]));
           _pred->set(w,e);
           break;
         case Heap::IN_HEAP:
           {
-            Value newvalue = OperationTraits::plus(oldvalue, (*_length)[e]);
+            Value newvalue = OperationTraits::plus(oldvalue, (*length)[e]);
             if ( OperationTraits::less(newvalue, (*_heap)[w]) ) {
               _heap->decrease(w, newvalue);
@@ -680,14 +659,15 @@
     }
 
-    ///Returns \c false if there are nodes to be processed.
-
-    ///Returns \c false if there are nodes to be processed
-    ///in the priority heap.
+    ///\brief Returns \c false if there are nodes
+    ///to be processed.
+    ///
+    ///Returns \c false if there are nodes
+    ///to be processed in the priority heap.
     bool emptyQueue() const { return _heap->empty(); }
 
-    ///Returns the number of the nodes to be processed.
-
-    ///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
+
+    ///Returns the number of the nodes to be processed in the priority heap.
+    ///
     int queueSize() const { return _heap->size(); }
 
@@ -810,60 +790,59 @@
 
     ///\name Query Functions
-    ///The results of the %Dijkstra algorithm can be obtained using these
+    ///The result of the %Dijkstra algorithm can be obtained using these
     ///functions.\n
-    ///Either \ref run(Node) "run()" or \ref init() should be called
-    ///before using them.
+    ///Either \ref lemon::Dijkstra::run() "run()" or
+    ///\ref lemon::Dijkstra::start() "start()" must be called before
+    ///using them.
 
     ///@{
 
-    ///The shortest path to the given node.
-
-    ///Returns 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(Node) "run()" or \ref init()
-    ///must be called before using this function.
+    ///The shortest path to a node.
+
+    ///Returns the shortest path to a node.
+    ///
+    ///\warning \c t should be reachable from the root(s).
+    ///
+    ///\pre Either \ref run() or \ref start() must be called before
+    ///using this function.
     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).
-    ///
-    ///\warning If node \c v is not reached from the root(s), then
+    ///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 reachable from the root(s), then
     ///the return value of this function is undefined.
     ///
-    ///\pre Either \ref run(Node) "run()" or \ref init()
-    ///must be called before using this function.
+    ///\pre Either \ref run() or \ref start() 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.
-    ///
+    ///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
-    ///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.
+    ///shortest path from the root(s) to \c v. It is \c INVALID if \c v
+    ///is not reachable 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(Node) "run()" or \ref init()
-    ///must be called before using this function.
+    ///tree used in \ref predNode().
+    ///
+    ///\pre Either \ref run() or \ref start() 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.
-    ///
+    ///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
-    ///if \c v is not reached from the root(s) or if \c v is a root.
+    ///from a shortest path from the root(s) to \c v. It is \c INVALID
+    ///if \c v is not reachable 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(Node) "run()" or \ref init()
-    ///must be called before using this function.
+    ///tree used in \ref predArc().
+    ///
+    ///\pre Either \ref run() or \ref start() must be called before
+    ///using this function.
     Node predNode(Node v) const { return (*_pred)[v]==INVALID ? INVALID:
                                   G->source((*_pred)[v]); }
@@ -875,5 +854,5 @@
     ///of the nodes calculated by the algorithm.
     ///
-    ///\pre Either \ref run(Node) "run()" or \ref init()
+    ///\pre Either \ref run() or \ref init()
     ///must be called before using this function.
     const DistMap &distMap() const { return *_dist;}
@@ -883,15 +862,14 @@
     ///
     ///Returns a const reference to the node map that stores the predecessor
-    ///arcs, which form the shortest path tree (forest).
-    ///
-    ///\pre Either \ref run(Node) "run()" or \ref init()
+    ///arcs, which form the shortest path tree.
+    ///
+    ///\pre Either \ref run() or \ref init()
     ///must be called before using this function.
     const PredMap &predMap() const { return *_pred;}
 
-    ///Checks if the given node is reached from the root(s).
-
-    ///Returns \c true if \c v is reached from the root(s).
-    ///
-    ///\pre Either \ref run(Node) "run()" or \ref init()
+    ///Checks if a node is reachable from the root(s).
+
+    ///Returns \c true if \c v is reachable from the root(s).
+    ///\pre Either \ref run() or \ref start()
     ///must be called before using this function.
     bool reached(Node v) const { return (*_heap_cross_ref)[v] !=
@@ -902,16 +880,14 @@
     ///Returns \c true if \c v is processed, i.e. the shortest
     ///path to \c v has already found.
-    ///
-    ///\pre Either \ref run(Node) "run()" or \ref init()
+    ///\pre Either \ref run() or \ref init()
     ///must be called before using this function.
     bool processed(Node v) const { return (*_heap_cross_ref)[v] ==
                                           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.
-    ///
-    ///\pre Either \ref run(Node) "run()" or \ref init()
+    ///\pre Either \ref run() or \ref init()
     ///must be called before using this function and
     ///node \c v must be reached but not necessarily processed.
@@ -928,6 +904,6 @@
   ///Default traits class of dijkstra() function.
   ///\tparam GR The type of the digraph.
-  ///\tparam LEN The type of the length map.
-  template<class GR, class LEN>
+  ///\tparam LM The type of the length map.
+  template<class GR, class LM>
   struct DijkstraWizardDefaultTraits
   {
@@ -937,8 +913,8 @@
 
     ///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;
+    ///It must meet the \ref concepts::ReadMap "ReadMap" concept.
+    typedef LM LengthMap;
+    ///The type of the length of the arcs.
+    typedef typename LM::Value Value;
 
     /// Operation traits for Dijkstra algorithm.
@@ -986,5 +962,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 +977,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,6 +997,6 @@
 
     ///The type of the map that stores the distances of the nodes.
-    ///It must conform to the \ref concepts::WriteMap "WriteMap" concept.
-    typedef typename Digraph::template NodeMap<typename LEN::Value> DistMap;
+    ///It must meet the \ref concepts::WriteMap "WriteMap" concept.
+    typedef typename Digraph::template NodeMap<typename LM::Value> DistMap;
     ///Instantiates a DistMap.
 
@@ -1036,5 +1012,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,11 +1018,14 @@
   /// 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.
-  template<typename GR, typename LEN>
-  class DijkstraWizardBase : public DijkstraWizardDefaultTraits<GR,LEN>
+  /// 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<class GR,class LM>
+  class DijkstraWizardBase : public DijkstraWizardDefaultTraits<GR,LM>
   {
-    typedef DijkstraWizardDefaultTraits<GR,LEN> Base;
+    typedef DijkstraWizardDefaultTraits<GR,LM> Base;
   protected:
     //The type of the nodes in the digraph.
@@ -1082,7 +1061,7 @@
     /// \param g The digraph the algorithm runs on.
     /// \param l The length map.
-    DijkstraWizardBase(const GR &g,const LEN &l) :
+    DijkstraWizardBase(const GR &g,const LM &l) :
       _g(reinterpret_cast<void*>(const_cast<GR*>(&g))),
-      _length(reinterpret_cast<void*>(const_cast<LEN*>(&l))),
+      _length(reinterpret_cast<void*>(const_cast<LM*>(&l))),
       _processed(0), _pred(0), _dist(0), _path(0), _di(0) {}
 
@@ -1093,12 +1072,9 @@
   /// This auxiliary class is created to implement the
   /// \ref dijkstra() "function-type interface" of \ref Dijkstra algorithm.
-  /// It does not have own \ref run(Node) "run()" method, it uses the
-  /// functions and features of the plain \ref Dijkstra.
+  /// It does not have own \ref run() method, it uses the functions
+  /// and features of the plain \ref Dijkstra.
   ///
   /// 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 +1082,5 @@
     typedef TR Base;
 
+    ///The type of the digraph the algorithm runs on.
     typedef typename TR::Digraph Digraph;
 
@@ -1113,10 +1090,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 +1175,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 +1193,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 +1211,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 +1228,4 @@
       SetPathBase(const TR &b) : TR(b) {}
     };
-
     ///\brief \ref named-func-param "Named parameter"
     ///for getting the shortest path to the target node.
@@ -1288,13 +1268,13 @@
   ///  bool reached = dijkstra(g,length).path(p).dist(d).run(s,t);
   ///\endcode
-  ///\warning Don't forget to put the \ref DijkstraWizard::run(Node) "run()"
+  ///\warning Don't forget to put the \ref DijkstraWizard::run() "run()"
   ///to the end of the parameter list.
   ///\sa DijkstraWizard
   ///\sa Dijkstra
-  template<typename GR, typename LEN>
-  DijkstraWizard<DijkstraWizardBase<GR,LEN> >
-  dijkstra(const GR &digraph, const LEN &length)
+  template<class GR, class LM>
+  DijkstraWizard<DijkstraWizardBase<GR,LM> >
+  dijkstra(const GR &digraph, const LM &length)
   {
-    return DijkstraWizard<DijkstraWizardBase<GR,LEN> >(digraph,length);
+    return DijkstraWizard<DijkstraWizardBase<GR,LM> >(digraph,length);
   }
 
Index: lemon/dim2.h
===================================================================
--- lemon/dim2.h	(revision 761)
+++ lemon/dim2.h	(revision 314)
@@ -3,5 +3,5 @@
  * This file is a part of LEMON, a generic C++ optimization library.
  *
- * Copyright (C) 2003-2009
+ * Copyright (C) 2003-2008
  * Egervary Jeno Kombinatorikus Optimalizalasi Kutatocsoport
  * (Egervary Research Group on Combinatorial Optimization, EGRES).
@@ -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: mon/dimacs.h
===================================================================
--- lemon/dimacs.h	(revision 956)
+++ 	(revision )
@@ -1,448 +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_DIMACS_H
-#define LEMON_DIMACS_H
-
-#include <iostream>
-#include <string>
-#include <vector>
-#include <limits>
-#include <lemon/maps.h>
-#include <lemon/error.h>
-/// \ingroup dimacs_group
-/// \file
-/// \brief DIMACS file format reader.
-
-namespace lemon {
-
-  /// \addtogroup dimacs_group
-  /// @{
-
-  /// DIMACS file type descriptor.
-  struct DimacsDescriptor
-  {
-    ///\brief DIMACS file type enum
-    ///
-    ///DIMACS file type enum.
-    enum Type {
-      NONE,  ///< Undefined type.
-      MIN,   ///< DIMACS file type for minimum cost flow problems.
-      MAX,   ///< DIMACS file type for maximum flow problems.
-      SP,    ///< DIMACS file type for shostest path problems.
-      MAT    ///< DIMACS file type for plain graphs and matching problems.
-    };
-    ///The file type
-    Type type;
-    ///The number of nodes in the graph
-    int nodeNum;
-    ///The number of edges in the graph
-    int edgeNum;
-    int lineShift;
-    ///Constructor. It sets the type to \c NONE.
-    DimacsDescriptor() : type(NONE) {}
-  };
-
-  ///Discover the type of a DIMACS file
-
-  ///This function starts seeking the beginning of the given file for the
-  ///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.
-  DimacsDescriptor dimacsType(std::istream& is)
-  {
-    DimacsDescriptor r;
-    std::string problem,str;
-    char c;
-    r.lineShift=0;
-    while (is >> c)
-      switch(c)
-        {
-        case 'p':
-          if(is >> problem >> r.nodeNum >> r.edgeNum)
-            {
-              getline(is, str);
-              r.lineShift++;
-              if(problem=="min") r.type=DimacsDescriptor::MIN;
-              else if(problem=="max") r.type=DimacsDescriptor::MAX;
-              else if(problem=="sp") r.type=DimacsDescriptor::SP;
-              else if(problem=="mat") r.type=DimacsDescriptor::MAT;
-              else throw FormatError("Unknown problem type");
-              return r;
-            }
-          else
-            {
-              throw FormatError("Missing or wrong problem type declaration.");
-            }
-          break;
-        case 'c':
-          getline(is, str);
-          r.lineShift++;
-          break;
-        default:
-          throw FormatError("Unknown DIMACS declaration.");
-        }
-    throw FormatError("Missing problem type declaration.");
-  }
-
-
-  /// \brief DIMACS minimum cost flow reader function.
-  ///
-  /// This function reads a minimum cost flow instance from DIMACS format,
-  /// i.e. from a DIMACS file having a line starting with
-  /// \code
-  ///   p min
-  /// \endcode
-  /// At the beginning, \c g is cleared by \c g.clear(). The supply
-  /// amount of the nodes are written to the \c supply node map
-  /// (they are signed values). The lower bounds, capacities and costs
-  /// of the arcs are written to the \c lower, \c capacity and \c cost
-  /// arc maps.
-  ///
-  /// If the capacity of an arc is less than the lower bound, it will
-  /// be set to "infinite" instead. The actual value of "infinite" is
-  /// contolled by the \c infty parameter. If it is 0 (the default value),
-  /// \c std::numeric_limits<Capacity>::infinity() will be used if available,
-  /// \c std::numeric_limits<Capacity>::max() otherwise. If \c infty is set to
-  /// a non-zero value, that value will be used as "infinite".
-  ///
-  /// If the file type was previously evaluated by dimacsType(), then
-  /// the descriptor struct should be given by the \c dest parameter.
-  template <typename Digraph, typename LowerMap,
-            typename CapacityMap, typename CostMap,
-            typename SupplyMap>
-  void readDimacsMin(std::istream& is,
-                     Digraph &g,
-                     LowerMap& lower,
-                     CapacityMap& capacity,
-                     CostMap& cost,
-                     SupplyMap& supply,
-                     typename CapacityMap::Value infty = 0,
-                     DimacsDescriptor desc=DimacsDescriptor())
-  {
-    g.clear();
-    std::vector<typename Digraph::Node> nodes;
-    typename Digraph::Arc e;
-    std::string problem, str;
-    char c;
-    int i, j;
-    if(desc.type==DimacsDescriptor::NONE) desc=dimacsType(is);
-    if(desc.type!=DimacsDescriptor::MIN)
-      throw FormatError("Problem type mismatch");
-
-    nodes.resize(desc.nodeNum + 1);
-    for (int k = 1; k <= desc.nodeNum; ++k) {
-      nodes[k] = g.addNode();
-      supply.set(nodes[k], 0);
-    }
-
-    typename SupplyMap::Value sup;
-    typename CapacityMap::Value low;
-    typename CapacityMap::Value cap;
-    typename CostMap::Value co;
-    typedef typename CapacityMap::Value Capacity;
-    if(infty==0)
-      infty = std::numeric_limits<Capacity>::has_infinity ?
-        std::numeric_limits<Capacity>::infinity() :
-        std::numeric_limits<Capacity>::max();
-
-    while (is >> c) {
-      switch (c) {
-      case 'c': // comment line
-        getline(is, str);
-        break;
-      case 'n': // node definition line
-        is >> i >> sup;
-        getline(is, str);
-        supply.set(nodes[i], sup);
-        break;
-      case 'a': // arc definition line
-        is >> i >> j >> low >> cap >> co;
-        getline(is, str);
-        e = g.addArc(nodes[i], nodes[j]);
-        lower.set(e, low);
-        if (cap >= low)
-          capacity.set(e, cap);
-        else
-          capacity.set(e, infty);
-        cost.set(e, co);
-        break;
-      }
-    }
-  }
-
-  template<typename Digraph, typename CapacityMap>
-  void _readDimacs(std::istream& is,
-                   Digraph &g,
-                   CapacityMap& capacity,
-                   typename Digraph::Node &s,
-                   typename Digraph::Node &t,
-                   typename CapacityMap::Value infty = 0,
-                   DimacsDescriptor desc=DimacsDescriptor()) {
-    g.clear();
-    s=t=INVALID;
-    std::vector<typename Digraph::Node> nodes;
-    typename Digraph::Arc e;
-    char c, d;
-    int i, j;
-    typename CapacityMap::Value _cap;
-    std::string str;
-    nodes.resize(desc.nodeNum + 1);
-    for (int k = 1; k <= desc.nodeNum; ++k) {
-      nodes[k] = g.addNode();
-    }
-    typedef typename CapacityMap::Value Capacity;
-
-    if(infty==0)
-      infty = std::numeric_limits<Capacity>::has_infinity ?
-        std::numeric_limits<Capacity>::infinity() :
-        std::numeric_limits<Capacity>::max();
-
-    while (is >> c) {
-      switch (c) {
-      case 'c': // comment line
-        getline(is, str);
-        break;
-      case 'n': // node definition line
-        if (desc.type==DimacsDescriptor::SP) { // shortest path problem
-          is >> i;
-          getline(is, str);
-          s = nodes[i];
-        }
-        if (desc.type==DimacsDescriptor::MAX) { // max flow problem
-          is >> i >> d;
-          getline(is, str);
-          if (d == 's') s = nodes[i];
-          if (d == 't') t = nodes[i];
-        }
-        break;
-      case 'a': // arc definition line
-        if (desc.type==DimacsDescriptor::SP) {
-          is >> i >> j >> _cap;
-          getline(is, str);
-          e = g.addArc(nodes[i], nodes[j]);
-          capacity.set(e, _cap);
-        }
-        else if (desc.type==DimacsDescriptor::MAX) {
-          is >> i >> j >> _cap;
-          getline(is, str);
-          e = g.addArc(nodes[i], nodes[j]);
-          if (_cap >= 0)
-            capacity.set(e, _cap);
-          else
-            capacity.set(e, infty);
-        }
-        else {
-          is >> i >> j;
-          getline(is, str);
-          g.addArc(nodes[i], nodes[j]);
-        }
-        break;
-      }
-    }
-  }
-
-  /// \brief DIMACS maximum flow reader function.
-  ///
-  /// This function reads a maximum flow instance from DIMACS format,
-  /// i.e. from a DIMACS file having a line starting with
-  /// \code
-  ///   p max
-  /// \endcode
-  /// At the beginning, \c g is cleared by \c g.clear(). The arc
-  /// capacities are written to the \c capacity arc map and \c s and
-  /// \c t are set to the source and the target nodes.
-  ///
-  /// If the capacity of an arc is negative, it will
-  /// be set to "infinite" instead. The actual value of "infinite" is
-  /// contolled by the \c infty parameter. If it is 0 (the default value),
-  /// \c std::numeric_limits<Capacity>::infinity() will be used if available,
-  /// \c std::numeric_limits<Capacity>::max() otherwise. If \c infty is set to
-  /// a non-zero value, that value will be used as "infinite".
-  ///
-  /// If the file type was previously evaluated by dimacsType(), then
-  /// the descriptor struct should be given by the \c dest parameter.
-  template<typename Digraph, typename CapacityMap>
-  void readDimacsMax(std::istream& is,
-                     Digraph &g,
-                     CapacityMap& capacity,
-                     typename Digraph::Node &s,
-                     typename Digraph::Node &t,
-                     typename CapacityMap::Value infty = 0,
-                     DimacsDescriptor desc=DimacsDescriptor()) {
-    if(desc.type==DimacsDescriptor::NONE) desc=dimacsType(is);
-    if(desc.type!=DimacsDescriptor::MAX)
-      throw FormatError("Problem type mismatch");
-    _readDimacs(is,g,capacity,s,t,infty,desc);
-  }
-
-  /// \brief DIMACS shortest path reader function.
-  ///
-  /// This function reads a shortest path instance from DIMACS format,
-  /// i.e. from a DIMACS file having a line starting with
-  /// \code
-  ///   p sp
-  /// \endcode
-  /// At the beginning, \c g is cleared by \c g.clear(). The arc
-  /// lengths are written to the \c length arc map and \c s is set to the
-  /// source node.
-  ///
-  /// If the file type was previously evaluated by dimacsType(), then
-  /// the descriptor struct should be given by the \c dest parameter.
-  template<typename Digraph, typename LengthMap>
-  void readDimacsSp(std::istream& is,
-                    Digraph &g,
-                    LengthMap& length,
-                    typename Digraph::Node &s,
-                    DimacsDescriptor desc=DimacsDescriptor()) {
-    typename Digraph::Node t;
-    if(desc.type==DimacsDescriptor::NONE) desc=dimacsType(is);
-    if(desc.type!=DimacsDescriptor::SP)
-      throw FormatError("Problem type mismatch");
-    _readDimacs(is, g, length, s, t, 0, desc);
-  }
-
-  /// \brief DIMACS capacitated digraph reader function.
-  ///
-  /// This function reads an arc capacitated digraph instance from
-  /// DIMACS 'max' or 'sp' format.
-  /// At the beginning, \c g is cleared by \c g.clear()
-  /// and the arc capacities/lengths are written to the \c capacity
-  /// arc map.
-  ///
-  /// In case of the 'max' format, if the capacity of an arc is negative,
-  /// it will
-  /// be set to "infinite" instead. The actual value of "infinite" is
-  /// contolled by the \c infty parameter. If it is 0 (the default value),
-  /// \c std::numeric_limits<Capacity>::infinity() will be used if available,
-  /// \c std::numeric_limits<Capacity>::max() otherwise. If \c infty is set to
-  /// a non-zero value, that value will be used as "infinite".
-  ///
-  /// If the file type was previously evaluated by dimacsType(), then
-  /// the descriptor struct should be given by the \c dest parameter.
-  template<typename Digraph, typename CapacityMap>
-  void readDimacsCap(std::istream& is,
-                     Digraph &g,
-                     CapacityMap& capacity,
-                     typename CapacityMap::Value infty = 0,
-                     DimacsDescriptor desc=DimacsDescriptor()) {
-    typename Digraph::Node u,v;
-    if(desc.type==DimacsDescriptor::NONE) desc=dimacsType(is);
-    if(desc.type!=DimacsDescriptor::MAX || desc.type!=DimacsDescriptor::SP)
-      throw FormatError("Problem type mismatch");
-    _readDimacs(is, g, capacity, u, v, infty, desc);
-  }
-
-  template<typename Graph>
-  typename enable_if<lemon::UndirectedTagIndicator<Graph>,void>::type
-  _addArcEdge(Graph &g, typename Graph::Node s, typename Graph::Node t,
-              dummy<0> = 0)
-  {
-    g.addEdge(s,t);
-  }
-  template<typename Graph>
-  typename disable_if<lemon::UndirectedTagIndicator<Graph>,void>::type
-  _addArcEdge(Graph &g, typename Graph::Node s, typename Graph::Node t,
-              dummy<1> = 1)
-  {
-    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
-  /// DIMACS files having a line starting with
-  /// \code
-  ///   p mat
-  /// \endcode
-  /// At the beginning, \c g is cleared by \c g.clear().
-  ///
-  /// If the file type was previously evaluated by dimacsType(), then
-  /// the descriptor struct should be given by the \c dest parameter.
-  template<typename Graph>
-  void readDimacsMat(std::istream& is, Graph &g,
-                     DimacsDescriptor desc=DimacsDescriptor())
-  {
-    if(desc.type==DimacsDescriptor::NONE) desc=dimacsType(is);
-    if(desc.type!=DimacsDescriptor::MAT)
-      throw FormatError("Problem type mismatch");
-
-    g.clear();
-    std::vector<typename Graph::Node> nodes;
-    char c;
-    int i, j;
-    std::string str;
-    nodes.resize(desc.nodeNum + 1);
-    for (int k = 1; k <= desc.nodeNum; ++k) {
-      nodes[k] = g.addNode();
-    }
-
-    while (is >> c) {
-      switch (c) {
-      case 'c': // comment line
-        getline(is, str);
-        break;
-      case 'n': // node definition line
-        break;
-      case 'a': // arc definition line
-        is >> i >> j;
-        getline(is, str);
-        _addArcEdge(g,nodes[i], nodes[j]);
-        break;
-      }
-    }
-  }
-
-  /// DIMACS plain digraph writer function.
-  ///
-  /// This function writes a digraph without any designated nodes and
-  /// maps into DIMACS format, i.e. into DIMACS file having a line
-  /// starting with
-  /// \code
-  ///   p mat
-  /// \endcode
-  /// If \c comment is not empty, then it will be printed in the first line
-  /// prefixed by 'c'.
-  template<typename Digraph>
-  void writeDimacsMat(std::ostream& os, const Digraph &g,
-                      std::string comment="") {
-    typedef typename Digraph::NodeIt NodeIt;
-    typedef typename Digraph::ArcIt ArcIt;
-
-    if(!comment.empty())
-      os << "c " << comment << std::endl;
-    os << "p mat " << g.nodeNum() << " " << g.arcNum() << std::endl;
-
-    typename Digraph::template NodeMap<int> nodes(g);
-    int i = 1;
-    for(NodeIt v(g); v != INVALID; ++v) {
-      nodes.set(v, i);
-      ++i;
-    }
-    for(ArcIt e(g); e != INVALID; ++e) {
-      os << "a " << nodes[g.source(e)] << " " << nodes[g.target(e)]
-         << std::endl;
-    }
-  }
-
-  /// @}
-
-} //namespace lemon
-
-#endif //LEMON_DIMACS_H
Index: mon/edge_set.h
===================================================================
--- lemon/edge_set.h	(revision 956)
+++ 	(revision )
@@ -1,1420 +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_EDGE_SET_H
-#define LEMON_EDGE_SET_H
-
-#include <lemon/core.h>
-#include <lemon/bits/edge_set_extender.h>
-
-/// \ingroup graphs
-/// \file
-/// \brief ArcSet and EdgeSet classes.
-///
-/// Graphs which use another graph's node-set as own.
-namespace lemon {
-
-  template <typename GR>
-  class ListArcSetBase {
-  public:
-
-    typedef typename GR::Node Node;
-    typedef typename GR::NodeIt NodeIt;
-
-  protected:
-
-    struct NodeT {
-      int first_out, first_in;
-      NodeT() : first_out(-1), first_in(-1) {}
-    };
-
-    typedef typename ItemSetTraits<GR, Node>::
-    template Map<NodeT>::Type NodesImplBase;
-
-    NodesImplBase* _nodes;
-
-    struct ArcT {
-      Node source, target;
-      int next_out, next_in;
-      int prev_out, prev_in;
-      ArcT() : prev_out(-1), prev_in(-1) {}
-    };
-
-    std::vector<ArcT> arcs;
-
-    int first_arc;
-    int first_free_arc;
-
-    const GR* _graph;
-
-    void initalize(const GR& graph, NodesImplBase& nodes) {
-      _graph = &graph;
-      _nodes = &nodes;
-    }
-
-  public:
-
-    class Arc {
-      friend class ListArcSetBase<GR>;
-    protected:
-      Arc(int _id) : id(_id) {}
-      int 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; }
-    };
-
-    ListArcSetBase() : first_arc(-1), first_free_arc(-1) {}
-
-    Node addNode() {
-      LEMON_ASSERT(false,
-        "This graph structure does not support node insertion");
-      return INVALID; // avoid warning
-    }
-
-    Arc addArc(const Node& u, const Node& v) {
-      int n;
-      if (first_free_arc == -1) {
-        n = arcs.size();
-        arcs.push_back(ArcT());
-      } else {
-        n = first_free_arc;
-        first_free_arc = arcs[first_free_arc].next_in;
-      }
-      arcs[n].next_in = (*_nodes)[v].first_in;
-      if ((*_nodes)[v].first_in != -1) {
-        arcs[(*_nodes)[v].first_in].prev_in = n;
-      }
-      (*_nodes)[v].first_in = n;
-      arcs[n].next_out = (*_nodes)[u].first_out;
-      if ((*_nodes)[u].first_out != -1) {
-        arcs[(*_nodes)[u].first_out].prev_out = n;
-      }
-      (*_nodes)[u].first_out = n;
-      arcs[n].source = u;
-      arcs[n].target = v;
-      return Arc(n);
-    }
-
-    void erase(const Arc& arc) {
-      int n = arc.id;
-      if (arcs[n].prev_in != -1) {
-        arcs[arcs[n].prev_in].next_in = arcs[n].next_in;
-      } else {
-        (*_nodes)[arcs[n].target].first_in = arcs[n].next_in;
-      }
-      if (arcs[n].next_in != -1) {
-        arcs[arcs[n].next_in].prev_in = arcs[n].prev_in;
-      }
-
-      if (arcs[n].prev_out != -1) {
-        arcs[arcs[n].prev_out].next_out = arcs[n].next_out;
-      } else {
-        (*_nodes)[arcs[n].source].first_out = arcs[n].next_out;
-      }
-      if (arcs[n].next_out != -1) {
-        arcs[arcs[n].next_out].prev_out = arcs[n].prev_out;
-      }
-
-    }
-
-    void clear() {
-      Node node;
-      for (first(node); node != INVALID; next(node)) {
-        (*_nodes)[node].first_in = -1;
-        (*_nodes)[node].first_out = -1;
-      }
-      arcs.clear();
-      first_arc = -1;
-      first_free_arc = -1;
-    }
-
-    void first(Node& node) const {
-      _graph->first(node);
-    }
-
-    void next(Node& node) const {
-      _graph->next(node);
-    }
-
-    void first(Arc& arc) const {
-      Node node;
-      first(node);
-      while (node != INVALID && (*_nodes)[node].first_in == -1) {
-        next(node);
-      }
-      arc.id = (node == INVALID) ? -1 : (*_nodes)[node].first_in;
-    }
-
-    void next(Arc& arc) const {
-      if (arcs[arc.id].next_in != -1) {
-        arc.id = arcs[arc.id].next_in;
-      } else {
-        Node node = arcs[arc.id].target;
-        next(node);
-        while (node != INVALID && (*_nodes)[node].first_in == -1) {
-          next(node);
-        }
-        arc.id = (node == INVALID) ? -1 : (*_nodes)[node].first_in;
-      }
-    }
-
-    void firstOut(Arc& arc, const Node& node) const {
-      arc.id = (*_nodes)[node].first_out;
-    }
-
-    void nextOut(Arc& arc) const {
-      arc.id = arcs[arc.id].next_out;
-    }
-
-    void firstIn(Arc& arc, const Node& node) const {
-      arc.id = (*_nodes)[node].first_in;
-    }
-
-    void nextIn(Arc& arc) const {
-      arc.id = arcs[arc.id].next_in;
-    }
-
-    int id(const Node& node) const { return _graph->id(node); }
-    int id(const Arc& arc) const { return arc.id; }
-
-    Node nodeFromId(int ix) const { return _graph->nodeFromId(ix); }
-    Arc arcFromId(int ix) const { return Arc(ix); }
-
-    int maxNodeId() const { return _graph->maxNodeId(); };
-    int maxArcId() const { return arcs.size() - 1; }
-
-    Node source(const Arc& arc) const { return arcs[arc.id].source;}
-    Node target(const Arc& arc) const { return arcs[arc.id].target;}
-
-    typedef typename ItemSetTraits<GR, Node>::ItemNotifier NodeNotifier;
-
-    NodeNotifier& notifier(Node) const {
-      return _graph->notifier(Node());
-    }
-
-    template <typename V>
-    class NodeMap : public GR::template NodeMap<V> {
-      typedef typename GR::template NodeMap<V> Parent;
-
-    public:
-
-      explicit NodeMap(const ListArcSetBase<GR>& arcset)
-        : Parent(*arcset._graph) {}
-
-      NodeMap(const ListArcSetBase<GR>& arcset, const V& value)
-        : Parent(*arcset._graph, value) {}
-
-      NodeMap& operator=(const NodeMap& cmap) {
-        return operator=<NodeMap>(cmap);
-      }
-
-      template <typename CMap>
-      NodeMap& operator=(const CMap& cmap) {
-        Parent::operator=(cmap);
-        return *this;
-      }
-    };
-
-  };
-
-  /// \ingroup graphs
-  ///
-  /// \brief Digraph using a node set of another digraph or graph and
-  /// an own arc set.
-  ///
-  /// This structure can be used to establish another directed graph
-  /// over a node set of an existing one. This class uses the same
-  /// Node type as the underlying graph, and each valid node of the
-  /// original graph is valid in this arc set, therefore the node
-  /// objects of the original graph can be used directly with this
-  /// class. The node handling functions (id handling, observing, and
-  /// iterators) works equivalently as in the original graph.
-  ///
-  /// This implementation is based on doubly-linked lists, from each
-  /// node the outgoing and the incoming arcs make up lists, therefore
-  /// one arc can be erased in constant time. It also makes possible,
-  /// that node can be removed from the underlying graph, in this case
-  /// 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.
-  template <typename GR>
-  class ListArcSet : public ArcSetExtender<ListArcSetBase<GR> > {
-    typedef ArcSetExtender<ListArcSetBase<GR> > Parent;
-
-  public:
-
-    typedef typename Parent::Node Node;
-    typedef typename Parent::Arc Arc;
-
-    typedef typename Parent::NodesImplBase NodesImplBase;
-
-    void eraseNode(const Node& node) {
-      Arc arc;
-      Parent::firstOut(arc, node);
-      while (arc != INVALID ) {
-        erase(arc);
-        Parent::firstOut(arc, node);
-      }
-
-      Parent::firstIn(arc, node);
-      while (arc != INVALID ) {
-        erase(arc);
-        Parent::firstIn(arc, node);
-      }
-    }
-
-    void clearNodes() {
-      Parent::clear();
-    }
-
-    class NodesImpl : public NodesImplBase {
-      typedef NodesImplBase Parent;
-
-    public:
-      NodesImpl(const GR& graph, ListArcSet& arcset)
-        : Parent(graph), _arcset(arcset) {}
-
-      virtual ~NodesImpl() {}
-
-    protected:
-
-      virtual void erase(const Node& node) {
-        _arcset.eraseNode(node);
-        Parent::erase(node);
-      }
-      virtual void erase(const std::vector<Node>& nodes) {
-        for (int i = 0; i < int(nodes.size()); ++i) {
-          _arcset.eraseNode(nodes[i]);
-        }
-        Parent::erase(nodes);
-      }
-      virtual void clear() {
-        _arcset.clearNodes();
-        Parent::clear();
-      }
-
-    private:
-      ListArcSet& _arcset;
-    };
-
-    NodesImpl _nodes;
-
-  public:
-
-    /// \brief Constructor of the ArcSet.
-    ///
-    /// Constructor of the ArcSet.
-    ListArcSet(const GR& graph) : _nodes(graph, *this) {
-      Parent::initalize(graph, _nodes);
-    }
-
-    /// \brief Add a new arc to the digraph.
-    ///
-    /// Add a new arc to the digraph with source node \c s
-    /// and target node \c t.
-    /// \return The new arc.
-    Arc addArc(const Node& s, const Node& t) {
-      return Parent::addArc(s, t);
-    }
-
-    /// \brief Erase an arc from the digraph.
-    ///
-    /// Erase an arc \c a from the digraph.
-    void erase(const Arc& a) {
-      return Parent::erase(a);
-    }
-
-  };
-
-  template <typename GR>
-  class ListEdgeSetBase {
-  public:
-
-    typedef typename GR::Node Node;
-    typedef typename GR::NodeIt NodeIt;
-
-  protected:
-
-    struct NodeT {
-      int first_out;
-      NodeT() : first_out(-1) {}
-    };
-
-    typedef typename ItemSetTraits<GR, Node>::
-    template Map<NodeT>::Type NodesImplBase;
-
-    NodesImplBase* _nodes;
-
-    struct ArcT {
-      Node target;
-      int prev_out, next_out;
-      ArcT() : prev_out(-1), next_out(-1) {}
-    };
-
-    std::vector<ArcT> arcs;
-
-    int first_arc;
-    int first_free_arc;
-
-    const GR* _graph;
-
-    void initalize(const GR& graph, NodesImplBase& nodes) {
-      _graph = &graph;
-      _nodes = &nodes;
-    }
-
-  public:
-
-    class Edge {
-      friend class ListEdgeSetBase;
-    protected:
-
-      int id;
-      explicit Edge(int _id) { id = _id;}
-
-    public:
-      Edge() {}
-      Edge (Invalid) { id = -1; }
-      bool operator==(const Edge& arc) const {return id == arc.id;}
-      bool operator!=(const Edge& arc) const {return id != arc.id;}
-      bool operator<(const Edge& arc) const {return id < arc.id;}
-    };
-
-    class Arc {
-      friend class ListEdgeSetBase;
-    protected:
-      Arc(int _id) : id(_id) {}
-      int id;
-    public:
-      operator Edge() const { return edgeFromId(id / 2); }
-
-      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; }
-    };
-
-    ListEdgeSetBase() : first_arc(-1), first_free_arc(-1) {}
-
-    Node addNode() {
-      LEMON_ASSERT(false,
-        "This graph structure does not support node insertion");
-      return INVALID; // avoid warning
-    }
-
-    Edge addEdge(const Node& u, const Node& v) {
-      int n;
-
-      if (first_free_arc == -1) {
-        n = arcs.size();
-        arcs.push_back(ArcT());
-        arcs.push_back(ArcT());
-      } else {
-        n = first_free_arc;
-        first_free_arc = arcs[n].next_out;
-      }
-
-      arcs[n].target = u;
-      arcs[n | 1].target = v;
-
-      arcs[n].next_out = (*_nodes)[v].first_out;
-      if ((*_nodes)[v].first_out != -1) {
-        arcs[(*_nodes)[v].first_out].prev_out = n;
-      }
-      (*_nodes)[v].first_out = n;
-      arcs[n].prev_out = -1;
-
-      if ((*_nodes)[u].first_out != -1) {
-        arcs[(*_nodes)[u].first_out].prev_out = (n | 1);
-      }
-      arcs[n | 1].next_out = (*_nodes)[u].first_out;
-      (*_nodes)[u].first_out = (n | 1);
-      arcs[n | 1].prev_out = -1;
-
-      return Edge(n / 2);
-    }
-
-    void erase(const Edge& arc) {
-      int n = arc.id * 2;
-
-      if (arcs[n].next_out != -1) {
-        arcs[arcs[n].next_out].prev_out = arcs[n].prev_out;
-      }
-
-      if (arcs[n].prev_out != -1) {
-        arcs[arcs[n].prev_out].next_out = arcs[n].next_out;
-      } else {
-        (*_nodes)[arcs[n | 1].target].first_out = arcs[n].next_out;
-      }
-
-      if (arcs[n | 1].next_out != -1) {
-        arcs[arcs[n | 1].next_out].prev_out = arcs[n | 1].prev_out;
-      }
-
-      if (arcs[n | 1].prev_out != -1) {
-        arcs[arcs[n | 1].prev_out].next_out = arcs[n | 1].next_out;
-      } else {
-        (*_nodes)[arcs[n].target].first_out = arcs[n | 1].next_out;
-      }
-
-      arcs[n].next_out = first_free_arc;
-      first_free_arc = n;
-
-    }
-
-    void clear() {
-      Node node;
-      for (first(node); node != INVALID; next(node)) {
-        (*_nodes)[node].first_out = -1;
-      }
-      arcs.clear();
-      first_arc = -1;
-      first_free_arc = -1;
-    }
-
-    void first(Node& node) const {
-      _graph->first(node);
-    }
-
-    void next(Node& node) const {
-      _graph->next(node);
-    }
-
-    void first(Arc& arc) const {
-      Node node;
-      first(node);
-      while (node != INVALID && (*_nodes)[node].first_out == -1) {
-        next(node);
-      }
-      arc.id = (node == INVALID) ? -1 : (*_nodes)[node].first_out;
-    }
-
-    void next(Arc& arc) const {
-      if (arcs[arc.id].next_out != -1) {
-        arc.id = arcs[arc.id].next_out;
-      } else {
-        Node node = arcs[arc.id ^ 1].target;
-        next(node);
-        while(node != INVALID && (*_nodes)[node].first_out == -1) {
-          next(node);
-        }
-        arc.id = (node == INVALID) ? -1 : (*_nodes)[node].first_out;
-      }
-    }
-
-    void first(Edge& edge) const {
-      Node node;
-      first(node);
-      while (node != INVALID) {
-        edge.id = (*_nodes)[node].first_out;
-        while ((edge.id & 1) != 1) {
-          edge.id = arcs[edge.id].next_out;
-        }
-        if (edge.id != -1) {
-          edge.id /= 2;
-          return;
-        }
-        next(node);
-      }
-      edge.id = -1;
-    }
-
-    void next(Edge& edge) const {
-      Node node = arcs[edge.id * 2].target;
-      edge.id = arcs[(edge.id * 2) | 1].next_out;
-      while ((edge.id & 1) != 1) {
-        edge.id = arcs[edge.id].next_out;
-      }
-      if (edge.id != -1) {
-        edge.id /= 2;
-        return;
-      }
-      next(node);
-      while (node != INVALID) {
-        edge.id = (*_nodes)[node].first_out;
-        while ((edge.id & 1) != 1) {
-          edge.id = arcs[edge.id].next_out;
-        }
-        if (edge.id != -1) {
-          edge.id /= 2;
-          return;
-        }
-        next(node);
-      }
-      edge.id = -1;
-    }
-
-    void firstOut(Arc& arc, const Node& node) const {
-      arc.id = (*_nodes)[node].first_out;
-    }
-
-    void nextOut(Arc& arc) const {
-      arc.id = arcs[arc.id].next_out;
-    }
-
-    void firstIn(Arc& arc, const Node& node) const {
-      arc.id = (((*_nodes)[node].first_out) ^ 1);
-      if (arc.id == -2) arc.id = -1;
-    }
-
-    void nextIn(Arc& arc) const {
-      arc.id = ((arcs[arc.id ^ 1].next_out) ^ 1);
-      if (arc.id == -2) arc.id = -1;
-    }
-
-    void firstInc(Edge &arc, bool& dir, const Node& node) const {
-      int de = (*_nodes)[node].first_out;
-      if (de != -1 ) {
-        arc.id = de / 2;
-        dir = ((de & 1) == 1);
-      } else {
-        arc.id = -1;
-        dir = true;
-      }
-    }
-    void nextInc(Edge &arc, bool& dir) const {
-      int de = (arcs[(arc.id * 2) | (dir ? 1 : 0)].next_out);
-      if (de != -1 ) {
-        arc.id = de / 2;
-        dir = ((de & 1) == 1);
-      } else {
-        arc.id = -1;
-        dir = true;
-      }
-    }
-
-    static bool direction(Arc arc) {
-      return (arc.id & 1) == 1;
-    }
-
-    static Arc direct(Edge edge, bool dir) {
-      return Arc(edge.id * 2 + (dir ? 1 : 0));
-    }
-
-    int id(const Node& node) const { return _graph->id(node); }
-    static int id(Arc e) { return e.id; }
-    static int id(Edge e) { return e.id; }
-
-    Node nodeFromId(int id) const { return _graph->nodeFromId(id); }
-    static Arc arcFromId(int id) { return Arc(id);}
-    static Edge edgeFromId(int id) { return Edge(id);}
-
-    int maxNodeId() const { return _graph->maxNodeId(); };
-    int maxEdgeId() const { return arcs.size() / 2 - 1; }
-    int maxArcId() const { return arcs.size()-1; }
-
-    Node source(Arc e) const { return arcs[e.id ^ 1].target; }
-    Node target(Arc e) const { return arcs[e.id].target; }
-
-    Node u(Edge e) const { return arcs[2 * e.id].target; }
-    Node v(Edge e) const { return arcs[2 * e.id + 1].target; }
-
-    typedef typename ItemSetTraits<GR, Node>::ItemNotifier NodeNotifier;
-
-    NodeNotifier& notifier(Node) const {
-      return _graph->notifier(Node());
-    }
-
-    template <typename V>
-    class NodeMap : public GR::template NodeMap<V> {
-      typedef typename GR::template NodeMap<V> Parent;
-
-    public:
-
-      explicit NodeMap(const ListEdgeSetBase<GR>& arcset)
-        : Parent(*arcset._graph) {}
-
-      NodeMap(const ListEdgeSetBase<GR>& arcset, const V& value)
-        : Parent(*arcset._graph, value) {}
-
-      NodeMap& operator=(const NodeMap& cmap) {
-        return operator=<NodeMap>(cmap);
-      }
-
-      template <typename CMap>
-      NodeMap& operator=(const CMap& cmap) {
-        Parent::operator=(cmap);
-        return *this;
-      }
-    };
-
-  };
-
-  /// \ingroup graphs
-  ///
-  /// \brief Graph using a node set of another digraph or graph and an
-  /// own edge set.
-  ///
-  /// This structure can be used to establish another graph over a
-  /// node set of an existing one. This class uses the same Node type
-  /// as the underlying graph, and each valid node of the original
-  /// graph is valid in this arc set, therefore the node objects of
-  /// the original graph can be used directly with this class. The
-  /// node handling functions (id handling, observing, and iterators)
-  /// works equivalently as in the original graph.
-  ///
-  /// This implementation is based on doubly-linked lists, from each
-  /// node the incident edges make up lists, therefore one edge can be
-  /// erased in constant time. It also makes possible, that node can
-  /// be removed from the underlying graph, in this case all edges
-  /// 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.
-  template <typename GR>
-  class ListEdgeSet : public EdgeSetExtender<ListEdgeSetBase<GR> > {
-    typedef EdgeSetExtender<ListEdgeSetBase<GR> > Parent;
-
-  public:
-
-    typedef typename Parent::Node Node;
-    typedef typename Parent::Arc Arc;
-    typedef typename Parent::Edge Edge;
-
-    typedef typename Parent::NodesImplBase NodesImplBase;
-
-    void eraseNode(const Node& node) {
-      Arc arc;
-      Parent::firstOut(arc, node);
-      while (arc != INVALID ) {
-        erase(arc);
-        Parent::firstOut(arc, node);
-      }
-
-    }
-
-    void clearNodes() {
-      Parent::clear();
-    }
-
-    class NodesImpl : public NodesImplBase {
-      typedef NodesImplBase Parent;
-
-    public:
-      NodesImpl(const GR& graph, ListEdgeSet& arcset)
-        : Parent(graph), _arcset(arcset) {}
-
-      virtual ~NodesImpl() {}
-
-    protected:
-
-      virtual void erase(const Node& node) {
-        _arcset.eraseNode(node);
-        Parent::erase(node);
-      }
-      virtual void erase(const std::vector<Node>& nodes) {
-        for (int i = 0; i < int(nodes.size()); ++i) {
-          _arcset.eraseNode(nodes[i]);
-        }
-        Parent::erase(nodes);
-      }
-      virtual void clear() {
-        _arcset.clearNodes();
-        Parent::clear();
-      }
-
-    private:
-      ListEdgeSet& _arcset;
-    };
-
-    NodesImpl _nodes;
-
-  public:
-
-    /// \brief Constructor of the EdgeSet.
-    ///
-    /// Constructor of the EdgeSet.
-    ListEdgeSet(const GR& graph) : _nodes(graph, *this) {
-      Parent::initalize(graph, _nodes);
-    }
-
-    /// \brief Add a new edge to the graph.
-    ///
-    /// Add a new edge to the graph with node \c u
-    /// and node \c v endpoints.
-    /// \return The new edge.
-    Edge addEdge(const Node& u, const Node& v) {
-      return Parent::addEdge(u, v);
-    }
-
-    /// \brief Erase an edge from the graph.
-    ///
-    /// Erase the edge \c e from the graph.
-    void erase(const Edge& e) {
-      return Parent::erase(e);
-    }
-
-  };
-
-  template <typename GR>
-  class SmartArcSetBase {
-  public:
-
-    typedef typename GR::Node Node;
-    typedef typename GR::NodeIt NodeIt;
-
-  protected:
-
-    struct NodeT {
-      int first_out, first_in;
-      NodeT() : first_out(-1), first_in(-1) {}
-    };
-
-    typedef typename ItemSetTraits<GR, Node>::
-    template Map<NodeT>::Type NodesImplBase;
-
-    NodesImplBase* _nodes;
-
-    struct ArcT {
-      Node source, target;
-      int next_out, next_in;
-      ArcT() {}
-    };
-
-    std::vector<ArcT> arcs;
-
-    const GR* _graph;
-
-    void initalize(const GR& graph, NodesImplBase& nodes) {
-      _graph = &graph;
-      _nodes = &nodes;
-    }
-
-  public:
-
-    class Arc {
-      friend class SmartArcSetBase<GR>;
-    protected:
-      Arc(int _id) : id(_id) {}
-      int 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; }
-    };
-
-    SmartArcSetBase() {}
-
-    Node addNode() {
-      LEMON_ASSERT(false,
-        "This graph structure does not support node insertion");
-      return INVALID; // avoid warning
-    }
-
-    Arc addArc(const Node& u, const Node& v) {
-      int n = arcs.size();
-      arcs.push_back(ArcT());
-      arcs[n].next_in = (*_nodes)[v].first_in;
-      (*_nodes)[v].first_in = n;
-      arcs[n].next_out = (*_nodes)[u].first_out;
-      (*_nodes)[u].first_out = n;
-      arcs[n].source = u;
-      arcs[n].target = v;
-      return Arc(n);
-    }
-
-    void clear() {
-      Node node;
-      for (first(node); node != INVALID; next(node)) {
-        (*_nodes)[node].first_in = -1;
-        (*_nodes)[node].first_out = -1;
-      }
-      arcs.clear();
-    }
-
-    void first(Node& node) const {
-      _graph->first(node);
-    }
-
-    void next(Node& node) const {
-      _graph->next(node);
-    }
-
-    void first(Arc& arc) const {
-      arc.id = arcs.size() - 1;
-    }
-
-    static void next(Arc& arc) {
-      --arc.id;
-    }
-
-    void firstOut(Arc& arc, const Node& node) const {
-      arc.id = (*_nodes)[node].first_out;
-    }
-
-    void nextOut(Arc& arc) const {
-      arc.id = arcs[arc.id].next_out;
-    }
-
-    void firstIn(Arc& arc, const Node& node) const {
-      arc.id = (*_nodes)[node].first_in;
-    }
-
-    void nextIn(Arc& arc) const {
-      arc.id = arcs[arc.id].next_in;
-    }
-
-    int id(const Node& node) const { return _graph->id(node); }
-    int id(const Arc& arc) const { return arc.id; }
-
-    Node nodeFromId(int ix) const { return _graph->nodeFromId(ix); }
-    Arc arcFromId(int ix) const { return Arc(ix); }
-
-    int maxNodeId() const { return _graph->maxNodeId(); };
-    int maxArcId() const { return arcs.size() - 1; }
-
-    Node source(const Arc& arc) const { return arcs[arc.id].source;}
-    Node target(const Arc& arc) const { return arcs[arc.id].target;}
-
-    typedef typename ItemSetTraits<GR, Node>::ItemNotifier NodeNotifier;
-
-    NodeNotifier& notifier(Node) const {
-      return _graph->notifier(Node());
-    }
-
-    template <typename V>
-    class NodeMap : public GR::template NodeMap<V> {
-      typedef typename GR::template NodeMap<V> Parent;
-
-    public:
-
-      explicit NodeMap(const SmartArcSetBase<GR>& arcset)
-        : Parent(*arcset._graph) { }
-
-      NodeMap(const SmartArcSetBase<GR>& arcset, const V& value)
-        : Parent(*arcset._graph, value) { }
-
-      NodeMap& operator=(const NodeMap& cmap) {
-        return operator=<NodeMap>(cmap);
-      }
-
-      template <typename CMap>
-      NodeMap& operator=(const CMap& cmap) {
-        Parent::operator=(cmap);
-        return *this;
-      }
-    };
-
-  };
-
-
-  /// \ingroup graphs
-  ///
-  /// \brief Digraph using a node set of another digraph or graph and
-  /// an own arc set.
-  ///
-  /// This structure can be used to establish another directed graph
-  /// over a node set of an existing one. This class uses the same
-  /// Node type as the underlying graph, and each valid node of the
-  /// original graph is valid in this arc set, therefore the node
-  /// objects of the original graph can be used directly with this
-  /// class. The node handling functions (id handling, observing, and
-  /// iterators) works equivalently as in the original graph.
-  ///
-  /// \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 implementation is slightly faster than the \c ListArcSet,
-  /// because it uses continuous storage for arcs and it uses just
-  /// single-linked lists for enumerate outgoing and incoming
-  /// 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.
-  template <typename GR>
-  class SmartArcSet : public ArcSetExtender<SmartArcSetBase<GR> > {
-    typedef ArcSetExtender<SmartArcSetBase<GR> > Parent;
-
-  public:
-
-    typedef typename Parent::Node Node;
-    typedef typename Parent::Arc Arc;
-
-  protected:
-
-    typedef typename Parent::NodesImplBase NodesImplBase;
-
-    void eraseNode(const Node& node) {
-      if (typename Parent::InArcIt(*this, node) == INVALID &&
-          typename Parent::OutArcIt(*this, node) == INVALID) {
-        return;
-      }
-      throw typename NodesImplBase::Notifier::ImmediateDetach();
-    }
-
-    void clearNodes() {
-      Parent::clear();
-    }
-
-    class NodesImpl : public NodesImplBase {
-      typedef NodesImplBase Parent;
-
-    public:
-      NodesImpl(const GR& graph, SmartArcSet& arcset)
-        : Parent(graph), _arcset(arcset) {}
-
-      virtual ~NodesImpl() {}
-
-      bool attached() const {
-        return Parent::attached();
-      }
-
-    protected:
-
-      virtual void erase(const Node& node) {
-        try {
-          _arcset.eraseNode(node);
-          Parent::erase(node);
-        } catch (const typename NodesImplBase::Notifier::ImmediateDetach&) {
-          Parent::clear();
-          throw;
-        }
-      }
-      virtual void erase(const std::vector<Node>& nodes) {
-        try {
-          for (int i = 0; i < int(nodes.size()); ++i) {
-            _arcset.eraseNode(nodes[i]);
-          }
-          Parent::erase(nodes);
-        } catch (const typename NodesImplBase::Notifier::ImmediateDetach&) {
-          Parent::clear();
-          throw;
-        }
-      }
-      virtual void clear() {
-        _arcset.clearNodes();
-        Parent::clear();
-      }
-
-    private:
-      SmartArcSet& _arcset;
-    };
-
-    NodesImpl _nodes;
-
-  public:
-
-    /// \brief Constructor of the ArcSet.
-    ///
-    /// Constructor of the ArcSet.
-    SmartArcSet(const GR& graph) : _nodes(graph, *this) {
-      Parent::initalize(graph, _nodes);
-    }
-
-    /// \brief Add a new arc to the digraph.
-    ///
-    /// Add a new arc to the digraph with source node \c s
-    /// and target node \c t.
-    /// \return The new arc.
-    Arc addArc(const Node& s, const Node& t) {
-      return Parent::addArc(s, t);
-    }
-
-    /// \brief Validity check
-    ///
-    /// This functions gives back false if the ArcSet is
-    /// invalidated. It occurs when a node in the underlying graph is
-    /// erased and it is not isolated in the ArcSet.
-    bool valid() const {
-      return _nodes.attached();
-    }
-
-  };
-
-
-  template <typename GR>
-  class SmartEdgeSetBase {
-  public:
-
-    typedef typename GR::Node Node;
-    typedef typename GR::NodeIt NodeIt;
-
-  protected:
-
-    struct NodeT {
-      int first_out;
-      NodeT() : first_out(-1) {}
-    };
-
-    typedef typename ItemSetTraits<GR, Node>::
-    template Map<NodeT>::Type NodesImplBase;
-
-    NodesImplBase* _nodes;
-
-    struct ArcT {
-      Node target;
-      int next_out;
-      ArcT() {}
-    };
-
-    std::vector<ArcT> arcs;
-
-    const GR* _graph;
-
-    void initalize(const GR& graph, NodesImplBase& nodes) {
-      _graph = &graph;
-      _nodes = &nodes;
-    }
-
-  public:
-
-    class Edge {
-      friend class SmartEdgeSetBase;
-    protected:
-
-      int id;
-      explicit Edge(int _id) { id = _id;}
-
-    public:
-      Edge() {}
-      Edge (Invalid) { id = -1; }
-      bool operator==(const Edge& arc) const {return id == arc.id;}
-      bool operator!=(const Edge& arc) const {return id != arc.id;}
-      bool operator<(const Edge& arc) const {return id < arc.id;}
-    };
-
-    class Arc {
-      friend class SmartEdgeSetBase;
-    protected:
-      Arc(int _id) : id(_id) {}
-      int id;
-    public:
-      operator Edge() const { return edgeFromId(id / 2); }
-
-      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; }
-    };
-
-    SmartEdgeSetBase() {}
-
-    Node addNode() {
-      LEMON_ASSERT(false,
-        "This graph structure does not support node insertion");
-      return INVALID; // avoid warning
-    }
-
-    Edge addEdge(const Node& u, const Node& v) {
-      int n = arcs.size();
-      arcs.push_back(ArcT());
-      arcs.push_back(ArcT());
-
-      arcs[n].target = u;
-      arcs[n | 1].target = v;
-
-      arcs[n].next_out = (*_nodes)[v].first_out;
-      (*_nodes)[v].first_out = n;
-
-      arcs[n | 1].next_out = (*_nodes)[u].first_out;
-      (*_nodes)[u].first_out = (n | 1);
-
-      return Edge(n / 2);
-    }
-
-    void clear() {
-      Node node;
-      for (first(node); node != INVALID; next(node)) {
-        (*_nodes)[node].first_out = -1;
-      }
-      arcs.clear();
-    }
-
-    void first(Node& node) const {
-      _graph->first(node);
-    }
-
-    void next(Node& node) const {
-      _graph->next(node);
-    }
-
-    void first(Arc& arc) const {
-      arc.id = arcs.size() - 1;
-    }
-
-    static void next(Arc& arc) {
-      --arc.id;
-    }
-
-    void first(Edge& arc) const {
-      arc.id = arcs.size() / 2 - 1;
-    }
-
-    static void next(Edge& arc) {
-      --arc.id;
-    }
-
-    void firstOut(Arc& arc, const Node& node) const {
-      arc.id = (*_nodes)[node].first_out;
-    }
-
-    void nextOut(Arc& arc) const {
-      arc.id = arcs[arc.id].next_out;
-    }
-
-    void firstIn(Arc& arc, const Node& node) const {
-      arc.id = (((*_nodes)[node].first_out) ^ 1);
-      if (arc.id == -2) arc.id = -1;
-    }
-
-    void nextIn(Arc& arc) const {
-      arc.id = ((arcs[arc.id ^ 1].next_out) ^ 1);
-      if (arc.id == -2) arc.id = -1;
-    }
-
-    void firstInc(Edge &arc, bool& dir, const Node& node) const {
-      int de = (*_nodes)[node].first_out;
-      if (de != -1 ) {
-        arc.id = de / 2;
-        dir = ((de & 1) == 1);
-      } else {
-        arc.id = -1;
-        dir = true;
-      }
-    }
-    void nextInc(Edge &arc, bool& dir) const {
-      int de = (arcs[(arc.id * 2) | (dir ? 1 : 0)].next_out);
-      if (de != -1 ) {
-        arc.id = de / 2;
-        dir = ((de & 1) == 1);
-      } else {
-        arc.id = -1;
-        dir = true;
-      }
-    }
-
-    static bool direction(Arc arc) {
-      return (arc.id & 1) == 1;
-    }
-
-    static Arc direct(Edge edge, bool dir) {
-      return Arc(edge.id * 2 + (dir ? 1 : 0));
-    }
-
-    int id(Node node) const { return _graph->id(node); }
-    static int id(Arc arc) { return arc.id; }
-    static int id(Edge arc) { return arc.id; }
-
-    Node nodeFromId(int id) const { return _graph->nodeFromId(id); }
-    static Arc arcFromId(int id) { return Arc(id); }
-    static Edge edgeFromId(int id) { return Edge(id);}
-
-    int maxNodeId() const { return _graph->maxNodeId(); };
-    int maxArcId() const { return arcs.size() - 1; }
-    int maxEdgeId() const { return arcs.size() / 2 - 1; }
-
-    Node source(Arc e) const { return arcs[e.id ^ 1].target; }
-    Node target(Arc e) const { return arcs[e.id].target; }
-
-    Node u(Edge e) const { return arcs[2 * e.id].target; }
-    Node v(Edge e) const { return arcs[2 * e.id + 1].target; }
-
-    typedef typename ItemSetTraits<GR, Node>::ItemNotifier NodeNotifier;
-
-    NodeNotifier& notifier(Node) const {
-      return _graph->notifier(Node());
-    }
-
-    template <typename V>
-    class NodeMap : public GR::template NodeMap<V> {
-      typedef typename GR::template NodeMap<V> Parent;
-
-    public:
-
-      explicit NodeMap(const SmartEdgeSetBase<GR>& arcset)
-        : Parent(*arcset._graph) { }
-
-      NodeMap(const SmartEdgeSetBase<GR>& arcset, const V& value)
-        : Parent(*arcset._graph, value) { }
-
-      NodeMap& operator=(const NodeMap& cmap) {
-        return operator=<NodeMap>(cmap);
-      }
-
-      template <typename CMap>
-      NodeMap& operator=(const CMap& cmap) {
-        Parent::operator=(cmap);
-        return *this;
-      }
-    };
-
-  };
-
-  /// \ingroup graphs
-  ///
-  /// \brief Graph using a node set of another digraph or graph and an
-  /// own edge set.
-  ///
-  /// This structure can be used to establish another graph over a
-  /// node set of an existing one. This class uses the same Node type
-  /// as the underlying graph, and each valid node of the original
-  /// graph is valid in this arc set, therefore the node objects of
-  /// the original graph can be used directly with this class. The
-  /// node handling functions (id handling, observing, and iterators)
-  /// works equivalently as in the original graph.
-  ///
-  /// \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 implementation is slightly faster than the \c ListEdgeSet,
-  /// because it uses continuous storage for edges and it uses just
-  /// single-linked lists for enumerate incident edges. Therefore the
-  /// 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.
-  template <typename GR>
-  class SmartEdgeSet : public EdgeSetExtender<SmartEdgeSetBase<GR> > {
-    typedef EdgeSetExtender<SmartEdgeSetBase<GR> > Parent;
-
-  public:
-
-    typedef typename Parent::Node Node;
-    typedef typename Parent::Arc Arc;
-    typedef typename Parent::Edge Edge;
-
-  protected:
-
-    typedef typename Parent::NodesImplBase NodesImplBase;
-
-    void eraseNode(const Node& node) {
-      if (typename Parent::IncEdgeIt(*this, node) == INVALID) {
-        return;
-      }
-      throw typename NodesImplBase::Notifier::ImmediateDetach();
-    }
-
-    void clearNodes() {
-      Parent::clear();
-    }
-
-    class NodesImpl : public NodesImplBase {
-      typedef NodesImplBase Parent;
-
-    public:
-      NodesImpl(const GR& graph, SmartEdgeSet& arcset)
-        : Parent(graph), _arcset(arcset) {}
-
-      virtual ~NodesImpl() {}
-
-      bool attached() const {
-        return Parent::attached();
-      }
-
-    protected:
-
-      virtual void erase(const Node& node) {
-        try {
-          _arcset.eraseNode(node);
-          Parent::erase(node);
-        } catch (const typename NodesImplBase::Notifier::ImmediateDetach&) {
-          Parent::clear();
-          throw;
-        }
-      }
-      virtual void erase(const std::vector<Node>& nodes) {
-        try {
-          for (int i = 0; i < int(nodes.size()); ++i) {
-            _arcset.eraseNode(nodes[i]);
-          }
-          Parent::erase(nodes);
-        } catch (const typename NodesImplBase::Notifier::ImmediateDetach&) {
-          Parent::clear();
-          throw;
-        }
-      }
-      virtual void clear() {
-        _arcset.clearNodes();
-        Parent::clear();
-      }
-
-    private:
-      SmartEdgeSet& _arcset;
-    };
-
-    NodesImpl _nodes;
-
-  public:
-
-    /// \brief Constructor of the EdgeSet.
-    ///
-    /// Constructor of the EdgeSet.
-    SmartEdgeSet(const GR& graph) : _nodes(graph, *this) {
-      Parent::initalize(graph, _nodes);
-    }
-
-    /// \brief Add a new edge to the graph.
-    ///
-    /// Add a new edge to the graph with node \c u
-    /// and node \c v endpoints.
-    /// \return The new edge.
-    Edge addEdge(const Node& u, const Node& v) {
-      return Parent::addEdge(u, v);
-    }
-
-    /// \brief Validity check
-    ///
-    /// This functions gives back false if the EdgeSet is
-    /// invalidated. It occurs when a node in the underlying graph is
-    /// erased and it is not isolated in the EdgeSet.
-    bool valid() const {
-      return _nodes.attached();
-    }
-
-  };
-
-}
-
-#endif
Index: mon/elevator.h
===================================================================
--- lemon/elevator.h	(revision 628)
+++ 	(revision )
@@ -1,982 +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_ELEVATOR_H
-#define LEMON_ELEVATOR_H
-
-///\ingroup auxdat
-///\file
-///\brief Elevator class
-///
-///Elevator class implements an efficient data structure
-///for labeling items in push-relabel type algorithms.
-///
-
-#include <lemon/core.h>
-#include <lemon/bits/traits.h>
-
-namespace lemon {
-
-  ///Class for handling "labels" in push-relabel type algorithms.
-
-  ///A class for handling "labels" in push-relabel type algorithms.
-  ///
-  ///\ingroup auxdat
-  ///Using this class you can assign "labels" (nonnegative integer numbers)
-  ///to the edges or nodes of a graph, manipulate and query them through
-  ///operations typically arising in "push-relabel" type algorithms.
-  ///
-  ///Each item is either \em active or not, and you can also choose a
-  ///highest level active item.
-  ///
-  ///\sa LinkedElevator
-  ///
-  ///\param GR Type of the underlying graph.
-  ///\param Item Type of the items the data is assigned to (\c GR::Node,
-  ///\c GR::Arc or \c GR::Edge).
-  template<class GR, class Item>
-  class Elevator
-  {
-  public:
-
-    typedef Item Key;
-    typedef int Value;
-
-  private:
-
-    typedef Item *Vit;
-    typedef typename ItemSetTraits<GR,Item>::template Map<Vit>::Type VitMap;
-    typedef typename ItemSetTraits<GR,Item>::template Map<int>::Type IntMap;
-
-    const GR &_g;
-    int _max_level;
-    int _item_num;
-    VitMap _where;
-    IntMap _level;
-    std::vector<Item> _items;
-    std::vector<Vit> _first;
-    std::vector<Vit> _last_active;
-
-    int _highest_active;
-
-    void copy(Item i, Vit p)
-    {
-      _where[*p=i] = p;
-    }
-    void copy(Vit s, Vit p)
-    {
-      if(s!=p)
-        {
-          Item i=*s;
-          *p=i;
-          _where[i] = p;
-        }
-    }
-    void swap(Vit i, Vit j)
-    {
-      Item ti=*i;
-      Vit ct = _where[ti];
-      _where[ti] = _where[*i=*j];
-      _where[*j] = ct;
-      *j=ti;
-    }
-
-  public:
-
-    ///Constructor with given maximum level.
-
-    ///Constructor with given maximum level.
-    ///
-    ///\param graph The underlying graph.
-    ///\param max_level The maximum allowed level.
-    ///Set the range of the possible labels to <tt>[0..max_level]</tt>.
-    Elevator(const GR &graph,int max_level) :
-      _g(graph),
-      _max_level(max_level),
-      _item_num(_max_level),
-      _where(graph),
-      _level(graph,0),
-      _items(_max_level),
-      _first(_max_level+2),
-      _last_active(_max_level+2),
-      _highest_active(-1) {}
-    ///Constructor.
-
-    ///Constructor.
-    ///
-    ///\param graph The underlying graph.
-    ///Set the range of the possible labels to <tt>[0..max_level]</tt>,
-    ///where \c max_level is equal to the number of labeled items in the graph.
-    Elevator(const GR &graph) :
-      _g(graph),
-      _max_level(countItems<GR, Item>(graph)),
-      _item_num(_max_level),
-      _where(graph),
-      _level(graph,0),
-      _items(_max_level),
-      _first(_max_level+2),
-      _last_active(_max_level+2),
-      _highest_active(-1)
-    {
-    }
-
-    ///Activate item \c i.
-
-    ///Activate item \c i.
-    ///\pre Item \c i shouldn't be active before.
-    void activate(Item i)
-    {
-      const int l=_level[i];
-      swap(_where[i],++_last_active[l]);
-      if(l>_highest_active) _highest_active=l;
-    }
-
-    ///Deactivate item \c i.
-
-    ///Deactivate item \c i.
-    ///\pre Item \c i must be active before.
-    void deactivate(Item i)
-    {
-      swap(_where[i],_last_active[_level[i]]--);
-      while(_highest_active>=0 &&
-            _last_active[_highest_active]<_first[_highest_active])
-        _highest_active--;
-    }
-
-    ///Query whether item \c i is active
-    bool active(Item i) const { return _where[i]<=_last_active[_level[i]]; }
-
-    ///Return the level of item \c i.
-    int operator[](Item i) const { return _level[i]; }
-
-    ///Return the number of items on level \c l.
-    int onLevel(int l) const
-    {
-      return _first[l+1]-_first[l];
-    }
-    ///Return true if level \c l is empty.
-    bool emptyLevel(int l) const
-    {
-      return _first[l+1]-_first[l]==0;
-    }
-    ///Return the number of items above level \c l.
-    int aboveLevel(int l) const
-    {
-      return _first[_max_level+1]-_first[l+1];
-    }
-    ///Return the number of active items on level \c l.
-    int activesOnLevel(int l) const
-    {
-      return _last_active[l]-_first[l]+1;
-    }
-    ///Return true if there is no active item on level \c l.
-    bool activeFree(int l) const
-    {
-      return _last_active[l]<_first[l];
-    }
-    ///Return the maximum allowed level.
-    int maxLevel() const
-    {
-      return _max_level;
-    }
-
-    ///\name Highest Active Item
-    ///Functions for working with the highest level
-    ///active item.
-
-    ///@{
-
-    ///Return a highest level active item.
-
-    ///Return a highest level active item or INVALID if there is no active
-    ///item.
-    Item highestActive() const
-    {
-      return _highest_active>=0?*_last_active[_highest_active]:INVALID;
-    }
-
-    ///Return the highest active level.
-
-    ///Return the level of the highest active item or -1 if there is no active
-    ///item.
-    int highestActiveLevel() const
-    {
-      return _highest_active;
-    }
-
-    ///Lift the highest active item by one.
-
-    ///Lift the item returned by highestActive() by one.
-    ///
-    void liftHighestActive()
-    {
-      Item it = *_last_active[_highest_active];
-      ++_level[it];
-      swap(_last_active[_highest_active]--,_last_active[_highest_active+1]);
-      --_first[++_highest_active];
-    }
-
-    ///Lift the highest active item to the given level.
-
-    ///Lift the item returned by highestActive() to level \c new_level.
-    ///
-    ///\warning \c new_level must be strictly higher
-    ///than the current level.
-    ///
-    void liftHighestActive(int new_level)
-    {
-      const Item li = *_last_active[_highest_active];
-
-      copy(--_first[_highest_active+1],_last_active[_highest_active]--);
-      for(int l=_highest_active+1;l<new_level;l++)
-        {
-          copy(--_first[l+1],_first[l]);
-          --_last_active[l];
-        }
-      copy(li,_first[new_level]);
-      _level[li] = new_level;
-      _highest_active=new_level;
-    }
-
-    ///Lift the highest active item to the top level.
-
-    ///Lift the item returned by highestActive() to the top level and
-    ///deactivate it.
-    void liftHighestActiveToTop()
-    {
-      const Item li = *_last_active[_highest_active];
-
-      copy(--_first[_highest_active+1],_last_active[_highest_active]--);
-      for(int l=_highest_active+1;l<_max_level;l++)
-        {
-          copy(--_first[l+1],_first[l]);
-          --_last_active[l];
-        }
-      copy(li,_first[_max_level]);
-      --_last_active[_max_level];
-      _level[li] = _max_level;
-
-      while(_highest_active>=0 &&
-            _last_active[_highest_active]<_first[_highest_active])
-        _highest_active--;
-    }
-
-    ///@}
-
-    ///\name Active Item on Certain Level
-    ///Functions for working with the active items.
-
-    ///@{
-
-    ///Return an active item on level \c l.
-
-    ///Return an active item on level \c l or \ref INVALID if there is no such
-    ///an item. (\c l must be from the range [0...\c max_level].
-    Item activeOn(int l) const
-    {
-      return _last_active[l]>=_first[l]?*_last_active[l]:INVALID;
-    }
-
-    ///Lift the active item returned by \c activeOn(level) by one.
-
-    ///Lift the active item returned by \ref activeOn() "activeOn(level)"
-    ///by one.
-    Item liftActiveOn(int level)
-    {
-      Item it =*_last_active[level];
-      ++_level[it];
-      swap(_last_active[level]--, --_first[level+1]);
-      if (level+1>_highest_active) ++_highest_active;
-    }
-
-    ///Lift the active item returned by \c activeOn(level) to the given level.
-
-    ///Lift the active item returned by \ref activeOn() "activeOn(level)"
-    ///to the given level.
-    void liftActiveOn(int level, int new_level)
-    {
-      const Item ai = *_last_active[level];
-
-      copy(--_first[level+1], _last_active[level]--);
-      for(int l=level+1;l<new_level;l++)
-        {
-          copy(_last_active[l],_first[l]);
-          copy(--_first[l+1], _last_active[l]--);
-        }
-      copy(ai,_first[new_level]);
-      _level[ai] = new_level;
-      if (new_level>_highest_active) _highest_active=new_level;
-    }
-
-    ///Lift the active item returned by \c activeOn(level) to the top level.
-
-    ///Lift the active item returned by \ref activeOn() "activeOn(level)"
-    ///to the top level and deactivate it.
-    void liftActiveToTop(int level)
-    {
-      const Item ai = *_last_active[level];
-
-      copy(--_first[level+1],_last_active[level]--);
-      for(int l=level+1;l<_max_level;l++)
-        {
-          copy(_last_active[l],_first[l]);
-          copy(--_first[l+1], _last_active[l]--);
-        }
-      copy(ai,_first[_max_level]);
-      --_last_active[_max_level];
-      _level[ai] = _max_level;
-
-      if (_highest_active==level) {
-        while(_highest_active>=0 &&
-              _last_active[_highest_active]<_first[_highest_active])
-          _highest_active--;
-      }
-    }
-
-    ///@}
-
-    ///Lift an active item to a higher level.
-
-    ///Lift an active item to a higher level.
-    ///\param i The item to be lifted. It must be active.
-    ///\param new_level The new level of \c i. It must be strictly higher
-    ///than the current level.
-    ///
-    void lift(Item i, int new_level)
-    {
-      const int lo = _level[i];
-      const Vit w = _where[i];
-
-      copy(_last_active[lo],w);
-      copy(--_first[lo+1],_last_active[lo]--);
-      for(int l=lo+1;l<new_level;l++)
-        {
-          copy(_last_active[l],_first[l]);
-          copy(--_first[l+1],_last_active[l]--);
-        }
-      copy(i,_first[new_level]);
-      _level[i] = new_level;
-      if(new_level>_highest_active) _highest_active=new_level;
-    }
-
-    ///Move an inactive item to the top but one level (in a dirty way).
-
-    ///This function moves an inactive item from the top level to the top
-    ///but one level (in a dirty way).
-    ///\warning It makes the underlying datastructure corrupt, so use it
-    ///only if you really know what it is for.
-    ///\pre The item is on the top level.
-    void dirtyTopButOne(Item i) {
-      _level[i] = _max_level - 1;
-    }
-
-    ///Lift all items on and above the given level to the top level.
-
-    ///This function lifts all items on and above level \c l to the top
-    ///level and deactivates them.
-    void liftToTop(int l)
-    {
-      const Vit f=_first[l];
-      const Vit tl=_first[_max_level];
-      for(Vit i=f;i!=tl;++i)
-        _level[*i] = _max_level;
-      for(int i=l;i<=_max_level;i++)
-        {
-          _first[i]=f;
-          _last_active[i]=f-1;
-        }
-      for(_highest_active=l-1;
-          _highest_active>=0 &&
-            _last_active[_highest_active]<_first[_highest_active];
-          _highest_active--) ;
-    }
-
-  private:
-    int _init_lev;
-    Vit _init_num;
-
-  public:
-
-    ///\name Initialization
-    ///Using these functions you can initialize the levels of the items.
-    ///\n
-    ///The initialization must be started with calling \c initStart().
-    ///Then the items should be listed level by level starting with the
-    ///lowest one (level 0) using \c initAddItem() and \c initNewLevel().
-    ///Finally \c initFinish() must be called.
-    ///The items not listed are put on the highest level.
-    ///@{
-
-    ///Start the initialization process.
-    void initStart()
-    {
-      _init_lev=0;
-      _init_num=&_items[0];
-      _first[0]=&_items[0];
-      _last_active[0]=&_items[0]-1;
-      Vit n=&_items[0];
-      for(typename ItemSetTraits<GR,Item>::ItemIt i(_g);i!=INVALID;++i)
-        {
-          *n=i;
-          _where[i] = n;
-          _level[i] = _max_level;
-          ++n;
-        }
-    }
-
-    ///Add an item to the current level.
-    void initAddItem(Item i)
-    {
-      swap(_where[i],_init_num);
-      _level[i] = _init_lev;
-      ++_init_num;
-    }
-
-    ///Start a new level.
-
-    ///Start a new level.
-    ///It shouldn't be used before the items on level 0 are listed.
-    void initNewLevel()
-    {
-      _init_lev++;
-      _first[_init_lev]=_init_num;
-      _last_active[_init_lev]=_init_num-1;
-    }
-
-    ///Finalize the initialization process.
-    void initFinish()
-    {
-      for(_init_lev++;_init_lev<=_max_level;_init_lev++)
-        {
-          _first[_init_lev]=_init_num;
-          _last_active[_init_lev]=_init_num-1;
-        }
-      _first[_max_level+1]=&_items[0]+_item_num;
-      _last_active[_max_level+1]=&_items[0]+_item_num-1;
-      _highest_active = -1;
-    }
-
-    ///@}
-
-  };
-
-  ///Class for handling "labels" in push-relabel type algorithms.
-
-  ///A class for handling "labels" in push-relabel type algorithms.
-  ///
-  ///\ingroup auxdat
-  ///Using this class you can assign "labels" (nonnegative integer numbers)
-  ///to the edges or nodes of a graph, manipulate and query them through
-  ///operations typically arising in "push-relabel" type algorithms.
-  ///
-  ///Each item is either \em active or not, and you can also choose a
-  ///highest level active item.
-  ///
-  ///\sa Elevator
-  ///
-  ///\param GR Type of the underlying graph.
-  ///\param Item Type of the items the data is assigned to (\c GR::Node,
-  ///\c GR::Arc or \c GR::Edge).
-  template <class GR, class Item>
-  class LinkedElevator {
-  public:
-
-    typedef Item Key;
-    typedef int Value;
-
-  private:
-
-    typedef typename ItemSetTraits<GR,Item>::
-    template Map<Item>::Type ItemMap;
-    typedef typename ItemSetTraits<GR,Item>::
-    template Map<int>::Type IntMap;
-    typedef typename ItemSetTraits<GR,Item>::
-    template Map<bool>::Type BoolMap;
-
-    const GR &_graph;
-    int _max_level;
-    int _item_num;
-    std::vector<Item> _first, _last;
-    ItemMap _prev, _next;
-    int _highest_active;
-    IntMap _level;
-    BoolMap _active;
-
-  public:
-    ///Constructor with given maximum level.
-
-    ///Constructor with given maximum level.
-    ///
-    ///\param graph The underlying graph.
-    ///\param max_level The maximum allowed level.
-    ///Set the range of the possible labels to <tt>[0..max_level]</tt>.
-    LinkedElevator(const GR& graph, int max_level)
-      : _graph(graph), _max_level(max_level), _item_num(_max_level),
-        _first(_max_level + 1), _last(_max_level + 1),
-        _prev(graph), _next(graph),
-        _highest_active(-1), _level(graph), _active(graph) {}
-
-    ///Constructor.
-
-    ///Constructor.
-    ///
-    ///\param graph The underlying graph.
-    ///Set the range of the possible labels to <tt>[0..max_level]</tt>,
-    ///where \c max_level is equal to the number of labeled items in the graph.
-    LinkedElevator(const GR& graph)
-      : _graph(graph), _max_level(countItems<GR, Item>(graph)),
-        _item_num(_max_level),
-        _first(_max_level + 1), _last(_max_level + 1),
-        _prev(graph, INVALID), _next(graph, INVALID),
-        _highest_active(-1), _level(graph), _active(graph) {}
-
-
-    ///Activate item \c i.
-
-    ///Activate item \c i.
-    ///\pre Item \c i shouldn't be active before.
-    void activate(Item i) {
-      _active[i] = true;
-
-      int level = _level[i];
-      if (level > _highest_active) {
-        _highest_active = level;
-      }
-
-      if (_prev[i] == INVALID || _active[_prev[i]]) return;
-      //unlace
-      _next[_prev[i]] = _next[i];
-      if (_next[i] != INVALID) {
-        _prev[_next[i]] = _prev[i];
-      } else {
-        _last[level] = _prev[i];
-      }
-      //lace
-      _next[i] = _first[level];
-      _prev[_first[level]] = i;
-      _prev[i] = INVALID;
-      _first[level] = i;
-
-    }
-
-    ///Deactivate item \c i.
-
-    ///Deactivate item \c i.
-    ///\pre Item \c i must be active before.
-    void deactivate(Item i) {
-      _active[i] = false;
-      int level = _level[i];
-
-      if (_next[i] == INVALID || !_active[_next[i]])
-        goto find_highest_level;
-
-      //unlace
-      _prev[_next[i]] = _prev[i];
-      if (_prev[i] != INVALID) {
-        _next[_prev[i]] = _next[i];
-      } else {
-        _first[_level[i]] = _next[i];
-      }
-      //lace
-      _prev[i] = _last[level];
-      _next[_last[level]] = i;
-      _next[i] = INVALID;
-      _last[level] = i;
-
-    find_highest_level:
-      if (level == _highest_active) {
-        while (_highest_active >= 0 && activeFree(_highest_active))
-          --_highest_active;
-      }
-    }
-
-    ///Query whether item \c i is active
-    bool active(Item i) const { return _active[i]; }
-
-    ///Return the level of item \c i.
-    int operator[](Item i) const { return _level[i]; }
-
-    ///Return the number of items on level \c l.
-    int onLevel(int l) const {
-      int num = 0;
-      Item n = _first[l];
-      while (n != INVALID) {
-        ++num;
-        n = _next[n];
-      }
-      return num;
-    }
-
-    ///Return true if the level is empty.
-    bool emptyLevel(int l) const {
-      return _first[l] == INVALID;
-    }
-
-    ///Return the number of items above level \c l.
-    int aboveLevel(int l) const {
-      int num = 0;
-      for (int level = l + 1; level < _max_level; ++level)
-        num += onLevel(level);
-      return num;
-    }
-
-    ///Return the number of active items on level \c l.
-    int activesOnLevel(int l) const {
-      int num = 0;
-      Item n = _first[l];
-      while (n != INVALID && _active[n]) {
-        ++num;
-        n = _next[n];
-      }
-      return num;
-    }
-
-    ///Return true if there is no active item on level \c l.
-    bool activeFree(int l) const {
-      return _first[l] == INVALID || !_active[_first[l]];
-    }
-
-    ///Return the maximum allowed level.
-    int maxLevel() const {
-      return _max_level;
-    }
-
-    ///\name Highest Active Item
-    ///Functions for working with the highest level
-    ///active item.
-
-    ///@{
-
-    ///Return a highest level active item.
-
-    ///Return a highest level active item or INVALID if there is no active
-    ///item.
-    Item highestActive() const {
-      return _highest_active >= 0 ? _first[_highest_active] : INVALID;
-    }
-
-    ///Return the highest active level.
-
-    ///Return the level of the highest active item or -1 if there is no active
-    ///item.
-    int highestActiveLevel() const {
-      return _highest_active;
-    }
-
-    ///Lift the highest active item by one.
-
-    ///Lift the item returned by highestActive() by one.
-    ///
-    void liftHighestActive() {
-      Item i = _first[_highest_active];
-      if (_next[i] != INVALID) {
-        _prev[_next[i]] = INVALID;
-        _first[_highest_active] = _next[i];
-      } else {
-        _first[_highest_active] = INVALID;
-        _last[_highest_active] = INVALID;
-      }
-      _level[i] = ++_highest_active;
-      if (_first[_highest_active] == INVALID) {
-        _first[_highest_active] = i;
-        _last[_highest_active] = i;
-        _prev[i] = INVALID;
-        _next[i] = INVALID;
-      } else {
-        _prev[_first[_highest_active]] = i;
-        _next[i] = _first[_highest_active];
-        _first[_highest_active] = i;
-      }
-    }
-
-    ///Lift the highest active item to the given level.
-
-    ///Lift the item returned by highestActive() to level \c new_level.
-    ///
-    ///\warning \c new_level must be strictly higher
-    ///than the current level.
-    ///
-    void liftHighestActive(int new_level) {
-      Item i = _first[_highest_active];
-      if (_next[i] != INVALID) {
-        _prev[_next[i]] = INVALID;
-        _first[_highest_active] = _next[i];
-      } else {
-        _first[_highest_active] = INVALID;
-        _last[_highest_active] = INVALID;
-      }
-      _level[i] = _highest_active = new_level;
-      if (_first[_highest_active] == INVALID) {
-        _first[_highest_active] = _last[_highest_active] = i;
-        _prev[i] = INVALID;
-        _next[i] = INVALID;
-      } else {
-        _prev[_first[_highest_active]] = i;
-        _next[i] = _first[_highest_active];
-        _first[_highest_active] = i;
-      }
-    }
-
-    ///Lift the highest active item to the top level.
-
-    ///Lift the item returned by highestActive() to the top level and
-    ///deactivate it.
-    void liftHighestActiveToTop() {
-      Item i = _first[_highest_active];
-      _level[i] = _max_level;
-      if (_next[i] != INVALID) {
-        _prev[_next[i]] = INVALID;
-        _first[_highest_active] = _next[i];
-      } else {
-        _first[_highest_active] = INVALID;
-        _last[_highest_active] = INVALID;
-      }
-      while (_highest_active >= 0 && activeFree(_highest_active))
-        --_highest_active;
-    }
-
-    ///@}
-
-    ///\name Active Item on Certain Level
-    ///Functions for working with the active items.
-
-    ///@{
-
-    ///Return an active item on level \c l.
-
-    ///Return an active item on level \c l or \ref INVALID if there is no such
-    ///an item. (\c l must be from the range [0...\c max_level].
-    Item activeOn(int l) const
-    {
-      return _active[_first[l]] ? _first[l] : INVALID;
-    }
-
-    ///Lift the active item returned by \c activeOn(l) by one.
-
-    ///Lift the active item returned by \ref activeOn() "activeOn(l)"
-    ///by one.
-    Item liftActiveOn(int l)
-    {
-      Item i = _first[l];
-      if (_next[i] != INVALID) {
-        _prev[_next[i]] = INVALID;
-        _first[l] = _next[i];
-      } else {
-        _first[l] = INVALID;
-        _last[l] = INVALID;
-      }
-      _level[i] = ++l;
-      if (_first[l] == INVALID) {
-        _first[l] = _last[l] = i;
-        _prev[i] = INVALID;
-        _next[i] = INVALID;
-      } else {
-        _prev[_first[l]] = i;
-        _next[i] = _first[l];
-        _first[l] = i;
-      }
-      if (_highest_active < l) {
-        _highest_active = l;
-      }
-    }
-
-    ///Lift the active item returned by \c activeOn(l) to the given level.
-
-    ///Lift the active item returned by \ref activeOn() "activeOn(l)"
-    ///to the given level.
-    void liftActiveOn(int l, int new_level)
-    {
-      Item i = _first[l];
-      if (_next[i] != INVALID) {
-        _prev[_next[i]] = INVALID;
-        _first[l] = _next[i];
-      } else {
-        _first[l] = INVALID;
-        _last[l] = INVALID;
-      }
-      _level[i] = l = new_level;
-      if (_first[l] == INVALID) {
-        _first[l] = _last[l] = i;
-        _prev[i] = INVALID;
-        _next[i] = INVALID;
-      } else {
-        _prev[_first[l]] = i;
-        _next[i] = _first[l];
-        _first[l] = i;
-      }
-      if (_highest_active < l) {
-        _highest_active = l;
-      }
-    }
-
-    ///Lift the active item returned by \c activeOn(l) to the top level.
-
-    ///Lift the active item returned by \ref activeOn() "activeOn(l)"
-    ///to the top level and deactivate it.
-    void liftActiveToTop(int l)
-    {
-      Item i = _first[l];
-      if (_next[i] != INVALID) {
-        _prev[_next[i]] = INVALID;
-        _first[l] = _next[i];
-      } else {
-        _first[l] = INVALID;
-        _last[l] = INVALID;
-      }
-      _level[i] = _max_level;
-      if (l == _highest_active) {
-        while (_highest_active >= 0 && activeFree(_highest_active))
-          --_highest_active;
-      }
-    }
-
-    ///@}
-
-    /// \brief Lift an active item to a higher level.
-    ///
-    /// Lift an active item to a higher level.
-    /// \param i The item to be lifted. It must be active.
-    /// \param new_level The new level of \c i. It must be strictly higher
-    /// than the current level.
-    ///
-    void lift(Item i, int new_level) {
-      if (_next[i] != INVALID) {
-        _prev[_next[i]] = _prev[i];
-      } else {
-        _last[new_level] = _prev[i];
-      }
-      if (_prev[i] != INVALID) {
-        _next[_prev[i]] = _next[i];
-      } else {
-        _first[new_level] = _next[i];
-      }
-      _level[i] = new_level;
-      if (_first[new_level] == INVALID) {
-        _first[new_level] = _last[new_level] = i;
-        _prev[i] = INVALID;
-        _next[i] = INVALID;
-      } else {
-        _prev[_first[new_level]] = i;
-        _next[i] = _first[new_level];
-        _first[new_level] = i;
-      }
-      if (_highest_active < new_level) {
-        _highest_active = new_level;
-      }
-    }
-
-    ///Move an inactive item to the top but one level (in a dirty way).
-
-    ///This function moves an inactive item from the top level to the top
-    ///but one level (in a dirty way).
-    ///\warning It makes the underlying datastructure corrupt, so use it
-    ///only if you really know what it is for.
-    ///\pre The item is on the top level.
-    void dirtyTopButOne(Item i) {
-      _level[i] = _max_level - 1;
-    }
-
-    ///Lift all items on and above the given level to the top level.
-
-    ///This function lifts all items on and above level \c l to the top
-    ///level and deactivates them.
-    void liftToTop(int l)  {
-      for (int i = l + 1; _first[i] != INVALID; ++i) {
-        Item n = _first[i];
-        while (n != INVALID) {
-          _level[n] = _max_level;
-          n = _next[n];
-        }
-        _first[i] = INVALID;
-        _last[i] = INVALID;
-      }
-      if (_highest_active > l - 1) {
-        _highest_active = l - 1;
-        while (_highest_active >= 0 && activeFree(_highest_active))
-          --_highest_active;
-      }
-    }
-
-  private:
-
-    int _init_level;
-
-  public:
-
-    ///\name Initialization
-    ///Using these functions you can initialize the levels of the items.
-    ///\n
-    ///The initialization must be started with calling \c initStart().
-    ///Then the items should be listed level by level starting with the
-    ///lowest one (level 0) using \c initAddItem() and \c initNewLevel().
-    ///Finally \c initFinish() must be called.
-    ///The items not listed are put on the highest level.
-    ///@{
-
-    ///Start the initialization process.
-    void initStart() {
-
-      for (int i = 0; i <= _max_level; ++i) {
-        _first[i] = _last[i] = INVALID;
-      }
-      _init_level = 0;
-      for(typename ItemSetTraits<GR,Item>::ItemIt i(_graph);
-          i != INVALID; ++i) {
-        _level[i] = _max_level;
-        _active[i] = false;
-      }
-    }
-
-    ///Add an item to the current level.
-    void initAddItem(Item i) {
-      _level[i] = _init_level;
-      if (_last[_init_level] == INVALID) {
-        _first[_init_level] = i;
-        _last[_init_level] = i;
-        _prev[i] = INVALID;
-        _next[i] = INVALID;
-      } else {
-        _prev[i] = _last[_init_level];
-        _next[i] = INVALID;
-        _next[_last[_init_level]] = i;
-        _last[_init_level] = i;
-      }
-    }
-
-    ///Start a new level.
-
-    ///Start a new level.
-    ///It shouldn't be used before the items on level 0 are listed.
-    void initNewLevel() {
-      ++_init_level;
-    }
-
-    ///Finalize the initialization process.
-    void initFinish() {
-      _highest_active = -1;
-    }
-
-    ///@}
-
-  };
-
-
-} //END OF NAMESPACE LEMON
-
-#endif
-
Index: lemon/error.h
===================================================================
--- lemon/error.h	(revision 463)
+++ lemon/error.h	(revision 291)
@@ -3,5 +3,5 @@
  * This file is a part of LEMON, a generic C++ optimization library.
  *
- * Copyright (C) 2003-2009
+ * Copyright (C) 2003-2008
  * Egervary Jeno Kombinatorikus Optimalizalasi Kutatocsoport
  * (Egervary Research Group on Combinatorial Optimization, EGRES).
Index: mon/euler.h
===================================================================
--- lemon/euler.h	(revision 956)
+++ 	(revision )
@@ -1,287 +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_EULER_H
-#define LEMON_EULER_H
-
-#include<lemon/core.h>
-#include<lemon/adaptors.h>
-#include<lemon/connectivity.h>
-#include <list>
-
-/// \ingroup graph_properties
-/// \file
-/// \brief Euler tour iterators and a function for checking the \e Eulerian
-/// property.
-///
-///This file provides Euler tour iterators and a function to check
-///if a (di)graph is \e Eulerian.
-
-namespace lemon {
-
-  ///Euler tour iterator for digraphs.
-
-  /// \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
-  ///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.
-  ///\code
-  ///  std::vector<ListDigraph::Arc> et;
-  ///  for(DiEulerIt<ListDigraph> e(g); e!=INVALID; ++e)
-  ///    et.push_back(e);
-  ///\endcode
-  ///If \c g has no Euler tour, then the resulted walk will not be closed
-  ///or not contain all arcs.
-  ///\sa EulerIt
-  template<typename GR>
-  class DiEulerIt
-  {
-    typedef typename GR::Node Node;
-    typedef typename GR::NodeIt NodeIt;
-    typedef typename GR::Arc Arc;
-    typedef typename GR::ArcIt ArcIt;
-    typedef typename GR::OutArcIt OutArcIt;
-    typedef typename GR::InArcIt InArcIt;
-
-    const GR &g;
-    typename GR::template NodeMap<OutArcIt> narc;
-    std::list<Arc> euler;
-
-  public:
-
-    ///Constructor
-
-    ///Constructor.
-    ///\param gr A digraph.
-    ///\param start The starting point of the tour. If it is not given,
-    ///the tour will start from the first node that has an outgoing arc.
-    DiEulerIt(const GR &gr, typename GR::Node start = INVALID)
-      : g(gr), narc(g)
-    {
-      if (start==INVALID) {
-        NodeIt n(g);
-        while (n!=INVALID && OutArcIt(g,n)==INVALID) ++n;
-        start=n;
-      }
-      if (start!=INVALID) {
-        for (NodeIt n(g); n!=INVALID; ++n) narc[n]=OutArcIt(g,n);
-        while (narc[start]!=INVALID) {
-          euler.push_back(narc[start]);
-          Node next=g.target(narc[start]);
-          ++narc[start];
-          start=next;
-        }
-      }
-    }
-
-    ///Arc conversion
-    operator Arc() { return euler.empty()?INVALID:euler.front(); }
-    ///Compare with \c INVALID
-    bool operator==(Invalid) { return euler.empty(); }
-    ///Compare with \c INVALID
-    bool operator!=(Invalid) { return !euler.empty(); }
-
-    ///Next arc of the tour
-
-    ///Next arc of the tour
-    ///
-    DiEulerIt &operator++() {
-      Node s=g.target(euler.front());
-      euler.pop_front();
-      typename std::list<Arc>::iterator next=euler.begin();
-      while(narc[s]!=INVALID) {
-        euler.insert(next,narc[s]);
-        Node n=g.target(narc[s]);
-        ++narc[s];
-        s=n;
-      }
-      return *this;
-    }
-    ///Postfix incrementation
-
-    /// Postfix incrementation.
-    ///
-    ///\warning This incrementation
-    ///returns an \c Arc, not a \ref DiEulerIt, as one may
-    ///expect.
-    Arc operator++(int)
-    {
-      Arc e=*this;
-      ++(*this);
-      return e;
-    }
-  };
-
-  ///Euler tour iterator for graphs.
-
-  /// \ingroup graph_properties
-  ///This iterator provides an Euler tour (Eulerian circuit) of an
-  ///\e undirected graph (if there exists) and it converts to the \c Arc
-  ///and \c Edge types of the graph.
-  ///
-  ///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
-  ///Euler tour of \c g.
-  ///\code
-  ///  for(EulerIt<ListGraph> e(g); e!=INVALID; ++e) {
-  ///    std::cout << g.id(Edge(e)) << std::eol;
-  ///  }
-  ///\endcode
-  ///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.)
-  ///
-  ///If \c g has no Euler tour, then the resulted walk will not be closed
-  ///or not contain all edges.
-  template<typename GR>
-  class EulerIt
-  {
-    typedef typename GR::Node Node;
-    typedef typename GR::NodeIt NodeIt;
-    typedef typename GR::Arc Arc;
-    typedef typename GR::Edge Edge;
-    typedef typename GR::ArcIt ArcIt;
-    typedef typename GR::OutArcIt OutArcIt;
-    typedef typename GR::InArcIt InArcIt;
-
-    const GR &g;
-    typename GR::template NodeMap<OutArcIt> narc;
-    typename GR::template EdgeMap<bool> visited;
-    std::list<Arc> euler;
-
-  public:
-
-    ///Constructor
-
-    ///Constructor.
-    ///\param gr A graph.
-    ///\param start The starting point of the tour. If it is not given,
-    ///the tour will start from the first node that has an incident edge.
-    EulerIt(const GR &gr, typename GR::Node start = INVALID)
-      : g(gr), narc(g), visited(g, false)
-    {
-      if (start==INVALID) {
-        NodeIt n(g);
-        while (n!=INVALID && OutArcIt(g,n)==INVALID) ++n;
-        start=n;
-      }
-      if (start!=INVALID) {
-        for (NodeIt n(g); n!=INVALID; ++n) narc[n]=OutArcIt(g,n);
-        while(narc[start]!=INVALID) {
-          euler.push_back(narc[start]);
-          visited[narc[start]]=true;
-          Node next=g.target(narc[start]);
-          ++narc[start];
-          start=next;
-          while(narc[start]!=INVALID && visited[narc[start]]) ++narc[start];
-        }
-      }
-    }
-
-    ///Arc conversion
-    operator Arc() const { return euler.empty()?INVALID:euler.front(); }
-    ///Edge conversion
-    operator Edge() const { return euler.empty()?INVALID:euler.front(); }
-    ///Compare with \c INVALID
-    bool operator==(Invalid) const { return euler.empty(); }
-    ///Compare with \c INVALID
-    bool operator!=(Invalid) const { return !euler.empty(); }
-
-    ///Next arc of the tour
-
-    ///Next arc of the tour
-    ///
-    EulerIt &operator++() {
-      Node s=g.target(euler.front());
-      euler.pop_front();
-      typename std::list<Arc>::iterator next=euler.begin();
-      while(narc[s]!=INVALID) {
-        while(narc[s]!=INVALID && visited[narc[s]]) ++narc[s];
-        if(narc[s]==INVALID) break;
-        else {
-          euler.insert(next,narc[s]);
-          visited[narc[s]]=true;
-          Node n=g.target(narc[s]);
-          ++narc[s];
-          s=n;
-        }
-      }
-      return *this;
-    }
-
-    ///Postfix incrementation
-
-    /// Postfix incrementation.
-    ///
-    ///\warning This incrementation returns an \c Arc (which converts to
-    ///an \c Edge), not an \ref EulerIt, as one may expect.
-    Arc operator++(int)
-    {
-      Arc e=*this;
-      ++(*this);
-      return e;
-    }
-  };
-
-
-  ///Check if the given graph is Eulerian
-
-  /// \ingroup graph_properties
-  ///This function checks if the given graph is Eulerian.
-  ///It works for both directed and undirected graphs.
-  ///
-  ///By definition, a digraph is called \e Eulerian if
-  ///and only if it is connected and the number of incoming and outgoing
-  ///arcs are the same for each node.
-  ///Similarly, an undirected graph is called \e Eulerian if
-  ///and only if it is connected and the number of incident edges is even
-  ///for each node.
-  ///
-  ///\note There are (di)graphs that are not Eulerian, but still have an
-  /// Euler tour, since they may contain isolated nodes.
-  ///
-  ///\sa DiEulerIt, EulerIt
-  template<typename GR>
-#ifdef DOXYGEN
-  bool
-#else
-  typename enable_if<UndirectedTagIndicator<GR>,bool>::type
-  eulerian(const GR &g)
-  {
-    for(typename GR::NodeIt n(g);n!=INVALID;++n)
-      if(countIncEdges(g,n)%2) return false;
-    return connected(g);
-  }
-  template<class GR>
-  typename disable_if<UndirectedTagIndicator<GR>,bool>::type
-#endif
-  eulerian(const GR &g)
-  {
-    for(typename GR::NodeIt n(g);n!=INVALID;++n)
-      if(countInArcs(g,n)!=countOutArcs(g,n)) return false;
-    return connected(undirector(g));
-  }
-
-}
-
-#endif
Index: mon/fib_heap.h
===================================================================
--- lemon/fib_heap.h	(revision 758)
+++ 	(revision )
@@ -1,475 +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_FIB_HEAP_H
-#define LEMON_FIB_HEAP_H
-
-///\file
-///\ingroup heaps
-///\brief Fibonacci heap implementation.
-
-#include <vector>
-#include <utility>
-#include <functional>
-#include <lemon/math.h>
-
-namespace lemon {
-
-  /// \ingroup heaps
-  ///
-  /// \brief Fibonacci heap data structure.
-  ///
-  /// This class implements the \e Fibonacci \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
-  /// Fibonacci 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 FibHeap {
-  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;
-
-  private:
-    class Store;
-
-    std::vector<Store> _data;
-    int _minimum;
-    ItemIntMap &_iim;
-    Compare _comp;
-    int _num;
-
-  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
-    /// 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.
-    };
-
-    /// \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 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.
-    FibHeap(ItemIntMap &map, const Compare &comp)
-      : _minimum(0), _iim(map), _comp(comp), _num() {}
-
-    /// \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; }
-
-    /// \brief Check if the heap is empty.
-    ///
-    /// This function returns \c true if the heap is empty.
-    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.
-    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) {
-      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].degree=0;
-        _data[i].in=true;
-        _data[i].marked=false;
-      }
-
-      if ( _num ) {
-        _data[_data[_minimum].right_neighbor].left_neighbor=i;
-        _data[i].right_neighbor=_data[_minimum].right_neighbor;
-        _data[_minimum].right_neighbor=i;
-        _data[i].left_neighbor=_minimum;
-        if ( _comp( prio, _data[_minimum].prio) ) _minimum=i;
-      } else {
-        _data[i].right_neighbor=_data[i].left_neighbor=i;
-        _minimum=i;
-      }
-      _data[i].prio=prio;
-      ++_num;
-    }
-
-    /// \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[_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.
-    /// \pre The heap must be non-empty.
-    void pop() {
-      /*The first case is that there are only one root.*/
-      if ( _data[_minimum].left_neighbor==_minimum ) {
-        _data[_minimum].in=false;
-        if ( _data[_minimum].degree!=0 ) {
-          makeRoot(_data[_minimum].child);
-          _minimum=_data[_minimum].child;
-          balance();
-        }
-      } else {
-        int right=_data[_minimum].right_neighbor;
-        unlace(_minimum);
-        _data[_minimum].in=false;
-        if ( _data[_minimum].degree > 0 ) {
-          int left=_data[_minimum].left_neighbor;
-          int child=_data[_minimum].child;
-          int last_child=_data[child].left_neighbor;
-
-          makeRoot(child);
-
-          _data[left].right_neighbor=child;
-          _data[child].left_neighbor=left;
-          _data[right].left_neighbor=last_child;
-          _data[last_child].right_neighbor=right;
-        }
-        _minimum=right;
-        balance();
-      } // the case where there are more roots
-      --_num;
-    }
-
-    /// \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 ) {
-        if ( _data[i].parent!=-1 ) {
-          int p=_data[i].parent;
-          cut(i,p);
-          cascade(p);
-        }
-        _minimum=i;     //As if its prio would be -infinity
-        pop();
-      }
-    }
-
-    /// \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) {
-      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;
-      int p=_data[i].parent;
-
-      if ( p!=-1 && _comp(prio, _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) {
-      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.
-    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 balance() {
-
-      int maxdeg=int( std::floor( 2.08*log(double(_data.size()))))+1;
-
-      std::vector<int> A(maxdeg,-1);
-
-      /*
-       *Recall that now minimum does not point to the minimum prio element.
-       *We set minimum to this during balance().
-       */
-      int anchor=_data[_minimum].left_neighbor;
-      int next=_minimum;
-      bool end=false;
-
-      do {
-        int active=next;
-        if ( anchor==active ) end=true;
-        int d=_data[active].degree;
-        next=_data[active].right_neighbor;
-
-        while (A[d]!=-1) {
-          if( _comp(_data[active].prio, _data[A[d]].prio) ) {
-            fuse(active,A[d]);
-          } else {
-            fuse(A[d],active);
-            active=A[d];
-          }
-          A[d]=-1;
-          ++d;
-        }
-        A[d]=active;
-      } while ( !end );
-
-
-      while ( _data[_minimum].parent >=0 )
-        _minimum=_data[_minimum].parent;
-      int s=_minimum;
-      int m=_minimum;
-      do {
-        if ( _comp(_data[s].prio, _data[_minimum].prio) ) _minimum=s;
-        s=_data[s].right_neighbor;
-      } while ( s != m );
-    }
-
-    void makeRoot(int c) {
-      int s=c;
-      do {
-        _data[s].parent=-1;
-        s=_data[s].right_neighbor;
-      } while ( s != c );
-    }
-
-    void cut(int a, int b) {
-      /*
-       *Replacing a from the children of b.
-       */
-      --_data[b].degree;
-
-      if ( _data[b].degree !=0 ) {
-        int child=_data[b].child;
-        if ( child==a )
-          _data[b].child=_data[child].right_neighbor;
-        unlace(a);
-      }
-
-
-      /*Lacing a to the roots.*/
-      int right=_data[_minimum].right_neighbor;
-      _data[_minimum].right_neighbor=a;
-      _data[a].left_neighbor=_minimum;
-      _data[a].right_neighbor=right;
-      _data[right].left_neighbor=a;
-
-      _data[a].parent=-1;
-      _data[a].marked=false;
-    }
-
-    void cascade(int a) {
-      if ( _data[a].parent!=-1 ) {
-        int p=_data[a].parent;
-
-        if ( _data[a].marked==false ) _data[a].marked=true;
-        else {
-          cut(a,p);
-          cascade(p);
-        }
-      }
-    }
-
-    void fuse(int a, int b) {
-      unlace(b);
-
-      /*Lacing b under a.*/
-      _data[b].parent=a;
-
-      if (_data[a].degree==0) {
-        _data[b].left_neighbor=b;
-        _data[b].right_neighbor=b;
-        _data[a].child=b;
-      } else {
-        int child=_data[a].child;
-        int last_child=_data[child].left_neighbor;
-        _data[child].left_neighbor=b;
-        _data[b].right_neighbor=child;
-        _data[last_child].right_neighbor=b;
-        _data[b].left_neighbor=last_child;
-      }
-
-      ++_data[a].degree;
-
-      _data[b].marked=false;
-    }
-
-    /*
-     *It is invoked only if a has siblings.
-     */
-    void unlace(int a) {
-      int leftn=_data[a].left_neighbor;
-      int rightn=_data[a].right_neighbor;
-      _data[leftn].right_neighbor=rightn;
-      _data[rightn].left_neighbor=leftn;
-    }
-
-
-    class Store {
-      friend class FibHeap;
-
-      Item name;
-      int parent;
-      int left_neighbor;
-      int right_neighbor;
-      int child;
-      int degree;
-      bool marked;
-      bool in;
-      Prio prio;
-
-      Store() : parent(-1), child(-1), degree(), marked(false), in(true) {}
-    };
-  };
-
-} //namespace lemon
-
-#endif //LEMON_FIB_HEAP_H
-
Index: mon/fractional_matching.h
===================================================================
--- lemon/fractional_matching.h	(revision 956)
+++ 	(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: mon/full_graph.h
===================================================================
--- lemon/full_graph.h	(revision 956)
+++ 	(revision )
@@ -1,628 +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_FULL_GRAPH_H
-#define LEMON_FULL_GRAPH_H
-
-#include <lemon/core.h>
-#include <lemon/bits/graph_extender.h>
-
-///\ingroup graphs
-///\file
-///\brief FullDigraph and FullGraph classes.
-
-namespace lemon {
-
-  class FullDigraphBase {
-  public:
-
-    typedef FullDigraphBase Digraph;
-
-    class Node;
-    class Arc;
-
-  protected:
-
-    int _node_num;
-    int _arc_num;
-
-    FullDigraphBase() {}
-
-    void construct(int n) { _node_num = n; _arc_num = n * n; }
-
-  public:
-
-    typedef True NodeNumTag;
-    typedef True ArcNumTag;
-
-    Node operator()(int ix) const { return Node(ix); }
-    static int index(const Node& node) { return node._id; }
-
-    Arc arc(const Node& s, const Node& t) const {
-      return Arc(s._id * _node_num + t._id);
-    }
-
-    int nodeNum() const { return _node_num; }
-    int arcNum() const { return _arc_num; }
-
-    int maxNodeId() const { return _node_num - 1; }
-    int maxArcId() const { return _arc_num - 1; }
-
-    Node source(Arc arc) const { return arc._id / _node_num; }
-    Node target(Arc arc) const { return arc._id % _node_num; }
-
-    static int id(Node node) { return node._id; }
-    static int id(Arc arc) { return arc._id; }
-
-    static Node nodeFromId(int id) { return Node(id);}
-    static Arc arcFromId(int id) { return Arc(id);}
-
-    typedef True FindArcTag;
-
-    Arc findArc(Node s, Node t, Arc prev = INVALID) const {
-      return prev == INVALID ? arc(s, t) : INVALID;
-    }
-
-    class Node {
-      friend class FullDigraphBase;
-
-    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 FullDigraphBase;
-
-    protected:
-      int _id;  // _node_num * source + target;
-
-      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;}
-    };
-
-    void first(Node& node) const {
-      node._id = _node_num - 1;
-    }
-
-    static void next(Node& node) {
-      --node._id;
-    }
-
-    void first(Arc& arc) const {
-      arc._id = _arc_num - 1;
-    }
-
-    static void next(Arc& arc) {
-      --arc._id;
-    }
-
-    void firstOut(Arc& arc, const Node& node) const {
-      arc._id = (node._id + 1) * _node_num - 1;
-    }
-
-    void nextOut(Arc& arc) const {
-      if (arc._id % _node_num == 0) arc._id = 0;
-      --arc._id;
-    }
-
-    void firstIn(Arc& arc, const Node& node) const {
-      arc._id = _arc_num + node._id - _node_num;
-    }
-
-    void nextIn(Arc& arc) const {
-      arc._id -= _node_num;
-      if (arc._id < 0) arc._id = -1;
-    }
-
-  };
-
-  typedef DigraphExtender<FullDigraphBase> ExtendedFullDigraphBase;
-
-  /// \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,
-  /// 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.
-  ///
-  /// \sa FullGraph
-  class FullDigraph : public ExtendedFullDigraphBase {
-    typedef ExtendedFullDigraphBase Parent;
-
-  public:
-
-    /// \brief Default constructor.
-    ///
-    /// Default constructor. The number of nodes and arcs will be zero.
-    FullDigraph() { construct(0); }
-
-    /// \brief Constructor
-    ///
-    /// Constructor.
-    /// \param n The number of the nodes.
-    FullDigraph(int n) { construct(n); }
-
-    /// \brief Resizes the digraph
-    ///
-    /// This function resizes the digraph. It fully destroys and
-    /// rebuilds the structure, therefore the maps of the digraph will be
-    /// reallocated automatically and the previous values will be lost.
-    void resize(int n) {
-      Parent::notifier(Arc()).clear();
-      Parent::notifier(Node()).clear();
-      construct(n);
-      Parent::notifier(Node()).build();
-      Parent::notifier(Arc()).build();
-    }
-
-    /// \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.
-    /// \sa index()
-    Node operator()(int ix) const { return Parent::operator()(ix); }
-
-    /// \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); }
-
-    /// \brief Returns the arc connecting the given nodes.
-    ///
-    /// Returns the arc connecting the given nodes.
-    Arc arc(Node u, Node v) const {
-      return Parent::arc(u, v);
-    }
-
-    /// \brief Number of nodes.
-    int nodeNum() const { return Parent::nodeNum(); }
-    /// \brief Number of arcs.
-    int arcNum() const { return Parent::arcNum(); }
-  };
-
-
-  class FullGraphBase {
-  public:
-
-    typedef FullGraphBase Graph;
-
-    class Node;
-    class Arc;
-    class Edge;
-
-  protected:
-
-    int _node_num;
-    int _edge_num;
-
-    FullGraphBase() {}
-
-    void construct(int n) { _node_num = n; _edge_num = n * (n - 1) / 2; }
-
-    int _uid(int e) const {
-      int u = e / _node_num;
-      int v = e % _node_num;
-      return u < v ? u : _node_num - 2 - u;
-    }
-
-    int _vid(int e) const {
-      int u = e / _node_num;
-      int v = e % _node_num;
-      return u < v ? v : _node_num - 1 - v;
-    }
-
-    void _uvid(int e, int& u, int& v) const {
-      u = e / _node_num;
-      v = e % _node_num;
-      if  (u >= v) {
-        u = _node_num - 2 - u;
-        v = _node_num - 1 - v;
-      }
-    }
-
-    void _stid(int a, int& s, int& t) const {
-      if ((a & 1) == 1) {
-        _uvid(a >> 1, s, t);
-      } else {
-        _uvid(a >> 1, t, s);
-      }
-    }
-
-    int _eid(int u, int v) const {
-      if (u < (_node_num - 1) / 2) {
-        return u * _node_num + v;
-      } else {
-        return (_node_num - 1 - u) * _node_num - v - 1;
-      }
-    }
-
-  public:
-
-    Node operator()(int ix) const { return Node(ix); }
-    static int index(const Node& node) { return node._id; }
-
-    Edge edge(const Node& u, const Node& v) const {
-      if (u._id < v._id) {
-        return Edge(_eid(u._id, v._id));
-      } else if (u._id != v._id) {
-        return Edge(_eid(v._id, u._id));
-      } else {
-        return INVALID;
-      }
-    }
-
-    Arc arc(const Node& s, const Node& t) const {
-      if (s._id < t._id) {
-        return Arc((_eid(s._id, t._id) << 1) | 1);
-      } else if (s._id != t._id) {
-        return Arc(_eid(t._id, s._id) << 1);
-      } else {
-        return INVALID;
-      }
-    }
-
-    typedef True NodeNumTag;
-    typedef True ArcNumTag;
-    typedef True EdgeNumTag;
-
-    int nodeNum() const { return _node_num; }
-    int arcNum() const { return 2 * _edge_num; }
-    int edgeNum() const { return _edge_num; }
-
-    static int id(Node node) { return node._id; }
-    static int id(Arc arc) { return arc._id; }
-    static int id(Edge edge) { return edge._id; }
-
-    int maxNodeId() const { return _node_num-1; }
-    int maxArcId() const { return 2 * _edge_num-1; }
-    int maxEdgeId() const { return _edge_num-1; }
-
-    static Node nodeFromId(int id) { return Node(id);}
-    static Arc arcFromId(int id) { return Arc(id);}
-    static Edge edgeFromId(int id) { return Edge(id);}
-
-    Node u(Edge edge) const {
-      return Node(_uid(edge._id));
-    }
-
-    Node v(Edge edge) const {
-      return Node(_vid(edge._id));
-    }
-
-    Node source(Arc arc) const {
-      return Node((arc._id & 1) == 1 ?
-                  _uid(arc._id >> 1) : _vid(arc._id >> 1));
-    }
-
-    Node target(Arc arc) const {
-      return Node((arc._id & 1) == 1 ?
-                  _vid(arc._id >> 1) : _uid(arc._id >> 1));
-    }
-
-    typedef True FindEdgeTag;
-    typedef True FindArcTag;
-
-    Edge findEdge(Node u, Node v, Edge prev = INVALID) const {
-      return prev != INVALID ? INVALID : edge(u, v);
-    }
-
-    Arc findArc(Node s, Node t, Arc prev = INVALID) const {
-      return prev != INVALID ? INVALID : arc(s, t);
-    }
-
-    class Node {
-      friend class FullGraphBase;
-
-    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 Edge {
-      friend class FullGraphBase;
-      friend class Arc;
-
-    protected:
-      int _id;
-
-      Edge(int id) : _id(id) {}
-
-    public:
-      Edge() { }
-      Edge (Invalid) { _id = -1; }
-
-      bool operator==(const Edge edge) const {return _id == edge._id;}
-      bool operator!=(const Edge edge) const {return _id != edge._id;}
-      bool operator<(const Edge edge) const {return _id < edge._id;}
-    };
-
-    class Arc {
-      friend class FullGraphBase;
-
-    protected:
-      int _id;
-
-      Arc(int id) : _id(id) {}
-
-    public:
-      Arc() { }
-      Arc (Invalid) { _id = -1; }
-
-      operator Edge() const { return Edge(_id != -1 ? (_id >> 1) : -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;}
-    };
-
-    static bool direction(Arc arc) {
-      return (arc._id & 1) == 1;
-    }
-
-    static Arc direct(Edge edge, bool dir) {
-      return Arc((edge._id << 1) | (dir ? 1 : 0));
-    }
-
-    void first(Node& node) const {
-      node._id = _node_num - 1;
-    }
-
-    static void next(Node& node) {
-      --node._id;
-    }
-
-    void first(Arc& arc) const {
-      arc._id = (_edge_num << 1) - 1;
-    }
-
-    static void next(Arc& arc) {
-      --arc._id;
-    }
-
-    void first(Edge& edge) const {
-      edge._id = _edge_num - 1;
-    }
-
-    static void next(Edge& edge) {
-      --edge._id;
-    }
-
-    void firstOut(Arc& arc, const Node& node) const {
-      int s = node._id, t = _node_num - 1;
-      if (s < t) {
-        arc._id = (_eid(s, t) << 1) | 1;
-      } else {
-        --t;
-        arc._id = (t != -1 ? (_eid(t, s) << 1) : -1);
-      }
-    }
-
-    void nextOut(Arc& arc) const {
-      int s, t;
-      _stid(arc._id, s, t);
-      --t;
-      if (s < t) {
-        arc._id = (_eid(s, t) << 1) | 1;
-      } else {
-        if (s == t) --t;
-        arc._id = (t != -1 ? (_eid(t, s) << 1) : -1);
-      }
-    }
-
-    void firstIn(Arc& arc, const Node& node) const {
-      int s = _node_num - 1, t = node._id;
-      if (s > t) {
-        arc._id = (_eid(t, s) << 1);
-      } else {
-        --s;
-        arc._id = (s != -1 ? (_eid(s, t) << 1) | 1 : -1);
-      }
-    }
-
-    void nextIn(Arc& arc) const {
-      int s, t;
-      _stid(arc._id, s, t);
-      --s;
-      if (s > t) {
-        arc._id = (_eid(t, s) << 1);
-      } else {
-        if (s == t) --s;
-        arc._id = (s != -1 ? (_eid(s, t) << 1) | 1 : -1);
-      }
-    }
-
-    void firstInc(Edge& edge, bool& dir, const Node& node) const {
-      int u = node._id, v = _node_num - 1;
-      if (u < v) {
-        edge._id = _eid(u, v);
-        dir = true;
-      } else {
-        --v;
-        edge._id = (v != -1 ? _eid(v, u) : -1);
-        dir = false;
-      }
-    }
-
-    void nextInc(Edge& edge, bool& dir) const {
-      int u, v;
-      if (dir) {
-        _uvid(edge._id, u, v);
-        --v;
-        if (u < v) {
-          edge._id = _eid(u, v);
-        } else {
-          --v;
-          edge._id = (v != -1 ? _eid(v, u) : -1);
-          dir = false;
-        }
-      } else {
-        _uvid(edge._id, v, u);
-        --v;
-        edge._id = (v != -1 ? _eid(v, u) : -1);
-      }
-    }
-
-  };
-
-  typedef GraphExtender<FullGraphBase> ExtendedFullGraphBase;
-
-  /// \ingroup graphs
-  ///
-  /// \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
-  /// 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.
-  ///
-  /// \sa FullDigraph
-  class FullGraph : public ExtendedFullGraphBase {
-    typedef ExtendedFullGraphBase Parent;
-
-  public:
-
-    /// \brief Default constructor.
-    ///
-    /// Default constructor. The number of nodes and edges will be zero.
-    FullGraph() { construct(0); }
-
-    /// \brief Constructor
-    ///
-    /// Constructor.
-    /// \param n The number of the nodes.
-    FullGraph(int n) { construct(n); }
-
-    /// \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 n) {
-      Parent::notifier(Arc()).clear();
-      Parent::notifier(Edge()).clear();
-      Parent::notifier(Node()).clear();
-      construct(n);
-      Parent::notifier(Node()).build();
-      Parent::notifier(Edge()).build();
-      Parent::notifier(Arc()).build();
-    }
-
-    /// \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.
-    /// \sa index()
-    Node operator()(int ix) const { return Parent::operator()(ix); }
-
-    /// \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); }
-
-    /// \brief Returns the arc connecting the given nodes.
-    ///
-    /// Returns the arc connecting the given nodes.
-    Arc arc(Node s, 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 {
-      return Parent::edge(u, v);
-    }
-
-    /// \brief Number of nodes.
-    int nodeNum() const { return Parent::nodeNum(); }
-    /// \brief Number of arcs.
-    int arcNum() const { return Parent::arcNum(); }
-    /// \brief Number of edges.
-    int edgeNum() const { return Parent::edgeNum(); }
-
-  };
-
-
-} //namespace lemon
-
-
-#endif //LEMON_FULL_GRAPH_H
Index: mon/glpk.cc
===================================================================
--- lemon/glpk.cc	(revision 956)
+++ 	(revision )
@@ -1,1003 +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.
- *
- */
-
-///\file
-///\brief Implementation of the LEMON GLPK LP and MIP solver interface.
-
-#include <lemon/glpk.h>
-#include <glpk.h>
-
-#include <lemon/assert.h>
-
-namespace lemon {
-
-  // GlpkBase members
-
-  GlpkBase::GlpkBase() : LpBase() {
-    lp = glp_create_prob();
-    glp_create_index(lp);
-    messageLevel(MESSAGE_NOTHING);
-  }
-
-  GlpkBase::GlpkBase(const GlpkBase &other) : LpBase() {
-    lp = glp_create_prob();
-    glp_copy_prob(lp, other.lp, GLP_ON);
-    glp_create_index(lp);
-    rows = other.rows;
-    cols = other.cols;
-    messageLevel(MESSAGE_NOTHING);
-  }
-
-  GlpkBase::~GlpkBase() {
-    glp_delete_prob(lp);
-  }
-
-  int GlpkBase::_addCol() {
-    int i = glp_add_cols(lp, 1);
-    glp_set_col_bnds(lp, i, GLP_FR, 0.0, 0.0);
-    return i;
-  }
-
-  int GlpkBase::_addRow() {
-    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;
-  }
-
-  void GlpkBase::_eraseCol(int i) {
-    int ca[2];
-    ca[1] = i;
-    glp_del_cols(lp, 1, ca);
-  }
-
-  void GlpkBase::_eraseRow(int i) {
-    int ra[2];
-    ra[1] = i;
-    glp_del_rows(lp, 1, ra);
-  }
-
-  void GlpkBase::_eraseColId(int i) {
-    cols.eraseIndex(i);
-    cols.shiftIndices(i);
-  }
-
-  void GlpkBase::_eraseRowId(int i) {
-    rows.eraseIndex(i);
-    rows.shiftIndices(i);
-  }
-
-  void GlpkBase::_getColName(int c, std::string& name) const {
-    const char *str = glp_get_col_name(lp, c);
-    if (str) name = str;
-    else name.clear();
-  }
-
-  void GlpkBase::_setColName(int c, const std::string & name) {
-    glp_set_col_name(lp, c, const_cast<char*>(name.c_str()));
-
-  }
-
-  int GlpkBase::_colByName(const std::string& name) const {
-    int k = glp_find_col(lp, const_cast<char*>(name.c_str()));
-    return k > 0 ? k : -1;
-  }
-
-  void GlpkBase::_getRowName(int r, std::string& name) const {
-    const char *str = glp_get_row_name(lp, r);
-    if (str) name = str;
-    else name.clear();
-  }
-
-  void GlpkBase::_setRowName(int r, const std::string & name) {
-    glp_set_row_name(lp, r, const_cast<char*>(name.c_str()));
-
-  }
-
-  int GlpkBase::_rowByName(const std::string& name) const {
-    int k = glp_find_row(lp, const_cast<char*>(name.c_str()));
-    return k > 0 ? k : -1;
-  }
-
-  void GlpkBase::_setRowCoeffs(int i, ExprIterator b, ExprIterator e) {
-    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());
-  }
-
-  void GlpkBase::_getRowCoeffs(int ix, InsertIterator b) const {
-    int length = glp_get_mat_row(lp, ix, 0, 0);
-
-    std::vector<int> indexes(length + 1);
-    std::vector<Value> values(length + 1);
-
-    glp_get_mat_row(lp, ix, &indexes.front(), &values.front());
-
-    for (int i = 1; i <= length; ++i) {
-      *b = std::make_pair(indexes[i], values[i]);
-      ++b;
-    }
-  }
-
-  void GlpkBase::_setColCoeffs(int ix, ExprIterator b,
-                                     ExprIterator e) {
-
-    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_col(lp, ix, values.size() - 1,
-                    &indexes.front(), &values.front());
-  }
-
-  void GlpkBase::_getColCoeffs(int ix, InsertIterator b) const {
-    int length = glp_get_mat_col(lp, ix, 0, 0);
-
-    std::vector<int> indexes(length + 1);
-    std::vector<Value> values(length + 1);
-
-    glp_get_mat_col(lp, ix, &indexes.front(), &values.front());
-
-    for (int i = 1; i  <= length; ++i) {
-      *b = std::make_pair(indexes[i], values[i]);
-      ++b;
-    }
-  }
-
-  void GlpkBase::_setCoeff(int ix, int jx, Value value) {
-
-    if (glp_get_num_cols(lp) < glp_get_num_rows(lp)) {
-
-      int length = glp_get_mat_row(lp, ix, 0, 0);
-
-      std::vector<int> indexes(length + 2);
-      std::vector<Value> values(length + 2);
-
-      glp_get_mat_row(lp, ix, &indexes.front(), &values.front());
-
-      //The following code does not suppose that the elements of the
-      //array indexes are sorted
-      bool found = false;
-      for (int i = 1; i  <= length; ++i) {
-        if (indexes[i] == jx) {
-          found = true;
-          values[i] = value;
-          break;
-        }
-      }
-      if (!found) {
-        ++length;
-        indexes[length] = jx;
-        values[length] = value;
-      }
-
-      glp_set_mat_row(lp, ix, length, &indexes.front(), &values.front());
-
-    } else {
-
-      int length = glp_get_mat_col(lp, jx, 0, 0);
-
-      std::vector<int> indexes(length + 2);
-      std::vector<Value> values(length + 2);
-
-      glp_get_mat_col(lp, jx, &indexes.front(), &values.front());
-
-      //The following code does not suppose that the elements of the
-      //array indexes are sorted
-      bool found = false;
-      for (int i = 1; i <= length; ++i) {
-        if (indexes[i] == ix) {
-          found = true;
-          values[i] = value;
-          break;
-        }
-      }
-      if (!found) {
-        ++length;
-        indexes[length] = ix;
-        values[length] = value;
-      }
-
-      glp_set_mat_col(lp, jx, length, &indexes.front(), &values.front());
-    }
-
-  }
-
-  GlpkBase::Value GlpkBase::_getCoeff(int ix, int jx) const {
-
-    int length = glp_get_mat_row(lp, ix, 0, 0);
-
-    std::vector<int> indexes(length + 1);
-    std::vector<Value> values(length + 1);
-
-    glp_get_mat_row(lp, ix, &indexes.front(), &values.front());
-
-    for (int i = 1; i  <= length; ++i) {
-      if (indexes[i] == jx) {
-        return values[i];
-      }
-    }
-
-    return 0;
-  }
-
-  void GlpkBase::_setColLowerBound(int i, Value lo) {
-    LEMON_ASSERT(lo != INF, "Invalid bound");
-
-    int b = glp_get_col_type(lp, i);
-    double up = glp_get_col_ub(lp, i);
-    if (lo == -INF) {
-      switch (b) {
-      case GLP_FR:
-      case GLP_LO:
-        glp_set_col_bnds(lp, i, GLP_FR, lo, up);
-        break;
-      case GLP_UP:
-        break;
-      case GLP_DB:
-      case GLP_FX:
-        glp_set_col_bnds(lp, i, GLP_UP, lo, up);
-        break;
-      default:
-        break;
-      }
-    } else {
-      switch (b) {
-      case GLP_FR:
-      case GLP_LO:
-        glp_set_col_bnds(lp, i, GLP_LO, lo, up);
-        break;
-      case GLP_UP:
-      case GLP_DB:
-      case GLP_FX:
-        if (lo == up)
-          glp_set_col_bnds(lp, i, GLP_FX, lo, up);
-        else
-          glp_set_col_bnds(lp, i, GLP_DB, lo, up);
-        break;
-      default:
-        break;
-      }
-    }
-  }
-
-  GlpkBase::Value GlpkBase::_getColLowerBound(int i) const {
-    int b = glp_get_col_type(lp, i);
-    switch (b) {
-    case GLP_LO:
-    case GLP_DB:
-    case GLP_FX:
-      return glp_get_col_lb(lp, i);
-    default:
-      return -INF;
-    }
-  }
-
-  void GlpkBase::_setColUpperBound(int i, Value up) {
-    LEMON_ASSERT(up != -INF, "Invalid bound");
-
-    int b = glp_get_col_type(lp, i);
-    double lo = glp_get_col_lb(lp, i);
-    if (up == INF) {
-      switch (b) {
-      case GLP_FR:
-      case GLP_LO:
-        break;
-      case GLP_UP:
-        glp_set_col_bnds(lp, i, GLP_FR, lo, up);
-        break;
-      case GLP_DB:
-      case GLP_FX:
-        glp_set_col_bnds(lp, i, GLP_LO, lo, up);
-        break;
-      default:
-        break;
-      }
-    } else {
-      switch (b) {
-      case GLP_FR:
-        glp_set_col_bnds(lp, i, GLP_UP, lo, up);
-        break;
-      case GLP_UP:
-        glp_set_col_bnds(lp, i, GLP_UP, lo, up);
-        break;
-      case GLP_LO:
-      case GLP_DB:
-      case GLP_FX:
-        if (lo == up)
-          glp_set_col_bnds(lp, i, GLP_FX, lo, up);
-        else
-          glp_set_col_bnds(lp, i, GLP_DB, lo, up);
-        break;
-      default:
-        break;
-      }
-    }
-
-  }
-
-  GlpkBase::Value GlpkBase::_getColUpperBound(int i) const {
-    int b = glp_get_col_type(lp, i);
-      switch (b) {
-      case GLP_UP:
-      case GLP_DB:
-      case GLP_FX:
-        return glp_get_col_ub(lp, i);
-      default:
-        return INF;
-      }
-  }
-
-  void GlpkBase::_setRowLowerBound(int i, Value lo) {
-    LEMON_ASSERT(lo != INF, "Invalid bound");
-
-    int b = glp_get_row_type(lp, i);
-    double up = glp_get_row_ub(lp, i);
-    if (lo == -INF) {
-      switch (b) {
-      case GLP_FR:
-      case GLP_LO:
-        glp_set_row_bnds(lp, i, GLP_FR, lo, up);
-        break;
-      case GLP_UP:
-        break;
-      case GLP_DB:
-      case GLP_FX:
-        glp_set_row_bnds(lp, i, GLP_UP, lo, up);
-        break;
-      default:
-        break;
-      }
-    } else {
-      switch (b) {
-      case GLP_FR:
-      case GLP_LO:
-        glp_set_row_bnds(lp, i, GLP_LO, lo, up);
-        break;
-      case GLP_UP:
-      case GLP_DB:
-      case GLP_FX:
-        if (lo == up)
-          glp_set_row_bnds(lp, i, GLP_FX, lo, up);
-        else
-          glp_set_row_bnds(lp, i, GLP_DB, lo, up);
-        break;
-      default:
-        break;
-      }
-    }
-
-  }
-
-  GlpkBase::Value GlpkBase::_getRowLowerBound(int i) const {
-    int b = glp_get_row_type(lp, i);
-    switch (b) {
-    case GLP_LO:
-    case GLP_DB:
-    case GLP_FX:
-      return glp_get_row_lb(lp, i);
-    default:
-      return -INF;
-    }
-  }
-
-  void GlpkBase::_setRowUpperBound(int i, Value up) {
-    LEMON_ASSERT(up != -INF, "Invalid bound");
-
-    int b = glp_get_row_type(lp, i);
-    double lo = glp_get_row_lb(lp, i);
-    if (up == INF) {
-      switch (b) {
-      case GLP_FR:
-      case GLP_LO:
-        break;
-      case GLP_UP:
-        glp_set_row_bnds(lp, i, GLP_FR, lo, up);
-        break;
-      case GLP_DB:
-      case GLP_FX:
-        glp_set_row_bnds(lp, i, GLP_LO, lo, up);
-        break;
-      default:
-        break;
-      }
-    } else {
-      switch (b) {
-      case GLP_FR:
-        glp_set_row_bnds(lp, i, GLP_UP, lo, up);
-        break;
-      case GLP_UP:
-        glp_set_row_bnds(lp, i, GLP_UP, lo, up);
-        break;
-      case GLP_LO:
-      case GLP_DB:
-      case GLP_FX:
-        if (lo == up)
-          glp_set_row_bnds(lp, i, GLP_FX, lo, up);
-        else
-          glp_set_row_bnds(lp, i, GLP_DB, lo, up);
-        break;
-      default:
-        break;
-      }
-    }
-  }
-
-  GlpkBase::Value GlpkBase::_getRowUpperBound(int i) const {
-    int b = glp_get_row_type(lp, i);
-    switch (b) {
-    case GLP_UP:
-    case GLP_DB:
-    case GLP_FX:
-      return glp_get_row_ub(lp, i);
-    default:
-      return INF;
-    }
-  }
-
-  void GlpkBase::_setObjCoeffs(ExprIterator b, ExprIterator e) {
-    for (int i = 1; i <= glp_get_num_cols(lp); ++i) {
-      glp_set_obj_coef(lp, i, 0.0);
-    }
-    for (ExprIterator it = b; it != e; ++it) {
-      glp_set_obj_coef(lp, it->first, it->second);
-    }
-  }
-
-  void GlpkBase::_getObjCoeffs(InsertIterator b) const {
-    for (int i = 1; i <= glp_get_num_cols(lp); ++i) {
-      Value val = glp_get_obj_coef(lp, i);
-      if (val != 0.0) {
-        *b = std::make_pair(i, val);
-        ++b;
-      }
-    }
-  }
-
-  void GlpkBase::_setObjCoeff(int i, Value obj_coef) {
-    //i = 0 means the constant term (shift)
-    glp_set_obj_coef(lp, i, obj_coef);
-  }
-
-  GlpkBase::Value GlpkBase::_getObjCoeff(int i) const {
-    //i = 0 means the constant term (shift)
-    return glp_get_obj_coef(lp, i);
-  }
-
-  void GlpkBase::_setSense(GlpkBase::Sense sense) {
-    switch (sense) {
-    case MIN:
-      glp_set_obj_dir(lp, GLP_MIN);
-      break;
-    case MAX:
-      glp_set_obj_dir(lp, GLP_MAX);
-      break;
-    }
-  }
-
-  GlpkBase::Sense GlpkBase::_getSense() const {
-    switch(glp_get_obj_dir(lp)) {
-    case GLP_MIN:
-      return MIN;
-    case GLP_MAX:
-      return MAX;
-    default:
-      LEMON_ASSERT(false, "Wrong sense");
-      return GlpkBase::Sense();
-    }
-  }
-
-  void GlpkBase::_clear() {
-    glp_erase_prob(lp);
-    rows.clear();
-    cols.clear();
-  }
-
-  void GlpkBase::freeEnv() {
-    glp_free_env();
-  }
-
-  void GlpkBase::_messageLevel(MessageLevel level) {
-    switch (level) {
-    case MESSAGE_NOTHING:
-      _message_level = GLP_MSG_OFF;
-      break;
-    case MESSAGE_ERROR:
-      _message_level = GLP_MSG_ERR;
-      break;
-    case MESSAGE_WARNING:
-      _message_level = GLP_MSG_ERR;
-      break;
-    case MESSAGE_NORMAL:
-      _message_level = GLP_MSG_ON;
-      break;
-    case MESSAGE_VERBOSE:
-      _message_level = GLP_MSG_ALL;
-      break;
-    }
-  }
-
-  GlpkBase::FreeEnvHelper GlpkBase::freeEnvHelper;
-
-  // GlpkLp members
-
-  GlpkLp::GlpkLp()
-    : LpBase(), LpSolver(), GlpkBase() {
-    presolver(false);
-  }
-
-  GlpkLp::GlpkLp(const GlpkLp& other)
-    : LpBase(other), LpSolver(other), GlpkBase(other) {
-    presolver(false);
-  }
-
-  GlpkLp* GlpkLp::newSolver() const { return new GlpkLp; }
-  GlpkLp* GlpkLp::cloneSolver() const { return new GlpkLp(*this); }
-
-  const char* GlpkLp::_solverName() const { return "GlpkLp"; }
-
-  void GlpkLp::_clear_temporals() {
-    _primal_ray.clear();
-    _dual_ray.clear();
-  }
-
-  GlpkLp::SolveExitStatus GlpkLp::_solve() {
-    return solvePrimal();
-  }
-
-  GlpkLp::SolveExitStatus GlpkLp::solvePrimal() {
-    _clear_temporals();
-
-    glp_smcp smcp;
-    glp_init_smcp(&smcp);
-
-    smcp.msg_lev = _message_level;
-    smcp.presolve = _presolve;
-
-    // If the basis is not valid we get an error return value.
-    // In this case we can try to create a new basis.
-    switch (glp_simplex(lp, &smcp)) {
-    case 0:
-      break;
-    case GLP_EBADB:
-    case GLP_ESING:
-    case GLP_ECOND:
-      glp_term_out(false);
-      glp_adv_basis(lp, 0);
-      glp_term_out(true);
-      if (glp_simplex(lp, &smcp) != 0) return UNSOLVED;
-      break;
-    default:
-      return UNSOLVED;
-    }
-
-    return SOLVED;
-  }
-
-  GlpkLp::SolveExitStatus GlpkLp::solveDual() {
-    _clear_temporals();
-
-    glp_smcp smcp;
-    glp_init_smcp(&smcp);
-
-    smcp.msg_lev = _message_level;
-    smcp.meth = GLP_DUAL;
-    smcp.presolve = _presolve;
-
-    // If the basis is not valid we get an error return value.
-    // In this case we can try to create a new basis.
-    switch (glp_simplex(lp, &smcp)) {
-    case 0:
-      break;
-    case GLP_EBADB:
-    case GLP_ESING:
-    case GLP_ECOND:
-      glp_term_out(false);
-      glp_adv_basis(lp, 0);
-      glp_term_out(true);
-      if (glp_simplex(lp, &smcp) != 0) return UNSOLVED;
-      break;
-    default:
-      return UNSOLVED;
-    }
-    return SOLVED;
-  }
-
-  GlpkLp::Value GlpkLp::_getPrimal(int i) const {
-    return glp_get_col_prim(lp, i);
-  }
-
-  GlpkLp::Value GlpkLp::_getDual(int i) const {
-    return glp_get_row_dual(lp, i);
-  }
-
-  GlpkLp::Value GlpkLp::_getPrimalValue() const {
-    return glp_get_obj_val(lp);
-  }
-
-  GlpkLp::VarStatus GlpkLp::_getColStatus(int i) const {
-    switch (glp_get_col_stat(lp, i)) {
-    case GLP_BS:
-      return BASIC;
-    case GLP_UP:
-      return UPPER;
-    case GLP_LO:
-      return LOWER;
-    case GLP_NF:
-      return FREE;
-    case GLP_NS:
-      return FIXED;
-    default:
-      LEMON_ASSERT(false, "Wrong column status");
-      return GlpkLp::VarStatus();
-    }
-  }
-
-  GlpkLp::VarStatus GlpkLp::_getRowStatus(int i) const {
-    switch (glp_get_row_stat(lp, i)) {
-    case GLP_BS:
-      return BASIC;
-    case GLP_UP:
-      return UPPER;
-    case GLP_LO:
-      return LOWER;
-    case GLP_NF:
-      return FREE;
-    case GLP_NS:
-      return FIXED;
-    default:
-      LEMON_ASSERT(false, "Wrong row status");
-      return GlpkLp::VarStatus();
-    }
-  }
-
-  GlpkLp::Value GlpkLp::_getPrimalRay(int i) const {
-    if (_primal_ray.empty()) {
-      int row_num = glp_get_num_rows(lp);
-      int col_num = glp_get_num_cols(lp);
-
-      _primal_ray.resize(col_num + 1, 0.0);
-
-      int index = glp_get_unbnd_ray(lp);
-      if (index != 0) {
-        // The primal ray is found in primal simplex second phase
-        LEMON_ASSERT((index <= row_num ? glp_get_row_stat(lp, index) :
-                      glp_get_col_stat(lp, index - row_num)) != GLP_BS,
-                     "Wrong primal ray");
-
-        bool negate = glp_get_obj_dir(lp) == GLP_MAX;
-
-        if (index > row_num) {
-          _primal_ray[index - row_num] = 1.0;
-          if (glp_get_col_dual(lp, index - row_num) > 0) {
-            negate = !negate;
-          }
-        } else {
-          if (glp_get_row_dual(lp, index) > 0) {
-            negate = !negate;
-          }
-        }
-
-        std::vector<int> ray_indexes(row_num + 1);
-        std::vector<Value> ray_values(row_num + 1);
-        int ray_length = glp_eval_tab_col(lp, index, &ray_indexes.front(),
-                                          &ray_values.front());
-
-        for (int i = 1; i <= ray_length; ++i) {
-          if (ray_indexes[i] > row_num) {
-            _primal_ray[ray_indexes[i] - row_num] = ray_values[i];
-          }
-        }
-
-        if (negate) {
-          for (int i = 1; i <= col_num; ++i) {
-            _primal_ray[i] = - _primal_ray[i];
-          }
-        }
-      } else {
-        for (int i = 1; i <= col_num; ++i) {
-          _primal_ray[i] = glp_get_col_prim(lp, i);
-        }
-      }
-    }
-    return _primal_ray[i];
-  }
-
-  GlpkLp::Value GlpkLp::_getDualRay(int i) const {
-    if (_dual_ray.empty()) {
-      int row_num = glp_get_num_rows(lp);
-
-      _dual_ray.resize(row_num + 1, 0.0);
-
-      int index = glp_get_unbnd_ray(lp);
-      if (index != 0) {
-        // The dual ray is found in dual simplex second phase
-        LEMON_ASSERT((index <= row_num ? glp_get_row_stat(lp, index) :
-                      glp_get_col_stat(lp, index - row_num)) == GLP_BS,
-
-                     "Wrong dual ray");
-
-        int idx;
-        bool negate = false;
-
-        if (index > row_num) {
-          idx = glp_get_col_bind(lp, index - row_num);
-          if (glp_get_col_prim(lp, index - row_num) >
-              glp_get_col_ub(lp, index - row_num)) {
-            negate = true;
-          }
-        } else {
-          idx = glp_get_row_bind(lp, index);
-          if (glp_get_row_prim(lp, index) > glp_get_row_ub(lp, index)) {
-            negate = true;
-          }
-        }
-
-        _dual_ray[idx] = negate ?  - 1.0 : 1.0;
-
-        glp_btran(lp, &_dual_ray.front());
-      } else {
-        double eps = 1e-7;
-        // The dual ray is found in primal simplex first phase
-        // We assume that the glpk minimizes the slack to get feasible solution
-        for (int i = 1; i <= row_num; ++i) {
-          int index = glp_get_bhead(lp, i);
-          if (index <= row_num) {
-            double res = glp_get_row_prim(lp, index);
-            if (res > glp_get_row_ub(lp, index) + eps) {
-              _dual_ray[i] = -1;
-            } else if (res < glp_get_row_lb(lp, index) - eps) {
-              _dual_ray[i] = 1;
-            } else {
-              _dual_ray[i] = 0;
-            }
-            _dual_ray[i] *= glp_get_rii(lp, index);
-          } else {
-            double res = glp_get_col_prim(lp, index - row_num);
-            if (res > glp_get_col_ub(lp, index - row_num) + eps) {
-              _dual_ray[i] = -1;
-            } else if (res < glp_get_col_lb(lp, index - row_num) - eps) {
-              _dual_ray[i] = 1;
-            } else {
-              _dual_ray[i] = 0;
-            }
-            _dual_ray[i] /= glp_get_sjj(lp, index - row_num);
-          }
-        }
-
-        glp_btran(lp, &_dual_ray.front());
-
-        for (int i = 1; i <= row_num; ++i) {
-          _dual_ray[i] /= glp_get_rii(lp, i);
-        }
-      }
-    }
-    return _dual_ray[i];
-  }
-
-  GlpkLp::ProblemType GlpkLp::_getPrimalType() const {
-    if (glp_get_status(lp) == GLP_OPT)
-      return OPTIMAL;
-    switch (glp_get_prim_stat(lp)) {
-    case GLP_UNDEF:
-      return UNDEFINED;
-    case GLP_FEAS:
-    case GLP_INFEAS:
-      if (glp_get_dual_stat(lp) == GLP_NOFEAS) {
-        return UNBOUNDED;
-      } else {
-        return UNDEFINED;
-      }
-    case GLP_NOFEAS:
-      return INFEASIBLE;
-    default:
-      LEMON_ASSERT(false, "Wrong primal type");
-      return  GlpkLp::ProblemType();
-    }
-  }
-
-  GlpkLp::ProblemType GlpkLp::_getDualType() const {
-    if (glp_get_status(lp) == GLP_OPT)
-      return OPTIMAL;
-    switch (glp_get_dual_stat(lp)) {
-    case GLP_UNDEF:
-      return UNDEFINED;
-    case GLP_FEAS:
-    case GLP_INFEAS:
-      if (glp_get_prim_stat(lp) == GLP_NOFEAS) {
-        return UNBOUNDED;
-      } else {
-        return UNDEFINED;
-      }
-    case GLP_NOFEAS:
-      return INFEASIBLE;
-    default:
-      LEMON_ASSERT(false, "Wrong primal type");
-      return  GlpkLp::ProblemType();
-    }
-  }
-
-  void GlpkLp::presolver(bool presolve) {
-    _presolve = presolve;
-  }
-
-  // GlpkMip members
-
-  GlpkMip::GlpkMip()
-    : LpBase(), MipSolver(), GlpkBase() {
-  }
-
-  GlpkMip::GlpkMip(const GlpkMip& other)
-    : LpBase(), MipSolver(), GlpkBase(other) {
-  }
-
-  void GlpkMip::_setColType(int i, GlpkMip::ColTypes col_type) {
-    switch (col_type) {
-    case INTEGER:
-      glp_set_col_kind(lp, i, GLP_IV);
-      break;
-    case REAL:
-      glp_set_col_kind(lp, i, GLP_CV);
-      break;
-    }
-  }
-
-  GlpkMip::ColTypes GlpkMip::_getColType(int i) const {
-    switch (glp_get_col_kind(lp, i)) {
-    case GLP_IV:
-    case GLP_BV:
-      return INTEGER;
-    default:
-      return REAL;
-    }
-
-  }
-
-  GlpkMip::SolveExitStatus GlpkMip::_solve() {
-    glp_smcp smcp;
-    glp_init_smcp(&smcp);
-
-    smcp.msg_lev = _message_level;
-    smcp.meth = GLP_DUAL;
-
-    // If the basis is not valid we get an error return value.
-    // In this case we can try to create a new basis.
-    switch (glp_simplex(lp, &smcp)) {
-    case 0:
-      break;
-    case GLP_EBADB:
-    case GLP_ESING:
-    case GLP_ECOND:
-      glp_term_out(false);
-      glp_adv_basis(lp, 0);
-      glp_term_out(true);
-      if (glp_simplex(lp, &smcp) != 0) return UNSOLVED;
-      break;
-    default:
-      return UNSOLVED;
-    }
-
-    if (glp_get_status(lp) != GLP_OPT) return SOLVED;
-
-    glp_iocp iocp;
-    glp_init_iocp(&iocp);
-
-    iocp.msg_lev = _message_level;
-
-    if (glp_intopt(lp, &iocp) != 0) return UNSOLVED;
-    return SOLVED;
-  }
-
-
-  GlpkMip::ProblemType GlpkMip::_getType() const {
-    switch (glp_get_status(lp)) {
-    case GLP_OPT:
-      switch (glp_mip_status(lp)) {
-      case GLP_UNDEF:
-        return UNDEFINED;
-      case GLP_NOFEAS:
-        return INFEASIBLE;
-      case GLP_FEAS:
-        return FEASIBLE;
-      case GLP_OPT:
-        return OPTIMAL;
-      default:
-        LEMON_ASSERT(false, "Wrong problem type.");
-        return GlpkMip::ProblemType();
-      }
-    case GLP_NOFEAS:
-      return INFEASIBLE;
-    case GLP_INFEAS:
-    case GLP_FEAS:
-      if (glp_get_dual_stat(lp) == GLP_NOFEAS) {
-        return UNBOUNDED;
-      } else {
-        return UNDEFINED;
-      }
-    default:
-      LEMON_ASSERT(false, "Wrong problem type.");
-      return GlpkMip::ProblemType();
-    }
-  }
-
-  GlpkMip::Value GlpkMip::_getSol(int i) const {
-    return glp_mip_col_val(lp, i);
-  }
-
-  GlpkMip::Value GlpkMip::_getSolValue() const {
-    return glp_mip_obj_val(lp);
-  }
-
-  GlpkMip* GlpkMip::newSolver() const { return new GlpkMip; }
-  GlpkMip* GlpkMip::cloneSolver() const {return new GlpkMip(*this); }
-
-  const char* GlpkMip::_solverName() const { return "GlpkMip"; }
-
-} //END OF NAMESPACE LEMON
Index: mon/glpk.h
===================================================================
--- lemon/glpk.h	(revision 956)
+++ 	(revision )
@@ -1,248 +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_GLPK_H
-#define LEMON_GLPK_H
-
-///\file
-///\brief Header of the LEMON-GLPK lp solver interface.
-///\ingroup lp_group
-
-#include <lemon/lp_base.h>
-
-namespace lemon {
-
-  namespace _solver_bits {
-    class VoidPtr {
-    private:
-      void *_ptr;
-    public:
-      VoidPtr() : _ptr(0) {}
-
-      template <typename T>
-      VoidPtr(T* ptr) : _ptr(reinterpret_cast<void*>(ptr)) {}
-
-      template <typename T>
-      VoidPtr& operator=(T* ptr) {
-        _ptr = reinterpret_cast<void*>(ptr);
-        return *this;
-      }
-
-      template <typename T>
-      operator T*() const { return reinterpret_cast<T*>(_ptr); }
-    };
-  }
-
-  /// \brief Base interface for the GLPK LP and MIP solver
-  ///
-  /// This class implements the common interface of the GLPK LP and MIP solver.
-  /// \ingroup lp_group
-  class GlpkBase : virtual public LpBase {
-  protected:
-
-    _solver_bits::VoidPtr lp;
-
-    GlpkBase();
-    GlpkBase(const GlpkBase&);
-    virtual ~GlpkBase();
-
-  protected:
-
-    virtual int _addCol();
-    virtual int _addRow();
-    virtual int _addRow(Value l, ExprIterator b, ExprIterator e, Value u);
-
-    virtual void _eraseCol(int i);
-    virtual void _eraseRow(int i);
-
-    virtual void _eraseColId(int i);
-    virtual void _eraseRowId(int i);
-
-    virtual void _getColName(int col, std::string& name) const;
-    virtual void _setColName(int col, const std::string& name);
-    virtual int _colByName(const std::string& name) const;
-
-    virtual void _getRowName(int row, std::string& name) const;
-    virtual void _setRowName(int row, const std::string& name);
-    virtual int _rowByName(const std::string& name) const;
-
-    virtual void _setRowCoeffs(int i, ExprIterator b, ExprIterator e);
-    virtual void _getRowCoeffs(int i, InsertIterator b) const;
-
-    virtual void _setColCoeffs(int i, ExprIterator b, ExprIterator e);
-    virtual void _getColCoeffs(int i, InsertIterator b) const;
-
-    virtual void _setCoeff(int row, int col, Value value);
-    virtual Value _getCoeff(int row, int col) const;
-
-    virtual void _setColLowerBound(int i, Value value);
-    virtual Value _getColLowerBound(int i) const;
-
-    virtual void _setColUpperBound(int i, Value value);
-    virtual Value _getColUpperBound(int i) const;
-
-    virtual void _setRowLowerBound(int i, Value value);
-    virtual Value _getRowLowerBound(int i) const;
-
-    virtual void _setRowUpperBound(int i, Value value);
-    virtual Value _getRowUpperBound(int i) const;
-
-    virtual void _setObjCoeffs(ExprIterator b, ExprIterator e);
-    virtual void _getObjCoeffs(InsertIterator b) const;
-
-    virtual void _setObjCoeff(int i, Value obj_coef);
-    virtual Value _getObjCoeff(int i) const;
-
-    virtual void _setSense(Sense);
-    virtual Sense _getSense() const;
-
-    virtual void _clear();
-
-    virtual void _messageLevel(MessageLevel level);
-
-  private:
-
-    static void freeEnv();
-
-    struct FreeEnvHelper {
-      ~FreeEnvHelper() {
-        freeEnv();
-      }
-    };
-
-    static FreeEnvHelper freeEnvHelper;
-
-  protected:
-
-    int _message_level;
-
-  public:
-
-    ///Pointer to the underlying GLPK data structure.
-    _solver_bits::VoidPtr lpx() {return lp;}
-    ///Const pointer to the underlying GLPK data structure.
-    _solver_bits::VoidPtr lpx() const {return lp;}
-
-    ///Returns the constraint identifier understood by GLPK.
-    int lpxRow(Row r) const { return rows(id(r)); }
-
-    ///Returns the variable identifier understood by GLPK.
-    int lpxCol(Col c) const { return cols(id(c)); }
-
-  };
-
-  /// \brief Interface for the GLPK LP solver
-  ///
-  /// This class implements an interface for the GLPK LP solver.
-  ///\ingroup lp_group
-  class GlpkLp : public LpSolver, public GlpkBase {
-  public:
-
-    ///\e
-    GlpkLp();
-    ///\e
-    GlpkLp(const GlpkLp&);
-
-    ///\e
-    virtual GlpkLp* cloneSolver() const;
-    ///\e
-    virtual GlpkLp* newSolver() const;
-
-  private:
-
-    mutable std::vector<double> _primal_ray;
-    mutable std::vector<double> _dual_ray;
-
-    void _clear_temporals();
-
-  protected:
-
-    virtual const char* _solverName() const;
-
-    virtual SolveExitStatus _solve();
-    virtual Value _getPrimal(int i) const;
-    virtual Value _getDual(int i) const;
-
-    virtual Value _getPrimalValue() const;
-
-    virtual VarStatus _getColStatus(int i) const;
-    virtual VarStatus _getRowStatus(int i) const;
-
-    virtual Value _getPrimalRay(int i) const;
-    virtual Value _getDualRay(int i) const;
-
-    virtual ProblemType _getPrimalType() const;
-    virtual ProblemType _getDualType() const;
-
-  public:
-
-    ///Solve with primal simplex
-    SolveExitStatus solvePrimal();
-
-    ///Solve with dual simplex
-    SolveExitStatus solveDual();
-
-  private:
-
-    bool _presolve;
-
-  public:
-
-    ///Turns on or off the presolver
-
-    ///Turns on (\c b is \c true) or off (\c b is \c false) the presolver
-    ///
-    ///The presolver is off by default.
-    void presolver(bool presolve);
-
-  };
-
-  /// \brief Interface for the GLPK MIP solver
-  ///
-  /// This class implements an interface for the GLPK MIP solver.
-  ///\ingroup lp_group
-  class GlpkMip : public MipSolver, public GlpkBase {
-  public:
-
-    ///\e
-    GlpkMip();
-    ///\e
-    GlpkMip(const GlpkMip&);
-
-    virtual GlpkMip* cloneSolver() const;
-    virtual GlpkMip* newSolver() const;
-
-  protected:
-
-    virtual const char* _solverName() const;
-
-    virtual ColTypes _getColType(int col) const;
-    virtual void _setColType(int col, ColTypes col_type);
-
-    virtual SolveExitStatus _solve();
-    virtual ProblemType _getType() const;
-    virtual Value _getSol(int i) const;
-    virtual Value _getSolValue() const;
-
-  };
-
-
-} //END OF NAMESPACE LEMON
-
-#endif //LEMON_GLPK_H
-
Index: mon/gomory_hu.h
===================================================================
--- lemon/gomory_hu.h	(revision 956)
+++ 	(revision )
@@ -1,568 +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_GOMORY_HU_TREE_H
-#define LEMON_GOMORY_HU_TREE_H
-
-#include <limits>
-
-#include <lemon/core.h>
-#include <lemon/preflow.h>
-#include <lemon/concept_check.h>
-#include <lemon/concepts/maps.h>
-
-/// \ingroup min_cut
-/// \file
-/// \brief Gomory-Hu cut tree in graphs.
-
-namespace lemon {
-
-  /// \ingroup min_cut
-  ///
-  /// \brief Gomory-Hu cut tree algorithm
-  ///
-  /// 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
-  /// in this tree has the same weight as the minimum cut in the graph
-  /// between these nodes. Moreover the components obtained by removing
-  /// this edge from the tree determine the corresponding minimum cut.
-  /// 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
-  /// time complexity. It calculates a rooted Gomory-Hu tree.
-  /// The structure of the tree and the edge weights can be
-  /// obtained using \c predNode(), \c predValue() and \c rootDist().
-  /// The functions \c minCutMap() and \c minCutValue() calculate
-  /// the minimum cut and the minimum cut value between any two nodes
-  /// in the graph. You can also list (iterate on) the nodes and the
-  /// edges of the cuts using \c MinCutNodeIt and \c MinCutEdgeIt.
-  ///
-  /// \tparam GR The type of the undirected graph the algorithm runs on.
-  /// \tparam CAP The type of the edge map containing the capacities.
-  /// The default map type is \ref concepts::Graph::EdgeMap "GR::EdgeMap<int>".
-#ifdef DOXYGEN
-  template <typename GR,
-            typename CAP>
-#else
-  template <typename GR,
-            typename CAP = typename GR::template EdgeMap<int> >
-#endif
-  class GomoryHu {
-  public:
-
-    /// The graph type of the algorithm
-    typedef GR Graph;
-    /// The capacity map type of the algorithm
-    typedef CAP Capacity;
-    /// The value type of capacities
-    typedef typename Capacity::Value Value;
-
-  private:
-
-    TEMPLATE_GRAPH_TYPEDEFS(Graph);
-
-    const Graph& _graph;
-    const Capacity& _capacity;
-
-    Node _root;
-    typename Graph::template NodeMap<Node>* _pred;
-    typename Graph::template NodeMap<Value>* _weight;
-    typename Graph::template NodeMap<int>* _order;
-
-    void createStructures() {
-      if (!_pred) {
-        _pred = new typename Graph::template NodeMap<Node>(_graph);
-      }
-      if (!_weight) {
-        _weight = new typename Graph::template NodeMap<Value>(_graph);
-      }
-      if (!_order) {
-        _order = new typename Graph::template NodeMap<int>(_graph);
-      }
-    }
-
-    void destroyStructures() {
-      if (_pred) {
-        delete _pred;
-      }
-      if (_weight) {
-        delete _weight;
-      }
-      if (_order) {
-        delete _order;
-      }
-    }
-
-  public:
-
-    /// \brief Constructor
-    ///
-    /// Constructor.
-    /// \param graph The undirected graph the algorithm runs on.
-    /// \param capacity The edge capacity map.
-    GomoryHu(const Graph& graph, const Capacity& capacity)
-      : _graph(graph), _capacity(capacity),
-        _pred(0), _weight(0), _order(0)
-    {
-      checkConcept<concepts::ReadMap<Edge, Value>, Capacity>();
-    }
-
-
-    /// \brief Destructor
-    ///
-    /// Destructor.
-    ~GomoryHu() {
-      destroyStructures();
-    }
-
-  private:
-
-    // Initialize the internal data structures
-    void init() {
-      createStructures();
-
-      _root = NodeIt(_graph);
-      for (NodeIt n(_graph); n != INVALID; ++n) {
-        (*_pred)[n] = _root;
-        (*_order)[n] = -1;
-      }
-      (*_pred)[_root] = INVALID;
-      (*_weight)[_root] = std::numeric_limits<Value>::max();
-    }
-
-
-    // Start the algorithm
-    void start() {
-      Preflow<Graph, Capacity> fa(_graph, _capacity, _root, INVALID);
-
-      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();
-        }
-      }
-
-      (*_order)[_root] = 0;
-      int index = 1;
-
-      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();
-        }
-      }
-    }
-
-  public:
-
-    ///\name Execution Control
-
-    ///@{
-
-    /// \brief Run the Gomory-Hu algorithm.
-    ///
-    /// This function runs the Gomory-Hu algorithm.
-    void run() {
-      init();
-      start();
-    }
-
-    /// @}
-
-    ///\name Query Functions
-    ///The results of the algorithm can be obtained using these
-    ///functions.\n
-    ///\ref run() should be called before using them.\n
-    ///See also \ref MinCutNodeIt and \ref MinCutEdgeIt.
-
-    ///@{
-
-    /// \brief Return the predecessor node in the Gomory-Hu tree.
-    ///
-    /// This function returns the predecessor node of the given node
-    /// in the Gomory-Hu tree.
-    /// If \c node is the root of the tree, then it returns \c INVALID.
-    ///
-    /// \pre \ref run() must be called before using this function.
-    Node predNode(const Node& node) const {
-      return (*_pred)[node];
-    }
-
-    /// \brief Return the weight of the predecessor edge in the
-    /// Gomory-Hu tree.
-    ///
-    /// 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.
-    ///
-    /// \pre \ref run() must be called before using this function.
-    Value predValue(const Node& node) const {
-      return (*_weight)[node];
-    }
-
-    /// \brief Return the distance from the root node in the Gomory-Hu tree.
-    ///
-    /// This function returns the distance of the given node from the root
-    /// node in the Gomory-Hu tree.
-    ///
-    /// \pre \ref run() must be called before using this function.
-    int rootDist(const Node& node) const {
-      return (*_order)[node];
-    }
-
-    /// \brief Return the minimum cut value between two nodes
-    ///
-    /// This function returns the minimum cut value between the nodes
-    /// \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
-    /// paths to the ancestor.
-    ///
-    /// \pre \ref run() must be called before using this function.
-    Value minCutValue(const Node& s, const Node& t) const {
-      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];
-        }
-      }
-      return value;
-    }
-
-    /// \brief Return the minimum cut between two nodes
-    ///
-    /// This function returns the minimum cut between the nodes \c s and \c t
-    /// in the \c cutMap parameter by setting the nodes in the component of
-    /// \c s to \c true and the other nodes to \c false.
-    ///
-    /// For higher level interfaces see MinCutNodeIt and MinCutEdgeIt.
-    ///
-    /// \param s The base node.
-    /// \param t The node you want to separate from node \c s.
-    /// \param cutMap The cut will be returned in this map.
-    /// It must be a \c bool (or convertible) \ref concepts::ReadWriteMap
-    /// "ReadWriteMap" on the graph nodes.
-    ///
-    /// \return The value of the minimum cut between \c s and \c t.
-    ///
-    /// \pre \ref run() must be called before using this function.
-    template <typename CutMap>
-    Value minCutMap(const Node& s,
-                    const Node& t,
-                    CutMap& cutMap
-                    ) const {
-      Node sn = s, tn = t;
-      bool s_root=false;
-      Node rn = INVALID;
-      Value value = std::numeric_limits<Value>::max();
-
-      while (sn != 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;
-            s_root = true;
-            value = (*_weight)[sn];
-          }
-          sn = (*_pred)[sn];
-        }
-      }
-
-      typename Graph::template NodeMap<bool> reached(_graph, false);
-      reached[_root] = true;
-      cutMap.set(_root, !s_root);
-      reached[rn] = true;
-      cutMap.set(rn, s_root);
-
-      std::vector<Node> st;
-      for (NodeIt n(_graph); n != INVALID; ++n) {
-        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();
-        }
-      }
-
-      return value;
-    }
-
-    ///@}
-
-    friend class MinCutNodeIt;
-
-    /// 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
-    /// and call its \ref GomoryHu::run() "run()" method.
-    ///
-    /// This example counts the nodes in the minimum cut separating \c s from
-    /// \c t.
-    /// \code
-    /// GomoryHu<Graph> gom(g, capacities);
-    /// gom.run();
-    /// int cnt=0;
-    /// for(GomoryHu<Graph>::MinCutNodeIt n(gom,s,t); n!=INVALID; ++n) ++cnt;
-    /// \endcode
-    class MinCutNodeIt
-    {
-      bool _side;
-      typename Graph::NodeIt _node_it;
-      typename Graph::template NodeMap<bool> _cut;
-    public:
-      /// Constructor
-
-      /// Constructor.
-      ///
-      MinCutNodeIt(GomoryHu const &gomory,
-                   ///< The GomoryHu class. You must call its
-                   ///  run() method
-                   ///  before initializing this iterator.
-                   const Node& s, ///< The base node.
-                   const Node& t,
-                   ///< The node you want to separate from node \c s.
-                   bool side=true
-                   ///< If it is \c true (default) then the iterator lists
-                   ///  the nodes of the component containing \c s,
-                   ///  otherwise it lists the other component.
-                   /// \note As the minimum cut is not always unique,
-                   /// \code
-                   /// MinCutNodeIt(gomory, s, t, true);
-                   /// \endcode
-                   /// and
-                   /// \code
-                   /// MinCutNodeIt(gomory, t, s, false);
-                   /// \endcode
-                   /// does not necessarily give the same set of nodes.
-                   /// However, it is ensured that
-                   /// \code
-                   /// MinCutNodeIt(gomory, s, t, true);
-                   /// \endcode
-                   /// and
-                   /// \code
-                   /// MinCutNodeIt(gomory, s, t, false);
-                   /// \endcode
-                   /// together list each node exactly once.
-                   )
-        : _side(side), _cut(gomory._graph)
-      {
-        gomory.minCutMap(s,t,_cut);
-        for(_node_it=typename Graph::NodeIt(gomory._graph);
-            _node_it!=INVALID && _cut[_node_it]!=_side;
-            ++_node_it) {}
-      }
-      /// Conversion to \c Node
-
-      /// Conversion to \c Node.
-      ///
-      operator typename Graph::Node() const
-      {
-        return _node_it;
-      }
-      bool operator==(Invalid) { return _node_it==INVALID; }
-      bool operator!=(Invalid) { return _node_it!=INVALID; }
-      /// Next node
-
-      /// Next node.
-      ///
-      MinCutNodeIt &operator++()
-      {
-        for(++_node_it;_node_it!=INVALID&&_cut[_node_it]!=_side;++_node_it) {}
-        return *this;
-      }
-      /// Postfix incrementation
-
-      /// Postfix incrementation.
-      ///
-      /// \warning This incrementation
-      /// returns a \c Node, not a \c MinCutNodeIt, as one may
-      /// expect.
-      typename Graph::Node operator++(int)
-      {
-        typename Graph::Node n=*this;
-        ++(*this);
-        return n;
-      }
-    };
-
-    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
-    /// and call its \ref GomoryHu::run() "run()" method.
-    ///
-    /// This example computes the value of the minimum cut separating \c s from
-    /// \c t.
-    /// \code
-    /// GomoryHu<Graph> gom(g, capacities);
-    /// gom.run();
-    /// int value=0;
-    /// for(GomoryHu<Graph>::MinCutEdgeIt e(gom,s,t); e!=INVALID; ++e)
-    ///   value+=capacities[e];
-    /// \endcode
-    /// The result will be the same as the value returned by
-    /// \ref GomoryHu::minCutValue() "gom.minCutValue(s,t)".
-    class MinCutEdgeIt
-    {
-      bool _side;
-      const Graph &_graph;
-      typename Graph::NodeIt _node_it;
-      typename Graph::OutArcIt _arc_it;
-      typename Graph::template NodeMap<bool> _cut;
-      void step()
-      {
-        ++_arc_it;
-        while(_node_it!=INVALID && _arc_it==INVALID)
-          {
-            for(++_node_it;_node_it!=INVALID&&!_cut[_node_it];++_node_it) {}
-            if(_node_it!=INVALID)
-              _arc_it=typename Graph::OutArcIt(_graph,_node_it);
-          }
-      }
-
-    public:
-      /// Constructor
-
-      /// Constructor.
-      ///
-      MinCutEdgeIt(GomoryHu const &gomory,
-                   ///< The GomoryHu class. You must call its
-                   ///  run() method
-                   ///  before initializing this iterator.
-                   const Node& s,  ///< The base node.
-                   const Node& t,
-                   ///< The node you want to separate from node \c s.
-                   bool side=true
-                   ///< If it is \c true (default) then the listed arcs
-                   ///  will be oriented from the
-                   ///  nodes of the component containing \c s,
-                   ///  otherwise they will be oriented in the opposite
-                   ///  direction.
-                   )
-        : _graph(gomory._graph), _cut(_graph)
-      {
-        gomory.minCutMap(s,t,_cut);
-        if(!side)
-          for(typename Graph::NodeIt n(_graph);n!=INVALID;++n)
-            _cut[n]=!_cut[n];
-
-        for(_node_it=typename Graph::NodeIt(_graph);
-            _node_it!=INVALID && !_cut[_node_it];
-            ++_node_it) {}
-        _arc_it = _node_it!=INVALID ?
-          typename Graph::OutArcIt(_graph,_node_it) : INVALID;
-        while(_node_it!=INVALID && _arc_it == INVALID)
-          {
-            for(++_node_it; _node_it!=INVALID&&!_cut[_node_it]; ++_node_it) {}
-            if(_node_it!=INVALID)
-              _arc_it= typename Graph::OutArcIt(_graph,_node_it);
-          }
-        while(_arc_it!=INVALID && _cut[_graph.target(_arc_it)]) step();
-      }
-      /// Conversion to \c Arc
-
-      /// Conversion to \c Arc.
-      ///
-      operator typename Graph::Arc() const
-      {
-        return _arc_it;
-      }
-      /// Conversion to \c Edge
-
-      /// Conversion to \c Edge.
-      ///
-      operator typename Graph::Edge() const
-      {
-        return _arc_it;
-      }
-      bool operator==(Invalid) { return _node_it==INVALID; }
-      bool operator!=(Invalid) { return _node_it!=INVALID; }
-      /// Next edge
-
-      /// Next edge.
-      ///
-      MinCutEdgeIt &operator++()
-      {
-        step();
-        while(_arc_it!=INVALID && _cut[_graph.target(_arc_it)]) step();
-        return *this;
-      }
-      /// Postfix incrementation
-
-      /// Postfix incrementation.
-      ///
-      /// \warning This incrementation
-      /// returns an \c Arc, not a \c MinCutEdgeIt, as one may expect.
-      typename Graph::Arc operator++(int)
-      {
-        typename Graph::Arc e=*this;
-        ++(*this);
-        return e;
-      }
-    };
-
-  };
-
-}
-
-#endif
Index: lemon/graph_to_eps.h
===================================================================
--- lemon/graph_to_eps.h	(revision 956)
+++ lemon/graph_to_eps.h	(revision 906)
@@ -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).
@@ -65,10 +65,9 @@
 ///Default traits class of \ref GraphToEps.
 ///
-///\param GR is the type of the underlying graph.
-template<class GR>
+///\c G is the type of the underlying graph.
+template<class G>
 struct DefaultGraphToEpsTraits
 {
-  typedef GR Graph;
-  typedef GR Digraph;
+  typedef G Graph;
   typedef typename Graph::Node Node;
   typedef typename Graph::NodeIt NodeIt;
@@ -141,12 +140,13 @@
 
   ///Constructor
-  ///\param gr  Reference to the graph to be printed.
-  ///\param ost Reference to the output stream.
-  ///By default, it is <tt>std::cout</tt>.
-  ///\param pros If it is \c true, then the \c ostream referenced by \c os
+  ///\param _g  Reference to the graph to be printed.
+  ///\param _os Reference to the output stream.
+  ///\param _os Reference to the output stream.
+  ///By default it is <tt>std::cout</tt>.
+  ///\param _pros If it is \c true, then the \c ostream referenced by \c _os
   ///will be explicitly deallocated by the destructor.
-  DefaultGraphToEpsTraits(const GR &gr, std::ostream& ost = std::cout,
-                          bool pros = false) :
-    g(gr), os(ost),
+  DefaultGraphToEpsTraits(const G &_g,std::ostream& _os=std::cout,
+                          bool _pros=false) :
+    g(_g), os(_os),
     _coords(dim2::Point<double>(1,1)), _nodeSizes(1), _nodeShapes(0),
     _nodeColors(WHITE), _arcColors(BLACK),
@@ -159,6 +159,6 @@
     _showNodeText(false), _nodeTexts(false), _nodeTextSize(1),
     _showNodePsText(false), _nodePsTexts(false), _nodePsTextsPreamble(0),
-    _undirected(lemon::UndirectedTagIndicator<GR>::value),
-    _pleaseRemoveOsStream(pros), _scaleToA4(false),
+    _undirected(lemon::UndirectedTagIndicator<G>::value),
+    _pleaseRemoveOsStream(_pros), _scaleToA4(false),
     _nodeTextColorType(SAME_COL), _nodeTextColors(BLACK),
     _autoNodeScale(false),
@@ -243,5 +243,4 @@
 
   typedef typename T::Graph Graph;
-  typedef typename T::Digraph Digraph;
   typedef typename Graph::Node Node;
   typedef typename Graph::NodeIt NodeIt;
@@ -271,16 +270,20 @@
     ///\image html nodeshape_1.png
     ///\image latex nodeshape_1.eps "SQUARE shape (1)" width=2cm
+    ///
     SQUARE=1,
     /// = 2
     ///\image html nodeshape_2.png
     ///\image latex nodeshape_2.eps "DIAMOND shape (2)" width=2cm
+    ///
     DIAMOND=2,
     /// = 3
     ///\image html nodeshape_3.png
-    ///\image latex nodeshape_3.eps "MALE shape (3)" width=2cm
+    ///\image latex nodeshape_2.eps "MALE shape (4)" width=2cm
+    ///
     MALE=3,
     /// = 4
     ///\image html nodeshape_4.png
-    ///\image latex nodeshape_4.eps "FEMALE shape (4)" width=2cm
+    ///\image latex nodeshape_2.eps "FEMALE shape (4)" width=2cm
+    ///
     FEMALE=4
   };
@@ -513,5 +516,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 +1118,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,16 +1130,16 @@
 ///\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()"
 ///to the end of the parameter list.
 ///\sa GraphToEps
-///\sa graphToEps(GR &g, const char *file_name)
-template<class GR>
-GraphToEps<DefaultGraphToEpsTraits<GR> >
-graphToEps(GR &g, std::ostream& os=std::cout)
+///\sa graphToEps(G &g, const char *file_name)
+template<class G>
+GraphToEps<DefaultGraphToEpsTraits<G> >
+graphToEps(G &g, std::ostream& os=std::cout)
 {
   return
-    GraphToEps<DefaultGraphToEpsTraits<GR> >(DefaultGraphToEpsTraits<GR>(g,os));
+    GraphToEps<DefaultGraphToEpsTraits<G> >(DefaultGraphToEpsTraits<G>(g,os));
 }
 
@@ -1145,11 +1148,11 @@
 ///\ingroup eps_io
 ///This function does the same as
-///\ref graphToEps(GR &g,std::ostream& os)
+///\ref graphToEps(G &g,std::ostream& os)
 ///but it writes its output into the file \c file_name
 ///instead of a stream.
-///\sa graphToEps(GR &g, std::ostream& os)
-template<class GR>
-GraphToEps<DefaultGraphToEpsTraits<GR> >
-graphToEps(GR &g,const char *file_name)
+///\sa graphToEps(G &g, std::ostream& os)
+template<class G>
+GraphToEps<DefaultGraphToEpsTraits<G> >
+graphToEps(G &g,const char *file_name)
 {
   std::ostream* os = new std::ofstream(file_name);
@@ -1158,6 +1161,6 @@
     throw IoError("Cannot write file", file_name);
   }
-  return GraphToEps<DefaultGraphToEpsTraits<GR> >
-    (DefaultGraphToEpsTraits<GR>(g,*os,true));
+  return GraphToEps<DefaultGraphToEpsTraits<G> >
+    (DefaultGraphToEpsTraits<G>(g,*os,true));
 }
 
@@ -1166,11 +1169,11 @@
 ///\ingroup eps_io
 ///This function does the same as
-///\ref graphToEps(GR &g,std::ostream& os)
+///\ref graphToEps(G &g,std::ostream& os)
 ///but it writes its output into the file \c file_name
 ///instead of a stream.
-///\sa graphToEps(GR &g, std::ostream& os)
-template<class GR>
-GraphToEps<DefaultGraphToEpsTraits<GR> >
-graphToEps(GR &g,const std::string& file_name)
+///\sa graphToEps(G &g, std::ostream& os)
+template<class G>
+GraphToEps<DefaultGraphToEpsTraits<G> >
+graphToEps(G &g,const std::string& file_name)
 {
   std::ostream* os = new std::ofstream(file_name.c_str());
@@ -1179,6 +1182,6 @@
     throw IoError("Cannot write file", file_name);
   }
-  return GraphToEps<DefaultGraphToEpsTraits<GR> >
-    (DefaultGraphToEpsTraits<GR>(g,*os,true));
+  return GraphToEps<DefaultGraphToEpsTraits<G> >
+    (DefaultGraphToEpsTraits<G>(g,*os,true));
 }
 
Index: mon/grid_graph.h
===================================================================
--- lemon/grid_graph.h	(revision 834)
+++ 	(revision )
@@ -1,699 +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 GRID_GRAPH_H
-#define GRID_GRAPH_H
-
-#include <lemon/core.h>
-#include <lemon/bits/graph_extender.h>
-#include <lemon/dim2.h>
-#include <lemon/assert.h>
-
-///\ingroup graphs
-///\file
-///\brief GridGraph class.
-
-namespace lemon {
-
-  class GridGraphBase {
-
-  public:
-
-    typedef GridGraphBase Graph;
-
-    class Node;
-    class Edge;
-    class Arc;
-
-  public:
-
-    GridGraphBase() {}
-
-  protected:
-
-    void construct(int width, int height) {
-       _width = width; _height = height;
-      _node_num = width * height;
-      _edge_num = 2 * _node_num - width - height;
-      _edge_limit = _node_num - _width;
-    }
-
-  public:
-
-    Node operator()(int i, int j) const {
-      LEMON_DEBUG(0 <= i && i < _width &&
-                  0 <= j  && j < _height, "Index out of range");
-      return Node(i + j * _width);
-    }
-
-    int col(Node n) const {
-      return n._id % _width;
-    }
-
-    int row(Node n) const {
-      return n._id / _width;
-    }
-
-    dim2::Point<int> pos(Node n) const {
-      return dim2::Point<int>(col(n), row(n));
-    }
-
-    int width() const {
-      return _width;
-    }
-
-    int height() const {
-      return _height;
-    }
-
-    typedef True NodeNumTag;
-    typedef True EdgeNumTag;
-    typedef True ArcNumTag;
-
-    int nodeNum() const { return _node_num; }
-    int edgeNum() const { return _edge_num; }
-    int arcNum() const { return 2 * _edge_num; }
-
-    Node u(Edge edge) const {
-      if (edge._id < _edge_limit) {
-        return edge._id;
-      } else {
-        return (edge._id - _edge_limit) % (_width - 1) +
-          (edge._id - _edge_limit) / (_width - 1) * _width;
-      }
-    }
-
-    Node v(Edge edge) const {
-      if (edge._id < _edge_limit) {
-        return edge._id + _width;
-      } else {
-        return (edge._id - _edge_limit) % (_width - 1) +
-          (edge._id - _edge_limit) / (_width - 1) * _width + 1;
-      }
-    }
-
-    Node source(Arc arc) const {
-      return (arc._id & 1) == 1 ? u(arc) : v(arc);
-    }
-
-    Node target(Arc arc) const {
-      return (arc._id & 1) == 1 ? v(arc) : u(arc);
-    }
-
-    static int id(Node node) { return node._id; }
-    static int id(Edge edge) { return edge._id; }
-    static int id(Arc arc) { return arc._id; }
-
-    int maxNodeId() const { return _node_num - 1; }
-    int maxEdgeId() const { return _edge_num - 1; }
-    int maxArcId() const { return 2 * _edge_num - 1; }
-
-    static Node nodeFromId(int id) { return Node(id);}
-    static Edge edgeFromId(int id) { return Edge(id);}
-    static Arc arcFromId(int id) { return Arc(id);}
-
-    typedef True FindEdgeTag;
-    typedef True FindArcTag;
-
-    Edge findEdge(Node u, Node v, Edge prev = INVALID) const {
-      if (prev != INVALID) return INVALID;
-      if (v._id > u._id) {
-        if (v._id - u._id == _width)
-          return Edge(u._id);
-        if (v._id - u._id == 1 && u._id % _width < _width - 1) {
-          return Edge(u._id / _width * (_width - 1) +
-                      u._id % _width + _edge_limit);
-        }
-      } else {
-        if (u._id - v._id == _width)
-          return Edge(v._id);
-        if (u._id - v._id == 1 && v._id % _width < _width - 1) {
-          return Edge(v._id / _width * (_width - 1) +
-                      v._id % _width + _edge_limit);
-        }
-      }
-      return INVALID;
-    }
-
-    Arc findArc(Node u, Node v, Arc prev = INVALID) const {
-      if (prev != INVALID) return INVALID;
-      if (v._id > u._id) {
-        if (v._id - u._id == _width)
-          return Arc((u._id << 1) | 1);
-        if (v._id - u._id == 1 && u._id % _width < _width - 1) {
-          return Arc(((u._id / _width * (_width - 1) +
-                       u._id % _width + _edge_limit) << 1) | 1);
-        }
-      } else {
-        if (u._id - v._id == _width)
-          return Arc(v._id << 1);
-        if (u._id - v._id == 1 && v._id % _width < _width - 1) {
-          return Arc((v._id / _width * (_width - 1) +
-                       v._id % _width + _edge_limit) << 1);
-        }
-      }
-      return INVALID;
-    }
-
-    class Node {
-      friend class GridGraphBase;
-
-    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 Edge {
-      friend class GridGraphBase;
-      friend class Arc;
-
-    protected:
-      int _id;
-
-      Edge(int id) : _id(id) {}
-
-    public:
-      Edge() {}
-      Edge (Invalid) : _id(-1) {}
-      bool operator==(const Edge edge) const {return _id == edge._id;}
-      bool operator!=(const Edge edge) const {return _id != edge._id;}
-      bool operator<(const Edge edge) const {return _id < edge._id;}
-    };
-
-    class Arc {
-      friend class GridGraphBase;
-
-    protected:
-      int _id;
-
-      Arc(int id) : _id(id) {}
-
-    public:
-      Arc() {}
-      Arc (Invalid) : _id(-1) {}
-      operator Edge() const { return _id != -1 ? Edge(_id >> 1) : INVALID; }
-      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;}
-    };
-
-    static bool direction(Arc arc) {
-      return (arc._id & 1) == 1;
-    }
-
-    static Arc direct(Edge edge, bool dir) {
-      return Arc((edge._id << 1) | (dir ? 1 : 0));
-    }
-
-    void first(Node& node) const {
-      node._id = _node_num - 1;
-    }
-
-    static void next(Node& node) {
-      --node._id;
-    }
-
-    void first(Edge& edge) const {
-      edge._id = _edge_num - 1;
-    }
-
-    static void next(Edge& edge) {
-      --edge._id;
-    }
-
-    void first(Arc& arc) const {
-      arc._id = 2 * _edge_num - 1;
-    }
-
-    static void next(Arc& arc) {
-      --arc._id;
-    }
-
-    void firstOut(Arc& arc, const Node& node) const {
-      if (node._id % _width < _width - 1) {
-        arc._id = (_edge_limit + node._id % _width +
-                   (node._id / _width) * (_width - 1)) << 1 | 1;
-        return;
-      }
-      if (node._id < _node_num - _width) {
-        arc._id = node._id << 1 | 1;
-        return;
-      }
-      if (node._id % _width > 0) {
-        arc._id = (_edge_limit + node._id % _width +
-                   (node._id / _width) * (_width - 1) - 1) << 1;
-        return;
-      }
-      if (node._id >= _width) {
-        arc._id = (node._id - _width) << 1;
-        return;
-      }
-      arc._id = -1;
-    }
-
-    void nextOut(Arc& arc) const {
-      int nid = arc._id >> 1;
-      if ((arc._id & 1) == 1) {
-        if (nid >= _edge_limit) {
-          nid = (nid - _edge_limit) % (_width - 1) +
-            (nid - _edge_limit) / (_width - 1) * _width;
-          if (nid < _node_num - _width) {
-            arc._id = nid << 1 | 1;
-            return;
-          }
-        }
-        if (nid % _width > 0) {
-          arc._id = (_edge_limit + nid % _width +
-                     (nid / _width) * (_width - 1) - 1) << 1;
-          return;
-        }
-        if (nid >= _width) {
-          arc._id = (nid - _width) << 1;
-          return;
-        }
-      } else {
-        if (nid >= _edge_limit) {
-          nid = (nid - _edge_limit) % (_width - 1) +
-            (nid - _edge_limit) / (_width - 1) * _width + 1;
-          if (nid >= _width) {
-            arc._id = (nid - _width) << 1;
-            return;
-          }
-        }
-      }
-      arc._id = -1;
-    }
-
-    void firstIn(Arc& arc, const Node& node) const {
-      if (node._id % _width < _width - 1) {
-        arc._id = (_edge_limit + node._id % _width +
-                   (node._id / _width) * (_width - 1)) << 1;
-        return;
-      }
-      if (node._id < _node_num - _width) {
-        arc._id = node._id << 1;
-        return;
-      }
-      if (node._id % _width > 0) {
-        arc._id = (_edge_limit + node._id % _width +
-                   (node._id / _width) * (_width - 1) - 1) << 1 | 1;
-        return;
-      }
-      if (node._id >= _width) {
-        arc._id = (node._id - _width) << 1 | 1;
-        return;
-      }
-      arc._id = -1;
-    }
-
-    void nextIn(Arc& arc) const {
-      int nid = arc._id >> 1;
-      if ((arc._id & 1) == 0) {
-        if (nid >= _edge_limit) {
-          nid = (nid - _edge_limit) % (_width - 1) +
-            (nid - _edge_limit) / (_width - 1) * _width;
-          if (nid < _node_num - _width) {
-            arc._id = nid << 1;
-            return;
-          }
-        }
-        if (nid % _width > 0) {
-          arc._id = (_edge_limit + nid % _width +
-                     (nid / _width) * (_width - 1) - 1) << 1 | 1;
-          return;
-        }
-        if (nid >= _width) {
-          arc._id = (nid - _width) << 1 | 1;
-          return;
-        }
-      } else {
-        if (nid >= _edge_limit) {
-          nid = (nid - _edge_limit) % (_width - 1) +
-            (nid - _edge_limit) / (_width - 1) * _width + 1;
-          if (nid >= _width) {
-            arc._id = (nid - _width) << 1 | 1;
-            return;
-          }
-        }
-      }
-      arc._id = -1;
-    }
-
-    void firstInc(Edge& edge, bool& dir, const Node& node) const {
-      if (node._id % _width < _width - 1) {
-        edge._id = _edge_limit + node._id % _width +
-          (node._id / _width) * (_width - 1);
-        dir = true;
-        return;
-      }
-      if (node._id < _node_num - _width) {
-        edge._id = node._id;
-        dir = true;
-        return;
-      }
-      if (node._id % _width > 0) {
-        edge._id = _edge_limit + node._id % _width +
-          (node._id / _width) * (_width - 1) - 1;
-        dir = false;
-        return;
-      }
-      if (node._id >= _width) {
-        edge._id = node._id - _width;
-        dir = false;
-        return;
-      }
-      edge._id = -1;
-      dir = true;
-    }
-
-    void nextInc(Edge& edge, bool& dir) const {
-      int nid = edge._id;
-      if (dir) {
-        if (nid >= _edge_limit) {
-          nid = (nid - _edge_limit) % (_width - 1) +
-            (nid - _edge_limit) / (_width - 1) * _width;
-          if (nid < _node_num - _width) {
-            edge._id = nid;
-            return;
-          }
-        }
-        if (nid % _width > 0) {
-          edge._id = _edge_limit + nid % _width +
-            (nid / _width) * (_width - 1) - 1;
-          dir = false;
-          return;
-        }
-        if (nid >= _width) {
-          edge._id = nid - _width;
-          dir = false;
-          return;
-        }
-      } else {
-        if (nid >= _edge_limit) {
-          nid = (nid - _edge_limit) % (_width - 1) +
-            (nid - _edge_limit) / (_width - 1) * _width + 1;
-          if (nid >= _width) {
-            edge._id = nid - _width;
-            return;
-          }
-        }
-      }
-      edge._id = -1;
-      dir = true;
-    }
-
-    Arc right(Node n) const {
-      if (n._id % _width < _width - 1) {
-        return Arc(((_edge_limit + n._id % _width +
-                    (n._id / _width) * (_width - 1)) << 1) | 1);
-      } else {
-        return INVALID;
-      }
-    }
-
-    Arc left(Node n) const {
-      if (n._id % _width > 0) {
-        return Arc((_edge_limit + n._id % _width +
-                     (n._id / _width) * (_width - 1) - 1) << 1);
-      } else {
-        return INVALID;
-      }
-    }
-
-    Arc up(Node n) const {
-      if (n._id < _edge_limit) {
-        return Arc((n._id << 1) | 1);
-      } else {
-        return INVALID;
-      }
-    }
-
-    Arc down(Node n) const {
-      if (n._id >= _width) {
-        return Arc((n._id - _width) << 1);
-      } else {
-        return INVALID;
-      }
-    }
-
-  private:
-    int _width, _height;
-    int _node_num, _edge_num;
-    int _edge_limit;
-  };
-
-
-  typedef GraphExtender<GridGraphBase> ExtendedGridGraphBase;
-
-  /// \ingroup graphs
-  ///
-  /// \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
-  /// 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
-  /// \image latex grid_graph.eps "Grid graph" width=\textwidth
-  ///
-  /// A short example about the basic usage:
-  ///\code
-  /// GridGraph graph(rows, cols);
-  /// GridGraph::NodeMap<int> val(graph);
-  /// for (int i = 0; i < graph.width(); ++i) {
-  ///   for (int j = 0; j < graph.height(); ++j) {
-  ///     val[graph(i, j)] = i + j;
-  ///   }
-  /// }
-  ///\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.
-  class GridGraph : public ExtendedGridGraphBase {
-    typedef ExtendedGridGraphBase Parent;
-
-  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>".
-    class IndexMap {
-    public:
-      /// \brief The key type of the map
-      typedef GridGraph::Node Key;
-      /// \brief The value type of the map
-      typedef dim2::Point<int> Value;
-
-      /// \brief Constructor
-      IndexMap(const GridGraph& graph) : _graph(graph) {}
-
-      /// \brief The subscript operator
-      Value operator[](Key key) const {
-        return _graph.pos(key);
-      }
-
-    private:
-      const GridGraph& _graph;
-    };
-
-    /// \brief Map to get the column of the nodes.
-    ///
-    /// Map to get the column of the nodes.
-    class ColMap {
-    public:
-      /// \brief The key type of the map
-      typedef GridGraph::Node Key;
-      /// \brief The value type of the map
-      typedef int Value;
-
-      /// \brief Constructor
-      ColMap(const GridGraph& graph) : _graph(graph) {}
-
-      /// \brief The subscript operator
-      Value operator[](Key key) const {
-        return _graph.col(key);
-      }
-
-    private:
-      const GridGraph& _graph;
-    };
-
-    /// \brief Map to get the row of the nodes.
-    ///
-    /// Map to get the row of the nodes.
-    class RowMap {
-    public:
-      /// \brief The key type of the map
-      typedef GridGraph::Node Key;
-      /// \brief The value type of the map
-      typedef int Value;
-
-      /// \brief Constructor
-      RowMap(const GridGraph& graph) : _graph(graph) {}
-
-      /// \brief The subscript operator
-      Value operator[](Key key) const {
-        return _graph.row(key);
-      }
-
-    private:
-      const GridGraph& _graph;
-    };
-
-    /// \brief Constructor
-    ///
-    /// Construct a grid graph with the 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.
-    void resize(int width, int height) {
-      Parent::notifier(Arc()).clear();
-      Parent::notifier(Edge()).clear();
-      Parent::notifier(Node()).clear();
-      construct(width, height);
-      Parent::notifier(Node()).build();
-      Parent::notifier(Edge()).build();
-      Parent::notifier(Arc()).build();
-    }
-
-    /// \brief The node on the given position.
-    ///
-    /// Gives back the node on the given position.
-    Node operator()(int i, int j) const {
-      return Parent::operator()(i, j);
-    }
-
-    /// \brief The column index of the node.
-    ///
-    /// Gives back the column index of the node.
-    int col(Node n) const {
-      return Parent::col(n);
-    }
-
-    /// \brief The row index of the node.
-    ///
-    /// Gives back the row index of the node.
-    int row(Node n) const {
-      return Parent::row(n);
-    }
-
-    /// \brief The position of the node.
-    ///
-    /// Gives back the position of the node, ie. the <tt>(col,row)</tt> pair.
-    dim2::Point<int> pos(Node n) const {
-      return Parent::pos(n);
-    }
-
-    /// \brief The number of the columns.
-    ///
-    /// Gives back the number of the columns.
-    int width() const {
-      return Parent::width();
-    }
-
-    /// \brief The number of the rows.
-    ///
-    /// Gives back the number of the rows.
-    int height() const {
-      return Parent::height();
-    }
-
-    /// \brief The arc goes right from the node.
-    ///
-    /// Gives back the arc goes right from the node. If there is not
-    /// outgoing arc then it gives back INVALID.
-    Arc right(Node n) const {
-      return Parent::right(n);
-    }
-
-    /// \brief The arc goes left from the node.
-    ///
-    /// Gives back the arc goes left from the node. If there is not
-    /// outgoing arc then it gives back INVALID.
-    Arc left(Node n) const {
-      return Parent::left(n);
-    }
-
-    /// \brief The arc goes up from the node.
-    ///
-    /// Gives back the arc goes up from the node. If there is not
-    /// outgoing arc then it gives back INVALID.
-    Arc up(Node n) const {
-      return Parent::up(n);
-    }
-
-    /// \brief The arc goes down from the node.
-    ///
-    /// Gives back the arc goes down from the node. If there is not
-    /// outgoing arc then it gives back INVALID.
-    Arc down(Node n) const {
-      return Parent::down(n);
-    }
-
-    /// \brief Index map of the grid graph
-    ///
-    /// Just returns an IndexMap for the grid graph.
-    IndexMap indexMap() const {
-      return IndexMap(*this);
-    }
-
-    /// \brief Row map of the grid graph
-    ///
-    /// Just returns a RowMap for the grid graph.
-    RowMap rowMap() const {
-      return RowMap(*this);
-    }
-
-    /// \brief Column map of the grid graph
-    ///
-    /// Just returns a ColMap for the grid graph.
-    ColMap colMap() const {
-      return ColMap(*this);
-    }
-
-  };
-
-}
-#endif
Index: mon/hao_orlin.h
===================================================================
--- lemon/hao_orlin.h	(revision 956)
+++ 	(revision )
@@ -1,1005 +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_HAO_ORLIN_H
-#define LEMON_HAO_ORLIN_H
-
-#include <vector>
-#include <list>
-#include <limits>
-
-#include <lemon/maps.h>
-#include <lemon/core.h>
-#include <lemon/tolerance.h>
-
-/// \file
-/// \ingroup min_cut
-/// \brief Implementation of the Hao-Orlin algorithm.
-///
-/// Implementation of the Hao-Orlin algorithm for finding a minimum cut
-/// in a digraph.
-
-namespace lemon {
-
-  /// \ingroup min_cut
-  ///
-  /// \brief Hao-Orlin algorithm for finding a minimum cut in a digraph.
-  ///
-  /// This class implements the Hao-Orlin algorithm for finding a minimum
-  /// 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
-  /// minimum cut with \f$ source \f$ on the source-side (i.e. a set
-  /// \f$ X\subsetneq V \f$ with \f$ source \in X \f$ and minimal outgoing
-  /// capacity) and in the second phase it determines a minimum cut
-  /// with \f$ source \f$ on the sink-side (i.e. a set
-  /// \f$ X\subsetneq V \f$ with \f$ source \notin X \f$ and minimal outgoing
-  /// capacity). Obviously, the smaller of these two cuts will be a
-  /// minimum cut of \f$ D \f$. The algorithm is a modified
-  /// 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. 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$
-  /// time. It is implemented in the NagamochiIbaraki algorithm class.
-  ///
-  /// \tparam GR The type of the digraph the algorithm runs on.
-  /// \tparam CAP The type of the arc map containing the capacities,
-  /// which can be any numreric type. The default map type is
-  /// \ref concepts::Digraph::ArcMap "GR::ArcMap<int>".
-  /// \tparam TOL Tolerance class for handling inexact computations. The
-  /// default tolerance type is \ref Tolerance "Tolerance<CAP::Value>".
-#ifdef DOXYGEN
-  template <typename GR, typename CAP, typename TOL>
-#else
-  template <typename GR,
-            typename CAP = typename GR::template ArcMap<int>,
-            typename TOL = Tolerance<typename CAP::Value> >
-#endif
-  class HaoOrlin {
-  public:
-
-    /// The digraph type of the algorithm
-    typedef GR Digraph;
-    /// The capacity map type of the algorithm
-    typedef CAP CapacityMap;
-    /// The tolerance type of the algorithm
-    typedef TOL Tolerance;
-
-  private:
-
-    typedef typename CapacityMap::Value Value;
-
-    TEMPLATE_DIGRAPH_TYPEDEFS(Digraph);
-
-    const Digraph& _graph;
-    const CapacityMap* _capacity;
-
-    typedef typename Digraph::template ArcMap<Value> FlowMap;
-    FlowMap* _flow;
-
-    Node _source;
-
-    int _node_num;
-
-    // Bucketing structure
-    std::vector<Node> _first, _last;
-    typename Digraph::template NodeMap<Node>* _next;
-    typename Digraph::template NodeMap<Node>* _prev;
-    typename Digraph::template NodeMap<bool>* _active;
-    typename Digraph::template NodeMap<int>* _bucket;
-
-    std::vector<bool> _dormant;
-
-    std::list<std::list<int> > _sets;
-    std::list<int>::iterator _highest;
-
-    typedef typename Digraph::template NodeMap<Value> ExcessMap;
-    ExcessMap* _excess;
-
-    typedef typename Digraph::template NodeMap<bool> SourceSetMap;
-    SourceSetMap* _source_set;
-
-    Value _min_cut;
-
-    typedef typename Digraph::template NodeMap<bool> MinCutMap;
-    MinCutMap* _min_cut_map;
-
-    Tolerance _tolerance;
-
-  public:
-
-    /// \brief Constructor
-    ///
-    /// Constructor of the algorithm class.
-    HaoOrlin(const Digraph& graph, const CapacityMap& capacity,
-             const Tolerance& tolerance = Tolerance()) :
-      _graph(graph), _capacity(&capacity), _flow(0), _source(),
-      _node_num(), _first(), _last(), _next(0), _prev(0),
-      _active(0), _bucket(0), _dormant(), _sets(), _highest(),
-      _excess(0), _source_set(0), _min_cut(), _min_cut_map(0),
-      _tolerance(tolerance) {}
-
-    ~HaoOrlin() {
-      if (_min_cut_map) {
-        delete _min_cut_map;
-      }
-      if (_source_set) {
-        delete _source_set;
-      }
-      if (_excess) {
-        delete _excess;
-      }
-      if (_next) {
-        delete _next;
-      }
-      if (_prev) {
-        delete _prev;
-      }
-      if (_active) {
-        delete _active;
-      }
-      if (_bucket) {
-        delete _bucket;
-      }
-      if (_flow) {
-        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;
-    }
-
-  private:
-
-    void activate(const Node& i) {
-      (*_active)[i] = true;
-
-      int bucket = (*_bucket)[i];
-
-      if ((*_prev)[i] == INVALID || (*_active)[(*_prev)[i]]) return;
-      //unlace
-      (*_next)[(*_prev)[i]] = (*_next)[i];
-      if ((*_next)[i] != INVALID) {
-        (*_prev)[(*_next)[i]] = (*_prev)[i];
-      } else {
-        _last[bucket] = (*_prev)[i];
-      }
-      //lace
-      (*_next)[i] = _first[bucket];
-      (*_prev)[_first[bucket]] = i;
-      (*_prev)[i] = INVALID;
-      _first[bucket] = i;
-    }
-
-    void deactivate(const Node& i) {
-      (*_active)[i] = false;
-      int bucket = (*_bucket)[i];
-
-      if ((*_next)[i] == INVALID || !(*_active)[(*_next)[i]]) return;
-
-      //unlace
-      (*_prev)[(*_next)[i]] = (*_prev)[i];
-      if ((*_prev)[i] != INVALID) {
-        (*_next)[(*_prev)[i]] = (*_next)[i];
-      } else {
-        _first[bucket] = (*_next)[i];
-      }
-      //lace
-      (*_prev)[i] = _last[bucket];
-      (*_next)[_last[bucket]] = i;
-      (*_next)[i] = INVALID;
-      _last[bucket] = i;
-    }
-
-    void addItem(const Node& i, int bucket) {
-      (*_bucket)[i] = bucket;
-      if (_last[bucket] != INVALID) {
-        (*_prev)[i] = _last[bucket];
-        (*_next)[_last[bucket]] = i;
-        (*_next)[i] = INVALID;
-        _last[bucket] = i;
-      } else {
-        (*_prev)[i] = INVALID;
-        _first[bucket] = i;
-        (*_next)[i] = INVALID;
-        _last[bucket] = i;
-      }
-    }
-
-    void findMinCutOut() {
-
-      for (NodeIt n(_graph); n != INVALID; ++n) {
-        (*_excess)[n] = 0;
-        (*_source_set)[n] = false;
-      }
-
-      for (ArcIt a(_graph); a != INVALID; ++a) {
-        (*_flow)[a] = 0;
-      }
-
-      int bucket_num = 0;
-      std::vector<Node> queue(_node_num);
-      int qfirst = 0, qlast = 0, qsep = 0;
-
-      {
-        typename Digraph::template NodeMap<bool> reached(_graph, false);
-
-        reached[_source] = true;
-        bool first_set = true;
-
-        for (NodeIt t(_graph); t != INVALID; ++t) {
-          if (reached[t]) continue;
-          _sets.push_front(std::list<int>());
-
-          queue[qlast++] = t;
-          reached[t] = true;
-
-          while (qfirst != qlast) {
-            if (qsep == qfirst) {
-              ++bucket_num;
-              _sets.front().push_front(bucket_num);
-              _dormant[bucket_num] = !first_set;
-              _first[bucket_num] = _last[bucket_num] = INVALID;
-              qsep = qlast;
-            }
-
-            Node n = queue[qfirst++];
-            addItem(n, bucket_num);
-
-            for (InArcIt a(_graph, n); a != INVALID; ++a) {
-              Node u = _graph.source(a);
-              if (!reached[u] && _tolerance.positive((*_capacity)[a])) {
-                reached[u] = true;
-                queue[qlast++] = u;
-              }
-            }
-          }
-          first_set = false;
-        }
-
-        ++bucket_num;
-        (*_bucket)[_source] = 0;
-        _dormant[0] = true;
-      }
-      (*_source_set)[_source] = true;
-
-      Node target = _last[_sets.back().back()];
-      {
-        for (OutArcIt a(_graph, _source); a != INVALID; ++a) {
-          if (_tolerance.positive((*_capacity)[a])) {
-            Node u = _graph.target(a);
-            (*_flow)[a] = (*_capacity)[a];
-            (*_excess)[u] += (*_capacity)[a];
-            if (!(*_active)[u] && u != _source) {
-              activate(u);
-            }
-          }
-        }
-
-        if ((*_active)[target]) {
-          deactivate(target);
-        }
-
-        _highest = _sets.back().begin();
-        while (_highest != _sets.back().end() &&
-               !(*_active)[_first[*_highest]]) {
-          ++_highest;
-        }
-      }
-
-      while (true) {
-        while (_highest != _sets.back().end()) {
-          Node n = _first[*_highest];
-          Value excess = (*_excess)[n];
-          int next_bucket = _node_num;
-
-          int under_bucket;
-          if (++std::list<int>::iterator(_highest) == _sets.back().end()) {
-            under_bucket = -1;
-          } else {
-            under_bucket = *(++std::list<int>::iterator(_highest));
-          }
-
-          for (OutArcIt a(_graph, n); a != INVALID; ++a) {
-            Node v = _graph.target(a);
-            if (_dormant[(*_bucket)[v]]) continue;
-            Value rem = (*_capacity)[a] - (*_flow)[a];
-            if (!_tolerance.positive(rem)) continue;
-            if ((*_bucket)[v] == under_bucket) {
-              if (!(*_active)[v] && v != target) {
-                activate(v);
-              }
-              if (!_tolerance.less(rem, excess)) {
-                (*_flow)[a] += excess;
-                (*_excess)[v] += excess;
-                excess = 0;
-                goto no_more_push;
-              } else {
-                excess -= rem;
-                (*_excess)[v] += rem;
-                (*_flow)[a] = (*_capacity)[a];
-              }
-            } else if (next_bucket > (*_bucket)[v]) {
-              next_bucket = (*_bucket)[v];
-            }
-          }
-
-          for (InArcIt a(_graph, n); a != INVALID; ++a) {
-            Node v = _graph.source(a);
-            if (_dormant[(*_bucket)[v]]) continue;
-            Value rem = (*_flow)[a];
-            if (!_tolerance.positive(rem)) continue;
-            if ((*_bucket)[v] == under_bucket) {
-              if (!(*_active)[v] && v != target) {
-                activate(v);
-              }
-              if (!_tolerance.less(rem, excess)) {
-                (*_flow)[a] -= excess;
-                (*_excess)[v] += excess;
-                excess = 0;
-                goto no_more_push;
-              } else {
-                excess -= rem;
-                (*_excess)[v] += rem;
-                (*_flow)[a] = 0;
-              }
-            } else if (next_bucket > (*_bucket)[v]) {
-              next_bucket = (*_bucket)[v];
-            }
-          }
-
-        no_more_push:
-
-          (*_excess)[n] = excess;
-
-          if (excess != 0) {
-            if ((*_next)[n] == INVALID) {
-              typename std::list<std::list<int> >::iterator new_set =
-                _sets.insert(--_sets.end(), std::list<int>());
-              new_set->splice(new_set->end(), _sets.back(),
-                              _sets.back().begin(), ++_highest);
-              for (std::list<int>::iterator it = new_set->begin();
-                   it != new_set->end(); ++it) {
-                _dormant[*it] = true;
-              }
-              while (_highest != _sets.back().end() &&
-                     !(*_active)[_first[*_highest]]) {
-                ++_highest;
-              }
-            } else if (next_bucket == _node_num) {
-              _first[(*_bucket)[n]] = (*_next)[n];
-              (*_prev)[(*_next)[n]] = INVALID;
-
-              std::list<std::list<int> >::iterator new_set =
-                _sets.insert(--_sets.end(), std::list<int>());
-
-              new_set->push_front(bucket_num);
-              (*_bucket)[n] = bucket_num;
-              _first[bucket_num] = _last[bucket_num] = n;
-              (*_next)[n] = INVALID;
-              (*_prev)[n] = INVALID;
-              _dormant[bucket_num] = true;
-              ++bucket_num;
-
-              while (_highest != _sets.back().end() &&
-                     !(*_active)[_first[*_highest]]) {
-                ++_highest;
-              }
-            } else {
-              _first[*_highest] = (*_next)[n];
-              (*_prev)[(*_next)[n]] = INVALID;
-
-              while (next_bucket != *_highest) {
-                --_highest;
-              }
-
-              if (_highest == _sets.back().begin()) {
-                _sets.back().push_front(bucket_num);
-                _dormant[bucket_num] = false;
-                _first[bucket_num] = _last[bucket_num] = INVALID;
-                ++bucket_num;
-              }
-              --_highest;
-
-              (*_bucket)[n] = *_highest;
-              (*_next)[n] = _first[*_highest];
-              if (_first[*_highest] != INVALID) {
-                (*_prev)[_first[*_highest]] = n;
-              } else {
-                _last[*_highest] = n;
-              }
-              _first[*_highest] = n;
-            }
-          } else {
-
-            deactivate(n);
-            if (!(*_active)[_first[*_highest]]) {
-              ++_highest;
-              if (_highest != _sets.back().end() &&
-                  !(*_active)[_first[*_highest]]) {
-                _highest = _sets.back().end();
-              }
-            }
-          }
-        }
-
-        if ((*_excess)[target] < _min_cut) {
-          _min_cut = (*_excess)[target];
-          for (NodeIt i(_graph); i != INVALID; ++i) {
-            (*_min_cut_map)[i] = true;
-          }
-          for (std::list<int>::iterator it = _sets.back().begin();
-               it != _sets.back().end(); ++it) {
-            Node n = _first[*it];
-            while (n != INVALID) {
-              (*_min_cut_map)[n] = false;
-              n = (*_next)[n];
-            }
-          }
-        }
-
-        {
-          Node new_target;
-          if ((*_prev)[target] != INVALID || (*_next)[target] != INVALID) {
-            if ((*_next)[target] == INVALID) {
-              _last[(*_bucket)[target]] = (*_prev)[target];
-              new_target = (*_prev)[target];
-            } else {
-              (*_prev)[(*_next)[target]] = (*_prev)[target];
-              new_target = (*_next)[target];
-            }
-            if ((*_prev)[target] == INVALID) {
-              _first[(*_bucket)[target]] = (*_next)[target];
-            } else {
-              (*_next)[(*_prev)[target]] = (*_next)[target];
-            }
-          } else {
-            _sets.back().pop_back();
-            if (_sets.back().empty()) {
-              _sets.pop_back();
-              if (_sets.empty())
-                break;
-              for (std::list<int>::iterator it = _sets.back().begin();
-                   it != _sets.back().end(); ++it) {
-                _dormant[*it] = false;
-              }
-            }
-            new_target = _last[_sets.back().back()];
-          }
-
-          (*_bucket)[target] = 0;
-
-          (*_source_set)[target] = true;
-          for (OutArcIt a(_graph, target); a != INVALID; ++a) {
-            Value rem = (*_capacity)[a] - (*_flow)[a];
-            if (!_tolerance.positive(rem)) continue;
-            Node v = _graph.target(a);
-            if (!(*_active)[v] && !(*_source_set)[v]) {
-              activate(v);
-            }
-            (*_excess)[v] += rem;
-            (*_flow)[a] = (*_capacity)[a];
-          }
-
-          for (InArcIt a(_graph, target); a != INVALID; ++a) {
-            Value rem = (*_flow)[a];
-            if (!_tolerance.positive(rem)) continue;
-            Node v = _graph.source(a);
-            if (!(*_active)[v] && !(*_source_set)[v]) {
-              activate(v);
-            }
-            (*_excess)[v] += rem;
-            (*_flow)[a] = 0;
-          }
-
-          target = new_target;
-          if ((*_active)[target]) {
-            deactivate(target);
-          }
-
-          _highest = _sets.back().begin();
-          while (_highest != _sets.back().end() &&
-                 !(*_active)[_first[*_highest]]) {
-            ++_highest;
-          }
-        }
-      }
-    }
-
-    void findMinCutIn() {
-
-      for (NodeIt n(_graph); n != INVALID; ++n) {
-        (*_excess)[n] = 0;
-        (*_source_set)[n] = false;
-      }
-
-      for (ArcIt a(_graph); a != INVALID; ++a) {
-        (*_flow)[a] = 0;
-      }
-
-      int bucket_num = 0;
-      std::vector<Node> queue(_node_num);
-      int qfirst = 0, qlast = 0, qsep = 0;
-
-      {
-        typename Digraph::template NodeMap<bool> reached(_graph, false);
-
-        reached[_source] = true;
-
-        bool first_set = true;
-
-        for (NodeIt t(_graph); t != INVALID; ++t) {
-          if (reached[t]) continue;
-          _sets.push_front(std::list<int>());
-
-          queue[qlast++] = t;
-          reached[t] = true;
-
-          while (qfirst != qlast) {
-            if (qsep == qfirst) {
-              ++bucket_num;
-              _sets.front().push_front(bucket_num);
-              _dormant[bucket_num] = !first_set;
-              _first[bucket_num] = _last[bucket_num] = INVALID;
-              qsep = qlast;
-            }
-
-            Node n = queue[qfirst++];
-            addItem(n, bucket_num);
-
-            for (OutArcIt a(_graph, n); a != INVALID; ++a) {
-              Node u = _graph.target(a);
-              if (!reached[u] && _tolerance.positive((*_capacity)[a])) {
-                reached[u] = true;
-                queue[qlast++] = u;
-              }
-            }
-          }
-          first_set = false;
-        }
-
-        ++bucket_num;
-        (*_bucket)[_source] = 0;
-        _dormant[0] = true;
-      }
-      (*_source_set)[_source] = true;
-
-      Node target = _last[_sets.back().back()];
-      {
-        for (InArcIt a(_graph, _source); a != INVALID; ++a) {
-          if (_tolerance.positive((*_capacity)[a])) {
-            Node u = _graph.source(a);
-            (*_flow)[a] = (*_capacity)[a];
-            (*_excess)[u] += (*_capacity)[a];
-            if (!(*_active)[u] && u != _source) {
-              activate(u);
-            }
-          }
-        }
-        if ((*_active)[target]) {
-          deactivate(target);
-        }
-
-        _highest = _sets.back().begin();
-        while (_highest != _sets.back().end() &&
-               !(*_active)[_first[*_highest]]) {
-          ++_highest;
-        }
-      }
-
-
-      while (true) {
-        while (_highest != _sets.back().end()) {
-          Node n = _first[*_highest];
-          Value excess = (*_excess)[n];
-          int next_bucket = _node_num;
-
-          int under_bucket;
-          if (++std::list<int>::iterator(_highest) == _sets.back().end()) {
-            under_bucket = -1;
-          } else {
-            under_bucket = *(++std::list<int>::iterator(_highest));
-          }
-
-          for (InArcIt a(_graph, n); a != INVALID; ++a) {
-            Node v = _graph.source(a);
-            if (_dormant[(*_bucket)[v]]) continue;
-            Value rem = (*_capacity)[a] - (*_flow)[a];
-            if (!_tolerance.positive(rem)) continue;
-            if ((*_bucket)[v] == under_bucket) {
-              if (!(*_active)[v] && v != target) {
-                activate(v);
-              }
-              if (!_tolerance.less(rem, excess)) {
-                (*_flow)[a] += excess;
-                (*_excess)[v] += excess;
-                excess = 0;
-                goto no_more_push;
-              } else {
-                excess -= rem;
-                (*_excess)[v] += rem;
-                (*_flow)[a] = (*_capacity)[a];
-              }
-            } else if (next_bucket > (*_bucket)[v]) {
-              next_bucket = (*_bucket)[v];
-            }
-          }
-
-          for (OutArcIt a(_graph, n); a != INVALID; ++a) {
-            Node v = _graph.target(a);
-            if (_dormant[(*_bucket)[v]]) continue;
-            Value rem = (*_flow)[a];
-            if (!_tolerance.positive(rem)) continue;
-            if ((*_bucket)[v] == under_bucket) {
-              if (!(*_active)[v] && v != target) {
-                activate(v);
-              }
-              if (!_tolerance.less(rem, excess)) {
-                (*_flow)[a] -= excess;
-                (*_excess)[v] += excess;
-                excess = 0;
-                goto no_more_push;
-              } else {
-                excess -= rem;
-                (*_excess)[v] += rem;
-                (*_flow)[a] = 0;
-              }
-            } else if (next_bucket > (*_bucket)[v]) {
-              next_bucket = (*_bucket)[v];
-            }
-          }
-
-        no_more_push:
-
-          (*_excess)[n] = excess;
-
-          if (excess != 0) {
-            if ((*_next)[n] == INVALID) {
-              typename std::list<std::list<int> >::iterator new_set =
-                _sets.insert(--_sets.end(), std::list<int>());
-              new_set->splice(new_set->end(), _sets.back(),
-                              _sets.back().begin(), ++_highest);
-              for (std::list<int>::iterator it = new_set->begin();
-                   it != new_set->end(); ++it) {
-                _dormant[*it] = true;
-              }
-              while (_highest != _sets.back().end() &&
-                     !(*_active)[_first[*_highest]]) {
-                ++_highest;
-              }
-            } else if (next_bucket == _node_num) {
-              _first[(*_bucket)[n]] = (*_next)[n];
-              (*_prev)[(*_next)[n]] = INVALID;
-
-              std::list<std::list<int> >::iterator new_set =
-                _sets.insert(--_sets.end(), std::list<int>());
-
-              new_set->push_front(bucket_num);
-              (*_bucket)[n] = bucket_num;
-              _first[bucket_num] = _last[bucket_num] = n;
-              (*_next)[n] = INVALID;
-              (*_prev)[n] = INVALID;
-              _dormant[bucket_num] = true;
-              ++bucket_num;
-
-              while (_highest != _sets.back().end() &&
-                     !(*_active)[_first[*_highest]]) {
-                ++_highest;
-              }
-            } else {
-              _first[*_highest] = (*_next)[n];
-              (*_prev)[(*_next)[n]] = INVALID;
-
-              while (next_bucket != *_highest) {
-                --_highest;
-              }
-              if (_highest == _sets.back().begin()) {
-                _sets.back().push_front(bucket_num);
-                _dormant[bucket_num] = false;
-                _first[bucket_num] = _last[bucket_num] = INVALID;
-                ++bucket_num;
-              }
-              --_highest;
-
-              (*_bucket)[n] = *_highest;
-              (*_next)[n] = _first[*_highest];
-              if (_first[*_highest] != INVALID) {
-                (*_prev)[_first[*_highest]] = n;
-              } else {
-                _last[*_highest] = n;
-              }
-              _first[*_highest] = n;
-            }
-          } else {
-
-            deactivate(n);
-            if (!(*_active)[_first[*_highest]]) {
-              ++_highest;
-              if (_highest != _sets.back().end() &&
-                  !(*_active)[_first[*_highest]]) {
-                _highest = _sets.back().end();
-              }
-            }
-          }
-        }
-
-        if ((*_excess)[target] < _min_cut) {
-          _min_cut = (*_excess)[target];
-          for (NodeIt i(_graph); i != INVALID; ++i) {
-            (*_min_cut_map)[i] = false;
-          }
-          for (std::list<int>::iterator it = _sets.back().begin();
-               it != _sets.back().end(); ++it) {
-            Node n = _first[*it];
-            while (n != INVALID) {
-              (*_min_cut_map)[n] = true;
-              n = (*_next)[n];
-            }
-          }
-        }
-
-        {
-          Node new_target;
-          if ((*_prev)[target] != INVALID || (*_next)[target] != INVALID) {
-            if ((*_next)[target] == INVALID) {
-              _last[(*_bucket)[target]] = (*_prev)[target];
-              new_target = (*_prev)[target];
-            } else {
-              (*_prev)[(*_next)[target]] = (*_prev)[target];
-              new_target = (*_next)[target];
-            }
-            if ((*_prev)[target] == INVALID) {
-              _first[(*_bucket)[target]] = (*_next)[target];
-            } else {
-              (*_next)[(*_prev)[target]] = (*_next)[target];
-            }
-          } else {
-            _sets.back().pop_back();
-            if (_sets.back().empty()) {
-              _sets.pop_back();
-              if (_sets.empty())
-                break;
-              for (std::list<int>::iterator it = _sets.back().begin();
-                   it != _sets.back().end(); ++it) {
-                _dormant[*it] = false;
-              }
-            }
-            new_target = _last[_sets.back().back()];
-          }
-
-          (*_bucket)[target] = 0;
-
-          (*_source_set)[target] = true;
-          for (InArcIt a(_graph, target); a != INVALID; ++a) {
-            Value rem = (*_capacity)[a] - (*_flow)[a];
-            if (!_tolerance.positive(rem)) continue;
-            Node v = _graph.source(a);
-            if (!(*_active)[v] && !(*_source_set)[v]) {
-              activate(v);
-            }
-            (*_excess)[v] += rem;
-            (*_flow)[a] = (*_capacity)[a];
-          }
-
-          for (OutArcIt a(_graph, target); a != INVALID; ++a) {
-            Value rem = (*_flow)[a];
-            if (!_tolerance.positive(rem)) continue;
-            Node v = _graph.target(a);
-            if (!(*_active)[v] && !(*_source_set)[v]) {
-              activate(v);
-            }
-            (*_excess)[v] += rem;
-            (*_flow)[a] = 0;
-          }
-
-          target = new_target;
-          if ((*_active)[target]) {
-            deactivate(target);
-          }
-
-          _highest = _sets.back().begin();
-          while (_highest != _sets.back().end() &&
-                 !(*_active)[_first[*_highest]]) {
-            ++_highest;
-          }
-        }
-      }
-    }
-
-  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 better control on the execution,
-    /// you have to call one of the \ref init() functions first, then
-    /// \ref calculateOut() and/or \ref calculateIn().
-
-    /// @{
-
-    /// \brief Initialize the internal data structures.
-    ///
-    /// This function initializes the internal data structures. It creates
-    /// the maps and some bucket structures for the algorithm.
-    /// The first node is used as the source node for the push-relabel
-    /// algorithm.
-    void init() {
-      init(NodeIt(_graph));
-    }
-
-    /// \brief Initialize the internal data structures.
-    ///
-    /// This function initializes the internal data structures. It creates
-    /// the maps and some bucket structures for the algorithm.
-    /// The given node is used as the source node for the push-relabel
-    /// algorithm.
-    void init(const Node& source) {
-      _source = source;
-
-      _node_num = countNodes(_graph);
-
-      _first.resize(_node_num);
-      _last.resize(_node_num);
-
-      _dormant.resize(_node_num);
-
-      if (!_flow) {
-        _flow = new FlowMap(_graph);
-      }
-      if (!_next) {
-        _next = new typename Digraph::template NodeMap<Node>(_graph);
-      }
-      if (!_prev) {
-        _prev = new typename Digraph::template NodeMap<Node>(_graph);
-      }
-      if (!_active) {
-        _active = new typename Digraph::template NodeMap<bool>(_graph);
-      }
-      if (!_bucket) {
-        _bucket = new typename Digraph::template NodeMap<int>(_graph);
-      }
-      if (!_excess) {
-        _excess = new ExcessMap(_graph);
-      }
-      if (!_source_set) {
-        _source_set = new SourceSetMap(_graph);
-      }
-      if (!_min_cut_map) {
-        _min_cut_map = new MinCutMap(_graph);
-      }
-
-      _min_cut = std::numeric_limits<Value>::max();
-    }
-
-
-    /// \brief Calculate a minimum cut with \f$ source \f$ on the
-    /// source-side.
-    ///
-    /// This function calculates a minimum cut with \f$ source \f$ on the
-    /// source-side (i.e. a set \f$ X\subsetneq V \f$ with
-    /// \f$ source \in X \f$ and minimal outgoing capacity).
-    ///
-    /// \pre \ref init() must be called before using this function.
-    void calculateOut() {
-      findMinCutOut();
-    }
-
-    /// \brief Calculate a minimum cut with \f$ source \f$ on the
-    /// sink-side.
-    ///
-    /// This function calculates a minimum cut with \f$ source \f$ on the
-    /// sink-side (i.e. a set \f$ X\subsetneq V \f$ with
-    /// \f$ source \notin X \f$ and minimal outgoing capacity).
-    ///
-    /// \pre \ref init() must be called before using this function.
-    void calculateIn() {
-      findMinCutIn();
-    }
-
-
-    /// \brief Run the algorithm.
-    ///
-    /// 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() {
-      init();
-      calculateOut();
-      calculateIn();
-    }
-
-    /// \brief Run the algorithm.
-    ///
-    /// 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);
-      calculateOut();
-      calculateIn();
-    }
-
-    /// @}
-
-    /// \name Query Functions
-    /// The result of the %HaoOrlin algorithm
-    /// can be obtained using these functions.\n
-    /// \ref run(), \ref calculateOut() or \ref calculateIn()
-    /// should be called before using them.
-
-    /// @{
-
-    /// \brief Return the value of the minimum cut.
-    ///
-    /// 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 {
-      return _min_cut;
-    }
-
-
-    /// \brief Return a minimum cut.
-    ///
-    /// 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$).
-    ///
-    /// \param cutMap A \ref concepts::WriteMap "writable" node map with
-    /// \c bool (or convertible) value type.
-    ///
-    /// \return The value of the minimum cut.
-    ///
-    /// \pre \ref run(), \ref calculateOut() or \ref calculateIn()
-    /// must be called before using this function.
-    template <typename CutMap>
-    Value minCutMap(CutMap& cutMap) const {
-      for (NodeIt it(_graph); it != INVALID; ++it) {
-        cutMap.set(it, (*_min_cut_map)[it]);
-      }
-      return _min_cut;
-    }
-
-    /// @}
-
-  }; //class HaoOrlin
-
-} //namespace lemon
-
-#endif //LEMON_HAO_ORLIN_H
Index: mon/hartmann_orlin_mmc.h
===================================================================
--- lemon/hartmann_orlin_mmc.h	(revision 959)
+++ 	(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 956)
+++ 	(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: mon/hypercube_graph.h
===================================================================
--- lemon/hypercube_graph.h	(revision 835)
+++ 	(revision )
@@ -1,459 +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 HYPERCUBE_GRAPH_H
-#define HYPERCUBE_GRAPH_H
-
-#include <vector>
-#include <lemon/core.h>
-#include <lemon/assert.h>
-#include <lemon/bits/graph_extender.h>
-
-///\ingroup graphs
-///\file
-///\brief HypercubeGraph class.
-
-namespace lemon {
-
-  class HypercubeGraphBase {
-
-  public:
-
-    typedef HypercubeGraphBase Graph;
-
-    class Node;
-    class Edge;
-    class Arc;
-
-  public:
-
-    HypercubeGraphBase() {}
-
-  protected:
-
-    void construct(int dim) {
-      LEMON_ASSERT(dim >= 1, "The number of dimensions must be at least 1.");
-      _dim = dim;
-      _node_num = 1 << dim;
-      _edge_num = dim * (1 << (dim-1));
-    }
-
-  public:
-
-    typedef True NodeNumTag;
-    typedef True EdgeNumTag;
-    typedef True ArcNumTag;
-
-    int nodeNum() const { return _node_num; }
-    int edgeNum() const { return _edge_num; }
-    int arcNum() const { return 2 * _edge_num; }
-
-    int maxNodeId() const { return _node_num - 1; }
-    int maxEdgeId() const { return _edge_num - 1; }
-    int maxArcId() const { return 2 * _edge_num - 1; }
-
-    static Node nodeFromId(int id) { return Node(id); }
-    static Edge edgeFromId(int id) { return Edge(id); }
-    static Arc arcFromId(int id) { return Arc(id); }
-
-    static int id(Node node) { return node._id; }
-    static int id(Edge edge) { return edge._id; }
-    static int id(Arc arc) { return arc._id; }
-
-    Node u(Edge edge) const {
-      int base = edge._id & ((1 << (_dim-1)) - 1);
-      int k = edge._id >> (_dim-1);
-      return ((base >> k) << (k+1)) | (base & ((1 << k) - 1));
-    }
-
-    Node v(Edge edge) const {
-      int base = edge._id & ((1 << (_dim-1)) - 1);
-      int k = edge._id >> (_dim-1);
-      return ((base >> k) << (k+1)) | (base & ((1 << k) - 1)) | (1 << k);
-    }
-
-    Node source(Arc arc) const {
-      return (arc._id & 1) == 1 ? u(arc) : v(arc);
-    }
-
-    Node target(Arc arc) const {
-      return (arc._id & 1) == 1 ? v(arc) : u(arc);
-    }
-
-    typedef True FindEdgeTag;
-    typedef True FindArcTag;
-
-    Edge findEdge(Node u, Node v, Edge prev = INVALID) const {
-      if (prev != INVALID) return INVALID;
-      int d = u._id ^ v._id;
-      int k = 0;
-      if (d == 0) return INVALID;
-      for ( ; (d & 1) == 0; d >>= 1) ++k;
-      if (d >> 1 != 0) return INVALID;
-      return (k << (_dim-1)) | ((u._id >> (k+1)) << k) |
-        (u._id & ((1 << k) - 1));
-    }
-
-    Arc findArc(Node u, Node v, Arc prev = INVALID) const {
-      Edge edge = findEdge(u, v, prev);
-      if (edge == INVALID) return INVALID;
-      int k = edge._id >> (_dim-1);
-      return ((u._id >> k) & 1) == 1 ? edge._id << 1 : (edge._id << 1) | 1;
-    }
-
-    class Node {
-      friend class HypercubeGraphBase;
-
-    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 Edge {
-      friend class HypercubeGraphBase;
-      friend class Arc;
-
-    protected:
-      int _id;
-
-      Edge(int id) : _id(id) {}
-
-    public:
-      Edge() {}
-      Edge (Invalid) : _id(-1) {}
-      bool operator==(const Edge edge) const {return _id == edge._id;}
-      bool operator!=(const Edge edge) const {return _id != edge._id;}
-      bool operator<(const Edge edge) const {return _id < edge._id;}
-    };
-
-    class Arc {
-      friend class HypercubeGraphBase;
-
-    protected:
-      int _id;
-
-      Arc(int id) : _id(id) {}
-
-    public:
-      Arc() {}
-      Arc (Invalid) : _id(-1) {}
-      operator Edge() const { return _id != -1 ? Edge(_id >> 1) : INVALID; }
-      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;}
-    };
-
-    void first(Node& node) const {
-      node._id = _node_num - 1;
-    }
-
-    static void next(Node& node) {
-      --node._id;
-    }
-
-    void first(Edge& edge) const {
-      edge._id = _edge_num - 1;
-    }
-
-    static void next(Edge& edge) {
-      --edge._id;
-    }
-
-    void first(Arc& arc) const {
-      arc._id = 2 * _edge_num - 1;
-    }
-
-    static void next(Arc& arc) {
-      --arc._id;
-    }
-
-    void firstInc(Edge& edge, bool& dir, const Node& node) const {
-      edge._id = node._id >> 1;
-      dir = (node._id & 1) == 0;
-    }
-
-    void nextInc(Edge& edge, bool& dir) const {
-      Node n = dir ? u(edge) : v(edge);
-      int k = (edge._id >> (_dim-1)) + 1;
-      if (k < _dim) {
-        edge._id = (k << (_dim-1)) |
-          ((n._id >> (k+1)) << k) | (n._id & ((1 << k) - 1));
-        dir = ((n._id >> k) & 1) == 0;
-      } else {
-        edge._id = -1;
-        dir = true;
-      }
-    }
-
-    void firstOut(Arc& arc, const Node& node) const {
-      arc._id = ((node._id >> 1) << 1) | (~node._id & 1);
-    }
-
-    void nextOut(Arc& arc) const {
-      Node n = (arc._id & 1) == 1 ? u(arc) : v(arc);
-      int k = (arc._id >> _dim) + 1;
-      if (k < _dim) {
-        arc._id = (k << (_dim-1)) |
-          ((n._id >> (k+1)) << k) | (n._id & ((1 << k) - 1));
-        arc._id = (arc._id << 1) | (~(n._id >> k) & 1);
-      } else {
-        arc._id = -1;
-      }
-    }
-
-    void firstIn(Arc& arc, const Node& node) const {
-      arc._id = ((node._id >> 1) << 1) | (node._id & 1);
-    }
-
-    void nextIn(Arc& arc) const {
-      Node n = (arc._id & 1) == 1 ? v(arc) : u(arc);
-      int k = (arc._id >> _dim) + 1;
-      if (k < _dim) {
-        arc._id = (k << (_dim-1)) |
-          ((n._id >> (k+1)) << k) | (n._id & ((1 << k) - 1));
-        arc._id = (arc._id << 1) | ((n._id >> k) & 1);
-      } else {
-        arc._id = -1;
-      }
-    }
-
-    static bool direction(Arc arc) {
-      return (arc._id & 1) == 1;
-    }
-
-    static Arc direct(Edge edge, bool dir) {
-      return Arc((edge._id << 1) | (dir ? 1 : 0));
-    }
-
-    int dimension() const {
-      return _dim;
-    }
-
-    bool projection(Node node, int n) const {
-      return static_cast<bool>(node._id & (1 << n));
-    }
-
-    int dimension(Edge edge) const {
-      return edge._id >> (_dim-1);
-    }
-
-    int dimension(Arc arc) const {
-      return arc._id >> _dim;
-    }
-
-    static int index(Node node) {
-      return node._id;
-    }
-
-    Node operator()(int ix) const {
-      return Node(ix);
-    }
-
-  private:
-    int _dim;
-    int _node_num, _edge_num;
-  };
-
-
-  typedef GraphExtender<HypercubeGraphBase> ExtendedHypercubeGraphBase;
-
-  /// \ingroup graphs
-  ///
-  /// \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.
-  /// 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).
-  class HypercubeGraph : public ExtendedHypercubeGraphBase {
-    typedef ExtendedHypercubeGraphBase Parent;
-
-  public:
-
-    /// \brief Constructs a hypercube graph with \c dim dimensions.
-    ///
-    /// 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.
-    ///
-    /// Gives back the number of dimensions.
-    int dimension() const {
-      return Parent::dimension();
-    }
-
-    /// \brief Returns \c true if the n'th bit of the node is one.
-    ///
-    /// Returns \c true if the n'th bit of the node is one.
-    bool projection(Node node, int n) const {
-      return Parent::projection(node, n);
-    }
-
-    /// \brief The dimension id of an edge.
-    ///
-    /// Gives back the dimension id of the given edge.
-    /// It is in the range <tt>[0..dim-1]</tt>.
-    int dimension(Edge edge) const {
-      return Parent::dimension(edge);
-    }
-
-    /// \brief The dimension id of an arc.
-    ///
-    /// Gives back the dimension id of the given arc.
-    /// It is in the range <tt>[0..dim-1]</tt>.
-    int dimension(Arc arc) const {
-      return Parent::dimension(arc);
-    }
-
-    /// \brief The index of a node.
-    ///
-    /// Gives back the index of the given node.
-    /// The lower bits of the integer describes the node.
-    static int index(Node node) {
-      return Parent::index(node);
-    }
-
-    /// \brief Gives back a node by its index.
-    ///
-    /// Gives back a node by its index.
-    Node operator()(int ix) const {
-      return Parent::operator()(ix);
-    }
-
-    /// \brief Number of nodes.
-    int nodeNum() const { return Parent::nodeNum(); }
-    /// \brief Number of edges.
-    int edgeNum() const { return Parent::edgeNum(); }
-    /// \brief Number of arcs.
-    int arcNum() const { return Parent::arcNum(); }
-
-    /// \brief Linear combination map.
-    ///
-    /// This map makes possible to give back a linear combination
-    /// for each node. It works like the \c std::accumulate function,
-    /// so it accumulates the \c bf binary function with the \c fv first
-    /// value. The map accumulates only on that positions (dimensions)
-    /// where the index of the node is one. The values that have to be
-    /// accumulated should be given by the \c begin and \c end iterators
-    /// and the length of this range should be equal to the dimension
-    /// number of the graph.
-    ///
-    ///\code
-    /// const int DIM = 3;
-    /// HypercubeGraph graph(DIM);
-    /// dim2::Point<double> base[DIM];
-    /// for (int k = 0; k < DIM; ++k) {
-    ///   base[k].x = rnd();
-    ///   base[k].y = rnd();
-    /// }
-    /// HypercubeGraph::HyperMap<dim2::Point<double> >
-    ///   pos(graph, base, base + DIM, dim2::Point<double>(0.0, 0.0));
-    ///\endcode
-    ///
-    /// \see HypercubeGraph
-    template <typename T, typename BF = std::plus<T> >
-    class HyperMap {
-    public:
-
-      /// \brief The key type of the map
-      typedef Node Key;
-      /// \brief The value type of the map
-      typedef T Value;
-
-      /// \brief Constructor for HyperMap.
-      ///
-      /// Construct a HyperMap for the given graph. The values that have
-      /// to be accumulated should be given by the \c begin and \c end
-      /// iterators and the length of this range should be equal to the
-      /// dimension number of the graph.
-      ///
-      /// This map accumulates the \c bf binary function with the \c fv
-      /// first value on that positions (dimensions) where the index of
-      /// the node is one.
-      template <typename It>
-      HyperMap(const Graph& graph, It begin, It end,
-               T fv = 0, const BF& bf = BF())
-        : _graph(graph), _values(begin, end), _first_value(fv), _bin_func(bf)
-      {
-        LEMON_ASSERT(_values.size() == graph.dimension(),
-                     "Wrong size of range");
-      }
-
-      /// \brief The partial accumulated value.
-      ///
-      /// Gives back the partial accumulated value.
-      Value operator[](const Key& k) const {
-        Value val = _first_value;
-        int id = _graph.index(k);
-        int n = 0;
-        while (id != 0) {
-          if (id & 1) {
-            val = _bin_func(val, _values[n]);
-          }
-          id >>= 1;
-          ++n;
-        }
-        return val;
-      }
-
-    private:
-      const Graph& _graph;
-      std::vector<T> _values;
-      T _first_value;
-      BF _bin_func;
-    };
-
-  };
-
-}
-
-#endif
Index: mon/karp_mmc.h
===================================================================
--- lemon/karp_mmc.h	(revision 956)
+++ 	(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 631)
+++ lemon/kruskal.h	(revision 220)
@@ -3,5 +3,5 @@
  * This file is a part of LEMON, a generic C++ optimization library.
  *
- * Copyright (C) 2003-2009
+ * Copyright (C) 2003-2008
  * Egervary Jeno Kombinatorikus Optimalizalasi Kutatocsoport
  * (Egervary Research Group on Combinatorial Optimization, EGRES).
@@ -249,9 +249,9 @@
   /// \ingroup spantree
   ///
-  /// \brief Kruskal's algorithm for finding a minimum cost spanning tree of
+  /// \brief Kruskal algorithm to find a minimum cost spanning tree of
   /// a graph.
   ///
   /// This function runs Kruskal's algorithm to find a minimum cost
-  /// spanning tree of a graph.
+  /// spanning tree.
   /// Due to some C++ hacking, it accepts various input and output types.
   ///
@@ -265,7 +265,7 @@
   /// It can be one of the following choices.
   /// - An STL compatible 'Forward Container' with
-  /// <tt>std::pair<GR::Arc,C></tt> or
-  /// <tt>std::pair<GR::Edge,C></tt> as its <tt>value_type</tt>, where
-  /// \c C is the type of the costs. The pairs indicates the arcs/edges
+  /// <tt>std::pair<GR::Arc,X></tt> or
+  /// <tt>std::pair<GR::Edge,X></tt> as its <tt>value_type</tt>, where
+  /// \c X is the type of the costs. The pairs indicates the arcs/edges
   /// along with the assigned cost. <em>They must be in a
   /// cost-ascending order.</em>
@@ -274,6 +274,6 @@
   ///
   /// \retval out Here we also have a choice.
-  /// - It can be a writable arc/edge map with \c bool value type. After
-  /// running the algorithm it will contain the found minimum cost spanning
+  /// - It can be a writable \c bool arc/edge map. After running the
+  /// algorithm it will contain the found minimum cost spanning
   /// tree: the value of an arc/edge will be set to \c true if it belongs
   /// to the tree, otherwise it will be set to \c false. The value of
@@ -302,6 +302,6 @@
 
 #ifdef DOXYGEN
-  template <typename Graph, typename In, typename Out>
-  Value kruskal(const Graph& g, const In& in, Out& out)
+  template <class Graph, class In, class Out>
+  Value kruskal(GR const& g, const In& in, Out& out)
 #else
   template <class Graph, class In, class Out>
@@ -315,4 +315,6 @@
 
 
+
+
   template <class Graph, class In, class Out>
   inline typename _kruskal_bits::KruskalValueSelector<In>::Value
Index: lemon/lemon.pc.in
===================================================================
--- lemon/lemon.pc.in	(revision 705)
+++ lemon/lemon.pc.in	(revision 259)
@@ -5,6 +5,6 @@
 
 Name: @PACKAGE_NAME@
-Description: Library for Efficient Modeling and Optimization in Networks
+Description: Library of Efficient Models and Optimization in Networks
 Version: @PACKAGE_VERSION@
-Libs: -L${libdir} -lemon @GLPK_LIBS@ @CPLEX_LIBS@ @SOPLEX_LIBS@ @CLP_LIBS@ @CBC_LIBS@
+Libs: -L${libdir} -lemon
 Cflags: -I${includedir}
Index: lemon/lgf_reader.h
===================================================================
--- lemon/lgf_reader.h	(revision 956)
+++ lemon/lgf_reader.h	(revision 517)
@@ -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).
@@ -102,21 +102,21 @@
     };
 
-    template <typename _GR, bool _dir, typename _Map,
+    template <typename _Graph, bool _dir, typename _Map,
               typename _Converter = DefaultConverter<typename _Map::Value> >
-    class GraphArcMapStorage : public MapStorageBase<typename _GR::Edge> {
+    class GraphArcMapStorage : public MapStorageBase<typename _Graph::Edge> {
     public:
       typedef _Map Map;
       typedef _Converter Converter;
-      typedef _GR GR;
-      typedef typename GR::Edge Item;
+      typedef _Graph Graph;
+      typedef typename Graph::Edge Item;
       static const bool dir = _dir;
 
     private:
-      const GR& _graph;
+      const Graph& _graph;
       Map& _map;
       Converter _converter;
 
     public:
-      GraphArcMapStorage(const GR& graph, Map& map,
+      GraphArcMapStorage(const Graph& graph, Map& map,
                          const Converter& converter = Converter())
         : _graph(graph), _map(map), _converter(converter) {}
@@ -174,19 +174,19 @@
     };
 
-    template <typename GR>
+    template <typename Graph>
     struct GraphArcLookUpConverter {
-      const GR& _graph;
-      const std::map<std::string, typename GR::Edge>& _map;
-
-      GraphArcLookUpConverter(const GR& graph,
+      const Graph& _graph;
+      const std::map<std::string, typename Graph::Edge>& _map;
+
+      GraphArcLookUpConverter(const Graph& graph,
                               const std::map<std::string,
-                                             typename GR::Edge>& map)
+                                             typename Graph::Edge>& map)
         : _graph(graph), _map(map) {}
 
-      typename GR::Arc operator()(const std::string& str) {
+      typename Graph::Arc operator()(const std::string& str) {
         if (str.empty() || (str[0] != '+' && str[0] != '-')) {
           throw FormatError("Item must start with '+' or '-'");
         }
-        typename std::map<std::string, typename GR::Edge>
+        typename std::map<std::string, typename Graph::Edge>
           ::const_iterator it = _map.find(str.substr(1));
         if (it == _map.end()) {
@@ -388,13 +388,14 @@
   }
 
-  template <typename DGR>
+  template <typename Digraph>
   class DigraphReader;
 
-  template <typename TDGR>
-  DigraphReader<TDGR> digraphReader(TDGR& digraph, std::istream& is = std::cin);
-  template <typename TDGR>
-  DigraphReader<TDGR> digraphReader(TDGR& digraph, const std::string& fn);
-  template <typename TDGR>
-  DigraphReader<TDGR> digraphReader(TDGR& digraph, const char *fn);
+  template <typename Digraph>
+  DigraphReader<Digraph> digraphReader(Digraph& digraph, 
+                                       std::istream& is = std::cin);
+  template <typename Digraph>
+  DigraphReader<Digraph> digraphReader(Digraph& digraph, const std::string& fn);
+  template <typename Digraph>
+  DigraphReader<Digraph> digraphReader(Digraph& digraph, const char *fn);
 
   /// \ingroup lemon_io
@@ -419,5 +420,5 @@
   ///
   ///\code
-  /// DigraphReader<DGR>(digraph, std::cin).
+  /// DigraphReader<Digraph>(digraph, std::cin).
   ///   nodeMap("coordinates", coord_map).
   ///   arcMap("capacity", cap_map).
@@ -428,5 +429,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
@@ -448,13 +449,13 @@
   /// a single pass, because the arcs are not constructed when the node
   /// maps are read.
-  template <typename DGR>
+  template <typename _Digraph>
   class DigraphReader {
   public:
 
-    typedef DGR Digraph;
+    typedef _Digraph Digraph;
+    TEMPLATE_DIGRAPH_TYPEDEFS(Digraph);
 
   private:
 
-    TEMPLATE_DIGRAPH_TYPEDEFS(DGR);
 
     std::istream* _is;
@@ -462,5 +463,5 @@
     std::string _filename;
 
-    DGR& _digraph;
+    Digraph& _digraph;
 
     std::string _nodes_caption;
@@ -500,5 +501,5 @@
     /// Construct a directed graph reader, which reads from the given
     /// input stream.
-    DigraphReader(DGR& digraph, std::istream& is = std::cin)
+    DigraphReader(Digraph& digraph, std::istream& is = std::cin)
       : _is(&is), local_is(false), _digraph(digraph),
         _use_nodes(false), _use_arcs(false),
@@ -509,5 +510,5 @@
     /// Construct a directed graph reader, which reads from the given
     /// file.
-    DigraphReader(DGR& digraph, const std::string& fn)
+    DigraphReader(Digraph& digraph, const std::string& fn)
       : _is(new std::ifstream(fn.c_str())), local_is(true),
         _filename(fn), _digraph(digraph),
@@ -524,5 +525,5 @@
     /// Construct a directed graph reader, which reads from the given
     /// file.
-    DigraphReader(DGR& digraph, const char* fn)
+    DigraphReader(Digraph& digraph, const char* fn)
       : _is(new std::ifstream(fn)), local_is(true),
         _filename(fn), _digraph(digraph),
@@ -560,11 +561,11 @@
   private:
 
-    template <typename TDGR>
-    friend DigraphReader<TDGR> digraphReader(TDGR& digraph, std::istream& is);
-    template <typename TDGR>
-    friend DigraphReader<TDGR> digraphReader(TDGR& digraph,
-                                             const std::string& fn);
-    template <typename TDGR>
-    friend DigraphReader<TDGR> digraphReader(TDGR& digraph, const char *fn);
+    template <typename DGR>
+    friend DigraphReader<DGR> digraphReader(DGR& digraph, std::istream& is);
+    template <typename DGR>
+    friend DigraphReader<DGR> digraphReader(DGR& digraph, 
+                                            const std::string& fn);
+    template <typename DGR>
+    friend DigraphReader<DGR> digraphReader(DGR& digraph, const char *fn);
 
     DigraphReader(DigraphReader& other)
@@ -593,5 +594,5 @@
   public:
 
-    /// \name Reading Rules
+    /// \name Reading rules
     /// @{
 
@@ -698,5 +699,5 @@
     /// @}
 
-    /// \name Select Section by Name
+    /// \name Select section by name
     /// @{
 
@@ -727,5 +728,5 @@
     /// @}
 
-    /// \name Using Previously Constructed Node or Arc Set
+    /// \name Using previously constructed node or arc set
     /// @{
 
@@ -847,7 +848,5 @@
         readLine();
       }
-      if (readSuccess()) {
-        line.putback(c);
-      }
+      line.putback(c);
     }
 
@@ -1116,5 +1115,5 @@
   public:
 
-    /// \name Execution of the Reader
+    /// \name Execution of the reader
     /// @{
 
@@ -1189,49 +1188,11 @@
   };
 
-  /// \ingroup lemon_io
-  ///
-  /// \brief Return a \ref DigraphReader class
-  ///
-  /// This function just returns a \ref DigraphReader class.
-  ///
-  /// 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
-  /// digraph, i.e. a digraph with a \e capacity map on the arcs and
-  /// \e source and \e target nodes. This digraph can be read with the
-  /// following code:
-  ///
-  ///\code
-  ///ListDigraph digraph;
-  ///ListDigraph::ArcMap<int> cm(digraph);
-  ///ListDigraph::Node src, trg;
-  ///digraphReader(digraph, std::cin).
-  ///  arcMap("capacity", cap).
-  ///  node("source", src).
-  ///  node("target", trg).
-  ///  run();
-  ///\endcode
-  ///
-  /// For a complete documentation, please see the \ref DigraphReader
-  /// class documentation.
-  /// \warning Don't forget to put the \ref DigraphReader::run() "run()"
-  /// to the end of the parameter list.
-  /// \relates DigraphReader
-  /// \sa digraphReader(TDGR& digraph, const std::string& fn)
-  /// \sa digraphReader(TDGR& digraph, const char* fn)
-  template <typename TDGR>
-  DigraphReader<TDGR> digraphReader(TDGR& digraph, std::istream& is) {
-    DigraphReader<TDGR> tmp(digraph, is);
-    return tmp;
-  }
-
   /// \brief Return a \ref DigraphReader class
   ///
   /// This function just returns a \ref DigraphReader class.
   /// \relates DigraphReader
-  /// \sa digraphReader(TDGR& digraph, std::istream& is)
-  template <typename TDGR>
-  DigraphReader<TDGR> digraphReader(TDGR& digraph, const std::string& fn) {
-    DigraphReader<TDGR> tmp(digraph, fn);
+  template <typename Digraph>
+  DigraphReader<Digraph> digraphReader(Digraph& digraph, std::istream& is) {
+    DigraphReader<Digraph> tmp(digraph, is);
     return tmp;
   }
@@ -1241,20 +1202,31 @@
   /// This function just returns a \ref DigraphReader class.
   /// \relates DigraphReader
-  /// \sa digraphReader(TDGR& digraph, std::istream& is)
-  template <typename TDGR>
-  DigraphReader<TDGR> digraphReader(TDGR& digraph, const char* fn) {
-    DigraphReader<TDGR> tmp(digraph, fn);
+  template <typename Digraph>
+  DigraphReader<Digraph> digraphReader(Digraph& digraph,
+                                       const std::string& fn) {
+    DigraphReader<Digraph> tmp(digraph, fn);
     return tmp;
   }
 
-  template <typename GR>
+  /// \brief Return a \ref DigraphReader class
+  ///
+  /// This function just returns a \ref DigraphReader class.
+  /// \relates DigraphReader
+  template <typename Digraph>
+  DigraphReader<Digraph> digraphReader(Digraph& digraph, const char* fn) {
+    DigraphReader<Digraph> tmp(digraph, fn);
+    return tmp;
+  }
+
+  template <typename Graph>
   class GraphReader;
-
-  template <typename TGR>
-  GraphReader<TGR> graphReader(TGR& graph, std::istream& is = std::cin);
-  template <typename TGR>
-  GraphReader<TGR> graphReader(TGR& graph, const std::string& fn);
-  template <typename TGR>
-  GraphReader<TGR> graphReader(TGR& graph, const char *fn);
+ 
+  template <typename Graph>
+  GraphReader<Graph> graphReader(Graph& graph, 
+                                 std::istream& is = std::cin);
+  template <typename Graph>
+  GraphReader<Graph> graphReader(Graph& graph, const std::string& fn);
+  template <typename Graph>
+  GraphReader<Graph> graphReader(Graph& graph, const char *fn);
 
   /// \ingroup lemon_io
@@ -1273,13 +1245,12 @@
   /// arc map.  Similarly, an attribute can be read into an arc, if
   /// it's value is an edge label prefixed with \c '+' or \c '-'.
-  template <typename GR>
+  template <typename _Graph>
   class GraphReader {
   public:
 
-    typedef GR Graph;
+    typedef _Graph Graph;
+    TEMPLATE_GRAPH_TYPEDEFS(Graph);
 
   private:
-
-    TEMPLATE_GRAPH_TYPEDEFS(GR);
 
     std::istream* _is;
@@ -1287,5 +1258,5 @@
     std::string _filename;
 
-    GR& _graph;
+    Graph& _graph;
 
     std::string _nodes_caption;
@@ -1325,5 +1296,5 @@
     /// Construct an undirected graph reader, which reads from the given
     /// input stream.
-    GraphReader(GR& graph, std::istream& is = std::cin)
+    GraphReader(Graph& graph, std::istream& is = std::cin)
       : _is(&is), local_is(false), _graph(graph),
         _use_nodes(false), _use_edges(false),
@@ -1334,5 +1305,5 @@
     /// Construct an undirected graph reader, which reads from the given
     /// file.
-    GraphReader(GR& graph, const std::string& fn)
+    GraphReader(Graph& graph, const std::string& fn)
       : _is(new std::ifstream(fn.c_str())), local_is(true),
         _filename(fn), _graph(graph),
@@ -1349,5 +1320,5 @@
     /// Construct an undirected graph reader, which reads from the given
     /// file.
-    GraphReader(GR& graph, const char* fn)
+    GraphReader(Graph& graph, const char* fn)
       : _is(new std::ifstream(fn)), local_is(true),
         _filename(fn), _graph(graph),
@@ -1384,10 +1355,10 @@
 
   private:
-    template <typename TGR>
-    friend GraphReader<TGR> graphReader(TGR& graph, std::istream& is);
-    template <typename TGR>
-    friend GraphReader<TGR> graphReader(TGR& graph, const std::string& fn);
-    template <typename TGR>
-    friend GraphReader<TGR> graphReader(TGR& graph, const char *fn);
+    template <typename GR>
+    friend GraphReader<GR> graphReader(GR& graph, std::istream& is);
+    template <typename GR>
+    friend GraphReader<GR> graphReader(GR& graph, const std::string& fn); 
+    template <typename GR>
+    friend GraphReader<GR> graphReader(GR& graph, const char *fn);
 
     GraphReader(GraphReader& other)
@@ -1416,5 +1387,5 @@
   public:
 
-    /// \name Reading Rules
+    /// \name Reading rules
     /// @{
 
@@ -1481,5 +1452,5 @@
       _edge_maps.push_back(std::make_pair('+' + caption, forward_storage));
       _reader_bits::MapStorageBase<Edge>* backward_storage =
-        new _reader_bits::GraphArcMapStorage<GR, false, Map>(_graph, map);
+        new _reader_bits::GraphArcMapStorage<Graph, false, Map>(_graph, map);
       _edge_maps.push_back(std::make_pair('-' + caption, backward_storage));
       return *this;
@@ -1495,9 +1466,9 @@
       checkConcept<concepts::WriteMap<Arc, typename Map::Value>, Map>();
       _reader_bits::MapStorageBase<Edge>* forward_storage =
-        new _reader_bits::GraphArcMapStorage<GR, true, Map, Converter>
+        new _reader_bits::GraphArcMapStorage<Graph, true, Map, Converter>
         (_graph, map, converter);
       _edge_maps.push_back(std::make_pair('+' + caption, forward_storage));
       _reader_bits::MapStorageBase<Edge>* backward_storage =
-        new _reader_bits::GraphArcMapStorage<GR, false, Map, Converter>
+        new _reader_bits::GraphArcMapStorage<Graph, false, Map, Converter>
         (_graph, map, converter);
       _edge_maps.push_back(std::make_pair('-' + caption, backward_storage));
@@ -1557,5 +1528,5 @@
     /// Add an arc reading rule to reader.
     GraphReader& arc(const std::string& caption, Arc& arc) {
-      typedef _reader_bits::GraphArcLookUpConverter<GR> Converter;
+      typedef _reader_bits::GraphArcLookUpConverter<Graph> Converter;
       Converter converter(_graph, _edge_index);
       _reader_bits::ValueStorageBase* storage =
@@ -1567,5 +1538,5 @@
     /// @}
 
-    /// \name Select Section by Name
+    /// \name Select section by name
     /// @{
 
@@ -1596,5 +1567,5 @@
     /// @}
 
-    /// \name Using Previously Constructed Node or Edge Set
+    /// \name Using previously constructed node or edge set
     /// @{
 
@@ -1717,7 +1688,5 @@
         readLine();
       }
-      if (readSuccess()) {
-        line.putback(c);
-      }
+      line.putback(c);
     }
 
@@ -1986,5 +1955,5 @@
   public:
 
-    /// \name Execution of the Reader
+    /// \name Execution of the reader
     /// @{
 
@@ -2060,45 +2029,11 @@
   };
 
-  /// \ingroup lemon_io
-  ///
-  /// \brief Return a \ref GraphReader class
-  ///
-  /// 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
-  /// graph, i.e. a graph with a \e weight map on the edges. This
-  /// graph can be read with the following code:
-  ///
-  ///\code
-  ///ListGraph graph;
-  ///ListGraph::EdgeMap<int> weight(graph);
-  ///graphReader(graph, std::cin).
-  ///  edgeMap("weight", weight).
-  ///  run();
-  ///\endcode
-  ///
-  /// For a complete documentation, please see the \ref GraphReader
-  /// class documentation.
-  /// \warning Don't forget to put the \ref GraphReader::run() "run()"
-  /// to the end of the parameter list.
-  /// \relates GraphReader
-  /// \sa graphReader(TGR& graph, const std::string& fn)
-  /// \sa graphReader(TGR& graph, const char* fn)
-  template <typename TGR>
-  GraphReader<TGR> graphReader(TGR& graph, std::istream& is) {
-    GraphReader<TGR> tmp(graph, is);
-    return tmp;
-  }
-
   /// \brief Return a \ref GraphReader class
   ///
   /// This function just returns a \ref GraphReader class.
   /// \relates GraphReader
-  /// \sa graphReader(TGR& graph, std::istream& is)
-  template <typename TGR>
-  GraphReader<TGR> graphReader(TGR& graph, const std::string& fn) {
-    GraphReader<TGR> tmp(graph, fn);
+  template <typename Graph>
+  GraphReader<Graph> graphReader(Graph& graph, std::istream& is) {
+    GraphReader<Graph> tmp(graph, is);
     return tmp;
   }
@@ -2108,8 +2043,17 @@
   /// This function just returns a \ref GraphReader class.
   /// \relates GraphReader
-  /// \sa graphReader(TGR& graph, std::istream& is)
-  template <typename TGR>
-  GraphReader<TGR> graphReader(TGR& graph, const char* fn) {
-    GraphReader<TGR> tmp(graph, fn);
+  template <typename Graph>
+  GraphReader<Graph> graphReader(Graph& graph, const std::string& fn) {
+    GraphReader<Graph> tmp(graph, fn);
+    return tmp;
+  }
+
+  /// \brief Return a \ref GraphReader class
+  ///
+  /// This function just returns a \ref GraphReader class.
+  /// \relates GraphReader
+  template <typename Graph>
+  GraphReader<Graph> graphReader(Graph& graph, const char* fn) {
+    GraphReader<Graph> tmp(graph, fn);
     return tmp;
   }
@@ -2210,5 +2154,5 @@
   public:
 
-    /// \name Section Readers
+    /// \name Section readers
     /// @{
 
@@ -2222,5 +2166,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
@@ -2301,7 +2245,5 @@
         readLine();
       }
-      if (readSuccess()) {
-        line.putback(c);
-      }
+      line.putback(c);
     }
 
@@ -2309,5 +2251,5 @@
 
 
-    /// \name Execution of the Reader
+    /// \name Execution of the reader
     /// @{
 
@@ -2368,16 +2310,8 @@
   };
 
-  /// \ingroup lemon_io
-  ///
   /// \brief Return a \ref SectionReader class
   ///
   /// This function just returns a \ref SectionReader class.
-  ///
-  /// Please see SectionReader documentation about the custom section
-  /// input.
-  ///
   /// \relates SectionReader
-  /// \sa sectionReader(const std::string& fn)
-  /// \sa sectionReader(const char *fn)
   inline SectionReader sectionReader(std::istream& is) {
     SectionReader tmp(is);
@@ -2389,5 +2323,4 @@
   /// This function just returns a \ref SectionReader class.
   /// \relates SectionReader
-  /// \sa sectionReader(std::istream& is)
   inline SectionReader sectionReader(const std::string& fn) {
     SectionReader tmp(fn);
@@ -2399,5 +2332,4 @@
   /// This function just returns a \ref SectionReader class.
   /// \relates SectionReader
-  /// \sa sectionReader(std::istream& is)
   inline SectionReader sectionReader(const char* fn) {
     SectionReader tmp(fn);
@@ -2501,5 +2433,5 @@
 
 
-    /// \name Node Sections
+    /// \name Node sections
     /// @{
 
@@ -2527,5 +2459,5 @@
     /// @}
 
-    /// \name Arc/Edge Sections
+    /// \name Arc/Edge sections
     /// @{
 
@@ -2585,5 +2517,5 @@
     /// @}
 
-    /// \name Attribute Sections
+    /// \name Attribute sections
     /// @{
 
@@ -2611,5 +2543,5 @@
     /// @}
 
-    /// \name Extra Sections
+    /// \name Extra sections
     /// @{
 
@@ -2654,7 +2586,5 @@
         readLine();
       }
-      if (readSuccess()) {
-        line.putback(c);
-      }
+      line.putback(c);
     }
 
@@ -2687,5 +2617,5 @@
   public:
 
-    /// \name Execution of the Contents Reader
+    /// \name Execution of the contents reader
     /// @{
 
Index: lemon/lgf_writer.h
===================================================================
--- lemon/lgf_writer.h	(revision 956)
+++ lemon/lgf_writer.h	(revision 517)
@@ -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).
@@ -348,15 +348,17 @@
   }
 
-  template <typename DGR>
+  template <typename Digraph>
   class DigraphWriter;
 
-  template <typename TDGR>
-  DigraphWriter<TDGR> digraphWriter(const TDGR& digraph,
-                                   std::ostream& os = std::cout);
-  template <typename TDGR>
-  DigraphWriter<TDGR> digraphWriter(const TDGR& digraph, const std::string& fn);
-
-  template <typename TDGR>
-  DigraphWriter<TDGR> digraphWriter(const TDGR& digraph, const char* fn);
+  template <typename Digraph>
+  DigraphWriter<Digraph> digraphWriter(const Digraph& digraph,
+                                       std::ostream& os = std::cout);
+  template <typename Digraph>
+  DigraphWriter<Digraph> digraphWriter(const Digraph& digraph,
+                                       const std::string& fn);
+
+  template <typename Digraph>
+  DigraphWriter<Digraph> digraphWriter(const Digraph& digraph,
+                                       const char* fn);
 
 
@@ -380,5 +382,5 @@
   ///
   ///\code
-  /// DigraphWriter<DGR>(digraph, std::cout).
+  /// DigraphWriter<Digraph>(digraph, std::cout).
   ///   nodeMap("coordinates", coord_map).
   ///   nodeMap("size", size).
@@ -405,10 +407,10 @@
   /// the \c ostream() function, hence the second pass can append its
   /// output to the output of the first pass.
-  template <typename DGR>
+  template <typename _Digraph>
   class DigraphWriter {
   public:
 
-    typedef DGR Digraph;
-    TEMPLATE_DIGRAPH_TYPEDEFS(DGR);
+    typedef _Digraph Digraph;
+    TEMPLATE_DIGRAPH_TYPEDEFS(Digraph);
 
   private:
@@ -418,5 +420,5 @@
     bool local_os;
 
-    const DGR& _digraph;
+    const Digraph& _digraph;
 
     std::string _nodes_caption;
@@ -450,5 +452,5 @@
     /// Construct a directed graph writer, which writes to the given
     /// output stream.
-    DigraphWriter(const DGR& digraph, std::ostream& os = std::cout)
+    DigraphWriter(const Digraph& digraph, std::ostream& os = std::cout)
       : _os(&os), local_os(false), _digraph(digraph),
         _skip_nodes(false), _skip_arcs(false) {}
@@ -458,5 +460,5 @@
     /// Construct a directed graph writer, which writes to the given
     /// output file.
-    DigraphWriter(const DGR& digraph, const std::string& fn)
+    DigraphWriter(const Digraph& digraph, const std::string& fn)
       : _os(new std::ofstream(fn.c_str())), local_os(true), _digraph(digraph),
         _skip_nodes(false), _skip_arcs(false) {
@@ -471,5 +473,5 @@
     /// Construct a directed graph writer, which writes to the given
     /// output file.
-    DigraphWriter(const DGR& digraph, const char* fn)
+    DigraphWriter(const Digraph& digraph, const char* fn)
       : _os(new std::ofstream(fn)), local_os(true), _digraph(digraph),
         _skip_nodes(false), _skip_arcs(false) {
@@ -504,13 +506,13 @@
   private:
 
-    template <typename TDGR>
-    friend DigraphWriter<TDGR> digraphWriter(const TDGR& digraph,
-                                             std::ostream& os);
-    template <typename TDGR>
-    friend DigraphWriter<TDGR> digraphWriter(const TDGR& digraph,
-                                             const std::string& fn);
-    template <typename TDGR>
-    friend DigraphWriter<TDGR> digraphWriter(const TDGR& digraph,
-                                             const char *fn);
+    template <typename DGR>
+    friend DigraphWriter<DGR> digraphWriter(const DGR& digraph, 
+                                            std::ostream& os);
+    template <typename DGR>
+    friend DigraphWriter<DGR> digraphWriter(const DGR& digraph,
+                                            const std::string& fn);
+    template <typename DGR>
+    friend DigraphWriter<DGR> digraphWriter(const DGR& digraph,
+                                            const char *fn);
 
     DigraphWriter(DigraphWriter& other)
@@ -537,5 +539,5 @@
   public:
 
-    /// \name Writing Rules
+    /// \name Writing rules
     /// @{
 
@@ -640,5 +642,5 @@
     }
 
-    /// \name Section Captions
+    /// \name Section captions
     /// @{
 
@@ -667,5 +669,5 @@
     }
 
-    /// \name Skipping Section
+    /// \name Skipping section
     /// @{
 
@@ -723,6 +725,6 @@
 
       if (label == 0) {
-        IdMap<DGR, Node> id_map(_digraph);
-        _writer_bits::MapLess<IdMap<DGR, Node> > id_less(id_map);
+        IdMap<Digraph, Node> id_map(_digraph);
+        _writer_bits::MapLess<IdMap<Digraph, Node> > id_less(id_map);
         std::sort(nodes.begin(), nodes.end(), id_less);
       } else {
@@ -808,6 +810,6 @@
 
       if (label == 0) {
-        IdMap<DGR, Arc> id_map(_digraph);
-        _writer_bits::MapLess<IdMap<DGR, Arc> > id_less(id_map);
+        IdMap<Digraph, Arc> id_map(_digraph);
+        _writer_bits::MapLess<IdMap<Digraph, Arc> > id_less(id_map);
         std::sort(arcs.begin(), arcs.end(), id_less);
       } else {
@@ -884,5 +886,5 @@
   public:
 
-    /// \name Execution of the Writer
+    /// \name Execution of the writer
     /// @{
 
@@ -914,39 +916,12 @@
   };
 
-  /// \ingroup lemon_io
-  ///
   /// \brief Return 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
-  /// stream in \ref lgf-format "LGF" format with several maps and
-  /// attributes. For example, with the following code a network flow
-  /// problem can be written to the standard output, i.e. a digraph
-  /// with a \e capacity map on the arcs and \e source and \e target
-  /// nodes:
-  ///
-  ///\code
-  ///ListDigraph digraph;
-  ///ListDigraph::ArcMap<int> cap(digraph);
-  ///ListDigraph::Node src, trg;
-  ///  // Setting the capacity map and source and target nodes
-  ///digraphWriter(digraph, std::cout).
-  ///  arcMap("capacity", cap).
-  ///  node("source", src).
-  ///  node("target", trg).
-  ///  run();
-  ///\endcode
-  ///
-  /// For a complete documentation, please see the \ref DigraphWriter
-  /// class documentation.
-  /// \warning Don't forget to put the \ref DigraphWriter::run() "run()"
-  /// to the end of the parameter list.
   /// \relates DigraphWriter
-  /// \sa digraphWriter(const TDGR& digraph, const std::string& fn)
-  /// \sa digraphWriter(const TDGR& digraph, const char* fn)
-  template <typename TDGR>
-  DigraphWriter<TDGR> digraphWriter(const TDGR& digraph, std::ostream& os) {
-    DigraphWriter<TDGR> tmp(digraph, os);
+  template <typename Digraph>
+  DigraphWriter<Digraph> digraphWriter(const Digraph& digraph,
+                                       std::ostream& os) {
+    DigraphWriter<Digraph> tmp(digraph, os);
     return tmp;
   }
@@ -956,9 +931,8 @@
   /// This function just returns a \ref DigraphWriter class.
   /// \relates DigraphWriter
-  /// \sa digraphWriter(const TDGR& digraph, std::ostream& os)
-  template <typename TDGR>
-  DigraphWriter<TDGR> digraphWriter(const TDGR& digraph,
-                                    const std::string& fn) {
-    DigraphWriter<TDGR> tmp(digraph, fn);
+  template <typename Digraph>
+  DigraphWriter<Digraph> digraphWriter(const Digraph& digraph,
+                                       const std::string& fn) {
+    DigraphWriter<Digraph> tmp(digraph, fn);
     return tmp;
   }
@@ -968,20 +942,21 @@
   /// This function just returns a \ref DigraphWriter class.
   /// \relates DigraphWriter
-  /// \sa digraphWriter(const TDGR& digraph, std::ostream& os)
-  template <typename TDGR>
-  DigraphWriter<TDGR> digraphWriter(const TDGR& digraph, const char* fn) {
-    DigraphWriter<TDGR> tmp(digraph, fn);
+  template <typename Digraph>
+  DigraphWriter<Digraph> digraphWriter(const Digraph& digraph,
+                                       const char* fn) {
+    DigraphWriter<Digraph> tmp(digraph, fn);
     return tmp;
   }
 
-  template <typename GR>
+  template <typename Graph>
   class GraphWriter;
 
-  template <typename TGR>
-  GraphWriter<TGR> graphWriter(const TGR& graph, std::ostream& os = std::cout);
-  template <typename TGR>
-  GraphWriter<TGR> graphWriter(const TGR& graph, const std::string& fn);
-  template <typename TGR>
-  GraphWriter<TGR> graphWriter(const TGR& graph, const char* fn);
+  template <typename Graph>
+  GraphWriter<Graph> graphWriter(const Graph& graph,
+                                 std::ostream& os = std::cout);
+  template <typename Graph>
+  GraphWriter<Graph> graphWriter(const Graph& graph, const std::string& fn);
+  template <typename Graph>
+  GraphWriter<Graph> graphWriter(const Graph& graph, const char* fn);
 
   /// \ingroup lemon_io
@@ -1000,10 +975,10 @@
   /// section as a \c '+' or a \c '-' prefix (depends on the direction
   /// of the arc) and the label of corresponding edge.
-  template <typename GR>
+  template <typename _Graph>
   class GraphWriter {
   public:
 
-    typedef GR Graph;
-    TEMPLATE_GRAPH_TYPEDEFS(GR);
+    typedef _Graph Graph;
+    TEMPLATE_GRAPH_TYPEDEFS(Graph);
 
   private:
@@ -1013,5 +988,5 @@
     bool local_os;
 
-    const GR& _graph;
+    const Graph& _graph;
 
     std::string _nodes_caption;
@@ -1045,5 +1020,5 @@
     /// Construct a directed graph writer, which writes to the given
     /// output stream.
-    GraphWriter(const GR& graph, std::ostream& os = std::cout)
+    GraphWriter(const Graph& graph, std::ostream& os = std::cout)
       : _os(&os), local_os(false), _graph(graph),
         _skip_nodes(false), _skip_edges(false) {}
@@ -1053,5 +1028,5 @@
     /// Construct a directed graph writer, which writes to the given
     /// output file.
-    GraphWriter(const GR& graph, const std::string& fn)
+    GraphWriter(const Graph& graph, const std::string& fn)
       : _os(new std::ofstream(fn.c_str())), local_os(true), _graph(graph),
         _skip_nodes(false), _skip_edges(false) {
@@ -1066,5 +1041,5 @@
     /// Construct a directed graph writer, which writes to the given
     /// output file.
-    GraphWriter(const GR& graph, const char* fn)
+    GraphWriter(const Graph& graph, const char* fn)
       : _os(new std::ofstream(fn)), local_os(true), _graph(graph),
         _skip_nodes(false), _skip_edges(false) {
@@ -1099,12 +1074,14 @@
   private:
 
-    template <typename TGR>
-    friend GraphWriter<TGR> graphWriter(const TGR& graph, std::ostream& os);
-    template <typename TGR>
-    friend GraphWriter<TGR> graphWriter(const TGR& graph,
-                                        const std::string& fn);
-    template <typename TGR>
-    friend GraphWriter<TGR> graphWriter(const TGR& graph, const char *fn);
-
+    template <typename GR>
+    friend GraphWriter<GR> graphWriter(const GR& graph,
+                                       std::ostream& os);
+    template <typename GR>
+    friend GraphWriter<GR> graphWriter(const GR& graph,
+                                       const std::string& fn);
+    template <typename GR>
+    friend GraphWriter<GR> graphWriter(const GR& graph,
+                                       const char *fn);
+    
     GraphWriter(GraphWriter& other)
       : _os(other._os), local_os(other.local_os), _graph(other._graph),
@@ -1130,5 +1107,5 @@
   public:
 
-    /// \name Writing Rules
+    /// \name Writing rules
     /// @{
 
@@ -1192,8 +1169,8 @@
       checkConcept<concepts::ReadMap<Arc, typename Map::Value>, Map>();
       _writer_bits::MapStorageBase<Edge>* forward_storage =
-        new _writer_bits::GraphArcMapStorage<GR, true, Map>(_graph, map);
+        new _writer_bits::GraphArcMapStorage<Graph, true, Map>(_graph, map);
       _edge_maps.push_back(std::make_pair('+' + caption, forward_storage));
       _writer_bits::MapStorageBase<Edge>* backward_storage =
-        new _writer_bits::GraphArcMapStorage<GR, false, Map>(_graph, map);
+        new _writer_bits::GraphArcMapStorage<Graph, false, Map>(_graph, map);
       _edge_maps.push_back(std::make_pair('-' + caption, backward_storage));
       return *this;
@@ -1209,9 +1186,9 @@
       checkConcept<concepts::ReadMap<Arc, typename Map::Value>, Map>();
       _writer_bits::MapStorageBase<Edge>* forward_storage =
-        new _writer_bits::GraphArcMapStorage<GR, true, Map, Converter>
+        new _writer_bits::GraphArcMapStorage<Graph, true, Map, Converter>
         (_graph, map, converter);
       _edge_maps.push_back(std::make_pair('+' + caption, forward_storage));
       _writer_bits::MapStorageBase<Edge>* backward_storage =
-        new _writer_bits::GraphArcMapStorage<GR, false, Map, Converter>
+        new _writer_bits::GraphArcMapStorage<Graph, false, Map, Converter>
         (_graph, map, converter);
       _edge_maps.push_back(std::make_pair('-' + caption, backward_storage));
@@ -1271,5 +1248,5 @@
     /// Add an arc writing rule to writer.
     GraphWriter& arc(const std::string& caption, const Arc& arc) {
-      typedef _writer_bits::GraphArcLookUpConverter<GR> Converter;
+      typedef _writer_bits::GraphArcLookUpConverter<Graph> Converter;
       Converter converter(_graph, _edge_index);
       _writer_bits::ValueStorageBase* storage =
@@ -1279,5 +1256,5 @@
     }
 
-    /// \name Section Captions
+    /// \name Section captions
     /// @{
 
@@ -1306,5 +1283,5 @@
     }
 
-    /// \name Skipping Section
+    /// \name Skipping section
     /// @{
 
@@ -1362,6 +1339,6 @@
 
       if (label == 0) {
-        IdMap<GR, Node> id_map(_graph);
-        _writer_bits::MapLess<IdMap<GR, Node> > id_less(id_map);
+        IdMap<Graph, Node> id_map(_graph);
+        _writer_bits::MapLess<IdMap<Graph, Node> > id_less(id_map);
         std::sort(nodes.begin(), nodes.end(), id_less);
       } else {
@@ -1447,6 +1424,6 @@
 
       if (label == 0) {
-        IdMap<GR, Edge> id_map(_graph);
-        _writer_bits::MapLess<IdMap<GR, Edge> > id_less(id_map);
+        IdMap<Graph, Edge> id_map(_graph);
+        _writer_bits::MapLess<IdMap<Graph, Edge> > id_less(id_map);
         std::sort(edges.begin(), edges.end(), id_less);
       } else {
@@ -1523,5 +1500,5 @@
   public:
 
-    /// \name Execution of the Writer
+    /// \name Execution of the writer
     /// @{
 
@@ -1553,35 +1530,12 @@
   };
 
-  /// \ingroup lemon_io
-  ///
   /// \brief Return 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
-  /// stream in \ref lgf-format "LGF" format with several maps and
-  /// attributes. For example, with the following code a weighted
-  /// matching problem can be written to the standard output, i.e. a
-  /// graph with a \e weight map on the edges:
-  ///
-  ///\code
-  ///ListGraph graph;
-  ///ListGraph::EdgeMap<int> weight(graph);
-  ///  // Setting the weight map
-  ///graphWriter(graph, std::cout).
-  ///  edgeMap("weight", weight).
-  ///  run();
-  ///\endcode
-  ///
-  /// For a complete documentation, please see the \ref GraphWriter
-  /// class documentation.
-  /// \warning Don't forget to put the \ref GraphWriter::run() "run()"
-  /// to the end of the parameter list.
   /// \relates GraphWriter
-  /// \sa graphWriter(const TGR& graph, const std::string& fn)
-  /// \sa graphWriter(const TGR& graph, const char* fn)
-  template <typename TGR>
-  GraphWriter<TGR> graphWriter(const TGR& graph, std::ostream& os) {
-    GraphWriter<TGR> tmp(graph, os);
+  template <typename Graph>
+  GraphWriter<Graph> graphWriter(const Graph& graph,
+                                 std::ostream& os) {
+    GraphWriter<Graph> tmp(graph, os);
     return tmp;
   }
@@ -1591,8 +1545,7 @@
   /// This function just returns a \ref GraphWriter class.
   /// \relates GraphWriter
-  /// \sa graphWriter(const TGR& graph, std::ostream& os)
-  template <typename TGR>
-  GraphWriter<TGR> graphWriter(const TGR& graph, const std::string& fn) {
-    GraphWriter<TGR> tmp(graph, fn);
+  template <typename Graph>
+  GraphWriter<Graph> graphWriter(const Graph& graph, const std::string& fn) {
+    GraphWriter<Graph> tmp(graph, fn);
     return tmp;
   }
@@ -1602,8 +1555,7 @@
   /// This function just returns a \ref GraphWriter class.
   /// \relates GraphWriter
-  /// \sa graphWriter(const TGR& graph, std::ostream& os)
-  template <typename TGR>
-  GraphWriter<TGR> graphWriter(const TGR& graph, const char* fn) {
-    GraphWriter<TGR> tmp(graph, fn);
+  template <typename Graph>
+  GraphWriter<Graph> graphWriter(const Graph& graph, const char* fn) {
+    GraphWriter<Graph> tmp(graph, fn);
     return tmp;
   }
@@ -1700,5 +1652,5 @@
   public:
 
-    /// \name Section Writers
+    /// \name Section writers
     /// @{
 
@@ -1767,5 +1719,5 @@
 
 
-    /// \name Execution of the Writer
+    /// \name Execution of the writer
     /// @{
 
@@ -1795,16 +1747,8 @@
   };
 
-  /// \ingroup lemon_io
-  ///
   /// \brief Return a \ref SectionWriter class
   ///
   /// This function just returns a \ref SectionWriter class.
-  ///
-  /// Please see SectionWriter documentation about the custom section
-  /// output.
-  ///
   /// \relates SectionWriter
-  /// \sa sectionWriter(const std::string& fn)
-  /// \sa sectionWriter(const char *fn)
   inline SectionWriter sectionWriter(std::ostream& os) {
     SectionWriter tmp(os);
@@ -1816,5 +1760,4 @@
   /// This function just returns a \ref SectionWriter class.
   /// \relates SectionWriter
-  /// \sa sectionWriter(std::ostream& os)
   inline SectionWriter sectionWriter(const std::string& fn) {
     SectionWriter tmp(fn);
@@ -1826,5 +1769,4 @@
   /// This function just returns a \ref SectionWriter class.
   /// \relates SectionWriter
-  /// \sa sectionWriter(std::ostream& os)
   inline SectionWriter sectionWriter(const char* fn) {
     SectionWriter tmp(fn);
Index: lemon/list_graph.h
===================================================================
--- lemon/list_graph.h	(revision 956)
+++ lemon/list_graph.h	(revision 313)
@@ -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).
@@ -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,28 +312,35 @@
   ///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.
+  ///An important extra feature of this digraph implementation is that
+  ///its maps are real \ref concepts::ReferenceMap "reference map"s.
   ///
   ///\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:
 
+    typedef ExtendedListDigraphBase Parent;
+
     /// Constructor
 
@@ -348,14 +351,14 @@
     ///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) {
+    ///\return the new arc.
+    Arc addArc(const Node& s, const Node& t) {
       return Parent::addArc(s, t);
     }
@@ -363,43 +366,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 +409,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 +423,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 +518,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 +541,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 +713,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 +720,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 +759,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();
@@ -816,5 +797,9 @@
   public:
 
-    typedef ListGraphBase Graph;
+    typedef ListGraphBase Digraph;
+
+    class Node;
+    class Arc;
+    class Edge;
 
     class Node {
@@ -856,6 +841,6 @@
 
     public:
-      operator Edge() const {
-        return id != -1 ? edgeFromId(id / 2) : INVALID;
+      operator Edge() const { 
+        return id != -1 ? edgeFromId(id / 2) : INVALID; 
       }
 
@@ -866,4 +851,6 @@
       bool operator<(const Arc& arc) const {return id < arc.id;}
     };
+
+
 
     ListGraphBase()
@@ -1181,25 +1168,30 @@
   ///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.
+  ///An important extra feature of this graph implementation is that
+  ///its maps are real \ref concepts::ReferenceMap "reference map"s.
   ///
   ///\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:
@@ -1210,70 +1202,69 @@
     ListGraph() {}
 
+    typedef ExtendedListGraphBase Parent;
+
     typedef Parent::OutArcIt IncEdgeIt;
 
     /// \brief Add a new node to the graph.
     ///
-    /// This function adds a new node to the graph.
-    /// \return The new node.
+    /// Add a new node to the graph.
+    /// \return the new node.
     Node addNode() { return Parent::addNode(); }
 
     /// \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);
-    }
-
-    ///\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); }
+    /// Add a new edge to the graph with source node \c s
+    /// and target node \c t.
+    /// \return the new edge.
+    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 +1273,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 +1286,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 +1314,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 +1323,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 +1495,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 +1502,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 +1541,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: mon/lp.h
===================================================================
--- lemon/lp.h	(revision 956)
+++ 	(revision )
@@ -1,93 +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_LP_H
-#define LEMON_LP_H
-
-#include<lemon/config.h>
-
-
-#ifdef LEMON_HAVE_GLPK
-#include <lemon/glpk.h>
-#elif LEMON_HAVE_CPLEX
-#include <lemon/cplex.h>
-#elif LEMON_HAVE_SOPLEX
-#include <lemon/soplex.h>
-#elif LEMON_HAVE_CLP
-#include <lemon/clp.h>
-#endif
-
-///\file
-///\brief Defines a default LP solver
-///\ingroup lp_group
-namespace lemon {
-
-#ifdef DOXYGEN
-  ///The default LP solver identifier
-
-  ///The default LP solver identifier.
-  ///\ingroup lp_group
-  ///
-  ///Currently, the possible values are \c GLPK, \c CPLEX,
-  ///\c SOPLEX or \c CLP
-#define LEMON_DEFAULT_LP SOLVER
-  ///The default LP solver
-
-  ///The default LP solver.
-  ///\ingroup lp_group
-  ///
-  ///Currently, it is either \c GlpkLp, \c CplexLp, \c SoplexLp or \c ClpLp
-  typedef GlpkLp Lp;
-
-  ///The default MIP solver identifier
-
-  ///The default MIP solver identifier.
-  ///\ingroup lp_group
-  ///
-  ///Currently, the possible values are \c GLPK or \c CPLEX
-#define LEMON_DEFAULT_MIP SOLVER
-  ///The default MIP solver.
-
-  ///The default MIP solver.
-  ///\ingroup lp_group
-  ///
-  ///Currently, it is either \c GlpkMip or \c CplexMip
-  typedef GlpkMip Mip;
-#else
-#ifdef LEMON_HAVE_GLPK
-# define LEMON_DEFAULT_LP GLPK
-  typedef GlpkLp Lp;
-# define LEMON_DEFAULT_MIP GLPK
-  typedef GlpkMip Mip;
-#elif LEMON_HAVE_CPLEX
-# define LEMON_DEFAULT_LP CPLEX
-  typedef CplexLp Lp;
-# define LEMON_DEFAULT_MIP CPLEX
-  typedef CplexMip Mip;
-#elif LEMON_HAVE_SOPLEX
-# define DEFAULT_LP SOPLEX
-  typedef SoplexLp Lp;
-#elif LEMON_HAVE_CLP
-# define DEFAULT_LP CLP
-  typedef ClpLp Lp;
-#endif
-#endif
-
-} //namespace lemon
-
-#endif //LEMON_LP_H
Index: mon/lp_base.cc
===================================================================
--- lemon/lp_base.cc	(revision 956)
+++ 	(revision )
@@ -1,30 +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.
- *
- */
-
-///\file
-///\brief The implementation of the LP solver interface.
-
-#include <lemon/lp_base.h>
-namespace lemon {
-
-  const LpBase::Value LpBase::INF =
-    std::numeric_limits<LpBase::Value>::infinity();
-  const LpBase::Value LpBase::NaN =
-    std::numeric_limits<LpBase::Value>::quiet_NaN();
-
-} //namespace lemon
Index: mon/lp_base.h
===================================================================
--- lemon/lp_base.h	(revision 956)
+++ 	(revision )
@@ -1,2102 +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_LP_BASE_H
-#define LEMON_LP_BASE_H
-
-#include<iostream>
-#include<vector>
-#include<map>
-#include<limits>
-#include<lemon/math.h>
-
-#include<lemon/error.h>
-#include<lemon/assert.h>
-
-#include<lemon/core.h>
-#include<lemon/bits/solver_bits.h>
-
-///\file
-///\brief The interface of the LP solver interface.
-///\ingroup lp_group
-namespace lemon {
-
-  ///Common base class for LP and MIP solvers
-
-  ///Usually this class is not used directly, please use one of the concrete
-  ///implementations of the solver interface.
-  ///\ingroup lp_group
-  class LpBase {
-
-  protected:
-
-    _solver_bits::VarIndex rows;
-    _solver_bits::VarIndex cols;
-
-  public:
-
-    ///Possible outcomes of an LP solving procedure
-    enum SolveExitStatus {
-      /// = 0. It means that the problem has been successfully solved: either
-      ///an optimal solution has been found or infeasibility/unboundedness
-      ///has been proved.
-      SOLVED = 0,
-      /// = 1. Any other case (including the case when some user specified
-      ///limit has been exceeded).
-      UNSOLVED = 1
-    };
-
-    ///Direction of the optimization
-    enum Sense {
-      /// Minimization
-      MIN,
-      /// Maximization
-      MAX
-    };
-
-    ///Enum for \c messageLevel() parameter
-    enum MessageLevel {
-      /// No output (default value).
-      MESSAGE_NOTHING,
-      /// Error messages only.
-      MESSAGE_ERROR,
-      /// Warnings.
-      MESSAGE_WARNING,
-      /// Normal output.
-      MESSAGE_NORMAL,
-      /// Verbose output.
-      MESSAGE_VERBOSE
-    };
-
-
-    ///The floating point type used by the solver
-    typedef double Value;
-    ///The infinity constant
-    static const Value INF;
-    ///The not a number constant
-    static const Value NaN;
-
-    friend class Col;
-    friend class ColIt;
-    friend class Row;
-    friend class RowIt;
-
-    ///Refer to a column of the LP.
-
-    ///This type is used to refer to a column of the LP.
-    ///
-    ///Its value remains valid and correct even after the addition or erase of
-    ///other columns.
-    ///
-    ///\note This class is similar to other Item types in LEMON, like
-    ///Node and Arc types in digraph.
-    class Col {
-      friend class LpBase;
-    protected:
-      int _id;
-      explicit Col(int id) : _id(id) {}
-    public:
-      typedef Value ExprValue;
-      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.
-      Col(const Invalid&) : _id(-1) {}
-      /// Equality operator
-
-      /// Two \ref Col "Col"s are equal if and only if they point to
-      /// the same LP column or both are invalid.
-      bool operator==(Col c) const  {return _id == c._id;}
-      /// Inequality operator
-
-      /// \sa operator==(Col c)
-      ///
-      bool operator!=(Col c) const  {return _id != c._id;}
-      /// Artificial ordering operator.
-
-      /// To allow the use of this object 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<(Col c) const  {return _id < c._id;}
-    };
-
-    ///Iterator for iterate over the columns of an LP problem
-
-    /// Its usage is quite simple, for example, you can count the number
-    /// of columns in an LP \c lp:
-    ///\code
-    /// int count=0;
-    /// for (LpBase::ColIt c(lp); c!=INVALID; ++c) ++count;
-    ///\endcode
-    class ColIt : public Col {
-      const LpBase *_solver;
-    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.
-      ///
-      ColIt(const LpBase &solver) : _solver(&solver)
-      {
-        _solver->cols.firstItem(_id);
-      }
-      /// 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.
-      ///
-      ColIt &operator++()
-      {
-        _solver->cols.nextItem(_id);
-        return *this;
-      }
-    };
-
-    /// \brief Returns the ID of the column.
-    static int id(const Col& col) { return col._id; }
-    /// \brief Returns the column with the given ID.
-    ///
-    /// \pre The argument should be a valid column ID in the LP problem.
-    static Col colFromId(int id) { return Col(id); }
-
-    ///Refer to a row of the LP.
-
-    ///This type is used to refer to a row of the LP.
-    ///
-    ///Its value remains valid and correct even after the addition or erase of
-    ///other rows.
-    ///
-    ///\note This class is similar to other Item types in LEMON, like
-    ///Node and Arc types in digraph.
-    class Row {
-      friend class LpBase;
-    protected:
-      int _id;
-      explicit Row(int id) : _id(id) {}
-    public:
-      typedef Value ExprValue;
-      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.
-      Row(const Invalid&) : _id(-1) {}
-      /// Equality operator
-
-      /// Two \ref Row "Row"s are equal if and only if they point to
-      /// the same LP row or both are invalid.
-      bool operator==(Row r) const  {return _id == r._id;}
-      /// Inequality operator
-
-      /// \sa operator==(Row r)
-      ///
-      bool operator!=(Row r) const  {return _id != r._id;}
-      /// Artificial ordering operator.
-
-      /// To allow the use of this object 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<(Row r) const  {return _id < r._id;}
-    };
-
-    ///Iterator for iterate over the rows of an LP problem
-
-    /// Its usage is quite simple, for example, you can count the number
-    /// of rows in an LP \c lp:
-    ///\code
-    /// int count=0;
-    /// for (LpBase::RowIt c(lp); c!=INVALID; ++c) ++count;
-    ///\endcode
-    class RowIt : public Row {
-      const LpBase *_solver;
-    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.
-      ///
-      RowIt(const LpBase &solver) : _solver(&solver)
-      {
-        _solver->rows.firstItem(_id);
-      }
-      /// 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.
-      ///
-      RowIt &operator++()
-      {
-        _solver->rows.nextItem(_id);
-        return *this;
-      }
-    };
-
-    /// \brief Returns the ID of the row.
-    static int id(const Row& row) { return row._id; }
-    /// \brief Returns the row with the given ID.
-    ///
-    /// \pre The argument should be a valid row ID in the LP problem.
-    static Row rowFromId(int id) { return Row(id); }
-
-  public:
-
-    ///Linear expression of variables and a constant component
-
-    ///This data structure stores a linear expression of the variables
-    ///(\ref Col "Col"s) and also has a constant component.
-    ///
-    ///There are several ways to access and modify the contents of this
-    ///container.
-    ///\code
-    ///e[v]=5;
-    ///e[v]+=12;
-    ///e.erase(v);
-    ///\endcode
-    ///or you can also iterate through its elements.
-    ///\code
-    ///double s=0;
-    ///for(LpBase::Expr::ConstCoeffIt i(e);i!=INVALID;++i)
-    ///  s+=*i * primal(i);
-    ///\endcode
-    ///(This code computes the primal value of the expression).
-    ///- Numbers (<tt>double</tt>'s)
-    ///and variables (\ref Col "Col"s) directly convert to an
-    ///\ref Expr and the usual linear operations are defined, so
-    ///\code
-    ///v+w
-    ///2*v-3.12*(v-w/2)+2
-    ///v*2.1+(3*v+(v*12+w+6)*3)/2
-    ///\endcode
-    ///are valid expressions.
-    ///The usual assignment operations are also defined.
-    ///\code
-    ///e=v+w;
-    ///e+=2*v-3.12*(v-w/2)+2;
-    ///e*=3.4;
-    ///e/=5;
-    ///\endcode
-    ///- The constant member can be set and read by dereference
-    ///  operator (unary *)
-    ///
-    ///\code
-    ///*e=12;
-    ///double c=*e;
-    ///\endcode
-    ///
-    ///\sa Constr
-    class Expr {
-      friend class LpBase;
-    public:
-      /// The key type of the expression
-      typedef LpBase::Col Key;
-      /// The value type of the expression
-      typedef LpBase::Value Value;
-
-    protected:
-      Value const_comp;
-      std::map<int, Value> comps;
-
-    public:
-      typedef True SolverExpr;
-      /// Default constructor
-
-      /// Construct an empty expression, the coefficients and
-      /// the constant component are initialized to zero.
-      Expr() : const_comp(0) {}
-      /// Construct an expression from a column
-
-      /// Construct an expression, which has a term with \c c variable
-      /// and 1.0 coefficient.
-      Expr(const Col &c) : const_comp(0) {
-        typedef std::map<int, Value>::value_type pair_type;
-        comps.insert(pair_type(id(c), 1));
-      }
-      /// Construct an expression from a constant
-
-      /// Construct an expression, which's constant component is \c v.
-      ///
-      Expr(const Value &v) : const_comp(v) {}
-      /// Returns the coefficient of the column
-      Value operator[](const Col& c) const {
-        std::map<int, Value>::const_iterator it=comps.find(id(c));
-        if (it != comps.end()) {
-          return it->second;
-        } else {
-          return 0;
-        }
-      }
-      /// Returns the coefficient of the column
-      Value& operator[](const Col& c) {
-        return comps[id(c)];
-      }
-      /// Sets the coefficient of the column
-      void set(const Col &c, const Value &v) {
-        if (v != 0.0) {
-          typedef std::map<int, Value>::value_type pair_type;
-          comps.insert(pair_type(id(c), v));
-        } else {
-          comps.erase(id(c));
-        }
-      }
-      /// Returns the constant component of the expression
-      Value& operator*() { return const_comp; }
-      /// Returns the constant component of the expression
-      const Value& operator*() const { return const_comp; }
-      /// \brief Removes the coefficients which's absolute value does
-      /// not exceed \c epsilon. It also sets to zero the constant
-      /// component, if it does not exceed epsilon in absolute value.
-      void simplify(Value epsilon = 0.0) {
-        std::map<int, Value>::iterator it=comps.begin();
-        while (it != comps.end()) {
-          std::map<int, Value>::iterator jt=it;
-          ++jt;
-          if (std::fabs((*it).second) <= epsilon) comps.erase(it);
-          it=jt;
-        }
-        if (std::fabs(const_comp) <= epsilon) const_comp = 0;
-      }
-
-      void simplify(Value epsilon = 0.0) const {
-        const_cast<Expr*>(this)->simplify(epsilon);
-      }
-
-      ///Sets all coefficients and the constant component to 0.
-      void clear() {
-        comps.clear();
-        const_comp=0;
-      }
-
-      ///Compound assignment
-      Expr &operator+=(const Expr &e) {
-        for (std::map<int, Value>::const_iterator it=e.comps.begin();
-             it!=e.comps.end(); ++it)
-          comps[it->first]+=it->second;
-        const_comp+=e.const_comp;
-        return *this;
-      }
-      ///Compound assignment
-      Expr &operator-=(const Expr &e) {
-        for (std::map<int, Value>::const_iterator it=e.comps.begin();
-             it!=e.comps.end(); ++it)
-          comps[it->first]-=it->second;
-        const_comp-=e.const_comp;
-        return *this;
-      }
-      ///Multiply with a constant
-      Expr &operator*=(const Value &v) {
-        for (std::map<int, Value>::iterator it=comps.begin();
-             it!=comps.end(); ++it)
-          it->second*=v;
-        const_comp*=v;
-        return *this;
-      }
-      ///Division with a constant
-      Expr &operator/=(const Value &c) {
-        for (std::map<int, Value>::iterator it=comps.begin();
-             it!=comps.end(); ++it)
-          it->second/=c;
-        const_comp/=c;
-        return *this;
-      }
-
-      ///Iterator over the expression
-
-      ///The iterator iterates over the terms of the expression.
-      ///
-      ///\code
-      ///double s=0;
-      ///for(LpBase::Expr::CoeffIt i(e);i!=INVALID;++i)
-      ///  s+= *i * primal(i);
-      ///\endcode
-      class CoeffIt {
-      private:
-
-        std::map<int, Value>::iterator _it, _end;
-
-      public:
-
-        /// Sets the iterator to the first term
-
-        /// Sets the iterator to the first term of the expression.
-        ///
-        CoeffIt(Expr& e)
-          : _it(e.comps.begin()), _end(e.comps.end()){}
-
-        /// Convert the iterator to the column of the term
-        operator Col() const {
-          return colFromId(_it->first);
-        }
-
-        /// Returns the coefficient of the term
-        Value& operator*() { return _it->second; }
-
-        /// Returns the coefficient of the term
-        const Value& operator*() const { return _it->second; }
-        /// Next term
-
-        /// Assign the iterator to the next term.
-        ///
-        CoeffIt& operator++() { ++_it; return *this; }
-
-        /// Equality operator
-        bool operator==(Invalid) const { return _it == _end; }
-        /// Inequality operator
-        bool operator!=(Invalid) const { return _it != _end; }
-      };
-
-      /// Const iterator over the expression
-
-      ///The iterator iterates over the terms of the expression.
-      ///
-      ///\code
-      ///double s=0;
-      ///for(LpBase::Expr::ConstCoeffIt i(e);i!=INVALID;++i)
-      ///  s+=*i * primal(i);
-      ///\endcode
-      class ConstCoeffIt {
-      private:
-
-        std::map<int, Value>::const_iterator _it, _end;
-
-      public:
-
-        /// Sets the iterator to the first term
-
-        /// Sets the iterator to the first term of the expression.
-        ///
-        ConstCoeffIt(const Expr& e)
-          : _it(e.comps.begin()), _end(e.comps.end()){}
-
-        /// Convert the iterator to the column of the term
-        operator Col() const {
-          return colFromId(_it->first);
-        }
-
-        /// Returns the coefficient of the term
-        const Value& operator*() const { return _it->second; }
-
-        /// Next term
-
-        /// Assign the iterator to the next term.
-        ///
-        ConstCoeffIt& operator++() { ++_it; return *this; }
-
-        /// Equality operator
-        bool operator==(Invalid) const { return _it == _end; }
-        /// Inequality operator
-        bool operator!=(Invalid) const { return _it != _end; }
-      };
-
-    };
-
-    ///Linear constraint
-
-    ///This data stucture represents a linear constraint in the LP.
-    ///Basically it is a linear expression with a lower or an upper bound
-    ///(or both). These parts of the constraint can be obtained by the member
-    ///functions \ref expr(), \ref lowerBound() and \ref upperBound(),
-    ///respectively.
-    ///There are two ways to construct a constraint.
-    ///- You can set the linear expression and the bounds directly
-    ///  by the functions above.
-    ///- The operators <tt>\<=</tt>, <tt>==</tt> and  <tt>\>=</tt>
-    ///  are defined between expressions, or even between constraints whenever
-    ///  it makes sense. Therefore if \c e and \c f are linear expressions and
-    ///  \c s and \c t are numbers, then the followings are valid expressions
-    ///  and thus they can be used directly e.g. in \ref addRow() whenever
-    ///  it makes sense.
-    ///\code
-    ///  e<=s
-    ///  e<=f
-    ///  e==f
-    ///  s<=e<=t
-    ///  e>=t
-    ///\endcode
-    ///\warning The validity of a constraint is checked only at run
-    ///time, so e.g. \ref addRow(<tt>x[1]\<=x[2]<=5</tt>) will
-    ///compile, but will fail an assertion.
-    class Constr
-    {
-    public:
-      typedef LpBase::Expr Expr;
-      typedef Expr::Key Key;
-      typedef Expr::Value Value;
-
-    protected:
-      Expr _expr;
-      Value _lb,_ub;
-    public:
-      ///\e
-      Constr() : _expr(), _lb(NaN), _ub(NaN) {}
-      ///\e
-      Constr(Value lb, const Expr &e, Value ub) :
-        _expr(e), _lb(lb), _ub(ub) {}
-      Constr(const Expr &e) :
-        _expr(e), _lb(NaN), _ub(NaN) {}
-      ///\e
-      void clear()
-      {
-        _expr.clear();
-        _lb=_ub=NaN;
-      }
-
-      ///Reference to the linear expression
-      Expr &expr() { return _expr; }
-      ///Cont reference to the linear expression
-      const Expr &expr() const { return _expr; }
-      ///Reference to the lower bound.
-
-      ///\return
-      ///- \ref INF "INF": the constraint is lower unbounded.
-      ///- \ref NaN "NaN": lower bound has not been set.
-      ///- finite number: the lower bound
-      Value &lowerBound() { return _lb; }
-      ///The const version of \ref lowerBound()
-      const Value &lowerBound() const { return _lb; }
-      ///Reference to the upper bound.
-
-      ///\return
-      ///- \ref INF "INF": the constraint is upper unbounded.
-      ///- \ref NaN "NaN": upper bound has not been set.
-      ///- finite number: the upper bound
-      Value &upperBound() { return _ub; }
-      ///The const version of \ref upperBound()
-      const Value &upperBound() const { return _ub; }
-      ///Is the constraint lower bounded?
-      bool lowerBounded() const {
-        return _lb != -INF && !isNaN(_lb);
-      }
-      ///Is the constraint upper bounded?
-      bool upperBounded() const {
-        return _ub != INF && !isNaN(_ub);
-      }
-
-    };
-
-    ///Linear expression of rows
-
-    ///This data structure represents a column of the matrix,
-    ///thas is it strores a linear expression of the dual variables
-    ///(\ref Row "Row"s).
-    ///
-    ///There are several ways to access and modify the contents of this
-    ///container.
-    ///\code
-    ///e[v]=5;
-    ///e[v]+=12;
-    ///e.erase(v);
-    ///\endcode
-    ///or you can also iterate through its elements.
-    ///\code
-    ///double s=0;
-    ///for(LpBase::DualExpr::ConstCoeffIt i(e);i!=INVALID;++i)
-    ///  s+=*i;
-    ///\endcode
-    ///(This code computes the sum of all coefficients).
-    ///- Numbers (<tt>double</tt>'s)
-    ///and variables (\ref Row "Row"s) directly convert to an
-    ///\ref DualExpr and the usual linear operations are defined, so
-    ///\code
-    ///v+w
-    ///2*v-3.12*(v-w/2)
-    ///v*2.1+(3*v+(v*12+w)*3)/2
-    ///\endcode
-    ///are valid \ref DualExpr dual expressions.
-    ///The usual assignment operations are also defined.
-    ///\code
-    ///e=v+w;
-    ///e+=2*v-3.12*(v-w/2);
-    ///e*=3.4;
-    ///e/=5;
-    ///\endcode
-    ///
-    ///\sa Expr
-    class DualExpr {
-      friend class LpBase;
-    public:
-      /// The key type of the expression
-      typedef LpBase::Row Key;
-      /// The value type of the expression
-      typedef LpBase::Value Value;
-
-    protected:
-      std::map<int, Value> comps;
-
-    public:
-      typedef True SolverExpr;
-      /// Default constructor
-
-      /// Construct an empty expression, the coefficients are
-      /// initialized to zero.
-      DualExpr() {}
-      /// Construct an expression from a row
-
-      /// Construct an expression, which has a term with \c r dual
-      /// variable and 1.0 coefficient.
-      DualExpr(const Row &r) {
-        typedef std::map<int, Value>::value_type pair_type;
-        comps.insert(pair_type(id(r), 1));
-      }
-      /// Returns the coefficient of the row
-      Value operator[](const Row& r) const {
-        std::map<int, Value>::const_iterator it = comps.find(id(r));
-        if (it != comps.end()) {
-          return it->second;
-        } else {
-          return 0;
-        }
-      }
-      /// Returns the coefficient of the row
-      Value& operator[](const Row& r) {
-        return comps[id(r)];
-      }
-      /// Sets the coefficient of the row
-      void set(const Row &r, const Value &v) {
-        if (v != 0.0) {
-          typedef std::map<int, Value>::value_type pair_type;
-          comps.insert(pair_type(id(r), v));
-        } else {
-          comps.erase(id(r));
-        }
-      }
-      /// \brief Removes the coefficients which's absolute value does
-      /// not exceed \c epsilon.
-      void simplify(Value epsilon = 0.0) {
-        std::map<int, Value>::iterator it=comps.begin();
-        while (it != comps.end()) {
-          std::map<int, Value>::iterator jt=it;
-          ++jt;
-          if (std::fabs((*it).second) <= epsilon) comps.erase(it);
-          it=jt;
-        }
-      }
-
-      void simplify(Value epsilon = 0.0) const {
-        const_cast<DualExpr*>(this)->simplify(epsilon);
-      }
-
-      ///Sets all coefficients to 0.
-      void clear() {
-        comps.clear();
-      }
-      ///Compound assignment
-      DualExpr &operator+=(const DualExpr &e) {
-        for (std::map<int, Value>::const_iterator it=e.comps.begin();
-             it!=e.comps.end(); ++it)
-          comps[it->first]+=it->second;
-        return *this;
-      }
-      ///Compound assignment
-      DualExpr &operator-=(const DualExpr &e) {
-        for (std::map<int, Value>::const_iterator it=e.comps.begin();
-             it!=e.comps.end(); ++it)
-          comps[it->first]-=it->second;
-        return *this;
-      }
-      ///Multiply with a constant
-      DualExpr &operator*=(const Value &v) {
-        for (std::map<int, Value>::iterator it=comps.begin();
-             it!=comps.end(); ++it)
-          it->second*=v;
-        return *this;
-      }
-      ///Division with a constant
-      DualExpr &operator/=(const Value &v) {
-        for (std::map<int, Value>::iterator it=comps.begin();
-             it!=comps.end(); ++it)
-          it->second/=v;
-        return *this;
-      }
-
-      ///Iterator over the expression
-
-      ///The iterator iterates over the terms of the expression.
-      ///
-      ///\code
-      ///double s=0;
-      ///for(LpBase::DualExpr::CoeffIt i(e);i!=INVALID;++i)
-      ///  s+= *i * dual(i);
-      ///\endcode
-      class CoeffIt {
-      private:
-
-        std::map<int, Value>::iterator _it, _end;
-
-      public:
-
-        /// Sets the iterator to the first term
-
-        /// Sets the iterator to the first term of the expression.
-        ///
-        CoeffIt(DualExpr& e)
-          : _it(e.comps.begin()), _end(e.comps.end()){}
-
-        /// Convert the iterator to the row of the term
-        operator Row() const {
-          return rowFromId(_it->first);
-        }
-
-        /// Returns the coefficient of the term
-        Value& operator*() { return _it->second; }
-
-        /// Returns the coefficient of the term
-        const Value& operator*() const { return _it->second; }
-
-        /// Next term
-
-        /// Assign the iterator to the next term.
-        ///
-        CoeffIt& operator++() { ++_it; return *this; }
-
-        /// Equality operator
-        bool operator==(Invalid) const { return _it == _end; }
-        /// Inequality operator
-        bool operator!=(Invalid) const { return _it != _end; }
-      };
-
-      ///Iterator over the expression
-
-      ///The iterator iterates over the terms of the expression.
-      ///
-      ///\code
-      ///double s=0;
-      ///for(LpBase::DualExpr::ConstCoeffIt i(e);i!=INVALID;++i)
-      ///  s+= *i * dual(i);
-      ///\endcode
-      class ConstCoeffIt {
-      private:
-
-        std::map<int, Value>::const_iterator _it, _end;
-
-      public:
-
-        /// Sets the iterator to the first term
-
-        /// Sets the iterator to the first term of the expression.
-        ///
-        ConstCoeffIt(const DualExpr& e)
-          : _it(e.comps.begin()), _end(e.comps.end()){}
-
-        /// Convert the iterator to the row of the term
-        operator Row() const {
-          return rowFromId(_it->first);
-        }
-
-        /// Returns the coefficient of the term
-        const Value& operator*() const { return _it->second; }
-
-        /// Next term
-
-        /// Assign the iterator to the next term.
-        ///
-        ConstCoeffIt& operator++() { ++_it; return *this; }
-
-        /// Equality operator
-        bool operator==(Invalid) const { return _it == _end; }
-        /// Inequality operator
-        bool operator!=(Invalid) const { return _it != _end; }
-      };
-    };
-
-
-  protected:
-
-    class InsertIterator {
-    private:
-
-      std::map<int, Value>& _host;
-      const _solver_bits::VarIndex& _index;
-
-    public:
-
-      typedef std::output_iterator_tag iterator_category;
-      typedef void difference_type;
-      typedef void value_type;
-      typedef void reference;
-      typedef void pointer;
-
-      InsertIterator(std::map<int, Value>& host,
-                   const _solver_bits::VarIndex& index)
-        : _host(host), _index(index) {}
-
-      InsertIterator& operator=(const std::pair<int, Value>& value) {
-        typedef std::map<int, Value>::value_type pair_type;
-        _host.insert(pair_type(_index[value.first], value.second));
-        return *this;
-      }
-
-      InsertIterator& operator*() { return *this; }
-      InsertIterator& operator++() { return *this; }
-      InsertIterator operator++(int) { return *this; }
-
-    };
-
-    class ExprIterator {
-    private:
-      std::map<int, Value>::const_iterator _host_it;
-      const _solver_bits::VarIndex& _index;
-    public:
-
-      typedef std::bidirectional_iterator_tag iterator_category;
-      typedef std::ptrdiff_t difference_type;
-      typedef const std::pair<int, Value> value_type;
-      typedef value_type reference;
-
-      class pointer {
-      public:
-        pointer(value_type& _value) : value(_value) {}
-        value_type* operator->() { return &value; }
-      private:
-        value_type value;
-      };
-
-      ExprIterator(const std::map<int, Value>::const_iterator& host_it,
-                   const _solver_bits::VarIndex& index)
-        : _host_it(host_it), _index(index) {}
-
-      reference operator*() {
-        return std::make_pair(_index(_host_it->first), _host_it->second);
-      }
-
-      pointer operator->() {
-        return pointer(operator*());
-      }
-
-      ExprIterator& operator++() { ++_host_it; return *this; }
-      ExprIterator operator++(int) {
-        ExprIterator tmp(*this); ++_host_it; return tmp;
-      }
-
-      ExprIterator& operator--() { --_host_it; return *this; }
-      ExprIterator operator--(int) {
-        ExprIterator tmp(*this); --_host_it; return tmp;
-      }
-
-      bool operator==(const ExprIterator& it) const {
-        return _host_it == it._host_it;
-      }
-
-      bool operator!=(const ExprIterator& it) const {
-        return _host_it != it._host_it;
-      }
-
-    };
-
-  protected:
-
-    //Abstract virtual functions
-
-    virtual int _addColId(int col) { return cols.addIndex(col); }
-    virtual int _addRowId(int row) { return rows.addIndex(row); }
-
-    virtual void _eraseColId(int col) { cols.eraseIndex(col); }
-    virtual void _eraseRowId(int row) { rows.eraseIndex(row); }
-
-    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;
-    virtual void _eraseRow(int row) = 0;
-
-    virtual void _getColName(int col, std::string& name) const = 0;
-    virtual void _setColName(int col, const std::string& name) = 0;
-    virtual int _colByName(const std::string& name) const = 0;
-
-    virtual void _getRowName(int row, std::string& name) const = 0;
-    virtual void _setRowName(int row, const std::string& name) = 0;
-    virtual int _rowByName(const std::string& name) const = 0;
-
-    virtual void _setRowCoeffs(int i, ExprIterator b, ExprIterator e) = 0;
-    virtual void _getRowCoeffs(int i, InsertIterator b) const = 0;
-
-    virtual void _setColCoeffs(int i, ExprIterator b, ExprIterator e) = 0;
-    virtual void _getColCoeffs(int i, InsertIterator b) const = 0;
-
-    virtual void _setCoeff(int row, int col, Value value) = 0;
-    virtual Value _getCoeff(int row, int col) const = 0;
-
-    virtual void _setColLowerBound(int i, Value value) = 0;
-    virtual Value _getColLowerBound(int i) const = 0;
-
-    virtual void _setColUpperBound(int i, Value value) = 0;
-    virtual Value _getColUpperBound(int i) const = 0;
-
-    virtual void _setRowLowerBound(int i, Value value) = 0;
-    virtual Value _getRowLowerBound(int i) const = 0;
-
-    virtual void _setRowUpperBound(int i, Value value) = 0;
-    virtual Value _getRowUpperBound(int i) const = 0;
-
-    virtual void _setObjCoeffs(ExprIterator b, ExprIterator e) = 0;
-    virtual void _getObjCoeffs(InsertIterator b) const = 0;
-
-    virtual void _setObjCoeff(int i, Value obj_coef) = 0;
-    virtual Value _getObjCoeff(int i) const = 0;
-
-    virtual void _setSense(Sense) = 0;
-    virtual Sense _getSense() const = 0;
-
-    virtual void _clear() = 0;
-
-    virtual const char* _solverName() const = 0;
-
-    virtual void _messageLevel(MessageLevel level) = 0;
-
-    //Own protected stuff
-
-    //Constant component of the objective function
-    Value obj_const_comp;
-
-    LpBase() : rows(), cols(), obj_const_comp(0) {}
-
-  public:
-
-    /// Virtual destructor
-    virtual ~LpBase() {}
-
-    ///Gives back the name of the solver.
-    const char* solverName() const {return _solverName();}
-
-    ///\name Build Up and Modify the LP
-
-    ///@{
-
-    ///Add a new empty column (i.e a new variable) to the LP
-    Col addCol() { Col c; c._id = _addColId(_addCol()); return c;}
-
-    ///\brief Adds several new columns (i.e variables) at once
-    ///
-    ///This magic function takes a container as its argument and fills
-    ///its elements with new columns (i.e. variables)
-    ///\param t can be
-    ///- a standard STL compatible iterable container with
-    ///\ref Col as its \c values_type like
-    ///\code
-    ///std::vector<LpBase::Col>
-    ///std::list<LpBase::Col>
-    ///\endcode
-    ///- a standard STL compatible iterable container with
-    ///\ref Col as its \c mapped_type like
-    ///\code
-    ///std::map<AnyType,LpBase::Col>
-    ///\endcode
-    ///- an iterable lemon \ref concepts::WriteMap "write map" like
-    ///\code
-    ///ListGraph::NodeMap<LpBase::Col>
-    ///ListGraph::ArcMap<LpBase::Col>
-    ///\endcode
-    ///\return The number of the created column.
-#ifdef DOXYGEN
-    template<class T>
-    int addColSet(T &t) { return 0;}
-#else
-    template<class T>
-    typename enable_if<typename T::value_type::LpCol,int>::type
-    addColSet(T &t,dummy<0> = 0) {
-      int s=0;
-      for(typename T::iterator i=t.begin();i!=t.end();++i) {*i=addCol();s++;}
-      return s;
-    }
-    template<class T>
-    typename enable_if<typename T::value_type::second_type::LpCol,
-                       int>::type
-    addColSet(T &t,dummy<1> = 1) {
-      int s=0;
-      for(typename T::iterator i=t.begin();i!=t.end();++i) {
-        i->second=addCol();
-        s++;
-      }
-      return s;
-    }
-    template<class T>
-    typename enable_if<typename T::MapIt::Value::LpCol,
-                       int>::type
-    addColSet(T &t,dummy<2> = 2) {
-      int s=0;
-      for(typename T::MapIt i(t); i!=INVALID; ++i)
-        {
-          i.set(addCol());
-          s++;
-        }
-      return s;
-    }
-#endif
-
-    ///Set a column (i.e a dual constraint) of the LP
-
-    ///\param c is the column to be modified
-    ///\param e is a dual linear expression (see \ref DualExpr)
-    ///a better one.
-    void col(Col c, const DualExpr &e) {
-      e.simplify();
-      _setColCoeffs(cols(id(c)), ExprIterator(e.comps.begin(), rows),
-                    ExprIterator(e.comps.end(), rows));
-    }
-
-    ///Get a column (i.e a dual constraint) of the LP
-
-    ///\param c is the column to get
-    ///\return the dual expression associated to the column
-    DualExpr col(Col c) const {
-      DualExpr e;
-      _getColCoeffs(cols(id(c)), InsertIterator(e.comps, rows));
-      return e;
-    }
-
-    ///Add a new column to the LP
-
-    ///\param e is a dual linear expression (see \ref DualExpr)
-    ///\param o is the corresponding component of the objective
-    ///function. It is 0 by default.
-    ///\return The created column.
-    Col addCol(const DualExpr &e, Value o = 0) {
-      Col c=addCol();
-      col(c,e);
-      objCoeff(c,o);
-      return c;
-    }
-
-    ///Add a new empty row (i.e a new constraint) to the LP
-
-    ///This function adds a new empty row (i.e a new constraint) to the LP.
-    ///\return The created row
-    Row addRow() { Row r; r._id = _addRowId(_addRow()); return r;}
-
-    ///\brief Add several new rows (i.e constraints) at once
-    ///
-    ///This magic function takes a container as its argument and fills
-    ///its elements with new row (i.e. variables)
-    ///\param t can be
-    ///- a standard STL compatible iterable container with
-    ///\ref Row as its \c values_type like
-    ///\code
-    ///std::vector<LpBase::Row>
-    ///std::list<LpBase::Row>
-    ///\endcode
-    ///- a standard STL compatible iterable container with
-    ///\ref Row as its \c mapped_type like
-    ///\code
-    ///std::map<AnyType,LpBase::Row>
-    ///\endcode
-    ///- an iterable lemon \ref concepts::WriteMap "write map" like
-    ///\code
-    ///ListGraph::NodeMap<LpBase::Row>
-    ///ListGraph::ArcMap<LpBase::Row>
-    ///\endcode
-    ///\return The number of rows created.
-#ifdef DOXYGEN
-    template<class T>
-    int addRowSet(T &t) { return 0;}
-#else
-    template<class T>
-    typename enable_if<typename T::value_type::LpRow,int>::type
-    addRowSet(T &t, dummy<0> = 0) {
-      int s=0;
-      for(typename T::iterator i=t.begin();i!=t.end();++i) {*i=addRow();s++;}
-      return s;
-    }
-    template<class T>
-    typename enable_if<typename T::value_type::second_type::LpRow, int>::type
-    addRowSet(T &t, dummy<1> = 1) {
-      int s=0;
-      for(typename T::iterator i=t.begin();i!=t.end();++i) {
-        i->second=addRow();
-        s++;
-      }
-      return s;
-    }
-    template<class T>
-    typename enable_if<typename T::MapIt::Value::LpRow, int>::type
-    addRowSet(T &t, dummy<2> = 2) {
-      int s=0;
-      for(typename T::MapIt i(t); i!=INVALID; ++i)
-        {
-          i.set(addRow());
-          s++;
-        }
-      return s;
-    }
-#endif
-
-    ///Set a row (i.e a constraint) of the LP
-
-    ///\param r is the row to be modified
-    ///\param l is lower bound (-\ref INF means no bound)
-    ///\param e is a linear expression (see \ref Expr)
-    ///\param u is the upper bound (\ref INF means no bound)
-    void row(Row r, Value l, const Expr &e, Value u) {
-      e.simplify();
-      _setRowCoeffs(rows(id(r)), ExprIterator(e.comps.begin(), cols),
-                    ExprIterator(e.comps.end(), cols));
-      _setRowLowerBound(rows(id(r)),l - *e);
-      _setRowUpperBound(rows(id(r)),u - *e);
-    }
-
-    ///Set a row (i.e a constraint) of the LP
-
-    ///\param r is the row to be modified
-    ///\param c is a linear expression (see \ref Constr)
-    void row(Row r, const Constr &c) {
-      row(r, c.lowerBounded()?c.lowerBound():-INF,
-          c.expr(), c.upperBounded()?c.upperBound():INF);
-    }
-
-
-    ///Get a row (i.e a constraint) of the LP
-
-    ///\param r is the row to get
-    ///\return the expression associated to the row
-    Expr row(Row r) const {
-      Expr e;
-      _getRowCoeffs(rows(id(r)), InsertIterator(e.comps, cols));
-      return e;
-    }
-
-    ///Add a new row (i.e a new constraint) to the LP
-
-    ///\param l is the lower bound (-\ref INF means no bound)
-    ///\param e is a linear expression (see \ref Expr)
-    ///\param u is the upper bound (\ref INF means no bound)
-    ///\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));
-      return r;
-    }
-
-    ///Add a new row (i.e a new constraint) to the LP
-
-    ///\param c is a linear expression (see \ref Constr)
-    ///\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));
-      return r;
-    }
-    ///Erase a column (i.e a variable) from the LP
-
-    ///\param c is the column to be deleted
-    void erase(Col c) {
-      _eraseCol(cols(id(c)));
-      _eraseColId(cols(id(c)));
-    }
-    ///Erase a row (i.e a constraint) from the LP
-
-    ///\param r is the row to be deleted
-    void erase(Row r) {
-      _eraseRow(rows(id(r)));
-      _eraseRowId(rows(id(r)));
-    }
-
-    /// Get the name of a column
-
-    ///\param c is the coresponding column
-    ///\return The name of the colunm
-    std::string colName(Col c) const {
-      std::string name;
-      _getColName(cols(id(c)), name);
-      return name;
-    }
-
-    /// Set the name of a column
-
-    ///\param c is the coresponding column
-    ///\param name The name to be given
-    void colName(Col c, const std::string& name) {
-      _setColName(cols(id(c)), name);
-    }
-
-    /// Get the column by its name
-
-    ///\param name The name of the column
-    ///\return the proper column or \c INVALID
-    Col colByName(const std::string& name) const {
-      int k = _colByName(name);
-      return k != -1 ? Col(cols[k]) : Col(INVALID);
-    }
-
-    /// Get the name of a row
-
-    ///\param r is the coresponding row
-    ///\return The name of the row
-    std::string rowName(Row r) const {
-      std::string name;
-      _getRowName(rows(id(r)), name);
-      return name;
-    }
-
-    /// Set the name of a row
-
-    ///\param r is the coresponding row
-    ///\param name The name to be given
-    void rowName(Row r, const std::string& name) {
-      _setRowName(rows(id(r)), name);
-    }
-
-    /// Get the row by its name
-
-    ///\param name The name of the row
-    ///\return the proper row or \c INVALID
-    Row rowByName(const std::string& name) const {
-      int k = _rowByName(name);
-      return k != -1 ? Row(rows[k]) : Row(INVALID);
-    }
-
-    /// Set an element of the coefficient matrix of the LP
-
-    ///\param r is the row of the element to be modified
-    ///\param c is the column of the element to be modified
-    ///\param val is the new value of the coefficient
-    void coeff(Row r, Col c, Value val) {
-      _setCoeff(rows(id(r)),cols(id(c)), val);
-    }
-
-    /// Get an element of the coefficient matrix of the LP
-
-    ///\param r is the row of the element
-    ///\param c is the column of the element
-    ///\return the corresponding coefficient
-    Value coeff(Row r, Col c) const {
-      return _getCoeff(rows(id(r)),cols(id(c)));
-    }
-
-    /// Set the lower bound of a column (i.e a variable)
-
-    /// The lower bound of a variable (column) has to be given by an
-    /// extended number of type Value, i.e. a finite number of type
-    /// Value or -\ref INF.
-    void colLowerBound(Col c, Value value) {
-      _setColLowerBound(cols(id(c)),value);
-    }
-
-    /// Get the lower bound of a column (i.e a variable)
-
-    /// This function returns the lower bound for column (variable) \c c
-    /// (this might be -\ref INF as well).
-    ///\return The lower bound for column \c c
-    Value colLowerBound(Col c) const {
-      return _getColLowerBound(cols(id(c)));
-    }
-
-    ///\brief Set the lower bound of  several columns
-    ///(i.e variables) at once
-    ///
-    ///This magic function takes a container as its argument
-    ///and applies the function on all of its elements.
-    ///The lower bound of a variable (column) has to be given by an
-    ///extended number of type Value, i.e. a finite number of type
-    ///Value or -\ref INF.
-#ifdef DOXYGEN
-    template<class T>
-    void colLowerBound(T &t, Value value) { return 0;}
-#else
-    template<class T>
-    typename enable_if<typename T::value_type::LpCol,void>::type
-    colLowerBound(T &t, Value value,dummy<0> = 0) {
-      for(typename T::iterator i=t.begin();i!=t.end();++i) {
-        colLowerBound(*i, value);
-      }
-    }
-    template<class T>
-    typename enable_if<typename T::value_type::second_type::LpCol,
-                       void>::type
-    colLowerBound(T &t, Value value,dummy<1> = 1) {
-      for(typename T::iterator i=t.begin();i!=t.end();++i) {
-        colLowerBound(i->second, value);
-      }
-    }
-    template<class T>
-    typename enable_if<typename T::MapIt::Value::LpCol,
-                       void>::type
-    colLowerBound(T &t, Value value,dummy<2> = 2) {
-      for(typename T::MapIt i(t); i!=INVALID; ++i){
-        colLowerBound(*i, value);
-      }
-    }
-#endif
-
-    /// Set the upper bound of a column (i.e a variable)
-
-    /// The upper bound of a variable (column) has to be given by an
-    /// extended number of type Value, i.e. a finite number of type
-    /// Value or \ref INF.
-    void colUpperBound(Col c, Value value) {
-      _setColUpperBound(cols(id(c)),value);
-    };
-
-    /// Get the upper bound of a column (i.e a variable)
-
-    /// This function returns the upper bound for column (variable) \c c
-    /// (this might be \ref INF as well).
-    /// \return The upper bound for column \c c
-    Value colUpperBound(Col c) const {
-      return _getColUpperBound(cols(id(c)));
-    }
-
-    ///\brief Set the upper bound of  several columns
-    ///(i.e variables) at once
-    ///
-    ///This magic function takes a container as its argument
-    ///and applies the function on all of its elements.
-    ///The upper bound of a variable (column) has to be given by an
-    ///extended number of type Value, i.e. a finite number of type
-    ///Value or \ref INF.
-#ifdef DOXYGEN
-    template<class T>
-    void colUpperBound(T &t, Value value) { return 0;}
-#else
-    template<class T1>
-    typename enable_if<typename T1::value_type::LpCol,void>::type
-    colUpperBound(T1 &t, Value value,dummy<0> = 0) {
-      for(typename T1::iterator i=t.begin();i!=t.end();++i) {
-        colUpperBound(*i, value);
-      }
-    }
-    template<class T1>
-    typename enable_if<typename T1::value_type::second_type::LpCol,
-                       void>::type
-    colUpperBound(T1 &t, Value value,dummy<1> = 1) {
-      for(typename T1::iterator i=t.begin();i!=t.end();++i) {
-        colUpperBound(i->second, value);
-      }
-    }
-    template<class T1>
-    typename enable_if<typename T1::MapIt::Value::LpCol,
-                       void>::type
-    colUpperBound(T1 &t, Value value,dummy<2> = 2) {
-      for(typename T1::MapIt i(t); i!=INVALID; ++i){
-        colUpperBound(*i, value);
-      }
-    }
-#endif
-
-    /// Set the lower and the upper bounds of a column (i.e a variable)
-
-    /// The lower and the upper bounds of
-    /// a variable (column) have to be given by an
-    /// extended number of type Value, i.e. a finite number of type
-    /// Value, -\ref INF or \ref INF.
-    void colBounds(Col c, Value lower, Value upper) {
-      _setColLowerBound(cols(id(c)),lower);
-      _setColUpperBound(cols(id(c)),upper);
-    }
-
-    ///\brief Set the lower and the upper bound of several columns
-    ///(i.e variables) at once
-    ///
-    ///This magic function takes a container as its argument
-    ///and applies the function on all of its elements.
-    /// The lower and the upper bounds of
-    /// a variable (column) have to be given by an
-    /// extended number of type Value, i.e. a finite number of type
-    /// Value, -\ref INF or \ref INF.
-#ifdef DOXYGEN
-    template<class T>
-    void colBounds(T &t, Value lower, Value upper) { return 0;}
-#else
-    template<class T2>
-    typename enable_if<typename T2::value_type::LpCol,void>::type
-    colBounds(T2 &t, Value lower, Value upper,dummy<0> = 0) {
-      for(typename T2::iterator i=t.begin();i!=t.end();++i) {
-        colBounds(*i, lower, upper);
-      }
-    }
-    template<class T2>
-    typename enable_if<typename T2::value_type::second_type::LpCol, void>::type
-    colBounds(T2 &t, Value lower, Value upper,dummy<1> = 1) {
-      for(typename T2::iterator i=t.begin();i!=t.end();++i) {
-        colBounds(i->second, lower, upper);
-      }
-    }
-    template<class T2>
-    typename enable_if<typename T2::MapIt::Value::LpCol, void>::type
-    colBounds(T2 &t, Value lower, Value upper,dummy<2> = 2) {
-      for(typename T2::MapIt i(t); i!=INVALID; ++i){
-        colBounds(*i, lower, upper);
-      }
-    }
-#endif
-
-    /// Set the lower bound of a row (i.e a constraint)
-
-    /// The lower bound of a constraint (row) has to be given by an
-    /// extended number of type Value, i.e. a finite number of type
-    /// Value or -\ref INF.
-    void rowLowerBound(Row r, Value value) {
-      _setRowLowerBound(rows(id(r)),value);
-    }
-
-    /// Get the lower bound of a row (i.e a constraint)
-
-    /// This function returns the lower bound for row (constraint) \c c
-    /// (this might be -\ref INF as well).
-    ///\return The lower bound for row \c r
-    Value rowLowerBound(Row r) const {
-      return _getRowLowerBound(rows(id(r)));
-    }
-
-    /// Set the upper bound of a row (i.e a constraint)
-
-    /// The upper bound of a constraint (row) has to be given by an
-    /// extended number of type Value, i.e. a finite number of type
-    /// Value or -\ref INF.
-    void rowUpperBound(Row r, Value value) {
-      _setRowUpperBound(rows(id(r)),value);
-    }
-
-    /// Get the upper bound of a row (i.e a constraint)
-
-    /// This function returns the upper bound for row (constraint) \c c
-    /// (this might be -\ref INF as well).
-    ///\return The upper bound for row \c r
-    Value rowUpperBound(Row r) const {
-      return _getRowUpperBound(rows(id(r)));
-    }
-
-    ///Set an element of the objective function
-    void objCoeff(Col c, Value v) {_setObjCoeff(cols(id(c)),v); };
-
-    ///Get an element of the objective function
-    Value objCoeff(Col c) const { return _getObjCoeff(cols(id(c))); };
-
-    ///Set the objective function
-
-    ///\param e is a linear expression of type \ref Expr.
-    ///
-    void obj(const Expr& e) {
-      _setObjCoeffs(ExprIterator(e.comps.begin(), cols),
-                    ExprIterator(e.comps.end(), cols));
-      obj_const_comp = *e;
-    }
-
-    ///Get the objective function
-
-    ///\return the objective function as a linear expression of type
-    ///Expr.
-    Expr obj() const {
-      Expr e;
-      _getObjCoeffs(InsertIterator(e.comps, cols));
-      *e = obj_const_comp;
-      return e;
-    }
-
-
-    ///Set the direction of optimization
-    void sense(Sense sense) { _setSense(sense); }
-
-    ///Query the direction of the optimization
-    Sense sense() const {return _getSense(); }
-
-    ///Set the sense to maximization
-    void max() { _setSense(MAX); }
-
-    ///Set the sense to maximization
-    void min() { _setSense(MIN); }
-
-    ///Clears the problem
-    void clear() { _clear(); }
-
-    /// Sets the message level of the solver
-    void messageLevel(MessageLevel level) { _messageLevel(level); }
-
-    ///@}
-
-  };
-
-  /// Addition
-
-  ///\relates LpBase::Expr
-  ///
-  inline LpBase::Expr operator+(const LpBase::Expr &a, const LpBase::Expr &b) {
-    LpBase::Expr tmp(a);
-    tmp+=b;
-    return tmp;
-  }
-  ///Substraction
-
-  ///\relates LpBase::Expr
-  ///
-  inline LpBase::Expr operator-(const LpBase::Expr &a, const LpBase::Expr &b) {
-    LpBase::Expr tmp(a);
-    tmp-=b;
-    return tmp;
-  }
-  ///Multiply with constant
-
-  ///\relates LpBase::Expr
-  ///
-  inline LpBase::Expr operator*(const LpBase::Expr &a, const LpBase::Value &b) {
-    LpBase::Expr tmp(a);
-    tmp*=b;
-    return tmp;
-  }
-
-  ///Multiply with constant
-
-  ///\relates LpBase::Expr
-  ///
-  inline LpBase::Expr operator*(const LpBase::Value &a, const LpBase::Expr &b) {
-    LpBase::Expr tmp(b);
-    tmp*=a;
-    return tmp;
-  }
-  ///Divide with constant
-
-  ///\relates LpBase::Expr
-  ///
-  inline LpBase::Expr operator/(const LpBase::Expr &a, const LpBase::Value &b) {
-    LpBase::Expr tmp(a);
-    tmp/=b;
-    return tmp;
-  }
-
-  ///Create constraint
-
-  ///\relates LpBase::Constr
-  ///
-  inline LpBase::Constr operator<=(const LpBase::Expr &e,
-                                   const LpBase::Expr &f) {
-    return LpBase::Constr(0, f - e, LpBase::INF);
-  }
-
-  ///Create constraint
-
-  ///\relates LpBase::Constr
-  ///
-  inline LpBase::Constr operator<=(const LpBase::Value &e,
-                                   const LpBase::Expr &f) {
-    return LpBase::Constr(e, f, LpBase::NaN);
-  }
-
-  ///Create constraint
-
-  ///\relates LpBase::Constr
-  ///
-  inline LpBase::Constr operator<=(const LpBase::Expr &e,
-                                   const LpBase::Value &f) {
-    return LpBase::Constr(- LpBase::INF, e, f);
-  }
-
-  ///Create constraint
-
-  ///\relates LpBase::Constr
-  ///
-  inline LpBase::Constr operator>=(const LpBase::Expr &e,
-                                   const LpBase::Expr &f) {
-    return LpBase::Constr(0, e - f, LpBase::INF);
-  }
-
-
-  ///Create constraint
-
-  ///\relates LpBase::Constr
-  ///
-  inline LpBase::Constr operator>=(const LpBase::Value &e,
-                                   const LpBase::Expr &f) {
-    return LpBase::Constr(LpBase::NaN, f, e);
-  }
-
-
-  ///Create constraint
-
-  ///\relates LpBase::Constr
-  ///
-  inline LpBase::Constr operator>=(const LpBase::Expr &e,
-                                   const LpBase::Value &f) {
-    return LpBase::Constr(f, e, LpBase::INF);
-  }
-
-  ///Create constraint
-
-  ///\relates LpBase::Constr
-  ///
-  inline LpBase::Constr operator==(const LpBase::Expr &e,
-                                   const LpBase::Value &f) {
-    return LpBase::Constr(f, e, f);
-  }
-
-  ///Create constraint
-
-  ///\relates LpBase::Constr
-  ///
-  inline LpBase::Constr operator==(const LpBase::Expr &e,
-                                   const LpBase::Expr &f) {
-    return LpBase::Constr(0, f - e, 0);
-  }
-
-  ///Create constraint
-
-  ///\relates LpBase::Constr
-  ///
-  inline LpBase::Constr operator<=(const LpBase::Value &n,
-                                   const LpBase::Constr &c) {
-    LpBase::Constr tmp(c);
-    LEMON_ASSERT(isNaN(tmp.lowerBound()), "Wrong LP constraint");
-    tmp.lowerBound()=n;
-    return tmp;
-  }
-  ///Create constraint
-
-  ///\relates LpBase::Constr
-  ///
-  inline LpBase::Constr operator<=(const LpBase::Constr &c,
-                                   const LpBase::Value &n)
-  {
-    LpBase::Constr tmp(c);
-    LEMON_ASSERT(isNaN(tmp.upperBound()), "Wrong LP constraint");
-    tmp.upperBound()=n;
-    return tmp;
-  }
-
-  ///Create constraint
-
-  ///\relates LpBase::Constr
-  ///
-  inline LpBase::Constr operator>=(const LpBase::Value &n,
-                                   const LpBase::Constr &c) {
-    LpBase::Constr tmp(c);
-    LEMON_ASSERT(isNaN(tmp.upperBound()), "Wrong LP constraint");
-    tmp.upperBound()=n;
-    return tmp;
-  }
-  ///Create constraint
-
-  ///\relates LpBase::Constr
-  ///
-  inline LpBase::Constr operator>=(const LpBase::Constr &c,
-                                   const LpBase::Value &n)
-  {
-    LpBase::Constr tmp(c);
-    LEMON_ASSERT(isNaN(tmp.lowerBound()), "Wrong LP constraint");
-    tmp.lowerBound()=n;
-    return tmp;
-  }
-
-  ///Addition
-
-  ///\relates LpBase::DualExpr
-  ///
-  inline LpBase::DualExpr operator+(const LpBase::DualExpr &a,
-                                    const LpBase::DualExpr &b) {
-    LpBase::DualExpr tmp(a);
-    tmp+=b;
-    return tmp;
-  }
-  ///Substraction
-
-  ///\relates LpBase::DualExpr
-  ///
-  inline LpBase::DualExpr operator-(const LpBase::DualExpr &a,
-                                    const LpBase::DualExpr &b) {
-    LpBase::DualExpr tmp(a);
-    tmp-=b;
-    return tmp;
-  }
-  ///Multiply with constant
-
-  ///\relates LpBase::DualExpr
-  ///
-  inline LpBase::DualExpr operator*(const LpBase::DualExpr &a,
-                                    const LpBase::Value &b) {
-    LpBase::DualExpr tmp(a);
-    tmp*=b;
-    return tmp;
-  }
-
-  ///Multiply with constant
-
-  ///\relates LpBase::DualExpr
-  ///
-  inline LpBase::DualExpr operator*(const LpBase::Value &a,
-                                    const LpBase::DualExpr &b) {
-    LpBase::DualExpr tmp(b);
-    tmp*=a;
-    return tmp;
-  }
-  ///Divide with constant
-
-  ///\relates LpBase::DualExpr
-  ///
-  inline LpBase::DualExpr operator/(const LpBase::DualExpr &a,
-                                    const LpBase::Value &b) {
-    LpBase::DualExpr tmp(a);
-    tmp/=b;
-    return tmp;
-  }
-
-  /// \ingroup lp_group
-  ///
-  /// \brief Common base class for LP solvers
-  ///
-  /// This class is an abstract base class for LP solvers. This class
-  /// provides a full interface for set and modify an LP problem,
-  /// solve it and retrieve the solution. You can use one of the
-  /// descendants as a concrete implementation, or the \c Lp
-  /// default LP solver. However, if you would like to handle LP
-  /// solvers as reference or pointer in a generic way, you can use
-  /// this class directly.
-  class LpSolver : virtual public LpBase {
-  public:
-
-    /// The problem types for primal and dual problems
-    enum ProblemType {
-      /// = 0. Feasible solution hasn't been found (but may exist).
-      UNDEFINED = 0,
-      /// = 1. The problem has no feasible solution.
-      INFEASIBLE = 1,
-      /// = 2. Feasible solution found.
-      FEASIBLE = 2,
-      /// = 3. Optimal solution exists and found.
-      OPTIMAL = 3,
-      /// = 4. The cost function is unbounded.
-      UNBOUNDED = 4
-    };
-
-    ///The basis status of variables
-    enum VarStatus {
-      /// The variable is in the basis
-      BASIC,
-      /// The variable is free, but not basic
-      FREE,
-      /// The variable has active lower bound
-      LOWER,
-      /// The variable has active upper bound
-      UPPER,
-      /// The variable is non-basic and fixed
-      FIXED
-    };
-
-  protected:
-
-    virtual SolveExitStatus _solve() = 0;
-
-    virtual Value _getPrimal(int i) const = 0;
-    virtual Value _getDual(int i) const = 0;
-
-    virtual Value _getPrimalRay(int i) const = 0;
-    virtual Value _getDualRay(int i) const = 0;
-
-    virtual Value _getPrimalValue() const = 0;
-
-    virtual VarStatus _getColStatus(int i) const = 0;
-    virtual VarStatus _getRowStatus(int i) const = 0;
-
-    virtual ProblemType _getPrimalType() const = 0;
-    virtual ProblemType _getDualType() const = 0;
-
-  public:
-
-    ///Allocate a new LP problem instance
-    virtual LpSolver* newSolver() const = 0;
-    ///Make a copy of the LP problem
-    virtual LpSolver* cloneSolver() const = 0;
-
-    ///\name Solve the LP
-
-    ///@{
-
-    ///\e Solve the LP problem at hand
-    ///
-    ///\return The result of the optimization procedure. Possible
-    ///values and their meanings can be found in the documentation of
-    ///\ref SolveExitStatus.
-    SolveExitStatus solve() { return _solve(); }
-
-    ///@}
-
-    ///\name Obtain the Solution
-
-    ///@{
-
-    /// The type of the primal problem
-    ProblemType primalType() const {
-      return _getPrimalType();
-    }
-
-    /// The type of the dual problem
-    ProblemType dualType() const {
-      return _getDualType();
-    }
-
-    /// Return the primal value of the column
-
-    /// Return the primal value of the column.
-    /// \pre The problem is solved.
-    Value primal(Col c) const { return _getPrimal(cols(id(c))); }
-
-    /// Return the primal value of the expression
-
-    /// Return the primal value of the expression, i.e. the dot
-    /// product of the primal solution and the expression.
-    /// \pre The problem is solved.
-    Value primal(const Expr& e) const {
-      double res = *e;
-      for (Expr::ConstCoeffIt c(e); c != INVALID; ++c) {
-        res += *c * primal(c);
-      }
-      return res;
-    }
-    /// 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
-    /// negative objective value in case of minimization, and positive
-    /// objective value for maximization. If there is such solution,
-    /// that proofs the unsolvability of the dual problem, and if a
-    /// feasible primal solution exists, then the unboundness of
-    /// primal problem.
-    ///
-    /// \pre The problem is solved and the dual problem is infeasible.
-    /// \note Some solvers does not provide primal ray calculation
-    /// functions.
-    Value primalRay(Col c) const { return _getPrimalRay(cols(id(c))); }
-
-    /// Return the dual value of the row
-
-    /// Return the dual value of the row.
-    /// \pre The problem is solved.
-    Value dual(Row r) const { return _getDual(rows(id(r))); }
-
-    /// Return the dual value of the dual expression
-
-    /// Return the dual value of the dual expression, i.e. the dot
-    /// product of the dual solution and the dual expression.
-    /// \pre The problem is solved.
-    Value dual(const DualExpr& e) const {
-      double res = 0.0;
-      for (DualExpr::ConstCoeffIt r(e); r != INVALID; ++r) {
-        res += *r * dual(r);
-      }
-      return res;
-    }
-
-    /// 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
-    /// coefficients in the primal problem), and we looking for a
-    /// ositive objective value. If there is such solution, that
-    /// proofs the unsolvability of the primal problem, and if a
-    /// feasible dual solution exists, then the unboundness of
-    /// dual problem.
-    ///
-    /// \pre The problem is solved and the primal problem is infeasible.
-    /// \note Some solvers does not provide dual ray calculation
-    /// functions.
-    Value dualRay(Row r) const { return _getDualRay(rows(id(r))); }
-
-    /// Return the basis status of the column
-
-    /// \see VarStatus
-    VarStatus colStatus(Col c) const { return _getColStatus(cols(id(c))); }
-
-    /// Return the basis status of the row
-
-    /// \see VarStatus
-    VarStatus rowStatus(Row r) const { return _getRowStatus(rows(id(r))); }
-
-    ///The value of the objective function
-
-    ///\return
-    ///- \ref INF or -\ref INF means either infeasibility or unboundedness
-    /// of the primal problem, depending on whether we minimize or maximize.
-    ///- \ref NaN if no primal solution is found.
-    ///- The (finite) objective value if an optimal solution is found.
-    Value primal() const { return _getPrimalValue()+obj_const_comp;}
-    ///@}
-
-  protected:
-
-  };
-
-
-  /// \ingroup lp_group
-  ///
-  /// \brief Common base class for MIP solvers
-  ///
-  /// This class is an abstract base class for MIP solvers. This class
-  /// provides a full interface for set and modify an MIP problem,
-  /// solve it and retrieve the solution. You can use one of the
-  /// descendants as a concrete implementation, or the \c Lp
-  /// default MIP solver. However, if you would like to handle MIP
-  /// solvers as reference or pointer in a generic way, you can use
-  /// this class directly.
-  class MipSolver : virtual public LpBase {
-  public:
-
-    /// The problem types for MIP problems
-    enum ProblemType {
-      /// = 0. Feasible solution hasn't been found (but may exist).
-      UNDEFINED = 0,
-      /// = 1. The problem has no feasible solution.
-      INFEASIBLE = 1,
-      /// = 2. Feasible solution found.
-      FEASIBLE = 2,
-      /// = 3. Optimal solution exists and found.
-      OPTIMAL = 3,
-      /// = 4. The cost function is unbounded.
-      ///The Mip or at least the relaxed problem is unbounded.
-      UNBOUNDED = 4
-    };
-
-    ///Allocate a new MIP problem instance
-    virtual MipSolver* newSolver() const = 0;
-    ///Make a copy of the MIP problem
-    virtual MipSolver* cloneSolver() const = 0;
-
-    ///\name Solve the MIP
-
-    ///@{
-
-    /// Solve the MIP problem at hand
-    ///
-    ///\return The result of the optimization procedure. Possible
-    ///values and their meanings can be found in the documentation of
-    ///\ref SolveExitStatus.
-    SolveExitStatus solve() { return _solve(); }
-
-    ///@}
-
-    ///\name Set Column Type
-    ///@{
-
-    ///Possible variable (column) types (e.g. real, integer, binary etc.)
-    enum ColTypes {
-      /// = 0. Continuous variable (default).
-      REAL = 0,
-      /// = 1. Integer variable.
-      INTEGER = 1
-    };
-
-    ///Sets the type of the given column to the given type
-
-    ///Sets the type of the given column to the given type.
-    ///
-    void colType(Col c, ColTypes col_type) {
-      _setColType(cols(id(c)),col_type);
-    }
-
-    ///Gives back the type of the column.
-
-    ///Gives back the type of the column.
-    ///
-    ColTypes colType(Col c) const {
-      return _getColType(cols(id(c)));
-    }
-    ///@}
-
-    ///\name Obtain the Solution
-
-    ///@{
-
-    /// The type of the MIP problem
-    ProblemType type() const {
-      return _getType();
-    }
-
-    /// Return the value of the row in the solution
-
-    ///  Return the value of the row in the solution.
-    /// \pre The problem is solved.
-    Value sol(Col c) const { return _getSol(cols(id(c))); }
-
-    /// Return the value of the expression in the solution
-
-    /// Return the value of the expression in the solution, i.e. the
-    /// dot product of the solution and the expression.
-    /// \pre The problem is solved.
-    Value sol(const Expr& e) const {
-      double res = *e;
-      for (Expr::ConstCoeffIt c(e); c != INVALID; ++c) {
-        res += *c * sol(c);
-      }
-      return res;
-    }
-    ///The value of the objective function
-
-    ///\return
-    ///- \ref INF or -\ref INF means either infeasibility or unboundedness
-    /// of the problem, depending on whether we minimize or maximize.
-    ///- \ref NaN if no primal solution is found.
-    ///- The (finite) objective value if an optimal solution is found.
-    Value solValue() const { return _getSolValue()+obj_const_comp;}
-    ///@}
-
-  protected:
-
-    virtual SolveExitStatus _solve() = 0;
-    virtual ColTypes _getColType(int col) const = 0;
-    virtual void _setColType(int col, ColTypes col_type) = 0;
-    virtual ProblemType _getType() const = 0;
-    virtual Value _getSol(int i) const = 0;
-    virtual Value _getSolValue() const = 0;
-
-  };
-
-
-
-} //namespace lemon
-
-#endif //LEMON_LP_BASE_H
Index: mon/lp_skeleton.cc
===================================================================
--- lemon/lp_skeleton.cc	(revision 956)
+++ 	(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 <lemon/lp_skeleton.h>
-
-///\file
-///\brief A skeleton file to implement LP solver interfaces
-namespace lemon {
-
-  int SkeletonSolverBase::_addCol()
-  {
-    return ++col_num;
-  }
-
-  int SkeletonSolverBase::_addRow()
-  {
-    return ++row_num;
-  }
-
-  int SkeletonSolverBase::_addRow(Value, ExprIterator, ExprIterator, Value)
-  {
-    return ++row_num;
-  }
-
-  void SkeletonSolverBase::_eraseCol(int) {}
-  void SkeletonSolverBase::_eraseRow(int) {}
-
-  void SkeletonSolverBase::_getColName(int, std::string &) const {}
-  void SkeletonSolverBase::_setColName(int, const std::string &) {}
-  int SkeletonSolverBase::_colByName(const std::string&) const { return -1; }
-
-  void SkeletonSolverBase::_getRowName(int, std::string &) const {}
-  void SkeletonSolverBase::_setRowName(int, const std::string &) {}
-  int SkeletonSolverBase::_rowByName(const std::string&) const { return -1; }
-
-  void SkeletonSolverBase::_setRowCoeffs(int, ExprIterator, ExprIterator) {}
-  void SkeletonSolverBase::_getRowCoeffs(int, InsertIterator) const {}
-
-  void SkeletonSolverBase::_setColCoeffs(int, ExprIterator, ExprIterator) {}
-  void SkeletonSolverBase::_getColCoeffs(int, InsertIterator) const {}
-
-  void SkeletonSolverBase::_setCoeff(int, int, Value) {}
-  SkeletonSolverBase::Value SkeletonSolverBase::_getCoeff(int, int) const
-  { return 0; }
-
-  void SkeletonSolverBase::_setColLowerBound(int, Value) {}
-  SkeletonSolverBase::Value SkeletonSolverBase::_getColLowerBound(int) const
-  {  return 0; }
-
-  void SkeletonSolverBase::_setColUpperBound(int, Value) {}
-  SkeletonSolverBase::Value SkeletonSolverBase::_getColUpperBound(int) const
-  {  return 0; }
-
-  void SkeletonSolverBase::_setRowLowerBound(int, Value) {}
-  SkeletonSolverBase::Value SkeletonSolverBase::_getRowLowerBound(int) const
-  {  return 0; }
-
-  void SkeletonSolverBase::_setRowUpperBound(int, Value) {}
-  SkeletonSolverBase::Value SkeletonSolverBase::_getRowUpperBound(int) const
-  {  return 0; }
-
-  void SkeletonSolverBase::_setObjCoeffs(ExprIterator, ExprIterator) {}
-  void SkeletonSolverBase::_getObjCoeffs(InsertIterator) const {};
-
-  void SkeletonSolverBase::_setObjCoeff(int, Value) {}
-  SkeletonSolverBase::Value SkeletonSolverBase::_getObjCoeff(int) const
-  {  return 0; }
-
-  void SkeletonSolverBase::_setSense(Sense) {}
-  SkeletonSolverBase::Sense SkeletonSolverBase::_getSense() const
-  { return MIN; }
-
-  void SkeletonSolverBase::_clear() {
-    row_num = col_num = 0;
-  }
-
-  void SkeletonSolverBase::_messageLevel(MessageLevel) {}
-
-  LpSkeleton::SolveExitStatus LpSkeleton::_solve() { return SOLVED; }
-
-  LpSkeleton::Value LpSkeleton::_getPrimal(int) const { return 0; }
-  LpSkeleton::Value LpSkeleton::_getDual(int) const { return 0; }
-  LpSkeleton::Value LpSkeleton::_getPrimalValue() const { return 0; }
-
-  LpSkeleton::Value LpSkeleton::_getPrimalRay(int) const { return 0; }
-  LpSkeleton::Value LpSkeleton::_getDualRay(int) const { return 0; }
-
-  LpSkeleton::ProblemType LpSkeleton::_getPrimalType() const
-  { return UNDEFINED; }
-
-  LpSkeleton::ProblemType LpSkeleton::_getDualType() const
-  { return UNDEFINED; }
-
-  LpSkeleton::VarStatus LpSkeleton::_getColStatus(int) const
-  { return BASIC; }
-
-  LpSkeleton::VarStatus LpSkeleton::_getRowStatus(int) const
-  { return BASIC; }
-
-  LpSkeleton* LpSkeleton::newSolver() const
-  { return static_cast<LpSkeleton*>(0); }
-
-  LpSkeleton* LpSkeleton::cloneSolver() const
-  { return static_cast<LpSkeleton*>(0); }
-
-  const char* LpSkeleton::_solverName() const { return "LpSkeleton"; }
-
-  MipSkeleton::SolveExitStatus MipSkeleton::_solve()
-  { return SOLVED; }
-
-  MipSkeleton::Value MipSkeleton::_getSol(int) const { return 0; }
-  MipSkeleton::Value MipSkeleton::_getSolValue() const { return 0; }
-
-  MipSkeleton::ProblemType MipSkeleton::_getType() const
-  { return UNDEFINED; }
-
-  MipSkeleton* MipSkeleton::newSolver() const
-  { return static_cast<MipSkeleton*>(0); }
-
-  MipSkeleton* MipSkeleton::cloneSolver() const
-  { return static_cast<MipSkeleton*>(0); }
-
-  const char* MipSkeleton::_solverName() const { return "MipSkeleton"; }
-
-} //namespace lemon
-
Index: mon/lp_skeleton.h
===================================================================
--- lemon/lp_skeleton.h	(revision 956)
+++ 	(revision )
@@ -1,229 +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_LP_SKELETON_H
-#define LEMON_LP_SKELETON_H
-
-#include <lemon/lp_base.h>
-
-///\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.
-namespace lemon {
-
-  ///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.
-  class SkeletonSolverBase : public virtual LpBase {
-    int col_num,row_num;
-
-  protected:
-
-    SkeletonSolverBase()
-      : col_num(-1), row_num(-1) {}
-
-    /// \e
-    virtual int _addCol();
-    /// \e
-    virtual int _addRow();
-    /// \e
-    virtual int _addRow(Value l, ExprIterator b, ExprIterator e, Value u);
-    /// \e
-    virtual void _eraseCol(int i);
-    /// \e
-    virtual void _eraseRow(int i);
-
-    /// \e
-    virtual void _getColName(int col, std::string& name) const;
-    /// \e
-    virtual void _setColName(int col, const std::string& name);
-    /// \e
-    virtual int _colByName(const std::string& name) const;
-
-    /// \e
-    virtual void _getRowName(int row, std::string& name) const;
-    /// \e
-    virtual void _setRowName(int row, const std::string& name);
-    /// \e
-    virtual int _rowByName(const std::string& name) const;
-
-    /// \e
-    virtual void _setRowCoeffs(int i, ExprIterator b, ExprIterator e);
-    /// \e
-    virtual void _getRowCoeffs(int i, InsertIterator b) const;
-    /// \e
-    virtual void _setColCoeffs(int i, ExprIterator b, ExprIterator e);
-    /// \e
-    virtual void _getColCoeffs(int i, InsertIterator b) const;
-
-    /// Set one element of the coefficient matrix
-    virtual void _setCoeff(int row, int col, Value value);
-
-    /// Get one element of the coefficient matrix
-    virtual Value _getCoeff(int row, int col) const;
-
-    /// The lower bound of a variable (column) have to be given by an
-    /// extended number of type Value, i.e. a finite number of type
-    /// Value or -\ref INF.
-    virtual void _setColLowerBound(int i, Value value);
-    /// \e
-
-    /// The lower bound of a variable (column) is an
-    /// extended number of type Value, i.e. a finite number of type
-    /// Value or -\ref INF.
-    virtual Value _getColLowerBound(int i) const;
-
-    /// The upper bound of a variable (column) have to be given by an
-    /// extended number of type Value, i.e. a finite number of type
-    /// Value or \ref INF.
-    virtual void _setColUpperBound(int i, Value value);
-    /// \e
-
-    /// The upper bound of a variable (column) is an
-    /// extended number of type Value, i.e. a finite number of type
-    /// Value or \ref INF.
-    virtual Value _getColUpperBound(int i) const;
-
-    /// The lower bound of a constraint (row) have to be given by an
-    /// extended number of type Value, i.e. a finite number of type
-    /// Value or -\ref INF.
-    virtual void _setRowLowerBound(int i, Value value);
-    /// \e
-
-    /// The lower bound of a constraint (row) is an
-    /// extended number of type Value, i.e. a finite number of type
-    /// Value or -\ref INF.
-    virtual Value _getRowLowerBound(int i) const;
-
-    /// The upper bound of a constraint (row) have to be given by an
-    /// extended number of type Value, i.e. a finite number of type
-    /// Value or \ref INF.
-    virtual void _setRowUpperBound(int i, Value value);
-    /// \e
-
-    /// The upper bound of a constraint (row) is an
-    /// extended number of type Value, i.e. a finite number of type
-    /// Value or \ref INF.
-    virtual Value _getRowUpperBound(int i) const;
-
-    /// \e
-    virtual void _setObjCoeffs(ExprIterator b, ExprIterator e);
-    /// \e
-    virtual void _getObjCoeffs(InsertIterator b) const;
-
-    /// \e
-    virtual void _setObjCoeff(int i, Value obj_coef);
-    /// \e
-    virtual Value _getObjCoeff(int i) const;
-
-    ///\e
-    virtual void _setSense(Sense);
-    ///\e
-    virtual Sense _getSense() const;
-
-    ///\e
-    virtual void _clear();
-
-    ///\e
-    virtual void _messageLevel(MessageLevel);
-  };
-
-  /// \brief Skeleton class for an LP solver interface
-  ///
-  ///This class does nothing, but it can serve as a skeleton when
-  ///implementing an interface to new solvers.
-
-  ///\ingroup lp_group
-  class LpSkeleton : public LpSolver, public SkeletonSolverBase {
-  public:
-    ///\e
-    LpSkeleton() : LpSolver(), SkeletonSolverBase() {}
-    ///\e
-    virtual LpSkeleton* newSolver() const;
-    ///\e
-    virtual LpSkeleton* cloneSolver() const;
-  protected:
-
-    ///\e
-    virtual SolveExitStatus _solve();
-
-    ///\e
-    virtual Value _getPrimal(int i) const;
-    ///\e
-    virtual Value _getDual(int i) const;
-
-    ///\e
-    virtual Value _getPrimalValue() const;
-
-    ///\e
-    virtual Value _getPrimalRay(int i) const;
-    ///\e
-    virtual Value _getDualRay(int i) const;
-
-    ///\e
-    virtual ProblemType _getPrimalType() const;
-    ///\e
-    virtual ProblemType _getDualType() const;
-
-    ///\e
-    virtual VarStatus _getColStatus(int i) const;
-    ///\e
-    virtual VarStatus _getRowStatus(int i) const;
-
-    ///\e
-    virtual const char* _solverName() const;
-
-  };
-
-  /// \brief Skeleton class for a MIP solver interface
-  ///
-  ///This class does nothing, but it can serve as a skeleton when
-  ///implementing an interface to new solvers.
-  ///\ingroup lp_group
-  class MipSkeleton : public MipSolver, public SkeletonSolverBase {
-  public:
-    ///\e
-    MipSkeleton() : MipSolver(), SkeletonSolverBase() {}
-    ///\e
-    virtual MipSkeleton* newSolver() const;
-    ///\e
-    virtual MipSkeleton* cloneSolver() const;
-
-  protected:
-    ///\e
-    virtual SolveExitStatus _solve();
-
-    ///\e
-    virtual Value _getSol(int i) const;
-
-    ///\e
-    virtual Value _getSolValue() const;
-
-    ///\e
-    virtual ProblemType _getType() const;
-
-    ///\e
-    virtual const char* _solverName() const;
-  };
-
-} //namespace lemon
-
-#endif
Index: lemon/maps.h
===================================================================
--- lemon/maps.h	(revision 956)
+++ lemon/maps.h	(revision 314)
@@ -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).
@@ -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
@@ -63,8 +64,7 @@
   class NullMap : public MapBase<K, V> {
   public:
-    ///\e
-    typedef K Key;
-    ///\e
-    typedef V Value;
+    typedef MapBase<K, V> Parent;
+    typedef typename Parent::Key Key;
+    typedef typename Parent::Value Value;
 
     /// Gives back a default constructed element.
@@ -90,5 +90,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.
   ///
@@ -103,8 +103,7 @@
     V _value;
   public:
-    ///\e
-    typedef K Key;
-    ///\e
-    typedef V Value;
+    typedef MapBase<K, V> Parent;
+    typedef typename Parent::Key Key;
+    typedef typename Parent::Value Value;
 
     /// Default constructor
@@ -159,5 +158,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.
   ///
@@ -170,8 +169,7 @@
   class ConstMap<K, Const<V, v> > : public MapBase<K, V> {
   public:
-    ///\e
-    typedef K Key;
-    ///\e
-    typedef V Value;
+    typedef MapBase<K, V> Parent;
+    typedef typename Parent::Key Key;
+    typedef typename Parent::Value Value;
 
     /// Constructor.
@@ -205,8 +203,7 @@
   class IdentityMap : public MapBase<T, T> {
   public:
-    ///\e
-    typedef T Key;
-    ///\e
-    typedef T Value;
+    typedef MapBase<T, T> Parent;
+    typedef typename Parent::Key Key;
+    typedef typename Parent::Value Value;
 
     /// Gives back the given value without any modification.
@@ -231,7 +228,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.
   ///
@@ -249,8 +246,9 @@
   public:
 
+    typedef MapBase<int, V> Parent;
     /// Key type
-    typedef int Key;
+    typedef typename Parent::Key Key;
     /// Value type
-    typedef V Value;
+    typedef typename Parent::Value Value;
     /// Reference type
     typedef typename Vector::reference Reference;
@@ -341,5 +339,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,12 +347,12 @@
   /// 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.
   ///
   /// The simplest way of using this map is through the sparseMap()
   /// function.
-  template <typename K, typename V, typename Comp = std::less<K> >
+  template <typename K, typename V, typename Compare = std::less<K> >
   class SparseMap : public MapBase<K, V> {
     template <typename K1, typename V1, typename C1>
@@ -362,8 +360,9 @@
   public:
 
+    typedef MapBase<K, V> Parent;
     /// Key type
-    typedef K Key;
+    typedef typename Parent::Key Key;
     /// Value type
-    typedef V Value;
+    typedef typename Parent::Value Value;
     /// Reference type
     typedef Value& Reference;
@@ -375,5 +374,5 @@
   private:
 
-    typedef std::map<K, V, Comp> Map;
+    typedef std::map<K, V, Compare> Map;
     Map _map;
     Value _value;
@@ -491,13 +490,12 @@
     const M2 &_m2;
   public:
-    ///\e
-    typedef typename M2::Key Key;
-    ///\e
-    typedef typename M1::Value Value;
+    typedef MapBase<typename M2::Key, typename M1::Value> Parent;
+    typedef typename Parent::Key Key;
+    typedef typename Parent::Value Value;
 
     /// Constructor
     ComposeMap(const M1 &m1, const M2 &m2) : _m1(m1), _m2(m2) {}
 
-    ///\e
+    /// \e
     typename MapTraits<M1>::ConstReturnValue
     operator[](const Key &k) const { return _m1[_m2[k]]; }
@@ -548,13 +546,12 @@
     F _f;
   public:
-    ///\e
-    typedef typename M1::Key Key;
-    ///\e
-    typedef V Value;
+    typedef MapBase<typename M1::Key, V> Parent;
+    typedef typename Parent::Key Key;
+    typedef typename Parent::Value Value;
 
     /// Constructor
     CombineMap(const M1 &m1, const M2 &m2, const F &f = F())
       : _m1(m1), _m2(m2), _f(f) {}
-    ///\e
+    /// \e
     Value operator[](const Key &k) const { return _f(_m1[k],_m2[k]); }
   };
@@ -619,12 +616,11 @@
     F _f;
   public:
-    ///\e
-    typedef K Key;
-    ///\e
-    typedef V Value;
+    typedef MapBase<K, V> Parent;
+    typedef typename Parent::Key Key;
+    typedef typename Parent::Value Value;
 
     /// Constructor
     FunctorToMap(const F &f = F()) : _f(f) {}
-    ///\e
+    /// \e
     Value operator[](const Key &k) const { return _f(k); }
   };
@@ -674,17 +670,16 @@
     const M &_m;
   public:
-    ///\e
-    typedef typename M::Key Key;
-    ///\e
-    typedef typename M::Value Value;
-
-    typedef typename M::Key argument_type;
-    typedef typename M::Value result_type;
+    typedef MapBase<typename M::Key, typename M::Value> Parent;
+    typedef typename Parent::Key Key;
+    typedef typename Parent::Value Value;
+
+    typedef typename Parent::Key argument_type;
+    typedef typename Parent::Value result_type;
 
     /// Constructor
     MapToFunctor(const M &m) : _m(m) {}
-    ///\e
+    /// \e
     Value operator()(const Key &k) const { return _m[k]; }
-    ///\e
+    /// \e
     Value operator[](const Key &k) const { return _m[k]; }
   };
@@ -707,5 +702,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()
@@ -715,8 +710,7 @@
     const M &_m;
   public:
-    ///\e
-    typedef typename M::Key Key;
-    ///\e
-    typedef V Value;
+    typedef MapBase<typename M::Key, V> Parent;
+    typedef typename Parent::Key Key;
+    typedef typename Parent::Value Value;
 
     /// Constructor
@@ -726,5 +720,5 @@
     ConvertMap(const M &m) : _m(m) {}
 
-    ///\e
+    /// \e
     Value operator[](const Key &k) const { return _m[k]; }
   };
@@ -758,8 +752,7 @@
     M2 &_m2;
   public:
-    ///\e
-    typedef typename M1::Key Key;
-    ///\e
-    typedef typename M1::Value Value;
+    typedef MapBase<typename M1::Key, typename M1::Value> Parent;
+    typedef typename Parent::Key Key;
+    typedef typename Parent::Value Value;
 
     /// Constructor
@@ -805,12 +798,11 @@
     const M2 &_m2;
   public:
-    ///\e
-    typedef typename M1::Key Key;
-    ///\e
-    typedef typename M1::Value Value;
+    typedef MapBase<typename M1::Key, typename M1::Value> Parent;
+    typedef typename Parent::Key Key;
+    typedef typename Parent::Value Value;
 
     /// Constructor
     AddMap(const M1 &m1, const M2 &m2) : _m1(m1), _m2(m2) {}
-    ///\e
+    /// \e
     Value operator[](const Key &k) const { return _m1[k]+_m2[k]; }
   };
@@ -854,12 +846,11 @@
     const M2 &_m2;
   public:
-    ///\e
-    typedef typename M1::Key Key;
-    ///\e
-    typedef typename M1::Value Value;
+    typedef MapBase<typename M1::Key, typename M1::Value> Parent;
+    typedef typename Parent::Key Key;
+    typedef typename Parent::Value Value;
 
     /// Constructor
     SubMap(const M1 &m1, const M2 &m2) : _m1(m1), _m2(m2) {}
-    ///\e
+    /// \e
     Value operator[](const Key &k) const { return _m1[k]-_m2[k]; }
   };
@@ -904,12 +895,11 @@
     const M2 &_m2;
   public:
-    ///\e
-    typedef typename M1::Key Key;
-    ///\e
-    typedef typename M1::Value Value;
+    typedef MapBase<typename M1::Key, typename M1::Value> Parent;
+    typedef typename Parent::Key Key;
+    typedef typename Parent::Value Value;
 
     /// Constructor
     MulMap(const M1 &m1,const M2 &m2) : _m1(m1), _m2(m2) {}
-    ///\e
+    /// \e
     Value operator[](const Key &k) const { return _m1[k]*_m2[k]; }
   };
@@ -953,12 +943,11 @@
     const M2 &_m2;
   public:
-    ///\e
-    typedef typename M1::Key Key;
-    ///\e
-    typedef typename M1::Value Value;
+    typedef MapBase<typename M1::Key, typename M1::Value> Parent;
+    typedef typename Parent::Key Key;
+    typedef typename Parent::Value Value;
 
     /// Constructor
     DivMap(const M1 &m1,const M2 &m2) : _m1(m1), _m2(m2) {}
-    ///\e
+    /// \e
     Value operator[](const Key &k) const { return _m1[k]/_m2[k]; }
   };
@@ -1004,8 +993,7 @@
     C _v;
   public:
-    ///\e
-    typedef typename M::Key Key;
-    ///\e
-    typedef typename M::Value Value;
+    typedef MapBase<typename M::Key, typename M::Value> Parent;
+    typedef typename Parent::Key Key;
+    typedef typename Parent::Value Value;
 
     /// Constructor
@@ -1015,5 +1003,5 @@
     /// \param v The constant value.
     ShiftMap(const M &m, const C &v) : _m(m), _v(v) {}
-    ///\e
+    /// \e
     Value operator[](const Key &k) const { return _m[k]+_v; }
   };
@@ -1035,8 +1023,7 @@
     C _v;
   public:
-    ///\e
-    typedef typename M::Key Key;
-    ///\e
-    typedef typename M::Value Value;
+    typedef MapBase<typename M::Key, typename M::Value> Parent;
+    typedef typename Parent::Key Key;
+    typedef typename Parent::Value Value;
 
     /// Constructor
@@ -1046,7 +1033,7 @@
     /// \param v The constant value.
     ShiftWriteMap(M &m, const C &v) : _m(m), _v(v) {}
-    ///\e
+    /// \e
     Value operator[](const Key &k) const { return _m[k]+_v; }
-    ///\e
+    /// \e
     void set(const Key &k, const Value &v) { _m.set(k, v-_v); }
   };
@@ -1107,8 +1094,7 @@
     C _v;
   public:
-    ///\e
-    typedef typename M::Key Key;
-    ///\e
-    typedef typename M::Value Value;
+    typedef MapBase<typename M::Key, typename M::Value> Parent;
+    typedef typename Parent::Key Key;
+    typedef typename Parent::Value Value;
 
     /// Constructor
@@ -1118,5 +1104,5 @@
     /// \param v The constant value.
     ScaleMap(const M &m, const C &v) : _m(m), _v(v) {}
-    ///\e
+    /// \e
     Value operator[](const Key &k) const { return _v*_m[k]; }
   };
@@ -1139,8 +1125,7 @@
     C _v;
   public:
-    ///\e
-    typedef typename M::Key Key;
-    ///\e
-    typedef typename M::Value Value;
+    typedef MapBase<typename M::Key, typename M::Value> Parent;
+    typedef typename Parent::Key Key;
+    typedef typename Parent::Value Value;
 
     /// Constructor
@@ -1150,7 +1135,7 @@
     /// \param v The constant value.
     ScaleWriteMap(M &m, const C &v) : _m(m), _v(v) {}
-    ///\e
+    /// \e
     Value operator[](const Key &k) const { return _v*_m[k]; }
-    ///\e
+    /// \e
     void set(const Key &k, const Value &v) { _m.set(k, v/_v); }
   };
@@ -1209,12 +1194,11 @@
     const M& _m;
   public:
-    ///\e
-    typedef typename M::Key Key;
-    ///\e
-    typedef typename M::Value Value;
+    typedef MapBase<typename M::Key, typename M::Value> Parent;
+    typedef typename Parent::Key Key;
+    typedef typename Parent::Value Value;
 
     /// Constructor
     NegMap(const M &m) : _m(m) {}
-    ///\e
+    /// \e
     Value operator[](const Key &k) const { return -_m[k]; }
   };
@@ -1245,14 +1229,13 @@
     M &_m;
   public:
-    ///\e
-    typedef typename M::Key Key;
-    ///\e
-    typedef typename M::Value Value;
+    typedef MapBase<typename M::Key, typename M::Value> Parent;
+    typedef typename Parent::Key Key;
+    typedef typename Parent::Value Value;
 
     /// Constructor
     NegWriteMap(M &m) : _m(m) {}
-    ///\e
+    /// \e
     Value operator[](const Key &k) const { return -_m[k]; }
-    ///\e
+    /// \e
     void set(const Key &k, const Value &v) { _m.set(k, -v); }
   };
@@ -1300,12 +1283,11 @@
     const M &_m;
   public:
-    ///\e
-    typedef typename M::Key Key;
-    ///\e
-    typedef typename M::Value Value;
+    typedef MapBase<typename M::Key, typename M::Value> Parent;
+    typedef typename Parent::Key Key;
+    typedef typename Parent::Value Value;
 
     /// Constructor
     AbsMap(const M &m) : _m(m) {}
-    ///\e
+    /// \e
     Value operator[](const Key &k) const {
       Value tmp = _m[k];
@@ -1356,8 +1338,7 @@
   class TrueMap : public MapBase<K, bool> {
   public:
-    ///\e
-    typedef K Key;
-    ///\e
-    typedef bool Value;
+    typedef MapBase<K, bool> Parent;
+    typedef typename Parent::Key Key;
+    typedef typename Parent::Value Value;
 
     /// Gives back \c true.
@@ -1394,8 +1375,7 @@
   class FalseMap : public MapBase<K, bool> {
   public:
-    ///\e
-    typedef K Key;
-    ///\e
-    typedef bool Value;
+    typedef MapBase<K, bool> Parent;
+    typedef typename Parent::Key Key;
+    typedef typename Parent::Value Value;
 
     /// Gives back \c false.
@@ -1440,12 +1420,11 @@
     const M2 &_m2;
   public:
-    ///\e
-    typedef typename M1::Key Key;
-    ///\e
-    typedef bool Value;
+    typedef MapBase<typename M1::Key, bool> Parent;
+    typedef typename Parent::Key Key;
+    typedef typename Parent::Value Value;
 
     /// Constructor
     AndMap(const M1 &m1, const M2 &m2) : _m1(m1), _m2(m2) {}
-    ///\e
+    /// \e
     Value operator[](const Key &k) const { return _m1[k]&&_m2[k]; }
   };
@@ -1489,12 +1468,11 @@
     const M2 &_m2;
   public:
-    ///\e
-    typedef typename M1::Key Key;
-    ///\e
-    typedef bool Value;
+    typedef MapBase<typename M1::Key, bool> Parent;
+    typedef typename Parent::Key Key;
+    typedef typename Parent::Value Value;
 
     /// Constructor
     OrMap(const M1 &m1, const M2 &m2) : _m1(m1), _m2(m2) {}
-    ///\e
+    /// \e
     Value operator[](const Key &k) const { return _m1[k]||_m2[k]; }
   };
@@ -1529,12 +1507,11 @@
     const M &_m;
   public:
-    ///\e
-    typedef typename M::Key Key;
-    ///\e
-    typedef bool Value;
+    typedef MapBase<typename M::Key, bool> Parent;
+    typedef typename Parent::Key Key;
+    typedef typename Parent::Value Value;
 
     /// Constructor
     NotMap(const M &m) : _m(m) {}
-    ///\e
+    /// \e
     Value operator[](const Key &k) const { return !_m[k]; }
   };
@@ -1556,14 +1533,13 @@
     M &_m;
   public:
-    ///\e
-    typedef typename M::Key Key;
-    ///\e
-    typedef bool Value;
+    typedef MapBase<typename M::Key, bool> Parent;
+    typedef typename Parent::Key Key;
+    typedef typename Parent::Value Value;
 
     /// Constructor
     NotWriteMap(M &m) : _m(m) {}
-    ///\e
+    /// \e
     Value operator[](const Key &k) const { return !_m[k]; }
-    ///\e
+    /// \e
     void set(const Key &k, bool v) { _m.set(k, !v); }
   };
@@ -1620,12 +1596,11 @@
     const M2 &_m2;
   public:
-    ///\e
-    typedef typename M1::Key Key;
-    ///\e
-    typedef bool Value;
+    typedef MapBase<typename M1::Key, bool> Parent;
+    typedef typename Parent::Key Key;
+    typedef typename Parent::Value Value;
 
     /// Constructor
     EqualMap(const M1 &m1, const M2 &m2) : _m1(m1), _m2(m2) {}
-    ///\e
+    /// \e
     Value operator[](const Key &k) const { return _m1[k]==_m2[k]; }
   };
@@ -1669,12 +1644,11 @@
     const M2 &_m2;
   public:
-    ///\e
-    typedef typename M1::Key Key;
-    ///\e
-    typedef bool Value;
+    typedef MapBase<typename M1::Key, bool> Parent;
+    typedef typename Parent::Key Key;
+    typedef typename Parent::Value Value;
 
     /// Constructor
     LessMap(const M1 &m1, const M2 &m2) : _m1(m1), _m2(m2) {}
-    ///\e
+    /// \e
     Value operator[](const Key &k) const { return _m1[k]<_m2[k]; }
   };
@@ -1732,6 +1706,6 @@
   /// function.
   ///
-  /// \tparam IT The type of the iterator.
-  /// \tparam KEY The key type of the map. The default value set
+  /// \tparam It The type of the iterator.
+  /// \tparam Ke The key type of the map. The default value set
   /// according to the iterator type should work in most cases.
   ///
@@ -1739,18 +1713,15 @@
   /// for the elements or the iterator should be an inserter iterator.
 #ifdef DOXYGEN
-  template <typename IT, typename KEY>
+  template <typename It, typename Ke>
 #else
-  template <typename IT,
-            typename KEY = typename _maps_bits::IteratorTraits<IT>::Value>
+  template <typename It,
+            typename Ke=typename _maps_bits::IteratorTraits<It>::Value>
 #endif
-  class LoggerBoolMap : public MapBase<KEY, bool> {
-  public:
-
-    ///\e
-    typedef KEY Key;
-    ///\e
+  class LoggerBoolMap {
+  public:
+    typedef It Iterator;
+
+    typedef Ke Key;
     typedef bool Value;
-    ///\e
-    typedef IT Iterator;
 
     /// Constructor
@@ -1786,13 +1757,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 +1772,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.
   ///
@@ -1815,34 +1786,21 @@
   /// @{
 
-  /// \brief Provides an immutable and unique id for each item in a graph.
-  ///
-  /// IdMap provides a unique and immutable id for each item of the
-  /// same type (\c Node, \c Arc or \c Edge) in a graph. This id is
-  ///  - \b unique: different items get different ids,
-  ///  - \b immutable: the id of an item does not change (even if you
-  ///    delete other nodes).
-  ///
-  /// Using this map you get access (i.e. can read) the inner id values of
-  /// the items stored in the graph, which is returned by the \c id()
-  /// function of the graph. This map can be inverted with its member
-  /// class \c InverseMap or with the \c operator()() member.
-  ///
-  /// \tparam GR The graph type.
-  /// \tparam K The key type of the map (\c GR::Node, \c GR::Arc or
-  /// \c GR::Edge).
-  ///
-  /// \see RangeIdMap
-  template <typename GR, typename K>
-  class IdMap : public MapBase<K, int> {
-  public:
-    /// The graph type of IdMap.
-    typedef GR Graph;
-    typedef GR Digraph;
-    /// The key type of IdMap (\c Node, \c Arc or \c Edge).
-    typedef K Item;
-    /// The key type of IdMap (\c Node, \c Arc or \c Edge).
-    typedef K Key;
-    /// The value type of IdMap.
+  /// Provides an immutable and unique id for each item in the graph.
+
+  /// The IdMap class provides a unique and immutable id for each item of the
+  /// same type (e.g. node) in the graph. This id is <ul><li>\b unique:
+  /// different items (nodes) get different ids <li>\b immutable: the id of an
+  /// item (node) does not change (even if you delete other nodes).  </ul>
+  /// Through this map you get access (i.e. can read) the inner id values of
+  /// the items stored in the graph. This map can be inverted with its member
+  /// class \c InverseMap or with the \c operator() member.
+  ///
+  template <typename _Graph, typename _Item>
+  class IdMap {
+  public:
+    typedef _Graph Graph;
     typedef int Value;
+    typedef _Item Item;
+    typedef _Item Key;
 
     /// \brief Constructor.
@@ -1856,7 +1814,7 @@
     int operator[](const Item& item) const { return _graph->id(item);}
 
-    /// \brief Gives back the \e item by its id.
-    ///
-    /// Gives back the \e item by its id.
+    /// \brief Gives back the item by its id.
+    ///
+    /// Gives back the item by its id.
     Item operator()(int id) { return _graph->fromId(id, Item()); }
 
@@ -1866,9 +1824,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 The class represents the inverse of its owner (IdMap).
+    ///
+    /// The class represents the inverse of its owner (IdMap).
     /// \see inverse()
     class InverseMap {
@@ -1885,7 +1841,8 @@
       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());}
 
@@ -1898,105 +1855,76 @@
     /// Gives back the inverse of the IdMap.
     InverseMap inverse() const { return InverseMap(*_graph);}
-  };
-
-  /// \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.
-
-  /// This class provides simple invertable graph maps.
-  /// 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.
-  ///
-  /// 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.
+
+  };
+
+
+  /// \brief General invertable graph-map type.
+
+  /// This type provides simple invertable graph-maps.
+  /// The InvertableMap wraps an arbitrary ReadWriteMap
+  /// and if a key is set to a new value then store it
+  /// in the inverse map.
+  ///
+  /// The values of the map can be accessed
+  /// with stl compatible forward iterator.
+  ///
+  /// \tparam _Graph The graph type.
+  /// \tparam _Item The item type of the graph.
+  /// \tparam _Value The value type of the map.
   ///
   /// \see IterableValueMap
-  template <typename GR, typename K, typename V>
-  class CrossRefMap
-    : protected ItemSetTraits<GR, K>::template Map<V>::Type {
+  template <typename _Graph, typename _Item, typename _Value>
+  class InvertableMap
+    : protected ItemSetTraits<_Graph, _Item>::template Map<_Value>::Type {
   private:
 
-    typedef typename ItemSetTraits<GR, K>::
-      template Map<V>::Type Map;
-
-    typedef std::multimap<V, K> Container;
+    typedef typename ItemSetTraits<_Graph, _Item>::
+    template Map<_Value>::Type Map;
+    typedef _Graph Graph;
+
+    typedef std::map<_Value, _Item> Container;
     Container _inv_map;
 
   public:
 
-    /// The graph type of CrossRefMap.
-    typedef GR Graph;
-    typedef GR Digraph;
-    /// The key type of CrossRefMap (\c Node, \c Arc or \c Edge).
-    typedef K Item;
-    /// The key type of CrossRefMap (\c Node, \c Arc or \c Edge).
-    typedef K Key;
-    /// The value type of CrossRefMap.
-    typedef V Value;
+    /// The key type of InvertableMap (Node, Arc, Edge).
+    typedef typename Map::Key Key;
+    /// The value type of the InvertableMap.
+    typedef typename Map::Value Value;
 
     /// \brief Constructor.
     ///
-    /// Construct a new CrossRefMap for the given graph.
-    explicit CrossRefMap(const Graph& graph) : Map(graph) {}
+    /// Construct a new InvertableMap for the graph.
+    ///
+    explicit InvertableMap(const Graph& graph) : Map(graph) {}
 
     /// \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
+    /// be accessed in the [beginValue, endValue) range.
+    ///
+    class ValueIterator
       : public std::iterator<std::forward_iterator_tag, Value> {
-      friend class CrossRefMap;
+      friend class InvertableMap;
     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,47 +1932,40 @@
     };
 
-    /// 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>
+    /// map can be accessed in the [beginValue, endValue)
     /// 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>
+    /// map can be accessed in the [beginValue, endValue)
     /// range.
-    ValueIt endValue() const {
-      return ValueIt(_inv_map.end());
-    }
-
-    /// \brief Sets the value associated with the given key.
-    ///
-    /// Sets the value associated with the given key.
+    ValueIterator endValue() const {
+      return ValueIterator(_inv_map.end());
+    }
+
+    /// \brief The setter function of the map.
+    ///
+    /// Sets the mapped value.
     void set(const Key& key, const Value& val) {
       Value oldval = Map::operator[](key);
-      typename Container::iterator it;
-      for (it = _inv_map.equal_range(oldval).first;
-           it != _inv_map.equal_range(oldval).second; ++it) {
-        if (it->second == key) {
-          _inv_map.erase(it);
-          break;
-        }
+      typename Container::iterator it = _inv_map.find(oldval);
+      if (it != _inv_map.end() && it->second == key) {
+        _inv_map.erase(it);
       }
-      _inv_map.insert(std::make_pair(val, key));
+      _inv_map.insert(make_pair(val, key));
       Map::set(key, val);
     }
 
-    /// \brief Returns the value associated with the given key.
-    ///
-    /// Returns the value associated with the given key.
+    /// \brief The getter function of the map.
+    ///
+    /// It gives back the value associated with the key.
     typename MapTraits<Map>::ConstReturnValue
     operator[](const Key& key) const {
@@ -2052,56 +1973,37 @@
     }
 
-    /// \brief Gives back an item by its value.
-    ///
-    /// This function gives back an item that is assigned to
-    /// the given value or \c INVALID if no such item exists.
-    /// If there are more items with the same associated value,
-    /// only one of them is returned.
-    Key operator()(const Value& val) const {
-      typename Container::const_iterator it = _inv_map.find(val);
+    /// \brief Gives back the item by its value.
+    ///
+    /// Gives back the item by its value.
+    Key operator()(const Value& key) const {
+      typename Container::const_iterator it = _inv_map.find(key);
       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);
-    }
-
   protected:
 
-    /// \brief Erase the key from the map and the inverse map.
-    ///
-    /// Erase the key from the map and the inverse map. It is called by the
+    /// \brief Erase the key from the map.
+    ///
+    /// Erase the key to the map. It is called by the
     /// \c AlterationNotifier.
     virtual void erase(const Key& key) {
       Value val = Map::operator[](key);
-      typename Container::iterator it;
-      for (it = _inv_map.equal_range(val).first;
-           it != _inv_map.equal_range(val).second; ++it) {
-        if (it->second == key) {
-          _inv_map.erase(it);
-          break;
-        }
+      typename Container::iterator it = _inv_map.find(val);
+      if (it != _inv_map.end() && it->second == key) {
+        _inv_map.erase(it);
       }
       Map::erase(key);
     }
 
-    /// \brief Erase more keys from the map and the inverse map.
-    ///
-    /// Erase more keys from the map and the inverse map. It is called by the
+    /// \brief Erase more keys from the map.
+    ///
+    /// Erase more keys from the map. It is called by the
     /// \c AlterationNotifier.
     virtual void erase(const std::vector<Key>& keys) {
       for (int i = 0; i < int(keys.size()); ++i) {
         Value val = Map::operator[](keys[i]);
-        typename Container::iterator it;
-        for (it = _inv_map.equal_range(val).first;
-             it != _inv_map.equal_range(val).second; ++it) {
-          if (it->second == keys[i]) {
-            _inv_map.erase(it);
-            break;
-          }
+        typename Container::iterator it = _inv_map.find(val);
+        if (it != _inv_map.end() && it->second == keys[i]) {
+          _inv_map.erase(it);
         }
       }
@@ -2109,7 +2011,7 @@
     }
 
-    /// \brief Clear the keys from the map and the inverse map.
-    ///
-    /// Clear the keys from the map and the inverse map. It is called by the
+    /// \brief Clear the keys from the map and inverse map.
+    ///
+    /// Clear the keys from the map and inverse map. It is called by the
     /// \c AlterationNotifier.
     virtual void clear() {
@@ -2120,28 +2022,25 @@
   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 always the item what was last assigned to the value.
     class InverseMap {
     public:
-      /// \brief Constructor
+      /// \brief Constructor of the InverseMap.
       ///
       /// Constructor of the InverseMap.
-      explicit InverseMap(const CrossRefMap& inverted)
+      explicit InverseMap(const InvertableMap& inverted)
         : _inverted(inverted) {}
 
       /// The value type of the InverseMap.
-      typedef typename CrossRefMap::Key Value;
+      typedef typename InvertableMap::Key Value;
       /// The key type of the InverseMap.
-      typedef typename CrossRefMap::Value Key;
+      typedef typename InvertableMap::Value Key;
 
       /// \brief Subscript operator.
       ///
-      /// Subscript operator. It gives back an item
-      /// that is assigned to the given value or \c INVALID
-      /// if no such item exists.
+      /// Subscript operator. It gives back always the item
+      /// what was last assigned to the value.
       Value operator[](const Key& key) const {
         return _inverted(key);
@@ -2149,10 +2048,10 @@
 
     private:
-      const CrossRefMap& _inverted;
+      const InvertableMap& _inverted;
     };
 
-    /// \brief Gives back the inverse of the map.
-    ///
-    /// Gives back the inverse of the CrossRefMap.
+    /// \brief It gives back the just readable inverse map.
+    ///
+    /// It gives back the just readable inverse map.
     InverseMap inverse() const {
       return InverseMap(*this);
@@ -2161,47 +2060,39 @@
   };
 
-  /// \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
-  /// \c Edge) in a graph. This id is
-  ///  - \b unique: different items get different ids,
-  ///  - \b continuous: the range of the ids is the set of integers
-  ///    between 0 and \c n-1, where \c n is the number of the items of
-  ///    this type (\c Node, \c Arc or \c Edge).
-  ///  - So, the ids can change when deleting an item of the same type.
-  ///
-  /// Thus this id is not (necessarily) the same as what can get using
-  /// the \c id() function of the graph or \ref IdMap.
-  /// This map can be inverted with its member class \c InverseMap,
-  /// or with the \c operator()() member.
-  ///
-  /// \tparam GR The graph type.
-  /// \tparam K The key type of the map (\c GR::Node, \c GR::Arc or
-  /// \c GR::Edge).
-  ///
-  /// \see IdMap
-  template <typename GR, typename K>
-  class RangeIdMap
-    : protected ItemSetTraits<GR, K>::template Map<int>::Type {
-
-    typedef typename ItemSetTraits<GR, K>::template Map<int>::Type Map;
-
-  public:
-    /// The graph type of RangeIdMap.
-    typedef GR Graph;
-    typedef GR Digraph;
-    /// The key type of RangeIdMap (\c Node, \c Arc or \c Edge).
-    typedef K Item;
-    /// The key type of RangeIdMap (\c Node, \c Arc or \c Edge).
-    typedef K Key;
-    /// The value type of RangeIdMap.
-    typedef int Value;
+  /// \brief Provides a mutable, continuous and unique descriptor for each
+  /// item in the graph.
+  ///
+  /// The DescriptorMap class provides a unique and continuous (but mutable)
+  /// descriptor (id) for each item of the same type (e.g. node) in the
+  /// graph. This id is <ul><li>\b unique: different items (nodes) get
+  /// different ids <li>\b continuous: the range of the ids is the set of
+  /// integers between 0 and \c n-1, where \c n is the number of the items of
+  /// this type (e.g. nodes) (so the id of a node can change if you delete an
+  /// other node, i.e. this id is mutable).  </ul> This map can be inverted
+  /// with its member class \c InverseMap, or with the \c operator() member.
+  ///
+  /// \tparam _Graph The graph class the \c DescriptorMap belongs to.
+  /// \tparam _Item The Item is the Key of the Map. It may be Node, Arc or
+  /// Edge.
+  template <typename _Graph, typename _Item>
+  class DescriptorMap
+    : protected ItemSetTraits<_Graph, _Item>::template Map<int>::Type {
+
+    typedef _Item Item;
+    typedef typename ItemSetTraits<_Graph, _Item>::template Map<int>::Type Map;
+
+  public:
+    /// The graph class of DescriptorMap.
+    typedef _Graph Graph;
+
+    /// The key type of DescriptorMap (Node, Arc, Edge).
+    typedef typename Map::Key Key;
+    /// The value type of DescriptorMap.
+    typedef typename Map::Value Value;
 
     /// \brief Constructor.
     ///
-    /// Constructor.
-    explicit RangeIdMap(const Graph& gr) : Map(gr) {
+    /// Constructor for descriptor map.
+    explicit DescriptorMap(const Graph& _graph) : Map(_graph) {
       Item it;
       const typename Map::Notifier* nf = Map::notifier();
@@ -2214,5 +2105,5 @@
   protected:
 
-    /// \brief Adds a new key to the map.
+    /// \brief Add a new key to the map.
     ///
     /// Add a new key to the map. It is called by the
@@ -2304,14 +2195,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 descriptor of the item.
+    ///
+    /// Gives back the mutable and unique \e descriptor of the map.
     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 by its descriptor.
+    ///
+    /// Gives back th item by its descriptor.
     Item operator()(int id) const {
       return _inv_map[id];
@@ -2324,28 +2215,25 @@
 
   public:
-
-    /// \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.
+    /// \brief The inverse map type of DescriptorMap.
+    ///
+    /// The inverse map type of DescriptorMap.
     class InverseMap {
     public:
-      /// \brief Constructor
+      /// \brief Constructor of the InverseMap.
       ///
       /// Constructor of the InverseMap.
-      explicit InverseMap(const RangeIdMap& inverted)
+      explicit InverseMap(const DescriptorMap& inverted)
         : _inverted(inverted) {}
 
 
       /// The value type of the InverseMap.
-      typedef typename RangeIdMap::Key Value;
+      typedef typename DescriptorMap::Key Value;
       /// The key type of the InverseMap.
-      typedef typename RangeIdMap::Value Key;
+      typedef typename DescriptorMap::Value Key;
 
       /// \brief Subscript operator.
       ///
       /// Subscript operator. It gives back the item
-      /// that the given \e range \e id currently belongs to.
+      /// that the descriptor belongs to currently.
       Value operator[](const Key& key) const {
         return _inverted(key);
@@ -2360,10 +2248,10 @@
 
     private:
-      const RangeIdMap& _inverted;
+      const DescriptorMap& _inverted;
     };
 
     /// \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);
@@ -2371,954 +2259,32 @@
   };
 
-  /// \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 {
+  /// \brief Returns the source of the given arc.
+  ///
+  /// The SourceMap gives back the source Node of the given arc.
+  /// \see TargetMap
+  template <typename Digraph>
+  class SourceMap {
+  public:
+
+    typedef typename Digraph::Node Value;
+    typedef typename Digraph::Arc Key;
+
+    /// \brief Constructor
+    ///
+    /// Constructor
+    /// \param digraph The digraph that the map belongs to.
+    explicit SourceMap(const Digraph& digraph) : _digraph(digraph) {}
+
+    /// \brief The subscript operator.
+    ///
+    /// The subscript operator.
+    /// \param arc The arc
+    /// \return The source of the arc
+    Value operator[](const Key& arc) const {
+      return _digraph.source(arc);
+    }
+
   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);
-      unlace(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;
-  };
-
-  /// \brief Map of the source nodes of arcs in a digraph.
-  ///
-  /// SourceMap provides access for the source node of each arc in a digraph,
-  /// which is returned by the \c source() function of the digraph.
-  /// \tparam GR The digraph type.
-  /// \see TargetMap
-  template <typename GR>
-  class SourceMap {
-  public:
-
-    /// The key type (the \c Arc type of the digraph).
-    typedef typename GR::Arc Key;
-    /// The value type (the \c Node type of the digraph).
-    typedef typename GR::Node Value;
-
-    /// \brief Constructor
-    ///
-    /// Constructor.
-    /// \param digraph The digraph that the map belongs to.
-    explicit SourceMap(const GR& digraph) : _graph(digraph) {}
-
-    /// \brief Returns the source node of the given arc.
-    ///
-    /// Returns the source node of the given arc.
-    Value operator[](const Key& arc) const {
-      return _graph.source(arc);
-    }
-
-  private:
-    const GR& _graph;
+    const Digraph& _digraph;
   };
 
@@ -3327,39 +2293,37 @@
   /// This function just returns an \c SourceMap class.
   /// \relates SourceMap
-  template <typename GR>
-  inline SourceMap<GR> sourceMap(const GR& graph) {
-    return SourceMap<GR>(graph);
-  }
-
-  /// \brief Map of the target nodes of arcs in a digraph.
-  ///
-  /// TargetMap provides access for the target node of each arc in a digraph,
-  /// which is returned by the \c target() function of the digraph.
-  /// \tparam GR The digraph type.
+  template <typename Digraph>
+  inline SourceMap<Digraph> sourceMap(const Digraph& digraph) {
+    return SourceMap<Digraph>(digraph);
+  }
+
+  /// \brief Returns the target of the given arc.
+  ///
+  /// The TargetMap gives back the target Node of the given arc.
   /// \see SourceMap
-  template <typename GR>
+  template <typename Digraph>
   class TargetMap {
   public:
 
-    /// The key type (the \c Arc type of the digraph).
-    typedef typename GR::Arc Key;
-    /// The value type (the \c Node type of the digraph).
-    typedef typename GR::Node Value;
+    typedef typename Digraph::Node Value;
+    typedef typename Digraph::Arc Key;
 
     /// \brief Constructor
     ///
-    /// Constructor.
+    /// Constructor
     /// \param digraph The digraph that the map belongs to.
-    explicit TargetMap(const GR& digraph) : _graph(digraph) {}
-
-    /// \brief Returns the target node of the given arc.
-    ///
-    /// Returns the target node of the given arc.
+    explicit TargetMap(const Digraph& digraph) : _digraph(digraph) {}
+
+    /// \brief The subscript operator.
+    ///
+    /// The subscript operator.
+    /// \param e The arc
+    /// \return The target of the arc
     Value operator[](const Key& e) const {
-      return _graph.target(e);
+      return _digraph.target(e);
     }
 
   private:
-    const GR& _graph;
+    const Digraph& _digraph;
   };
 
@@ -3368,34 +2332,31 @@
   /// This function just returns a \c TargetMap class.
   /// \relates TargetMap
-  template <typename GR>
-  inline TargetMap<GR> targetMap(const GR& graph) {
-    return TargetMap<GR>(graph);
-  }
-
-  /// \brief Map of the "forward" directed arc view of edges in a graph.
-  ///
-  /// ForwardMap provides access for the "forward" directed arc view of
-  /// each edge in a graph, which is returned by the \c direct() function
-  /// of the graph with \c true parameter.
-  /// \tparam GR The graph type.
+  template <typename Digraph>
+  inline TargetMap<Digraph> targetMap(const Digraph& digraph) {
+    return TargetMap<Digraph>(digraph);
+  }
+
+  /// \brief Returns the "forward" directed arc view of an edge.
+  ///
+  /// Returns the "forward" directed arc view of an edge.
   /// \see BackwardMap
-  template <typename GR>
+  template <typename Graph>
   class ForwardMap {
   public:
 
-    /// The key type (the \c Edge type of the digraph).
-    typedef typename GR::Edge Key;
-    /// The value type (the \c Arc type of the digraph).
-    typedef typename GR::Arc Value;
+    typedef typename Graph::Arc Value;
+    typedef typename Graph::Edge Key;
 
     /// \brief Constructor
     ///
-    /// Constructor.
+    /// Constructor
     /// \param graph The graph that the map belongs to.
-    explicit ForwardMap(const GR& graph) : _graph(graph) {}
-
-    /// \brief Returns the "forward" directed arc view of the given edge.
-    ///
-    /// Returns the "forward" directed arc view of the given edge.
+    explicit ForwardMap(const Graph& graph) : _graph(graph) {}
+
+    /// \brief The subscript operator.
+    ///
+    /// The subscript operator.
+    /// \param key An edge
+    /// \return The "forward" directed arc view of edge
     Value operator[](const Key& key) const {
       return _graph.direct(key, true);
@@ -3403,5 +2364,5 @@
 
   private:
-    const GR& _graph;
+    const Graph& _graph;
   };
 
@@ -3410,34 +2371,31 @@
   /// This function just returns an \c ForwardMap class.
   /// \relates ForwardMap
-  template <typename GR>
-  inline ForwardMap<GR> forwardMap(const GR& graph) {
-    return ForwardMap<GR>(graph);
-  }
-
-  /// \brief Map of the "backward" directed arc view of edges in a graph.
-  ///
-  /// BackwardMap provides access for the "backward" directed arc view of
-  /// each edge in a graph, which is returned by the \c direct() function
-  /// of the graph with \c false parameter.
-  /// \tparam GR The graph type.
+  template <typename Graph>
+  inline ForwardMap<Graph> forwardMap(const Graph& graph) {
+    return ForwardMap<Graph>(graph);
+  }
+
+  /// \brief Returns the "backward" directed arc view of an edge.
+  ///
+  /// Returns the "backward" directed arc view of an edge.
   /// \see ForwardMap
-  template <typename GR>
+  template <typename Graph>
   class BackwardMap {
   public:
 
-    /// The key type (the \c Edge type of the digraph).
-    typedef typename GR::Edge Key;
-    /// The value type (the \c Arc type of the digraph).
-    typedef typename GR::Arc Value;
+    typedef typename Graph::Arc Value;
+    typedef typename Graph::Edge Key;
 
     /// \brief Constructor
     ///
-    /// Constructor.
+    /// Constructor
     /// \param graph The graph that the map belongs to.
-    explicit BackwardMap(const GR& graph) : _graph(graph) {}
-
-    /// \brief Returns the "backward" directed arc view of the given edge.
-    ///
-    /// Returns the "backward" directed arc view of the given edge.
+    explicit BackwardMap(const Graph& graph) : _graph(graph) {}
+
+    /// \brief The subscript operator.
+    ///
+    /// The subscript operator.
+    /// \param key An edge
+    /// \return The "backward" directed arc view of edge
     Value operator[](const Key& key) const {
       return _graph.direct(key, false);
@@ -3445,5 +2403,5 @@
 
   private:
-    const GR& _graph;
+    const Graph& _graph;
   };
 
@@ -3452,21 +2410,61 @@
   /// This function just returns a \c BackwardMap class.
   /// \relates BackwardMap
-  template <typename GR>
-  inline BackwardMap<GR> backwardMap(const GR& graph) {
-    return BackwardMap<GR>(graph);
-  }
-
-  /// \brief Map of the in-degrees of nodes in a digraph.
+  template <typename Graph>
+  inline BackwardMap<Graph> backwardMap(const Graph& graph) {
+    return BackwardMap<Graph>(graph);
+  }
+
+  /// \brief Potential difference map
+  ///
+  /// If there is an potential map on the nodes then we
+  /// can get an arc map as we get the substraction of the
+  /// values of the target and source.
+  template <typename Digraph, typename NodeMap>
+  class PotentialDifferenceMap {
+  public:
+    typedef typename Digraph::Arc Key;
+    typedef typename NodeMap::Value Value;
+
+    /// \brief Constructor
+    ///
+    /// Contructor of the map
+    explicit PotentialDifferenceMap(const Digraph& digraph,
+                                    const NodeMap& potential)
+      : _digraph(digraph), _potential(potential) {}
+
+    /// \brief Const subscription operator
+    ///
+    /// Const subscription operator
+    Value operator[](const Key& arc) const {
+      return _potential[_digraph.target(arc)] -
+        _potential[_digraph.source(arc)];
+    }
+
+  private:
+    const Digraph& _digraph;
+    const NodeMap& _potential;
+  };
+
+  /// \brief Returns a PotentialDifferenceMap.
+  ///
+  /// This function just returns a PotentialDifferenceMap.
+  /// \relates PotentialDifferenceMap
+  template <typename Digraph, typename NodeMap>
+  PotentialDifferenceMap<Digraph, NodeMap>
+  potentialDifferenceMap(const Digraph& digraph, const NodeMap& potential) {
+    return PotentialDifferenceMap<Digraph, NodeMap>(digraph, potential);
+  }
+
+  /// \brief Map of the node in-degrees.
   ///
   /// This map returns the in-degree of a node. Once it is constructed,
-  /// the degrees are stored in a standard \c NodeMap, so each query is done
+  /// the degrees are stored in a standard NodeMap, so each query is done
   /// in constant time. On the other hand, the values are updated automatically
   /// whenever the digraph changes.
   ///
-  /// \warning Besides \c addNode() and \c addArc(), a digraph structure
-  /// may provide alternative ways to modify the digraph.
-  /// The correct behavior of InDegMap is not guarantied if these additional
-  /// features are used. For example, the functions
-  /// \ref ListDigraph::changeSource() "changeSource()",
+  /// \warning Besides addNode() and addArc(), a digraph structure may provide
+  /// alternative ways to modify the digraph. The correct behavior of InDegMap
+  /// is not guarantied if these additional features are used. For example
+  /// the functions \ref ListDigraph::changeSource() "changeSource()",
   /// \ref ListDigraph::changeTarget() "changeTarget()" and
   /// \ref ListDigraph::reverseArc() "reverseArc()"
@@ -3474,18 +2472,15 @@
   ///
   /// \sa OutDegMap
-  template <typename GR>
+
+  template <typename _Digraph>
   class InDegMap
-    : protected ItemSetTraits<GR, typename GR::Arc>
+    : protected ItemSetTraits<_Digraph, typename _Digraph::Arc>
       ::ItemNotifier::ObserverBase {
 
   public:
 
-    /// The graph type of InDegMap
-    typedef GR Graph;
-    typedef GR Digraph;
-    /// The key type
+    typedef _Digraph Digraph;
+    typedef int Value;
     typedef typename Digraph::Node Key;
-    /// The value type
-    typedef int Value;
 
     typedef typename ItemSetTraits<Digraph, typename Digraph::Arc>
@@ -3529,7 +2524,7 @@
     /// \brief Constructor.
     ///
-    /// Constructor for creating an in-degree map.
-    explicit InDegMap(const Digraph& graph)
-      : _digraph(graph), _deg(graph) {
+    /// Constructor for creating in-degree map.
+    explicit InDegMap(const Digraph& digraph)
+      : _digraph(digraph), _deg(digraph) {
       Parent::attach(_digraph.notifier(typename Digraph::Arc()));
 
@@ -3539,6 +2534,4 @@
     }
 
-    /// \brief Gives back the in-degree of a Node.
-    ///
     /// Gives back the in-degree of a Node.
     int operator[](const Key& key) const {
@@ -3587,16 +2580,15 @@
   };
 
-  /// \brief Map of the out-degrees of nodes in a digraph.
+  /// \brief Map of the node out-degrees.
   ///
   /// This map returns the out-degree of a node. Once it is constructed,
-  /// the degrees are stored in a standard \c NodeMap, so each query is done
+  /// the degrees are stored in a standard NodeMap, so each query is done
   /// in constant time. On the other hand, the values are updated automatically
   /// whenever the digraph changes.
   ///
-  /// \warning Besides \c addNode() and \c addArc(), a digraph structure
-  /// may provide alternative ways to modify the digraph.
-  /// The correct behavior of OutDegMap is not guarantied if these additional
-  /// features are used. For example, the functions
-  /// \ref ListDigraph::changeSource() "changeSource()",
+  /// \warning Besides addNode() and addArc(), a digraph structure may provide
+  /// alternative ways to modify the digraph. The correct behavior of OutDegMap
+  /// is not guarantied if these additional features are used. For example
+  /// the functions \ref ListDigraph::changeSource() "changeSource()",
   /// \ref ListDigraph::changeTarget() "changeTarget()" and
   /// \ref ListDigraph::reverseArc() "reverseArc()"
@@ -3604,18 +2596,15 @@
   ///
   /// \sa InDegMap
-  template <typename GR>
+
+  template <typename _Digraph>
   class OutDegMap
-    : protected ItemSetTraits<GR, typename GR::Arc>
+    : protected ItemSetTraits<_Digraph, typename _Digraph::Arc>
       ::ItemNotifier::ObserverBase {
 
   public:
 
-    /// The graph type of OutDegMap
-    typedef GR Graph;
-    typedef GR Digraph;
-    /// The key type
+    typedef _Digraph Digraph;
+    typedef int Value;
     typedef typename Digraph::Node Key;
-    /// The value type
-    typedef int Value;
 
     typedef typename ItemSetTraits<Digraph, typename Digraph::Arc>
@@ -3657,7 +2646,7 @@
     /// \brief Constructor.
     ///
-    /// Constructor for creating an out-degree map.
-    explicit OutDegMap(const Digraph& graph)
-      : _digraph(graph), _deg(graph) {
+    /// Constructor for creating out-degree map.
+    explicit OutDegMap(const Digraph& digraph)
+      : _digraph(digraph), _deg(digraph) {
       Parent::attach(_digraph.notifier(typename Digraph::Arc()));
 
@@ -3667,6 +2656,4 @@
     }
 
-    /// \brief Gives back the out-degree of a Node.
-    ///
     /// Gives back the out-degree of a Node.
     int operator[](const Key& key) const {
@@ -3715,341 +2702,4 @@
   };
 
-  /// \brief Potential difference map
-  ///
-  /// PotentialDifferenceMap returns the difference between the potentials of
-  /// the source and target nodes of each arc in a digraph, i.e. it returns
-  /// \code
-  ///   potential[gr.target(arc)] - potential[gr.source(arc)].
-  /// \endcode
-  /// \tparam GR The digraph type.
-  /// \tparam POT A node map storing the potentials.
-  template <typename GR, typename POT>
-  class PotentialDifferenceMap {
-  public:
-    /// Key type
-    typedef typename GR::Arc Key;
-    /// Value type
-    typedef typename POT::Value Value;
-
-    /// \brief Constructor
-    ///
-    /// Contructor of the map.
-    explicit PotentialDifferenceMap(const GR& gr,
-                                    const POT& potential)
-      : _digraph(gr), _potential(potential) {}
-
-    /// \brief Returns the potential difference for the given arc.
-    ///
-    /// Returns the potential difference for the given arc, i.e.
-    /// \code
-    ///   potential[gr.target(arc)] - potential[gr.source(arc)].
-    /// \endcode
-    Value operator[](const Key& arc) const {
-      return _potential[_digraph.target(arc)] -
-        _potential[_digraph.source(arc)];
-    }
-
-  private:
-    const GR& _digraph;
-    const POT& _potential;
-  };
-
-  /// \brief Returns a PotentialDifferenceMap.
-  ///
-  /// This function just returns a PotentialDifferenceMap.
-  /// \relates PotentialDifferenceMap
-  template <typename GR, typename POT>
-  PotentialDifferenceMap<GR, POT>
-  potentialDifferenceMap(const GR& gr, const POT& potential) {
-    return PotentialDifferenceMap<GR, POT>(gr, potential);
-  }
-
-
-  /// \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: mon/matching.h
===================================================================
--- lemon/matching.h	(revision 956)
+++ 	(revision )
@@ -1,3505 +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_MATCHING_H
-#define LEMON_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/fractional_matching.h>
-
-///\ingroup matching
-///\file
-///\brief Maximum matching algorithms in general graphs.
-
-namespace lemon {
-
-  /// \ingroup matching
-  ///
-  /// \brief Maximum cardinality matching in general graphs
-  ///
-  /// 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
-  /// (the default is the empty one).
-  ///
-  /// The dual solution of the problem is a map of the nodes to
-  /// \ref MaxMatching::Status "Status", having values \c EVEN (or \c D),
-  /// \c ODD (or \c A) and \c MATCHED (or \c C) defining the Gallai-Edmonds
-  /// decomposition of the graph. The nodes in \c EVEN/D induce a subgraph
-  /// with factor-critical components, the nodes in \c ODD/A form the
-  /// canonical barrier, and the nodes in \c MATCHED/C induce a graph having
-  /// a perfect matching. The number of the factor-critical components
-  /// minus the number of barrier nodes is a lower bound on the
-  /// unmatched nodes, and the matching is optimal if and only if this bound is
-  /// tight. This decomposition can be obtained using \ref status() or
-  /// \ref statusMap() after running the algorithm.
-  ///
-  /// \tparam GR The undirected graph type the algorithm runs on.
-  template <typename GR>
-  class MaxMatching {
-  public:
-
-    /// The graph type of the algorithm
-    typedef GR Graph;
-    /// The type of the matching map
-    typedef typename Graph::template NodeMap<typename Graph::Arc>
-    MatchingMap;
-
-    ///\brief Status constants for Gallai-Edmonds decomposition.
-    ///
-    ///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
-    ///perfect matching.
-    enum Status {
-      EVEN = 1,       ///< = 1. (\c D is an alias for \c EVEN.)
-      D = 1,
-      MATCHED = 0,    ///< = 0. (\c C is an alias for \c MATCHED.)
-      C = 0,
-      ODD = -1,       ///< = -1. (\c A is an alias for \c ODD.)
-      A = -1,
-      UNMATCHED = -2  ///< = -2.
-    };
-
-    /// The type of the status map
-    typedef typename Graph::template NodeMap<Status> StatusMap;
-
-  private:
-
-    TEMPLATE_GRAPH_TYPEDEFS(Graph);
-
-    typedef UnionFindEnum<IntNodeMap> BlossomSet;
-    typedef ExtendFindEnum<IntNodeMap> TreeSet;
-    typedef RangeMap<Node> NodeIntMap;
-    typedef MatchingMap EarMap;
-    typedef std::vector<Node> NodeQueue;
-
-    const Graph& _graph;
-    MatchingMap* _matching;
-    StatusMap* _status;
-
-    EarMap* _ear;
-
-    IntNodeMap* _blossom_set_index;
-    BlossomSet* _blossom_set;
-    NodeIntMap* _blossom_rep;
-
-    IntNodeMap* _tree_set_index;
-    TreeSet* _tree_set;
-
-    NodeQueue _node_queue;
-    int _process, _postpone, _last;
-
-    int _node_num;
-
-  private:
-
-    void createStructures() {
-      _node_num = countNodes(_graph);
-      if (!_matching) {
-        _matching = new MatchingMap(_graph);
-      }
-      if (!_status) {
-        _status = new StatusMap(_graph);
-      }
-      if (!_ear) {
-        _ear = new EarMap(_graph);
-      }
-      if (!_blossom_set) {
-        _blossom_set_index = new IntNodeMap(_graph);
-        _blossom_set = new BlossomSet(*_blossom_set_index);
-      }
-      if (!_blossom_rep) {
-        _blossom_rep = new NodeIntMap(_node_num);
-      }
-      if (!_tree_set) {
-        _tree_set_index = new IntNodeMap(_graph);
-        _tree_set = new TreeSet(*_tree_set_index);
-      }
-      _node_queue.resize(_node_num);
-    }
-
-    void destroyStructures() {
-      if (_matching) {
-        delete _matching;
-      }
-      if (_status) {
-        delete _status;
-      }
-      if (_ear) {
-        delete _ear;
-      }
-      if (_blossom_set) {
-        delete _blossom_set;
-        delete _blossom_set_index;
-      }
-      if (_blossom_rep) {
-        delete _blossom_rep;
-      }
-      if (_tree_set) {
-        delete _tree_set_index;
-        delete _tree_set;
-      }
-    }
-
-    void processDense(const Node& n) {
-      _process = _postpone = _last = 0;
-      _node_queue[_last++] = n;
-
-      while (_process != _last) {
-        Node u = _node_queue[_process++];
-        for (OutArcIt a(_graph, u); a != INVALID; ++a) {
-          Node v = _graph.target(a);
-          if ((*_status)[v] == MATCHED) {
-            extendOnArc(a);
-          } else if ((*_status)[v] == UNMATCHED) {
-            augmentOnArc(a);
-            return;
-          }
-        }
-      }
-
-      while (_postpone != _last) {
-        Node u = _node_queue[_postpone++];
-
-        for (OutArcIt a(_graph, u); a != INVALID ; ++a) {
-          Node v = _graph.target(a);
-
-          if ((*_status)[v] == EVEN) {
-            if (_blossom_set->find(u) != _blossom_set->find(v)) {
-              shrinkOnEdge(a);
-            }
-          }
-
-          while (_process != _last) {
-            Node w = _node_queue[_process++];
-            for (OutArcIt b(_graph, w); b != INVALID; ++b) {
-              Node x = _graph.target(b);
-              if ((*_status)[x] == MATCHED) {
-                extendOnArc(b);
-              } else if ((*_status)[x] == UNMATCHED) {
-                augmentOnArc(b);
-                return;
-              }
-            }
-          }
-        }
-      }
-    }
-
-    void processSparse(const Node& n) {
-      _process = _last = 0;
-      _node_queue[_last++] = n;
-      while (_process != _last) {
-        Node u = _node_queue[_process++];
-        for (OutArcIt a(_graph, u); a != INVALID; ++a) {
-          Node v = _graph.target(a);
-
-          if ((*_status)[v] == EVEN) {
-            if (_blossom_set->find(u) != _blossom_set->find(v)) {
-              shrinkOnEdge(a);
-            }
-          } else if ((*_status)[v] == MATCHED) {
-            extendOnArc(a);
-          } else if ((*_status)[v] == UNMATCHED) {
-            augmentOnArc(a);
-            return;
-          }
-        }
-      }
-    }
-
-    void shrinkOnEdge(const Edge& e) {
-      Node nca = INVALID;
-
-      {
-        std::set<Node> left_set, right_set;
-
-        Node left = (*_blossom_rep)[_blossom_set->find(_graph.u(e))];
-        left_set.insert(left);
-
-        Node right = (*_blossom_rep)[_blossom_set->find(_graph.v(e))];
-        right_set.insert(right);
-
-        while (true) {
-          if ((*_matching)[left] == INVALID) break;
-          left = _graph.target((*_matching)[left]);
-          left = (*_blossom_rep)[_blossom_set->
-                                 find(_graph.target((*_ear)[left]))];
-          if (right_set.find(left) != right_set.end()) {
-            nca = left;
-            break;
-          }
-          left_set.insert(left);
-
-          if ((*_matching)[right] == INVALID) break;
-          right = _graph.target((*_matching)[right]);
-          right = (*_blossom_rep)[_blossom_set->
-                                  find(_graph.target((*_ear)[right]))];
-          if (left_set.find(right) != left_set.end()) {
-            nca = right;
-            break;
-          }
-          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]);
-              nca =(*_blossom_rep)[_blossom_set->
-                                   find(_graph.target((*_ear)[nca]))];
-            }
-          } else {
-            nca = left;
-            while (right_set.find(nca) == right_set.end()) {
-              nca = _graph.target((*_matching)[nca]);
-              nca = (*_blossom_rep)[_blossom_set->
-                                   find(_graph.target((*_ear)[nca]))];
-            }
-          }
-        }
-      }
-
-      {
-
-        Node node = _graph.u(e);
-        Arc arc = _graph.direct(e, true);
-        Node base = (*_blossom_rep)[_blossom_set->find(node)];
-
-        while (base != nca) {
-          (*_ear)[node] = arc;
-
-          Node n = node;
-          while (n != base) {
-            n = _graph.target((*_matching)[n]);
-            Arc a = (*_ear)[n];
-            n = _graph.target(a);
-            (*_ear)[n] = _graph.oppositeArc(a);
-          }
-          node = _graph.target((*_matching)[base]);
-          _tree_set->erase(base);
-          _tree_set->erase(node);
-          _blossom_set->insert(node, _blossom_set->find(base));
-          (*_status)[node] = EVEN;
-          _node_queue[_last++] = node;
-          arc = _graph.oppositeArc((*_ear)[node]);
-          node = _graph.target((*_ear)[node]);
-          base = (*_blossom_rep)[_blossom_set->find(node)];
-          _blossom_set->join(_graph.target(arc), base);
-        }
-      }
-
-      (*_blossom_rep)[_blossom_set->find(nca)] = nca;
-
-      {
-
-        Node node = _graph.v(e);
-        Arc arc = _graph.direct(e, false);
-        Node base = (*_blossom_rep)[_blossom_set->find(node)];
-
-        while (base != nca) {
-          (*_ear)[node] = arc;
-
-          Node n = node;
-          while (n != base) {
-            n = _graph.target((*_matching)[n]);
-            Arc a = (*_ear)[n];
-            n = _graph.target(a);
-            (*_ear)[n] = _graph.oppositeArc(a);
-          }
-          node = _graph.target((*_matching)[base]);
-          _tree_set->erase(base);
-          _tree_set->erase(node);
-          _blossom_set->insert(node, _blossom_set->find(base));
-          (*_status)[node] = EVEN;
-          _node_queue[_last++] = node;
-          arc = _graph.oppositeArc((*_ear)[node]);
-          node = _graph.target((*_ear)[node]);
-          base = (*_blossom_rep)[_blossom_set->find(node)];
-          _blossom_set->join(_graph.target(arc), base);
-        }
-      }
-
-      (*_blossom_rep)[_blossom_set->find(nca)] = nca;
-    }
-
-    void extendOnArc(const Arc& a) {
-      Node base = _graph.source(a);
-      Node odd = _graph.target(a);
-
-      (*_ear)[odd] = _graph.oppositeArc(a);
-      Node even = _graph.target((*_matching)[odd]);
-      (*_blossom_rep)[_blossom_set->insert(even)] = even;
-      (*_status)[odd] = ODD;
-      (*_status)[even] = EVEN;
-      int tree = _tree_set->find((*_blossom_rep)[_blossom_set->find(base)]);
-      _tree_set->insert(odd, tree);
-      _tree_set->insert(even, tree);
-      _node_queue[_last++] = even;
-
-    }
-
-    void augmentOnArc(const Arc& a) {
-      Node even = _graph.source(a);
-      Node odd = _graph.target(a);
-
-      int tree = _tree_set->find((*_blossom_rep)[_blossom_set->find(even)]);
-
-      (*_matching)[odd] = _graph.oppositeArc(a);
-      (*_status)[odd] = MATCHED;
-
-      Arc arc = (*_matching)[even];
-      (*_matching)[even] = a;
-
-      while (arc != INVALID) {
-        odd = _graph.target(arc);
-        arc = (*_ear)[odd];
-        even = _graph.target(arc);
-        (*_matching)[odd] = arc;
-        arc = (*_matching)[even];
-        (*_matching)[even] = _graph.oppositeArc((*_matching)[odd]);
-      }
-
-      for (typename TreeSet::ItemIt it(*_tree_set, tree);
-           it != INVALID; ++it) {
-        if ((*_status)[it] == ODD) {
-          (*_status)[it] = MATCHED;
-        } else {
-          int blossom = _blossom_set->find(it);
-          for (typename BlossomSet::ItemIt jt(*_blossom_set, blossom);
-               jt != INVALID; ++jt) {
-            (*_status)[jt] = MATCHED;
-          }
-          _blossom_set->eraseClass(blossom);
-        }
-      }
-      _tree_set->eraseClass(tree);
-
-    }
-
-  public:
-
-    /// \brief Constructor
-    ///
-    /// Constructor.
-    MaxMatching(const Graph& graph)
-      : _graph(graph), _matching(0), _status(0), _ear(0),
-        _blossom_set_index(0), _blossom_set(0), _blossom_rep(0),
-        _tree_set_index(0), _tree_set(0) {}
-
-    ~MaxMatching() {
-      destroyStructures();
-    }
-
-    /// \name Execution Control
-    /// The simplest way to execute the algorithm is to use the
-    /// \c run() member function.\n
-    /// If you need better control on the execution, you have to call
-    /// one of the functions \ref init(), \ref greedyInit() or
-    /// \ref matchingInit() first, then you can start the algorithm with
-    /// \ref startSparse() or \ref startDense().
-
-    ///@{
-
-    /// \brief Set the initial matching to the empty matching.
-    ///
-    /// This function sets the initial matching to the empty matching.
-    void init() {
-      createStructures();
-      for(NodeIt n(_graph); n != INVALID; ++n) {
-        (*_matching)[n] = INVALID;
-        (*_status)[n] = UNMATCHED;
-      }
-    }
-
-    /// \brief Find an initial matching in a greedy way.
-    ///
-    /// This function finds an initial matching in a greedy way.
-    void greedyInit() {
-      createStructures();
-      for (NodeIt n(_graph); n != INVALID; ++n) {
-        (*_matching)[n] = INVALID;
-        (*_status)[n] = UNMATCHED;
-      }
-      for (NodeIt n(_graph); n != INVALID; ++n) {
-        if ((*_matching)[n] == INVALID) {
-          for (OutArcIt a(_graph, n); a != INVALID ; ++a) {
-            Node v = _graph.target(a);
-            if ((*_matching)[v] == INVALID && v != n) {
-              (*_matching)[n] = a;
-              (*_status)[n] = MATCHED;
-              (*_matching)[v] = _graph.oppositeArc(a);
-              (*_status)[v] = MATCHED;
-              break;
-            }
-          }
-        }
-      }
-    }
-
-
-    /// \brief Initialize the matching from a map.
-    ///
-    /// This function initializes the matching from a \c bool valued edge
-    /// map. This map should have the property that there are no two incident
-    /// edges with \c true value, i.e. it really contains a matching.
-    /// \return \c true if the map contains a matching.
-    template <typename MatchingMap>
-    bool matchingInit(const MatchingMap& matching) {
-      createStructures();
-
-      for (NodeIt n(_graph); n != INVALID; ++n) {
-        (*_matching)[n] = INVALID;
-        (*_status)[n] = UNMATCHED;
-      }
-      for(EdgeIt e(_graph); e!=INVALID; ++e) {
-        if (matching[e]) {
-
-          Node u = _graph.u(e);
-          if ((*_matching)[u] != INVALID) return false;
-          (*_matching)[u] = _graph.direct(e, true);
-          (*_status)[u] = MATCHED;
-
-          Node v = _graph.v(e);
-          if ((*_matching)[v] != INVALID) return false;
-          (*_matching)[v] = _graph.direct(e, false);
-          (*_status)[v] = MATCHED;
-        }
-      }
-      return true;
-    }
-
-    /// \brief Start Edmonds' algorithm
-    ///
-    /// This function runs the original Edmonds' algorithm.
-    ///
-    /// \pre \ref init(), \ref greedyInit() or \ref matchingInit() must be
-    /// called before using this function.
-    void startSparse() {
-      for(NodeIt n(_graph); n != INVALID; ++n) {
-        if ((*_status)[n] == UNMATCHED) {
-          (*_blossom_rep)[_blossom_set->insert(n)] = n;
-          _tree_set->insert(n);
-          (*_status)[n] = EVEN;
-          processSparse(n);
-        }
-      }
-    }
-
-    /// \brief Start Edmonds' algorithm with a heuristic improvement
-    /// for dense graphs
-    ///
-    /// This function runs Edmonds' algorithm with a heuristic of postponing
-    /// shrinks, therefore resulting in a faster algorithm for dense graphs.
-    ///
-    /// \pre \ref init(), \ref greedyInit() or \ref matchingInit() must be
-    /// called before using this function.
-    void startDense() {
-      for(NodeIt n(_graph); n != INVALID; ++n) {
-        if ((*_status)[n] == UNMATCHED) {
-          (*_blossom_rep)[_blossom_set->insert(n)] = n;
-          _tree_set->insert(n);
-          (*_status)[n] = EVEN;
-          processDense(n);
-        }
-      }
-    }
-
-
-    /// \brief Run Edmonds' algorithm
-    ///
-    /// 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() {
-      if (countEdges(_graph) < 2 * countNodes(_graph)) {
-        greedyInit();
-        startSparse();
-      } else {
-        init();
-        startDense();
-      }
-    }
-
-    /// @}
-
-    /// \name Primal Solution
-    /// Functions to get the primal solution, i.e. the maximum matching.
-
-    /// @{
-
-    /// \brief Return the size (cardinality) of the 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 {
-      int size = 0;
-      for (NodeIt n(_graph); n != INVALID; ++n) {
-        if ((*_matching)[n] != INVALID) {
-          ++size;
-        }
-      }
-      return size / 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 current
-    /// matching.
-    bool matching(const Edge& edge) const {
-      return edge == (*_matching)[_graph.u(edge)];
-    }
-
-    /// \brief Return the matching arc (or edge) incident to the given node.
-    ///
-    /// This function returns the matching arc (or edge) incident to the
-    /// given node in the current matching or \c INVALID if the node is
-    /// not covered by the matching.
-    Arc matching(const Node& n) const {
-      return (*_matching)[n];
-    }
-
-    /// \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;
-    }
-
-    /// \brief Return the mate of the given node.
-    ///
-    /// 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 {
-      return (*_matching)[n] != INVALID ?
-        _graph.target((*_matching)[n]) : INVALID;
-    }
-
-    /// @}
-
-    /// \name Dual Solution
-    /// Functions to get the dual solution, i.e. the Gallai-Edmonds
-    /// decomposition.
-
-    /// @{
-
-    /// \brief Return the status of the given node in the Edmonds-Gallai
-    /// decomposition.
-    ///
-    /// This function returns the \ref Status "status" of the given node
-    /// in the Edmonds-Gallai decomposition.
-    Status status(const Node& n) const {
-      return (*_status)[n];
-    }
-
-    /// \brief Return a const reference to the status map, which stores
-    /// the Edmonds-Gallai decomposition.
-    ///
-    /// This function returns a const reference to a node map that stores the
-    /// \ref Status "status" of each node in the Edmonds-Gallai decomposition.
-    const StatusMap& statusMap() const {
-      return *_status;
-    }
-
-    /// \brief Return \c true if the given node is in the barrier.
-    ///
-    /// This function returns \c true if the given node is in the barrier.
-    bool barrier(const Node& n) const {
-      return (*_status)[n] == ODD;
-    }
-
-    /// @}
-
-  };
-
-  /// \ingroup matching
-  ///
-  /// \brief Weighted matching in general graphs
-  ///
-  /// This class provides an efficient implementation of Edmond's
-  /// maximum weighted matching algorithm. The implementation is based
-  /// on extensive use of priority queues and provides
-  /// \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
-  /// each node has at most one incident edge.
-  /// 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[ \sum_{e \in \gamma(B)}x_e \le \frac{\vert B \vert - 1}{2}
-      \quad \forall B\in\mathcal{O}\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$, \f$\gamma(X)\f$ is the set of edges with both ends in
-  /// \f$X\f$ and \f$\mathcal{O}\f$ is the set of odd cardinality
-  /// subsets of the nodes.
-  ///
-  /// The algorithm calculates an optimal 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 + \sum_{B \in \mathcal{O}, uv \in \gamma(B)}
-      z_B \ge w_{uv} \quad \forall uv\in E\f] */
-  /// \f[y_u \ge 0 \quad \forall u \in V\f]
-  /// \f[z_B \ge 0 \quad \forall B \in \mathcal{O}\f]
-  /** \f[\min \sum_{u \in V}y_u + \sum_{B \in \mathcal{O}}
-      \frac{\vert B \vert - 1}{2}z_B\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 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
-  /// \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 MaxWeightedMatching {
-  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 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;
-    typedef std::vector<Node> BlossomNodeList;
-
-    struct BlossomVariable {
-      int begin, end;
-      Value value;
-
-      BlossomVariable(int _begin, int _end, Value _value)
-        : begin(_begin), end(_end), value(_value) {}
-
-    };
-
-    typedef std::vector<BlossomVariable> BlossomPotential;
-
-    const Graph& _graph;
-    const WeightMap& _weight;
-
-    MatchingMap* _matching;
-
-    NodePotential* _node_potential;
-
-    BlossomPotential _blossom_potential;
-    BlossomNodeList _blossom_node_list;
-
-    int _node_num;
-    int _blossom_num;
-
-    typedef RangeMap<int> IntIntMap;
-
-    enum Status {
-      EVEN = -1, MATCHED = 0, ODD = 1
-    };
-
-    typedef HeapUnionFind<Value, IntNodeMap> BlossomSet;
-    struct BlossomData {
-      int tree;
-      Status status;
-      Arc pred, next;
-      Value pot, offset;
-      Node base;
-    };
-
-    IntNodeMap *_blossom_index;
-    BlossomSet *_blossom_set;
-    RangeMap<BlossomData>* _blossom_data;
-
-    IntNodeMap *_node_index;
-    IntArcMap *_node_heap_index;
-
-    struct NodeData {
-
-      NodeData(IntArcMap& node_heap_index)
-        : heap(node_heap_index) {}
-
-      int blossom;
-      Value pot;
-      BinHeap<Value, IntArcMap> heap;
-      std::map<int, Arc> heap_index;
-
-      int tree;
-    };
-
-    RangeMap<NodeData>* _node_data;
-
-    typedef ExtendFindEnum<IntIntMap> TreeSet;
-
-    IntIntMap *_tree_set_index;
-    TreeSet *_tree_set;
-
-    IntNodeMap *_delta1_index;
-    BinHeap<Value, IntNodeMap> *_delta1;
-
-    IntIntMap *_delta2_index;
-    BinHeap<Value, IntIntMap> *_delta2;
-
-    IntEdgeMap *_delta3_index;
-    BinHeap<Value, IntEdgeMap> *_delta3;
-
-    IntIntMap *_delta4_index;
-    BinHeap<Value, IntIntMap> *_delta4;
-
-    Value _delta_sum;
-    int _unmatched;
-
-    typedef MaxWeightedFractionalMatching<Graph, WeightMap> FractionalMatching;
-    FractionalMatching *_fractional;
-
-    void createStructures() {
-      _node_num = countNodes(_graph);
-      _blossom_num = _node_num * 3 / 2;
-
-      if (!_matching) {
-        _matching = new MatchingMap(_graph);
-      }
-
-      if (!_node_potential) {
-        _node_potential = new NodePotential(_graph);
-      }
-
-      if (!_blossom_set) {
-        _blossom_index = new IntNodeMap(_graph);
-        _blossom_set = new BlossomSet(*_blossom_index);
-        _blossom_data = new RangeMap<BlossomData>(_blossom_num);
-      } else if (_blossom_data->size() != _blossom_num) {
-        delete _blossom_data;
-        _blossom_data = new RangeMap<BlossomData>(_blossom_num);
-      }
-
-      if (!_node_index) {
-        _node_index = new IntNodeMap(_graph);
-        _node_heap_index = new IntArcMap(_graph);
-        _node_data = new RangeMap<NodeData>(_node_num,
-                                            NodeData(*_node_heap_index));
-      } else {
-        delete _node_data;
-        _node_data = new RangeMap<NodeData>(_node_num,
-                                            NodeData(*_node_heap_index));
-      }
-
-      if (!_tree_set) {
-        _tree_set_index = new IntIntMap(_blossom_num);
-        _tree_set = new TreeSet(*_tree_set_index);
-      } else {
-        _tree_set_index->resize(_blossom_num);
-      }
-
-      if (!_delta1) {
-        _delta1_index = new IntNodeMap(_graph);
-        _delta1 = new BinHeap<Value, IntNodeMap>(*_delta1_index);
-      }
-
-      if (!_delta2) {
-        _delta2_index = new IntIntMap(_blossom_num);
-        _delta2 = new BinHeap<Value, IntIntMap>(*_delta2_index);
-      } else {
-        _delta2_index->resize(_blossom_num);
-      }
-
-      if (!_delta3) {
-        _delta3_index = new IntEdgeMap(_graph);
-        _delta3 = new BinHeap<Value, IntEdgeMap>(*_delta3_index);
-      }
-
-      if (!_delta4) {
-        _delta4_index = new IntIntMap(_blossom_num);
-        _delta4 = new BinHeap<Value, IntIntMap>(*_delta4_index);
-      } else {
-        _delta4_index->resize(_blossom_num);
-      }
-    }
-
-    void destroyStructures() {
-      if (_matching) {
-        delete _matching;
-      }
-      if (_node_potential) {
-        delete _node_potential;
-      }
-      if (_blossom_set) {
-        delete _blossom_index;
-        delete _blossom_set;
-        delete _blossom_data;
-      }
-
-      if (_node_index) {
-        delete _node_index;
-        delete _node_heap_index;
-        delete _node_data;
-      }
-
-      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;
-      }
-      if (_delta4) {
-        delete _delta4_index;
-        delete _delta4;
-      }
-    }
-
-    void matchedToEven(int blossom, int tree) {
-      if (_delta2->state(blossom) == _delta2->IN_HEAP) {
-        _delta2->erase(blossom);
-      }
-
-      if (!_blossom_set->trivial(blossom)) {
-        (*_blossom_data)[blossom].pot -=
-          2 * (_delta_sum - (*_blossom_data)[blossom].offset);
-      }
-
-      for (typename BlossomSet::ItemIt n(*_blossom_set, blossom);
-           n != INVALID; ++n) {
-
-        _blossom_set->increase(n, std::numeric_limits<Value>::max());
-        int ni = (*_node_index)[n];
-
-        (*_node_data)[ni].heap.clear();
-        (*_node_data)[ni].heap_index.clear();
-
-        (*_node_data)[ni].pot += _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;
-              }
-            } 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 {
-
-            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;
-              }
-            } 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 alternatePath(int even, int tree) {
-      int odd;
-
-      evenToMatched(even, tree);
-      (*_blossom_data)[even].status = MATCHED;
-
-      while ((*_blossom_data)[even].pred != INVALID) {
-        odd = _blossom_set->find(_graph.target((*_blossom_data)[even].pred));
-        (*_blossom_data)[odd].status = MATCHED;
-        oddToMatched(odd);
-        (*_blossom_data)[odd].next = (*_blossom_data)[odd].pred;
-
-        even = _blossom_set->find(_graph.target((*_blossom_data)[odd].pred));
-        (*_blossom_data)[even].status = MATCHED;
-        evenToMatched(even, tree);
-        (*_blossom_data)[even].next =
-          _graph.oppositeArc((*_blossom_data)[odd].pred);
-      }
-
-    }
-
-    void destroyTree(int tree) {
-      for (TreeSet::ItemIt b(*_tree_set, tree); b != INVALID; ++b) {
-        if ((*_blossom_data)[b].status == EVEN) {
-          (*_blossom_data)[b].status = MATCHED;
-          evenToMatched(b, tree);
-        } else if ((*_blossom_data)[b].status == ODD) {
-          (*_blossom_data)[b].status = MATCHED;
-          oddToMatched(b);
-        }
-      }
-      _tree_set->eraseClass(tree);
-    }
-
-
-    void unmatchNode(const Node& node) {
-      int blossom = _blossom_set->find(node);
-      int tree = _tree_set->find(blossom);
-
-      alternatePath(blossom, tree);
-      destroyTree(tree);
-
-      (*_blossom_data)[blossom].base = node;
-      (*_blossom_data)[blossom].next = INVALID;
-    }
-
-    void augmentOnEdge(const Edge& edge) {
-
-      int left = _blossom_set->find(_graph.u(edge));
-      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);
-
-      (*_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);
-    }
-
-    void extendOnArc(const Arc& arc) {
-      int base = _blossom_set->find(_graph.target(arc));
-      int tree = _tree_set->find(base);
-
-      int odd = _blossom_set->find(_graph.source(arc));
-      _tree_set->insert(odd, tree);
-      (*_blossom_data)[odd].status = ODD;
-      matchedToOdd(odd);
-      (*_blossom_data)[odd].pred = arc;
-
-      int even = _blossom_set->find(_graph.target((*_blossom_data)[odd].next));
-      (*_blossom_data)[even].pred = (*_blossom_data)[even].next;
-      _tree_set->insert(even, tree);
-      (*_blossom_data)[even].status = EVEN;
-      matchedToEven(even, tree);
-    }
-
-    void shrinkOnEdge(const Edge& edge, int tree) {
-      int nca = -1;
-      std::vector<int> left_path, right_path;
-
-      {
-        std::set<int> left_set, right_set;
-        int left = _blossom_set->find(_graph.u(edge));
-        left_path.push_back(left);
-        left_set.insert(left);
-
-        int right = _blossom_set->find(_graph.v(edge));
-        right_path.push_back(right);
-        right_set.insert(right);
-
-        while (true) {
-
-          if ((*_blossom_data)[left].pred == INVALID) break;
-
-          left =
-            _blossom_set->find(_graph.target((*_blossom_data)[left].pred));
-          left_path.push_back(left);
-          left =
-            _blossom_set->find(_graph.target((*_blossom_data)[left].pred));
-          left_path.push_back(left);
-
-          left_set.insert(left);
-
-          if (right_set.find(left) != right_set.end()) {
-            nca = left;
-            break;
-          }
-
-          if ((*_blossom_data)[right].pred == INVALID) break;
-
-          right =
-            _blossom_set->find(_graph.target((*_blossom_data)[right].pred));
-          right_path.push_back(right);
-          right =
-            _blossom_set->find(_graph.target((*_blossom_data)[right].pred));
-          right_path.push_back(right);
-
-          right_set.insert(right);
-
-          if (left_set.find(right) != left_set.end()) {
-            nca = right;
-            break;
-          }
-
-        }
-
-        if (nca == -1) {
-          if ((*_blossom_data)[left].pred == INVALID) {
-            nca = right;
-            while (left_set.find(nca) == left_set.end()) {
-              nca =
-                _blossom_set->find(_graph.target((*_blossom_data)[nca].pred));
-              right_path.push_back(nca);
-              nca =
-                _blossom_set->find(_graph.target((*_blossom_data)[nca].pred));
-              right_path.push_back(nca);
-            }
-          } else {
-            nca = left;
-            while (right_set.find(nca) == right_set.end()) {
-              nca =
-                _blossom_set->find(_graph.target((*_blossom_data)[nca].pred));
-              left_path.push_back(nca);
-              nca =
-                _blossom_set->find(_graph.target((*_blossom_data)[nca].pred));
-              left_path.push_back(nca);
-            }
-          }
-        }
-      }
-
-      std::vector<int> subblossoms;
-      Arc prev;
-
-      prev = _graph.direct(edge, true);
-      for (int i = 0; left_path[i] != nca; i += 2) {
-        subblossoms.push_back(left_path[i]);
-        (*_blossom_data)[left_path[i]].next = prev;
-        _tree_set->erase(left_path[i]);
-
-        subblossoms.push_back(left_path[i + 1]);
-        (*_blossom_data)[left_path[i + 1]].status = EVEN;
-        oddToEven(left_path[i + 1], tree);
-        _tree_set->erase(left_path[i + 1]);
-        prev = _graph.oppositeArc((*_blossom_data)[left_path[i + 1]].pred);
-      }
-
-      int k = 0;
-      while (right_path[k] != nca) ++k;
-
-      subblossoms.push_back(nca);
-      (*_blossom_data)[nca].next = prev;
-
-      for (int i = k - 2; i >= 0; i -= 2) {
-        subblossoms.push_back(right_path[i + 1]);
-        (*_blossom_data)[right_path[i + 1]].status = EVEN;
-        oddToEven(right_path[i + 1], tree);
-        _tree_set->erase(right_path[i + 1]);
-
-        (*_blossom_data)[right_path[i + 1]].next =
-          (*_blossom_data)[right_path[i + 1]].pred;
-
-        subblossoms.push_back(right_path[i]);
-        _tree_set->erase(right_path[i]);
-      }
-
-      int surface =
-        _blossom_set->join(subblossoms.begin(), subblossoms.end());
-
-      for (int i = 0; i < int(subblossoms.size()); ++i) {
-        if (!_blossom_set->trivial(subblossoms[i])) {
-          (*_blossom_data)[subblossoms[i]].pot += 2 * _delta_sum;
-        }
-        (*_blossom_data)[subblossoms[i]].status = MATCHED;
-      }
-
-      (*_blossom_data)[surface].pot = -2 * _delta_sum;
-      (*_blossom_data)[surface].offset = 0;
-      (*_blossom_data)[surface].status = EVEN;
-      (*_blossom_data)[surface].pred = (*_blossom_data)[nca].pred;
-      (*_blossom_data)[surface].next = (*_blossom_data)[nca].pred;
-
-      _tree_set->insert(surface, tree);
-      _tree_set->erase(nca);
-    }
-
-    void splitBlossom(int blossom) {
-      Arc next = (*_blossom_data)[blossom].next;
-      Arc pred = (*_blossom_data)[blossom].pred;
-
-      int tree = _tree_set->find(blossom);
-
-      (*_blossom_data)[blossom].status = MATCHED;
-      oddToMatched(blossom);
-      if (_delta2->state(blossom) == _delta2->IN_HEAP) {
-        _delta2->erase(blossom);
-      }
-
-      std::vector<int> subblossoms;
-      _blossom_set->split(blossom, std::back_inserter(subblossoms));
-
-      Value offset = (*_blossom_data)[blossom].offset;
-      int b = _blossom_set->find(_graph.source(pred));
-      int d = _blossom_set->find(_graph.source(next));
-
-      int ib = -1, id = -1;
-      for (int i = 0; i < int(subblossoms.size()); ++i) {
-        if (subblossoms[i] == b) ib = i;
-        if (subblossoms[i] == d) id = i;
-
-        (*_blossom_data)[subblossoms[i]].offset = offset;
-        if (!_blossom_set->trivial(subblossoms[i])) {
-          (*_blossom_data)[subblossoms[i]].pot -= 2 * offset;
-        }
-        if (_blossom_set->classPrio(subblossoms[i]) !=
-            std::numeric_limits<Value>::max()) {
-          _delta2->push(subblossoms[i],
-                        _blossom_set->classPrio(subblossoms[i]) -
-                        (*_blossom_data)[subblossoms[i]].offset);
-        }
-      }
-
-      if (id > ib ? ((id - ib) % 2 == 0) : ((ib - id) % 2 == 1)) {
-        for (int i = (id + 1) % subblossoms.size();
-             i != ib; i = (i + 2) % subblossoms.size()) {
-          int sb = subblossoms[i];
-          int tb = subblossoms[(i + 1) % subblossoms.size()];
-          (*_blossom_data)[sb].next =
-            _graph.oppositeArc((*_blossom_data)[tb].next);
-        }
-
-        for (int i = ib; i != id; i = (i + 2) % subblossoms.size()) {
-          int sb = subblossoms[i];
-          int tb = subblossoms[(i + 1) % subblossoms.size()];
-          int ub = subblossoms[(i + 2) % subblossoms.size()];
-
-          (*_blossom_data)[sb].status = ODD;
-          matchedToOdd(sb);
-          _tree_set->insert(sb, tree);
-          (*_blossom_data)[sb].pred = pred;
-          (*_blossom_data)[sb].next =
-            _graph.oppositeArc((*_blossom_data)[tb].next);
-
-          pred = (*_blossom_data)[ub].next;
-
-          (*_blossom_data)[tb].status = EVEN;
-          matchedToEven(tb, tree);
-          _tree_set->insert(tb, tree);
-          (*_blossom_data)[tb].pred = (*_blossom_data)[tb].next;
-        }
-
-        (*_blossom_data)[subblossoms[id]].status = ODD;
-        matchedToOdd(subblossoms[id]);
-        _tree_set->insert(subblossoms[id], tree);
-        (*_blossom_data)[subblossoms[id]].next = next;
-        (*_blossom_data)[subblossoms[id]].pred = pred;
-
-      } else {
-
-        for (int i = (ib + 1) % subblossoms.size();
-             i != id; i = (i + 2) % subblossoms.size()) {
-          int sb = subblossoms[i];
-          int tb = subblossoms[(i + 1) % subblossoms.size()];
-          (*_blossom_data)[sb].next =
-            _graph.oppositeArc((*_blossom_data)[tb].next);
-        }
-
-        for (int i = id; i != ib; i = (i + 2) % subblossoms.size()) {
-          int sb = subblossoms[i];
-          int tb = subblossoms[(i + 1) % subblossoms.size()];
-          int ub = subblossoms[(i + 2) % subblossoms.size()];
-
-          (*_blossom_data)[sb].status = ODD;
-          matchedToOdd(sb);
-          _tree_set->insert(sb, tree);
-          (*_blossom_data)[sb].next = next;
-          (*_blossom_data)[sb].pred =
-            _graph.oppositeArc((*_blossom_data)[tb].next);
-
-          (*_blossom_data)[tb].status = EVEN;
-          matchedToEven(tb, tree);
-          _tree_set->insert(tb, tree);
-          (*_blossom_data)[tb].pred =
-            (*_blossom_data)[tb].next =
-            _graph.oppositeArc((*_blossom_data)[ub].next);
-          next = (*_blossom_data)[ub].next;
-        }
-
-        (*_blossom_data)[subblossoms[ib]].status = ODD;
-        matchedToOdd(subblossoms[ib]);
-        _tree_set->insert(subblossoms[ib], tree);
-        (*_blossom_data)[subblossoms[ib]].next = next;
-        (*_blossom_data)[subblossoms[ib]].pred = pred;
-      }
-      _tree_set->erase(blossom);
-    }
-
-    void extractBlossom(int blossom, const Node& base, const Arc& matching) {
-      if (_blossom_set->trivial(blossom)) {
-        int bi = (*_node_index)[base];
-        Value pot = (*_node_data)[bi].pot;
-
-        (*_matching)[base] = matching;
-        _blossom_node_list.push_back(base);
-        (*_node_potential)[base] = pot;
-      } else {
-
-        Value pot = (*_blossom_data)[blossom].pot;
-        int bn = _blossom_node_list.size();
-
-        std::vector<int> subblossoms;
-        _blossom_set->split(blossom, std::back_inserter(subblossoms));
-        int b = _blossom_set->find(base);
-        int ib = -1;
-        for (int i = 0; i < int(subblossoms.size()); ++i) {
-          if (subblossoms[i] == b) { ib = i; break; }
-        }
-
-        for (int i = 1; i < int(subblossoms.size()); i += 2) {
-          int sb = subblossoms[(ib + i) % subblossoms.size()];
-          int tb = subblossoms[(ib + i + 1) % subblossoms.size()];
-
-          Arc m = (*_blossom_data)[tb].next;
-          extractBlossom(sb, _graph.target(m), _graph.oppositeArc(m));
-          extractBlossom(tb, _graph.source(m), m);
-        }
-        extractBlossom(subblossoms[ib], base, matching);
-
-        int en = _blossom_node_list.size();
-
-        _blossom_potential.push_back(BlossomVariable(bn, en, pot));
-      }
-    }
-
-    void extractMatching() {
-      std::vector<int> blossoms;
-      for (typename BlossomSet::ClassIt c(*_blossom_set); c != INVALID; ++c) {
-        blossoms.push_back(c);
-      }
-
-      for (int i = 0; i < int(blossoms.size()); ++i) {
-        if ((*_blossom_data)[blossoms[i]].next != INVALID) {
-
-          Value offset = (*_blossom_data)[blossoms[i]].offset;
-          (*_blossom_data)[blossoms[i]].pot += 2 * offset;
-          for (typename BlossomSet::ItemIt n(*_blossom_set, blossoms[i]);
-               n != INVALID; ++n) {
-            (*_node_data)[(*_node_index)[n]].pot -= offset;
-          }
-
-          Arc matching = (*_blossom_data)[blossoms[i]].next;
-          Node base = _graph.source(matching);
-          extractBlossom(blossoms[i], base, matching);
-        } else {
-          Node base = (*_blossom_data)[blossoms[i]].base;
-          extractBlossom(blossoms[i], base, INVALID);
-        }
-      }
-    }
-
-  public:
-
-    /// \brief Constructor
-    ///
-    /// Constructor.
-    MaxWeightedMatching(const Graph& graph, const WeightMap& weight)
-      : _graph(graph), _weight(weight), _matching(0),
-        _node_potential(0), _blossom_potential(), _blossom_node_list(),
-        _node_num(0), _blossom_num(0),
-
-        _blossom_index(0), _blossom_set(0), _blossom_data(0),
-        _node_index(0), _node_heap_index(0), _node_data(0),
-        _tree_set_index(0), _tree_set(0),
-
-        _delta1_index(0), _delta1(0),
-        _delta2_index(0), _delta2(0),
-        _delta3_index(0), _delta3(0),
-        _delta4_index(0), _delta4(0),
-
-        _delta_sum(), _unmatched(0),
-
-        _fractional(0)
-    {}
-
-    ~MaxWeightedMatching() {
-      destroyStructures();
-      if (_fractional) {
-        delete _fractional;
-      }
-    }
-
-    /// \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();
-
-      _blossom_node_list.clear();
-      _blossom_potential.clear();
-
-      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 = _node_num;
-
-      _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 max = 0;
-        for (OutArcIt e(_graph, n); e != INVALID; ++e) {
-          if (_graph.target(e) == n) continue;
-          if ((dualScale * _weight[e]) / 2 > max) {
-            max = (dualScale * _weight[e]) / 2;
-          }
-        }
-        (*_node_index)[n] = index;
-        (*_node_data)[index].heap_index.clear();
-        (*_node_data)[index].heap.clear();
-        (*_node_data)[index].pot = max;
-        _delta1->push(n, max);
-        int blossom =
-          _blossom_set->insert(n, std::numeric_limits<Value>::max());
-
-        _tree_set->insert(blossom);
-
-        (*_blossom_data)[blossom].status = EVEN;
-        (*_blossom_data)[blossom].pred = INVALID;
-        (*_blossom_data)[blossom].next = INVALID;
-        (*_blossom_data)[blossom].pot = 0;
-        (*_blossom_data)[blossom].offset = 0;
-        ++index;
-      }
-      for (EdgeIt e(_graph); e != INVALID; ++e) {
-        int si = (*_node_index)[_graph.u(e)];
-        int ti = (*_node_index)[_graph.v(e)];
-        if (_graph.u(e) != _graph.v(e)) {
-          _delta3->push(e, ((*_node_data)[si].pot + (*_node_data)[ti].pot -
-                            dualScale * _weight[e]) / 2);
-        }
-      }
-    }
-
-    /// \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.
-    void start() {
-      enum OpType {
-        D1, D2, D3, D4
-      };
-
-      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();
-
-        Value d4 = !_delta4->empty() ?
-          _delta4->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; }
-        if (d4 < _delta_sum) { _delta_sum = d4; ot = D4; }
-
-        switch (ot) {
-        case D1:
-          {
-            Node n = _delta1->top();
-            unmatchNode(n);
-            --_unmatched;
-          }
-          break;
-        case D2:
-          {
-            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);
-            }
-          }
-          break;
-        case D3:
-          {
-            Edge e = _delta3->top();
-
-            int left_blossom = _blossom_set->find(_graph.u(e));
-            int right_blossom = _blossom_set->find(_graph.v(e));
-
-            if (left_blossom == right_blossom) {
-              _delta3->pop();
-            } else {
-              int left_tree = _tree_set->find(left_blossom);
-              int right_tree = _tree_set->find(right_blossom);
-
-              if (left_tree == right_tree) {
-                shrinkOnEdge(e, left_tree);
-              } else {
-                augmentOnEdge(e);
-                _unmatched -= 2;
-              }
-            }
-          } break;
-        case D4:
-          splitBlossom(_delta4->top());
-          break;
-        }
-      }
-      extractMatching();
-    }
-
-    /// \brief Run the algorithm.
-    ///
-    /// This method runs the \c %MaxWeightedMatching algorithm.
-    ///
-    /// \note mwm.run() is just a shortcut of the following code.
-    /// \code
-    ///   mwm.fractionalInit();
-    ///   mwm.start();
-    /// \endcode
-    void run() {
-      fractionalInit();
-      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.
-    ///
-    /// \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 / 2;
-    }
-
-    /// \brief Return the size (cardinality) of the matching.
-    ///
-    /// This function returns the size (cardinality) of the found 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 /= 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
-    /// matching.
-    ///
-    /// \pre Either run() or start() must be called before using this function.
-    bool matching(const Edge& edge) const {
-      return edge == (*_matching)[_graph.u(edge)];
-    }
-
-    /// \brief Return the matching arc (or edge) incident to the given node.
-    ///
-    /// This function returns the 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.
-    ///
-    /// \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;
-    }
-
-    /// \brief Return the mate of the given node.
-    ///
-    /// 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.
-    ///
-    /// \pre Either run() or start() must be called before using this function.
-    Node mate(const Node& node) const {
-      return (*_matching)[node] != INVALID ?
-        _graph.target((*_matching)[node]) : INVALID;
-    }
-
-    /// @}
-
-    /// \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);
-      }
-      for (int i = 0; i < blossomNum(); ++i) {
-        sum += blossomValue(i) * (blossomSize(i) / 2);
-      }
-      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];
-    }
-
-    /// \brief Return the number of the blossoms in the basis.
-    ///
-    /// This function returns the number of the blossoms in the basis.
-    ///
-    /// \pre Either run() or start() must be called before using this function.
-    /// \see BlossomIt
-    int blossomNum() const {
-      return _blossom_potential.size();
-    }
-
-    /// \brief Return the number of the nodes in the given blossom.
-    ///
-    /// This function returns the number of the nodes in the given blossom.
-    ///
-    /// \pre Either run() or start() must be called before using this function.
-    /// \see BlossomIt
-    int blossomSize(int k) const {
-      return _blossom_potential[k].end - _blossom_potential[k].begin;
-    }
-
-    /// \brief Return the dual value (ptential) of the given blossom.
-    ///
-    /// This function returns the dual value (ptential) of the given blossom.
-    ///
-    /// \pre Either run() or start() must be called before using this function.
-    Value blossomValue(int k) const {
-      return _blossom_potential[k].value;
-    }
-
-    /// \brief Iterator for obtaining the nodes of a blossom.
-    ///
-    /// 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
-    /// MaxWeightedMatching class and execute it.
-    class BlossomIt {
-    public:
-
-      /// \brief Constructor.
-      ///
-      /// Constructor to get the nodes of the given variable.
-      ///
-      /// \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)
-        : _algorithm(&algorithm)
-      {
-        _index = _algorithm->_blossom_potential[variable].begin;
-        _last = _algorithm->_blossom_potential[variable].end;
-      }
-
-      /// \brief Conversion to \c Node.
-      ///
-      /// Conversion to \c Node.
-      operator Node() const {
-        return _algorithm->_blossom_node_list[_index];
-      }
-
-      /// \brief Increment operator.
-      ///
-      /// Increment operator.
-      BlossomIt& operator++() {
-        ++_index;
-        return *this;
-      }
-
-      /// \brief Validity checking
-      ///
-      /// Checks whether the iterator is invalid.
-      bool operator==(Invalid) const { return _index == _last; }
-
-      /// \brief Validity checking
-      ///
-      /// Checks whether the iterator is valid.
-      bool operator!=(Invalid) const { return _index != _last; }
-
-    private:
-      const MaxWeightedMatching* _algorithm;
-      int _last;
-      int _index;
-    };
-
-    /// @}
-
-  };
-
-  /// \ingroup matching
-  ///
-  /// \brief Weighted perfect matching in general graphs
-  ///
-  /// This class provides an efficient implementation of Edmond's
-  /// maximum weighted perfect matching algorithm. The implementation
-  /// is based on extensive use of priority queues and provides
-  /// \f$O(nm\log n)\f$ time complexity.
-  ///
-  /// 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.
-  /// \f[ \sum_{e \in \delta(u)}x_e = 1 \quad \forall u\in V\f]
-  /** \f[ \sum_{e \in \gamma(B)}x_e \le \frac{\vert B \vert - 1}{2}
-      \quad \forall B\in\mathcal{O}\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$, \f$\gamma(X)\f$ is the set of edges with both ends in
-  /// \f$X\f$ and \f$\mathcal{O}\f$ is the set of odd cardinality
-  /// subsets of the nodes.
-  ///
-  /// The algorithm calculates an optimal 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 + \sum_{B \in \mathcal{O}, uv \in \gamma(B)}z_B \ge
-      w_{uv} \quad \forall uv\in E\f] */
-  /// \f[z_B \ge 0 \quad \forall B \in \mathcal{O}\f]
-  /** \f[\min \sum_{u \in V}y_u + \sum_{B \in \mathcal{O}}
-      \frac{\vert B \vert - 1}{2}z_B\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 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
-  /// \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 MaxWeightedPerfectMatching {
-  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;
-
-    /// \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;
-
-    /// The type of the matching map
-    typedef typename Graph::template NodeMap<typename Graph::Arc>
-    MatchingMap;
-
-  private:
-
-    TEMPLATE_GRAPH_TYPEDEFS(Graph);
-
-    typedef typename Graph::template NodeMap<Value> NodePotential;
-    typedef std::vector<Node> BlossomNodeList;
-
-    struct BlossomVariable {
-      int begin, end;
-      Value value;
-
-      BlossomVariable(int _begin, int _end, Value _value)
-        : begin(_begin), end(_end), value(_value) {}
-
-    };
-
-    typedef std::vector<BlossomVariable> BlossomPotential;
-
-    const Graph& _graph;
-    const WeightMap& _weight;
-
-    MatchingMap* _matching;
-
-    NodePotential* _node_potential;
-
-    BlossomPotential _blossom_potential;
-    BlossomNodeList _blossom_node_list;
-
-    int _node_num;
-    int _blossom_num;
-
-    typedef RangeMap<int> IntIntMap;
-
-    enum Status {
-      EVEN = -1, MATCHED = 0, ODD = 1
-    };
-
-    typedef HeapUnionFind<Value, IntNodeMap> BlossomSet;
-    struct BlossomData {
-      int tree;
-      Status status;
-      Arc pred, next;
-      Value pot, offset;
-    };
-
-    IntNodeMap *_blossom_index;
-    BlossomSet *_blossom_set;
-    RangeMap<BlossomData>* _blossom_data;
-
-    IntNodeMap *_node_index;
-    IntArcMap *_node_heap_index;
-
-    struct NodeData {
-
-      NodeData(IntArcMap& node_heap_index)
-        : heap(node_heap_index) {}
-
-      int blossom;
-      Value pot;
-      BinHeap<Value, IntArcMap> heap;
-      std::map<int, Arc> heap_index;
-
-      int tree;
-    };
-
-    RangeMap<NodeData>* _node_data;
-
-    typedef ExtendFindEnum<IntIntMap> TreeSet;
-
-    IntIntMap *_tree_set_index;
-    TreeSet *_tree_set;
-
-    IntIntMap *_delta2_index;
-    BinHeap<Value, IntIntMap> *_delta2;
-
-    IntEdgeMap *_delta3_index;
-    BinHeap<Value, IntEdgeMap> *_delta3;
-
-    IntIntMap *_delta4_index;
-    BinHeap<Value, IntIntMap> *_delta4;
-
-    Value _delta_sum;
-    int _unmatched;
-
-    typedef MaxWeightedPerfectFractionalMatching<Graph, WeightMap>
-    FractionalMatching;
-    FractionalMatching *_fractional;
-
-    void createStructures() {
-      _node_num = countNodes(_graph);
-      _blossom_num = _node_num * 3 / 2;
-
-      if (!_matching) {
-        _matching = new MatchingMap(_graph);
-      }
-
-      if (!_node_potential) {
-        _node_potential = new NodePotential(_graph);
-      }
-
-      if (!_blossom_set) {
-        _blossom_index = new IntNodeMap(_graph);
-        _blossom_set = new BlossomSet(*_blossom_index);
-        _blossom_data = new RangeMap<BlossomData>(_blossom_num);
-      } else if (_blossom_data->size() != _blossom_num) {
-        delete _blossom_data;
-        _blossom_data = new RangeMap<BlossomData>(_blossom_num);
-      }
-
-      if (!_node_index) {
-        _node_index = new IntNodeMap(_graph);
-        _node_heap_index = new IntArcMap(_graph);
-        _node_data = new RangeMap<NodeData>(_node_num,
-                                            NodeData(*_node_heap_index));
-      } else if (_node_data->size() != _node_num) {
-        delete _node_data;
-        _node_data = new RangeMap<NodeData>(_node_num,
-                                            NodeData(*_node_heap_index));
-      }
-
-      if (!_tree_set) {
-        _tree_set_index = new IntIntMap(_blossom_num);
-        _tree_set = new TreeSet(*_tree_set_index);
-      } else {
-        _tree_set_index->resize(_blossom_num);
-      }
-
-      if (!_delta2) {
-        _delta2_index = new IntIntMap(_blossom_num);
-        _delta2 = new BinHeap<Value, IntIntMap>(*_delta2_index);
-      } else {
-        _delta2_index->resize(_blossom_num);
-      }
-
-      if (!_delta3) {
-        _delta3_index = new IntEdgeMap(_graph);
-        _delta3 = new BinHeap<Value, IntEdgeMap>(*_delta3_index);
-      }
-
-      if (!_delta4) {
-        _delta4_index = new IntIntMap(_blossom_num);
-        _delta4 = new BinHeap<Value, IntIntMap>(*_delta4_index);
-      } else {
-        _delta4_index->resize(_blossom_num);
-      }
-    }
-
-    void destroyStructures() {
-      if (_matching) {
-        delete _matching;
-      }
-      if (_node_potential) {
-        delete _node_potential;
-      }
-      if (_blossom_set) {
-        delete _blossom_index;
-        delete _blossom_set;
-        delete _blossom_data;
-      }
-
-      if (_node_index) {
-        delete _node_index;
-        delete _node_heap_index;
-        delete _node_data;
-      }
-
-      if (_tree_set) {
-        delete _tree_set_index;
-        delete _tree_set;
-      }
-      if (_delta2) {
-        delete _delta2_index;
-        delete _delta2;
-      }
-      if (_delta3) {
-        delete _delta3_index;
-        delete _delta3;
-      }
-      if (_delta4) {
-        delete _delta4_index;
-        delete _delta4;
-      }
-    }
-
-    void matchedToEven(int blossom, int tree) {
-      if (_delta2->state(blossom) == _delta2->IN_HEAP) {
-        _delta2->erase(blossom);
-      }
-
-      if (!_blossom_set->trivial(blossom)) {
-        (*_blossom_data)[blossom].pot -=
-          2 * (_delta_sum - (*_blossom_data)[blossom].offset);
-      }
-
-      for (typename BlossomSet::ItemIt n(*_blossom_set, blossom);
-           n != INVALID; ++n) {
-
-        _blossom_set->increase(n, std::numeric_limits<Value>::max());
-        int ni = (*_node_index)[n];
-
-        (*_node_data)[ni].heap.clear();
-        (*_node_data)[ni].heap_index.clear();
-
-        (*_node_data)[ni].pot += _delta_sum - (*_blossom_data)[blossom].offset;
-
-        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;
-              }
-            } 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;
-
-        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 {
-
-            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;
-
-        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;
-              }
-            } 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 alternatePath(int even, int tree) {
-      int odd;
-
-      evenToMatched(even, tree);
-      (*_blossom_data)[even].status = MATCHED;
-
-      while ((*_blossom_data)[even].pred != INVALID) {
-        odd = _blossom_set->find(_graph.target((*_blossom_data)[even].pred));
-        (*_blossom_data)[odd].status = MATCHED;
-        oddToMatched(odd);
-        (*_blossom_data)[odd].next = (*_blossom_data)[odd].pred;
-
-        even = _blossom_set->find(_graph.target((*_blossom_data)[odd].pred));
-        (*_blossom_data)[even].status = MATCHED;
-        evenToMatched(even, tree);
-        (*_blossom_data)[even].next =
-          _graph.oppositeArc((*_blossom_data)[odd].pred);
-      }
-
-    }
-
-    void destroyTree(int tree) {
-      for (TreeSet::ItemIt b(*_tree_set, tree); b != INVALID; ++b) {
-        if ((*_blossom_data)[b].status == EVEN) {
-          (*_blossom_data)[b].status = MATCHED;
-          evenToMatched(b, tree);
-        } else if ((*_blossom_data)[b].status == ODD) {
-          (*_blossom_data)[b].status = MATCHED;
-          oddToMatched(b);
-        }
-      }
-      _tree_set->eraseClass(tree);
-    }
-
-    void augmentOnEdge(const Edge& edge) {
-
-      int left = _blossom_set->find(_graph.u(edge));
-      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);
-
-      (*_blossom_data)[left].next = _graph.direct(edge, true);
-      (*_blossom_data)[right].next = _graph.direct(edge, false);
-    }
-
-    void extendOnArc(const Arc& arc) {
-      int base = _blossom_set->find(_graph.target(arc));
-      int tree = _tree_set->find(base);
-
-      int odd = _blossom_set->find(_graph.source(arc));
-      _tree_set->insert(odd, tree);
-      (*_blossom_data)[odd].status = ODD;
-      matchedToOdd(odd);
-      (*_blossom_data)[odd].pred = arc;
-
-      int even = _blossom_set->find(_graph.target((*_blossom_data)[odd].next));
-      (*_blossom_data)[even].pred = (*_blossom_data)[even].next;
-      _tree_set->insert(even, tree);
-      (*_blossom_data)[even].status = EVEN;
-      matchedToEven(even, tree);
-    }
-
-    void shrinkOnEdge(const Edge& edge, int tree) {
-      int nca = -1;
-      std::vector<int> left_path, right_path;
-
-      {
-        std::set<int> left_set, right_set;
-        int left = _blossom_set->find(_graph.u(edge));
-        left_path.push_back(left);
-        left_set.insert(left);
-
-        int right = _blossom_set->find(_graph.v(edge));
-        right_path.push_back(right);
-        right_set.insert(right);
-
-        while (true) {
-
-          if ((*_blossom_data)[left].pred == INVALID) break;
-
-          left =
-            _blossom_set->find(_graph.target((*_blossom_data)[left].pred));
-          left_path.push_back(left);
-          left =
-            _blossom_set->find(_graph.target((*_blossom_data)[left].pred));
-          left_path.push_back(left);
-
-          left_set.insert(left);
-
-          if (right_set.find(left) != right_set.end()) {
-            nca = left;
-            break;
-          }
-
-          if ((*_blossom_data)[right].pred == INVALID) break;
-
-          right =
-            _blossom_set->find(_graph.target((*_blossom_data)[right].pred));
-          right_path.push_back(right);
-          right =
-            _blossom_set->find(_graph.target((*_blossom_data)[right].pred));
-          right_path.push_back(right);
-
-          right_set.insert(right);
-
-          if (left_set.find(right) != left_set.end()) {
-            nca = right;
-            break;
-          }
-
-        }
-
-        if (nca == -1) {
-          if ((*_blossom_data)[left].pred == INVALID) {
-            nca = right;
-            while (left_set.find(nca) == left_set.end()) {
-              nca =
-                _blossom_set->find(_graph.target((*_blossom_data)[nca].pred));
-              right_path.push_back(nca);
-              nca =
-                _blossom_set->find(_graph.target((*_blossom_data)[nca].pred));
-              right_path.push_back(nca);
-            }
-          } else {
-            nca = left;
-            while (right_set.find(nca) == right_set.end()) {
-              nca =
-                _blossom_set->find(_graph.target((*_blossom_data)[nca].pred));
-              left_path.push_back(nca);
-              nca =
-                _blossom_set->find(_graph.target((*_blossom_data)[nca].pred));
-              left_path.push_back(nca);
-            }
-          }
-        }
-      }
-
-      std::vector<int> subblossoms;
-      Arc prev;
-
-      prev = _graph.direct(edge, true);
-      for (int i = 0; left_path[i] != nca; i += 2) {
-        subblossoms.push_back(left_path[i]);
-        (*_blossom_data)[left_path[i]].next = prev;
-        _tree_set->erase(left_path[i]);
-
-        subblossoms.push_back(left_path[i + 1]);
-        (*_blossom_data)[left_path[i + 1]].status = EVEN;
-        oddToEven(left_path[i + 1], tree);
-        _tree_set->erase(left_path[i + 1]);
-        prev = _graph.oppositeArc((*_blossom_data)[left_path[i + 1]].pred);
-      }
-
-      int k = 0;
-      while (right_path[k] != nca) ++k;
-
-      subblossoms.push_back(nca);
-      (*_blossom_data)[nca].next = prev;
-
-      for (int i = k - 2; i >= 0; i -= 2) {
-        subblossoms.push_back(right_path[i + 1]);
-        (*_blossom_data)[right_path[i + 1]].status = EVEN;
-        oddToEven(right_path[i + 1], tree);
-        _tree_set->erase(right_path[i + 1]);
-
-        (*_blossom_data)[right_path[i + 1]].next =
-          (*_blossom_data)[right_path[i + 1]].pred;
-
-        subblossoms.push_back(right_path[i]);
-        _tree_set->erase(right_path[i]);
-      }
-
-      int surface =
-        _blossom_set->join(subblossoms.begin(), subblossoms.end());
-
-      for (int i = 0; i < int(subblossoms.size()); ++i) {
-        if (!_blossom_set->trivial(subblossoms[i])) {
-          (*_blossom_data)[subblossoms[i]].pot += 2 * _delta_sum;
-        }
-        (*_blossom_data)[subblossoms[i]].status = MATCHED;
-      }
-
-      (*_blossom_data)[surface].pot = -2 * _delta_sum;
-      (*_blossom_data)[surface].offset = 0;
-      (*_blossom_data)[surface].status = EVEN;
-      (*_blossom_data)[surface].pred = (*_blossom_data)[nca].pred;
-      (*_blossom_data)[surface].next = (*_blossom_data)[nca].pred;
-
-      _tree_set->insert(surface, tree);
-      _tree_set->erase(nca);
-    }
-
-    void splitBlossom(int blossom) {
-      Arc next = (*_blossom_data)[blossom].next;
-      Arc pred = (*_blossom_data)[blossom].pred;
-
-      int tree = _tree_set->find(blossom);
-
-      (*_blossom_data)[blossom].status = MATCHED;
-      oddToMatched(blossom);
-      if (_delta2->state(blossom) == _delta2->IN_HEAP) {
-        _delta2->erase(blossom);
-      }
-
-      std::vector<int> subblossoms;
-      _blossom_set->split(blossom, std::back_inserter(subblossoms));
-
-      Value offset = (*_blossom_data)[blossom].offset;
-      int b = _blossom_set->find(_graph.source(pred));
-      int d = _blossom_set->find(_graph.source(next));
-
-      int ib = -1, id = -1;
-      for (int i = 0; i < int(subblossoms.size()); ++i) {
-        if (subblossoms[i] == b) ib = i;
-        if (subblossoms[i] == d) id = i;
-
-        (*_blossom_data)[subblossoms[i]].offset = offset;
-        if (!_blossom_set->trivial(subblossoms[i])) {
-          (*_blossom_data)[subblossoms[i]].pot -= 2 * offset;
-        }
-        if (_blossom_set->classPrio(subblossoms[i]) !=
-            std::numeric_limits<Value>::max()) {
-          _delta2->push(subblossoms[i],
-                        _blossom_set->classPrio(subblossoms[i]) -
-                        (*_blossom_data)[subblossoms[i]].offset);
-        }
-      }
-
-      if (id > ib ? ((id - ib) % 2 == 0) : ((ib - id) % 2 == 1)) {
-        for (int i = (id + 1) % subblossoms.size();
-             i != ib; i = (i + 2) % subblossoms.size()) {
-          int sb = subblossoms[i];
-          int tb = subblossoms[(i + 1) % subblossoms.size()];
-          (*_blossom_data)[sb].next =
-            _graph.oppositeArc((*_blossom_data)[tb].next);
-        }
-
-        for (int i = ib; i != id; i = (i + 2) % subblossoms.size()) {
-          int sb = subblossoms[i];
-          int tb = subblossoms[(i + 1) % subblossoms.size()];
-          int ub = subblossoms[(i + 2) % subblossoms.size()];
-
-          (*_blossom_data)[sb].status = ODD;
-          matchedToOdd(sb);
-          _tree_set->insert(sb, tree);
-          (*_blossom_data)[sb].pred = pred;
-          (*_blossom_data)[sb].next =
-                           _graph.oppositeArc((*_blossom_data)[tb].next);
-
-          pred = (*_blossom_data)[ub].next;
-
-          (*_blossom_data)[tb].status = EVEN;
-          matchedToEven(tb, tree);
-          _tree_set->insert(tb, tree);
-          (*_blossom_data)[tb].pred = (*_blossom_data)[tb].next;
-        }
-
-        (*_blossom_data)[subblossoms[id]].status = ODD;
-        matchedToOdd(subblossoms[id]);
-        _tree_set->insert(subblossoms[id], tree);
-        (*_blossom_data)[subblossoms[id]].next = next;
-        (*_blossom_data)[subblossoms[id]].pred = pred;
-
-      } else {
-
-        for (int i = (ib + 1) % subblossoms.size();
-             i != id; i = (i + 2) % subblossoms.size()) {
-          int sb = subblossoms[i];
-          int tb = subblossoms[(i + 1) % subblossoms.size()];
-          (*_blossom_data)[sb].next =
-            _graph.oppositeArc((*_blossom_data)[tb].next);
-        }
-
-        for (int i = id; i != ib; i = (i + 2) % subblossoms.size()) {
-          int sb = subblossoms[i];
-          int tb = subblossoms[(i + 1) % subblossoms.size()];
-          int ub = subblossoms[(i + 2) % subblossoms.size()];
-
-          (*_blossom_data)[sb].status = ODD;
-          matchedToOdd(sb);
-          _tree_set->insert(sb, tree);
-          (*_blossom_data)[sb].next = next;
-          (*_blossom_data)[sb].pred =
-            _graph.oppositeArc((*_blossom_data)[tb].next);
-
-          (*_blossom_data)[tb].status = EVEN;
-          matchedToEven(tb, tree);
-          _tree_set->insert(tb, tree);
-          (*_blossom_data)[tb].pred =
-            (*_blossom_data)[tb].next =
-            _graph.oppositeArc((*_blossom_data)[ub].next);
-          next = (*_blossom_data)[ub].next;
-        }
-
-        (*_blossom_data)[subblossoms[ib]].status = ODD;
-        matchedToOdd(subblossoms[ib]);
-        _tree_set->insert(subblossoms[ib], tree);
-        (*_blossom_data)[subblossoms[ib]].next = next;
-        (*_blossom_data)[subblossoms[ib]].pred = pred;
-      }
-      _tree_set->erase(blossom);
-    }
-
-    void extractBlossom(int blossom, const Node& base, const Arc& matching) {
-      if (_blossom_set->trivial(blossom)) {
-        int bi = (*_node_index)[base];
-        Value pot = (*_node_data)[bi].pot;
-
-        (*_matching)[base] = matching;
-        _blossom_node_list.push_back(base);
-        (*_node_potential)[base] = pot;
-      } else {
-
-        Value pot = (*_blossom_data)[blossom].pot;
-        int bn = _blossom_node_list.size();
-
-        std::vector<int> subblossoms;
-        _blossom_set->split(blossom, std::back_inserter(subblossoms));
-        int b = _blossom_set->find(base);
-        int ib = -1;
-        for (int i = 0; i < int(subblossoms.size()); ++i) {
-          if (subblossoms[i] == b) { ib = i; break; }
-        }
-
-        for (int i = 1; i < int(subblossoms.size()); i += 2) {
-          int sb = subblossoms[(ib + i) % subblossoms.size()];
-          int tb = subblossoms[(ib + i + 1) % subblossoms.size()];
-
-          Arc m = (*_blossom_data)[tb].next;
-          extractBlossom(sb, _graph.target(m), _graph.oppositeArc(m));
-          extractBlossom(tb, _graph.source(m), m);
-        }
-        extractBlossom(subblossoms[ib], base, matching);
-
-        int en = _blossom_node_list.size();
-
-        _blossom_potential.push_back(BlossomVariable(bn, en, pot));
-      }
-    }
-
-    void extractMatching() {
-      std::vector<int> blossoms;
-      for (typename BlossomSet::ClassIt c(*_blossom_set); c != INVALID; ++c) {
-        blossoms.push_back(c);
-      }
-
-      for (int i = 0; i < int(blossoms.size()); ++i) {
-
-        Value offset = (*_blossom_data)[blossoms[i]].offset;
-        (*_blossom_data)[blossoms[i]].pot += 2 * offset;
-        for (typename BlossomSet::ItemIt n(*_blossom_set, blossoms[i]);
-             n != INVALID; ++n) {
-          (*_node_data)[(*_node_index)[n]].pot -= offset;
-        }
-
-        Arc matching = (*_blossom_data)[blossoms[i]].next;
-        Node base = _graph.source(matching);
-        extractBlossom(blossoms[i], base, matching);
-      }
-    }
-
-  public:
-
-    /// \brief Constructor
-    ///
-    /// Constructor.
-    MaxWeightedPerfectMatching(const Graph& graph, const WeightMap& weight)
-      : _graph(graph), _weight(weight), _matching(0),
-        _node_potential(0), _blossom_potential(), _blossom_node_list(),
-        _node_num(0), _blossom_num(0),
-
-        _blossom_index(0), _blossom_set(0), _blossom_data(0),
-        _node_index(0), _node_heap_index(0), _node_data(0),
-        _tree_set_index(0), _tree_set(0),
-
-        _delta2_index(0), _delta2(0),
-        _delta3_index(0), _delta3(0),
-        _delta4_index(0), _delta4(0),
-
-        _delta_sum(), _unmatched(0),
-
-        _fractional(0)
-    {}
-
-    ~MaxWeightedPerfectMatching() {
-      destroyStructures();
-      if (_fractional) {
-        delete _fractional;
-      }
-    }
-
-    /// \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();
-
-      _blossom_node_list.clear();
-      _blossom_potential.clear();
-
-      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 = _node_num;
-
-      _delta2->clear();
-      _delta3->clear();
-      _delta4->clear();
-      _blossom_set->clear();
-      _tree_set->clear();
-
-      int index = 0;
-      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) continue;
-          if ((dualScale * _weight[e]) / 2 > max) {
-            max = (dualScale * _weight[e]) / 2;
-          }
-        }
-        (*_node_index)[n] = index;
-        (*_node_data)[index].heap_index.clear();
-        (*_node_data)[index].heap.clear();
-        (*_node_data)[index].pot = max;
-        int blossom =
-          _blossom_set->insert(n, std::numeric_limits<Value>::max());
-
-        _tree_set->insert(blossom);
-
-        (*_blossom_data)[blossom].status = EVEN;
-        (*_blossom_data)[blossom].pred = INVALID;
-        (*_blossom_data)[blossom].next = INVALID;
-        (*_blossom_data)[blossom].pot = 0;
-        (*_blossom_data)[blossom].offset = 0;
-        ++index;
-      }
-      for (EdgeIt e(_graph); e != INVALID; ++e) {
-        int si = (*_node_index)[_graph.u(e)];
-        int ti = (*_node_index)[_graph.v(e)];
-        if (_graph.u(e) != _graph.v(e)) {
-          _delta3->push(e, ((*_node_data)[si].pot + (*_node_data)[ti].pot -
-                            dualScale * _weight[e]) / 2);
-        }
-      }
-    }
-
-    /// \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.
-    bool start() {
-      enum OpType {
-        D2, D3, D4
-      };
-
-      if (_unmatched == -1) return false;
-
-      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();
-
-        Value d4 = !_delta4->empty() ?
-          _delta4->prio() : std::numeric_limits<Value>::max();
-
-        _delta_sum = d3; OpType ot = D3;
-        if (d2 < _delta_sum) { _delta_sum = d2; ot = D2; }
-        if (d4 < _delta_sum) { _delta_sum = d4; ot = D4; }
-
-        if (_delta_sum == std::numeric_limits<Value>::max()) {
-          return false;
-        }
-
-        switch (ot) {
-        case D2:
-          {
-            int blossom = _delta2->top();
-            Node n = _blossom_set->classTop(blossom);
-            Arc e = (*_node_data)[(*_node_index)[n]].heap.top();
-            extendOnArc(e);
-          }
-          break;
-        case D3:
-          {
-            Edge e = _delta3->top();
-
-            int left_blossom = _blossom_set->find(_graph.u(e));
-            int right_blossom = _blossom_set->find(_graph.v(e));
-
-            if (left_blossom == right_blossom) {
-              _delta3->pop();
-            } else {
-              int left_tree = _tree_set->find(left_blossom);
-              int right_tree = _tree_set->find(right_blossom);
-
-              if (left_tree == right_tree) {
-                shrinkOnEdge(e, left_tree);
-              } else {
-                augmentOnEdge(e);
-                _unmatched -= 2;
-              }
-            }
-          } break;
-        case D4:
-          splitBlossom(_delta4->top());
-          break;
-        }
-      }
-      extractMatching();
-      return true;
-    }
-
-    /// \brief Run the algorithm.
-    ///
-    /// This method runs the \c %MaxWeightedPerfectMatching algorithm.
-    ///
-    /// \note mwpm.run() is just a shortcut of the following code.
-    /// \code
-    ///   mwpm.fractionalInit();
-    ///   mwpm.start();
-    /// \endcode
-    bool run() {
-      fractionalInit();
-      return start();
-    }
-
-    /// @}
-
-    /// \name Primal Solution
-    /// 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
-    /// using them.
-
-    /// @{
-
-    /// \brief Return the weight of the matching.
-    ///
-    /// This function returns the weight of the found matching.
-    ///
-    /// \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 / 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
-    /// matching.
-    ///
-    /// \pre Either run() or start() must be called before using this function.
-    bool matching(const Edge& edge) const {
-      return static_cast<const Edge&>((*_matching)[_graph.u(edge)]) == edge;
-    }
-
-    /// \brief Return the matching arc (or edge) incident to the given node.
-    ///
-    /// This function returns the 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.
-    ///
-    /// \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;
-    }
-
-    /// \brief Return the mate of the given node.
-    ///
-    /// 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.
-    ///
-    /// \pre Either run() or start() must be called before using this function.
-    Node mate(const Node& node) const {
-      return _graph.target((*_matching)[node]);
-    }
-
-    /// @}
-
-    /// \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);
-      }
-      for (int i = 0; i < blossomNum(); ++i) {
-        sum += blossomValue(i) * (blossomSize(i) / 2);
-      }
-      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];
-    }
-
-    /// \brief Return the number of the blossoms in the basis.
-    ///
-    /// This function returns the number of the blossoms in the basis.
-    ///
-    /// \pre Either run() or start() must be called before using this function.
-    /// \see BlossomIt
-    int blossomNum() const {
-      return _blossom_potential.size();
-    }
-
-    /// \brief Return the number of the nodes in the given blossom.
-    ///
-    /// This function returns the number of the nodes in the given blossom.
-    ///
-    /// \pre Either run() or start() must be called before using this function.
-    /// \see BlossomIt
-    int blossomSize(int k) const {
-      return _blossom_potential[k].end - _blossom_potential[k].begin;
-    }
-
-    /// \brief Return the dual value (ptential) of the given blossom.
-    ///
-    /// This function returns the dual value (ptential) of the given blossom.
-    ///
-    /// \pre Either run() or start() must be called before using this function.
-    Value blossomValue(int k) const {
-      return _blossom_potential[k].value;
-    }
-
-    /// \brief Iterator for obtaining the nodes of a blossom.
-    ///
-    /// 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
-    /// MaxWeightedPerfectMatching class and execute it.
-    class BlossomIt {
-    public:
-
-      /// \brief Constructor.
-      ///
-      /// Constructor to get the nodes of the given variable.
-      ///
-      /// \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)
-        : _algorithm(&algorithm)
-      {
-        _index = _algorithm->_blossom_potential[variable].begin;
-        _last = _algorithm->_blossom_potential[variable].end;
-      }
-
-      /// \brief Conversion to \c Node.
-      ///
-      /// Conversion to \c Node.
-      operator Node() const {
-        return _algorithm->_blossom_node_list[_index];
-      }
-
-      /// \brief Increment operator.
-      ///
-      /// Increment operator.
-      BlossomIt& operator++() {
-        ++_index;
-        return *this;
-      }
-
-      /// \brief Validity checking
-      ///
-      /// This function checks whether the iterator is invalid.
-      bool operator==(Invalid) const { return _index == _last; }
-
-      /// \brief Validity checking
-      ///
-      /// This function checks whether the iterator is valid.
-      bool operator!=(Invalid) const { return _index != _last; }
-
-    private:
-      const MaxWeightedPerfectMatching* _algorithm;
-      int _last;
-      int _index;
-    };
-
-    /// @}
-
-  };
-
-} //END OF NAMESPACE LEMON
-
-#endif //LEMON_MATCHING_H
Index: lemon/math.h
===================================================================
--- lemon/math.h	(revision 956)
+++ lemon/math.h	(revision 209)
@@ -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).
@@ -56,13 +56,4 @@
   const long double SQRT1_2 = 0.7071067811865475244008443621048490L;
 
-  ///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
-  ///provided by all compilers.
-  inline bool isNaN(double v)
-    {
-      return v!=v;
-    }
 
   /// @}
Index: mon/min_cost_arborescence.h
===================================================================
--- lemon/min_cost_arborescence.h	(revision 956)
+++ 	(revision )
@@ -1,808 +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_MIN_COST_ARBORESCENCE_H
-#define LEMON_MIN_COST_ARBORESCENCE_H
-
-///\ingroup spantree
-///\file
-///\brief Minimum Cost Arborescence algorithm.
-
-#include <vector>
-
-#include <lemon/list_graph.h>
-#include <lemon/bin_heap.h>
-#include <lemon/assert.h>
-
-namespace lemon {
-
-
-  /// \brief Default traits class for MinCostArborescence class.
-  ///
-  /// Default traits class for MinCostArborescence class.
-  /// \param GR Digraph type.
-  /// \param CM Type of the cost map.
-  template <class GR, class CM>
-  struct MinCostArborescenceDefaultTraits{
-
-    /// \brief The digraph type the algorithm runs on.
-    typedef GR Digraph;
-
-    /// \brief The type of the map that stores the arc costs.
-    ///
-    /// The type of the map that stores the arc costs.
-    /// It must conform to the \ref concepts::ReadMap "ReadMap" concept.
-    typedef CM CostMap;
-
-    /// \brief The value type of the costs.
-    ///
-    /// The value type of the costs.
-    typedef typename CostMap::Value Value;
-
-    /// \brief The type of the map that stores which arcs are in the
-    /// arborescence.
-    ///
-    /// The type of the map that stores which arcs are in the
-    /// arborescence.  It must conform to the \ref concepts::WriteMap
-    /// "WriteMap" concept, and its value type must be \c bool
-    /// (or convertible). Initially it will be set to \c false on each
-    /// arc, then it will be set on each arborescence arc once.
-    typedef typename Digraph::template ArcMap<bool> ArborescenceMap;
-
-    /// \brief Instantiates a \c ArborescenceMap.
-    ///
-    /// This function instantiates a \c ArborescenceMap.
-    /// \param digraph The digraph to which we would like to calculate
-    /// the \c ArborescenceMap.
-    static ArborescenceMap *createArborescenceMap(const Digraph &digraph){
-      return new ArborescenceMap(digraph);
-    }
-
-    /// \brief The type of the \c PredMap
-    ///
-    /// The type of the \c PredMap. It must confrom to the
-    /// \ref concepts::WriteMap "WriteMap" concept, and its value type
-    /// must be the \c Arc type of the digraph.
-    typedef typename Digraph::template NodeMap<typename Digraph::Arc> PredMap;
-
-    /// \brief Instantiates a \c PredMap.
-    ///
-    /// This function instantiates a \c PredMap.
-    /// \param digraph The digraph to which we would like to define the
-    /// \c PredMap.
-    static PredMap *createPredMap(const Digraph &digraph){
-      return new PredMap(digraph);
-    }
-
-  };
-
-  /// \ingroup spantree
-  ///
-  /// \brief Minimum Cost Arborescence algorithm class.
-  ///
-  /// This class provides an efficient implementation of the
-  /// Minimum Cost Arborescence algorithm. The arborescence is a tree
-  /// which is directed from a given source node of the digraph. One or
-  /// more sources should be given to the algorithm and it will calculate
-  /// the minimum cost subgraph that is the union of arborescences with the
-  /// given sources and spans all the nodes which are reachable from the
-  /// sources. The time complexity of the algorithm is O(n<sup>2</sup>+e).
-  ///
-  /// The algorithm also provides an optimal dual solution, therefore
-  /// the optimality of the solution can be checked.
-  ///
-  /// \param GR The digraph type the algorithm runs on.
-  /// \param CM A read-only arc map storing the costs of the
-  /// arcs. It is read once for each arc, so the map may involve in
-  /// relatively time consuming process to compute the arc costs if
-  /// 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
-  /// "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,
-            typename CM = typename GR::template ArcMap<int>,
-            typename TR =
-              MinCostArborescenceDefaultTraits<GR, CM> >
-#else
-  template <typename GR, typename CM, typename TR>
-#endif
-  class MinCostArborescence {
-  public:
-
-    /// \brief The \ref MinCostArborescenceDefaultTraits "traits class"
-    /// of the algorithm.
-    typedef TR Traits;
-    /// The type of the underlying digraph.
-    typedef typename Traits::Digraph Digraph;
-    /// The type of the map that stores the arc costs.
-    typedef typename Traits::CostMap CostMap;
-    ///The type of the costs of the arcs.
-    typedef typename Traits::Value Value;
-    ///The type of the predecessor map.
-    typedef typename Traits::PredMap PredMap;
-    ///The type of the map that stores which arcs are in the arborescence.
-    typedef typename Traits::ArborescenceMap ArborescenceMap;
-
-    typedef MinCostArborescence Create;
-
-  private:
-
-    TEMPLATE_DIGRAPH_TYPEDEFS(Digraph);
-
-    struct CostArc {
-
-      Arc arc;
-      Value value;
-
-      CostArc() {}
-      CostArc(Arc _arc, Value _value) : arc(_arc), value(_value) {}
-
-    };
-
-    const Digraph *_digraph;
-    const CostMap *_cost;
-
-    PredMap *_pred;
-    bool local_pred;
-
-    ArborescenceMap *_arborescence;
-    bool local_arborescence;
-
-    typedef typename Digraph::template ArcMap<int> ArcOrder;
-    ArcOrder *_arc_order;
-
-    typedef typename Digraph::template NodeMap<int> NodeOrder;
-    NodeOrder *_node_order;
-
-    typedef typename Digraph::template NodeMap<CostArc> CostArcMap;
-    CostArcMap *_cost_arcs;
-
-    struct StackLevel {
-
-      std::vector<CostArc> arcs;
-      int node_level;
-
-    };
-
-    std::vector<StackLevel> level_stack;
-    std::vector<Node> queue;
-
-    typedef std::vector<typename Digraph::Node> DualNodeList;
-
-    DualNodeList _dual_node_list;
-
-    struct DualVariable {
-      int begin, end;
-      Value value;
-
-      DualVariable(int _begin, int _end, Value _value)
-        : begin(_begin), end(_end), value(_value) {}
-
-    };
-
-    typedef std::vector<DualVariable> DualVariables;
-
-    DualVariables _dual_variables;
-
-    typedef typename Digraph::template NodeMap<int> HeapCrossRef;
-
-    HeapCrossRef *_heap_cross_ref;
-
-    typedef BinHeap<int, HeapCrossRef> Heap;
-
-    Heap *_heap;
-
-  protected:
-
-    MinCostArborescence() {}
-
-  private:
-
-    void createStructures() {
-      if (!_pred) {
-        local_pred = true;
-        _pred = Traits::createPredMap(*_digraph);
-      }
-      if (!_arborescence) {
-        local_arborescence = true;
-        _arborescence = Traits::createArborescenceMap(*_digraph);
-      }
-      if (!_arc_order) {
-        _arc_order = new ArcOrder(*_digraph);
-      }
-      if (!_node_order) {
-        _node_order = new NodeOrder(*_digraph);
-      }
-      if (!_cost_arcs) {
-        _cost_arcs = new CostArcMap(*_digraph);
-      }
-      if (!_heap_cross_ref) {
-        _heap_cross_ref = new HeapCrossRef(*_digraph, -1);
-      }
-      if (!_heap) {
-        _heap = new Heap(*_heap_cross_ref);
-      }
-    }
-
-    void destroyStructures() {
-      if (local_arborescence) {
-        delete _arborescence;
-      }
-      if (local_pred) {
-        delete _pred;
-      }
-      if (_arc_order) {
-        delete _arc_order;
-      }
-      if (_node_order) {
-        delete _node_order;
-      }
-      if (_cost_arcs) {
-        delete _cost_arcs;
-      }
-      if (_heap) {
-        delete _heap;
-      }
-      if (_heap_cross_ref) {
-        delete _heap_cross_ref;
-      }
-    }
-
-    Arc prepare(Node node) {
-      std::vector<Node> nodes;
-      (*_node_order)[node] = _dual_node_list.size();
-      StackLevel level;
-      level.node_level = _dual_node_list.size();
-      _dual_node_list.push_back(node);
-      for (InArcIt it(*_digraph, node); it != INVALID; ++it) {
-        Arc arc = it;
-        Node source = _digraph->source(arc);
-        Value value = (*_cost)[it];
-        if (source == node || (*_node_order)[source] == -3) continue;
-        if ((*_cost_arcs)[source].arc == INVALID) {
-          (*_cost_arcs)[source].arc = arc;
-          (*_cost_arcs)[source].value = value;
-          nodes.push_back(source);
-        } else {
-          if ((*_cost_arcs)[source].value > value) {
-            (*_cost_arcs)[source].arc = arc;
-            (*_cost_arcs)[source].value = value;
-          }
-        }
-      }
-      CostArc minimum = (*_cost_arcs)[nodes[0]];
-      for (int i = 1; i < int(nodes.size()); ++i) {
-        if ((*_cost_arcs)[nodes[i]].value < minimum.value) {
-          minimum = (*_cost_arcs)[nodes[i]];
-        }
-      }
-      (*_arc_order)[minimum.arc] = _dual_variables.size();
-      DualVariable var(_dual_node_list.size() - 1,
-                       _dual_node_list.size(), minimum.value);
-      _dual_variables.push_back(var);
-      for (int i = 0; i < int(nodes.size()); ++i) {
-        (*_cost_arcs)[nodes[i]].value -= minimum.value;
-        level.arcs.push_back((*_cost_arcs)[nodes[i]]);
-        (*_cost_arcs)[nodes[i]].arc = INVALID;
-      }
-      level_stack.push_back(level);
-      return minimum.arc;
-    }
-
-    Arc contract(Node node) {
-      int node_bottom = bottom(node);
-      std::vector<Node> nodes;
-      while (!level_stack.empty() &&
-             level_stack.back().node_level >= node_bottom) {
-        for (int i = 0; i < int(level_stack.back().arcs.size()); ++i) {
-          Arc arc = level_stack.back().arcs[i].arc;
-          Node source = _digraph->source(arc);
-          Value value = level_stack.back().arcs[i].value;
-          if ((*_node_order)[source] >= node_bottom) continue;
-          if ((*_cost_arcs)[source].arc == INVALID) {
-            (*_cost_arcs)[source].arc = arc;
-            (*_cost_arcs)[source].value = value;
-            nodes.push_back(source);
-          } else {
-            if ((*_cost_arcs)[source].value > value) {
-              (*_cost_arcs)[source].arc = arc;
-              (*_cost_arcs)[source].value = value;
-            }
-          }
-        }
-        level_stack.pop_back();
-      }
-      CostArc minimum = (*_cost_arcs)[nodes[0]];
-      for (int i = 1; i < int(nodes.size()); ++i) {
-        if ((*_cost_arcs)[nodes[i]].value < minimum.value) {
-          minimum = (*_cost_arcs)[nodes[i]];
-        }
-      }
-      (*_arc_order)[minimum.arc] = _dual_variables.size();
-      DualVariable var(node_bottom, _dual_node_list.size(), minimum.value);
-      _dual_variables.push_back(var);
-      StackLevel level;
-      level.node_level = node_bottom;
-      for (int i = 0; i < int(nodes.size()); ++i) {
-        (*_cost_arcs)[nodes[i]].value -= minimum.value;
-        level.arcs.push_back((*_cost_arcs)[nodes[i]]);
-        (*_cost_arcs)[nodes[i]].arc = INVALID;
-      }
-      level_stack.push_back(level);
-      return minimum.arc;
-    }
-
-    int bottom(Node node) {
-      int k = level_stack.size() - 1;
-      while (level_stack[k].node_level > (*_node_order)[node]) {
-        --k;
-      }
-      return level_stack[k].node_level;
-    }
-
-    void finalize(Arc arc) {
-      Node node = _digraph->target(arc);
-      _heap->push(node, (*_arc_order)[arc]);
-      _pred->set(node, arc);
-      while (!_heap->empty()) {
-        Node source = _heap->top();
-        _heap->pop();
-        (*_node_order)[source] = -1;
-        for (OutArcIt it(*_digraph, source); it != INVALID; ++it) {
-          if ((*_arc_order)[it] < 0) continue;
-          Node target = _digraph->target(it);
-          switch(_heap->state(target)) {
-          case Heap::PRE_HEAP:
-            _heap->push(target, (*_arc_order)[it]);
-            _pred->set(target, it);
-            break;
-          case Heap::IN_HEAP:
-            if ((*_arc_order)[it] < (*_heap)[target]) {
-              _heap->decrease(target, (*_arc_order)[it]);
-              _pred->set(target, it);
-            }
-            break;
-          case Heap::POST_HEAP:
-            break;
-          }
-        }
-        _arborescence->set((*_pred)[source], true);
-      }
-    }
-
-
-  public:
-
-    /// \name Named Template Parameters
-
-    /// @{
-
-    template <class T>
-    struct SetArborescenceMapTraits : public Traits {
-      typedef T ArborescenceMap;
-      static ArborescenceMap *createArborescenceMap(const Digraph &)
-      {
-        LEMON_ASSERT(false, "ArborescenceMap is not initialized");
-        return 0; // ignore warnings
-      }
-    };
-
-    /// \brief \ref named-templ-param "Named parameter" for
-    /// setting \c ArborescenceMap type
-    ///
-    /// \ref named-templ-param "Named parameter" for setting
-    /// \c ArborescenceMap type.
-    /// It must conform to the \ref concepts::WriteMap "WriteMap" concept,
-    /// and its value type must be \c bool (or convertible).
-    /// Initially it will be set to \c false on each arc,
-    /// then it will be set on each arborescence arc once.
-    template <class T>
-    struct SetArborescenceMap
-      : public MinCostArborescence<Digraph, CostMap,
-                                   SetArborescenceMapTraits<T> > {
-    };
-
-    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 meet the \ref concepts::WriteMap "WriteMap" concept,
-    /// and its value type must be the \c Arc type of the digraph.
-    template <class T>
-    struct SetPredMap
-      : public MinCostArborescence<Digraph, CostMap, SetPredMapTraits<T> > {
-    };
-
-    /// @}
-
-    /// \brief Constructor.
-    ///
-    /// \param digraph The digraph the algorithm will run on.
-    /// \param cost The cost map used by the algorithm.
-    MinCostArborescence(const Digraph& digraph, const CostMap& cost)
-      : _digraph(&digraph), _cost(&cost), _pred(0), local_pred(false),
-        _arborescence(0), local_arborescence(false),
-        _arc_order(0), _node_order(0), _cost_arcs(0),
-        _heap_cross_ref(0), _heap(0) {}
-
-    /// \brief Destructor.
-    ~MinCostArborescence() {
-      destroyStructures();
-    }
-
-    /// \brief Sets the arborescence map.
-    ///
-    /// Sets the arborescence map.
-    /// \return <tt>(*this)</tt>
-    MinCostArborescence& arborescenceMap(ArborescenceMap& m) {
-      if (local_arborescence) {
-        delete _arborescence;
-      }
-      local_arborescence = false;
-      _arborescence = &m;
-      return *this;
-    }
-
-    /// \brief Sets the predecessor map.
-    ///
-    /// Sets the predecessor map.
-    /// \return <tt>(*this)</tt>
-    MinCostArborescence& predMap(PredMap& m) {
-      if (local_pred) {
-        delete _pred;
-      }
-      local_pred = false;
-      _pred = &m;
-      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 better control on the execution,
-    /// you have to call \ref init() first, then you can add several
-    /// source nodes with \ref addSource().
-    /// Finally \ref start() will perform the arborescence
-    /// computation.
-
-    ///@{
-
-    /// \brief Initializes the internal data structures.
-    ///
-    /// Initializes the internal data structures.
-    ///
-    void init() {
-      createStructures();
-      _heap->clear();
-      for (NodeIt it(*_digraph); it != INVALID; ++it) {
-        (*_cost_arcs)[it].arc = INVALID;
-        (*_node_order)[it] = -3;
-        (*_heap_cross_ref)[it] = Heap::PRE_HEAP;
-        _pred->set(it, INVALID);
-      }
-      for (ArcIt it(*_digraph); it != INVALID; ++it) {
-        _arborescence->set(it, false);
-        (*_arc_order)[it] = -1;
-      }
-      _dual_node_list.clear();
-      _dual_variables.clear();
-    }
-
-    /// \brief Adds a new source node.
-    ///
-    /// Adds a new source node to the algorithm.
-    void addSource(Node source) {
-      std::vector<Node> nodes;
-      nodes.push_back(source);
-      while (!nodes.empty()) {
-        Node node = nodes.back();
-        nodes.pop_back();
-        for (OutArcIt it(*_digraph, node); it != INVALID; ++it) {
-          Node target = _digraph->target(it);
-          if ((*_node_order)[target] == -3) {
-            (*_node_order)[target] = -2;
-            nodes.push_back(target);
-            queue.push_back(target);
-          }
-        }
-      }
-      (*_node_order)[source] = -1;
-    }
-
-    /// \brief Processes the next node in the priority queue.
-    ///
-    /// Processes the next node in the priority queue.
-    ///
-    /// \return The processed node.
-    ///
-    /// \warning The queue must not be empty.
-    Node processNextNode() {
-      Node node = queue.back();
-      queue.pop_back();
-      if ((*_node_order)[node] == -2) {
-        Arc arc = prepare(node);
-        Node source = _digraph->source(arc);
-        while ((*_node_order)[source] != -1) {
-          if ((*_node_order)[source] >= 0) {
-            arc = contract(source);
-          } else {
-            arc = prepare(source);
-          }
-          source = _digraph->source(arc);
-        }
-        finalize(arc);
-        level_stack.clear();
-      }
-      return node;
-    }
-
-    /// \brief Returns the number of the nodes to be processed.
-    ///
-    /// Returns the number of the nodes to be processed in the priority
-    /// queue.
-    int queueSize() const {
-      return queue.size();
-    }
-
-    /// \brief Returns \c false if there are nodes to be processed.
-    ///
-    /// Returns \c false if there are nodes to be processed.
-    bool emptyQueue() const {
-      return queue.empty();
-    }
-
-    /// \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.
-    ///
-    ///\note mca.start() is just a shortcut of the following code.
-    ///\code
-    ///while (!mca.emptyQueue()) {
-    ///  mca.processNextNode();
-    ///}
-    ///\endcode
-    void start() {
-      while (!emptyQueue()) {
-        processNextNode();
-      }
-    }
-
-    /// \brief Runs %MinCostArborescence algorithm from node \c s.
-    ///
-    /// This method runs the %MinCostArborescence algorithm from
-    /// a root node \c s.
-    ///
-    /// \note mca.run(s) is just a shortcut of the following code.
-    /// \code
-    /// mca.init();
-    /// mca.addSource(s);
-    /// mca.start();
-    /// \endcode
-    void run(Node s) {
-      init();
-      addSource(s);
-      start();
-    }
-
-    ///@}
-
-    /// \name Query Functions
-    /// The result of the %MinCostArborescence algorithm can be obtained
-    /// using these functions.\n
-    /// Either run() or start() must be called before using them.
-
-    /// @{
-
-    /// \brief Returns the cost of the arborescence.
-    ///
-    /// Returns the cost of the arborescence.
-    Value arborescenceCost() const {
-      Value sum = 0;
-      for (ArcIt it(*_digraph); it != INVALID; ++it) {
-        if (arborescence(it)) {
-          sum += (*_cost)[it];
-        }
-      }
-      return sum;
-    }
-
-    /// \brief Returns \c true if the arc is in the arborescence.
-    ///
-    /// Returns \c true if the given arc is in the arborescence.
-    /// \param arc An arc of the digraph.
-    /// \pre \ref run() must be called before using this function.
-    bool arborescence(Arc arc) const {
-      return (*_pred)[_digraph->target(arc)] == arc;
-    }
-
-    /// \brief Returns a const reference to the arborescence map.
-    ///
-    /// Returns a const reference to the arborescence map.
-    /// \pre \ref run() must be called before using this function.
-    const ArborescenceMap& arborescenceMap() const {
-      return *_arborescence;
-    }
-
-    /// \brief Returns the predecessor arc of the given node.
-    ///
-    /// Returns the predecessor arc of the given node.
-    /// \pre \ref run() must be called before using this function.
-    Arc pred(Node node) const {
-      return (*_pred)[node];
-    }
-
-    /// \brief Returns a const reference to the pred map.
-    ///
-    /// Returns a const reference to the pred map.
-    /// \pre \ref run() must be called before using this function.
-    const PredMap& predMap() const {
-      return *_pred;
-    }
-
-    /// \brief Indicates that a node is reachable from the sources.
-    ///
-    /// Indicates that a node is reachable from the sources.
-    bool reached(Node node) const {
-      return (*_node_order)[node] != -3;
-    }
-
-    /// \brief Indicates that a node is processed.
-    ///
-    /// Indicates that a node is processed. The arborescence path exists
-    /// from the source to the given node.
-    bool processed(Node node) const {
-      return (*_node_order)[node] == -1;
-    }
-
-    /// \brief Returns the number of the dual variables in basis.
-    ///
-    /// Returns the number of the dual variables in basis.
-    int dualNum() const {
-      return _dual_variables.size();
-    }
-
-    /// \brief Returns the value of the dual solution.
-    ///
-    /// Returns the value of the dual solution. It should be
-    /// equal to the arborescence value.
-    Value dualValue() const {
-      Value sum = 0;
-      for (int i = 0; i < int(_dual_variables.size()); ++i) {
-        sum += _dual_variables[i].value;
-      }
-      return sum;
-    }
-
-    /// \brief Returns the number of the nodes in the dual variable.
-    ///
-    /// Returns the number of the nodes in the dual variable.
-    int dualSize(int k) const {
-      return _dual_variables[k].end - _dual_variables[k].begin;
-    }
-
-    /// \brief Returns the value of the dual variable.
-    ///
-    /// Returns the the value of the dual variable.
-    Value dualValue(int k) const {
-      return _dual_variables[k].value;
-    }
-
-    /// \brief LEMON iterator for getting a dual variable.
-    ///
-    /// This class provides a common style LEMON iterator for getting a
-    /// dual variable of \ref MinCostArborescence algorithm.
-    /// It iterates over a subset of the nodes.
-    class DualIt {
-    public:
-
-      /// \brief Constructor.
-      ///
-      /// Constructor for getting the nodeset of the dual variable
-      /// of \ref MinCostArborescence algorithm.
-      DualIt(const MinCostArborescence& algorithm, int variable)
-        : _algorithm(&algorithm)
-      {
-        _index = _algorithm->_dual_variables[variable].begin;
-        _last = _algorithm->_dual_variables[variable].end;
-      }
-
-      /// \brief Conversion to \c Node.
-      ///
-      /// Conversion to \c Node.
-      operator Node() const {
-        return _algorithm->_dual_node_list[_index];
-      }
-
-      /// \brief Increment operator.
-      ///
-      /// Increment operator.
-      DualIt& operator++() {
-        ++_index;
-        return *this;
-      }
-
-      /// \brief Validity checking
-      ///
-      /// Checks whether the iterator is invalid.
-      bool operator==(Invalid) const {
-        return _index == _last;
-      }
-
-      /// \brief Validity checking
-      ///
-      /// Checks whether the iterator is valid.
-      bool operator!=(Invalid) const {
-        return _index != _last;
-      }
-
-    private:
-      const MinCostArborescence* _algorithm;
-      int _index, _last;
-    };
-
-    /// @}
-
-  };
-
-  /// \ingroup spantree
-  ///
-  /// \brief Function type interface for MinCostArborescence algorithm.
-  ///
-  /// Function type interface for MinCostArborescence algorithm.
-  /// \param digraph The digraph the algorithm runs on.
-  /// \param cost An arc map storing the costs.
-  /// \param source The source node of the arborescence.
-  /// \retval arborescence An arc map with \c bool (or convertible) value
-  /// type that stores the arborescence.
-  /// \return The total cost of the arborescence.
-  ///
-  /// \sa MinCostArborescence
-  template <typename Digraph, typename CostMap, typename ArborescenceMap>
-  typename CostMap::Value minCostArborescence(const Digraph& digraph,
-                                              const CostMap& cost,
-                                              typename Digraph::Node source,
-                                              ArborescenceMap& arborescence) {
-    typename MinCostArborescence<Digraph, CostMap>
-      ::template SetArborescenceMap<ArborescenceMap>
-      ::Create mca(digraph, cost);
-    mca.arborescenceMap(arborescence);
-    mca.run(source);
-    return mca.arborescenceCost();
-  }
-
-}
-
-#endif
Index: mon/nauty_reader.h
===================================================================
--- lemon/nauty_reader.h	(revision 463)
+++ 	(revision )
@@ -1,113 +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_NAUTY_READER_H
-#define LEMON_NAUTY_READER_H
-
-#include <vector>
-#include <iostream>
-#include <string>
-
-/// \ingroup nauty_group
-/// \file
-/// \brief Nauty file reader.
-
-namespace lemon {
-
-  /// \ingroup nauty_group
-  ///
-  /// \brief Nauty file reader
-  ///
-  /// The \e geng program is in the \e gtools suite of the nauty
-  /// package. This tool can generate all non-isomorphic undirected
-  /// graphs of several classes with given node number (e.g.
-  /// general, connected, biconnected, triangle-free, 4-cycle-free,
-  /// bipartite and graphs with given edge number and degree
-  /// constraints). This function reads a \e nauty \e graph6 \e format
-  /// line from the given stream and builds it in the given graph.
-  ///
-  /// The site of nauty package: http://cs.anu.edu.au/~bdm/nauty/
-  ///
-  /// For example, the number of all non-isomorphic planar graphs
-  /// can be computed with the following code.
-  ///\code
-  /// int num = 0;
-  /// SmartGraph graph;
-  /// while (readNautyGraph(graph, std::cin)) {
-  ///   PlanarityChecking<SmartGraph> pc(graph);
-  ///   if (pc.run()) ++num;
-  /// }
-  /// std::cout << "Number of planar graphs: " << num << std::endl;
-  ///\endcode
-  ///
-  /// The nauty files are quite huge, therefore instead of the direct
-  /// file generation pipelining is recommended. For example,
-  ///\code
-  /// ./geng -c 10 | ./num_of_planar_graphs
-  ///\endcode
-  template <typename Graph>
-  std::istream& readNautyGraph(Graph& graph, std::istream& is = std::cin) {
-    graph.clear();
-
-    std::string line;
-    if (getline(is, line)) {
-      int index = 0;
-
-      int n;
-
-      if (line[index] == '>') {
-        index += 10;
-      }
-
-      char c = line[index++]; c -= 63;
-      if (c != 63) {
-        n = int(c);
-      } else {
-        c = line[index++]; c -= 63;
-        n = (int(c) << 12);
-        c = line[index++]; c -= 63;
-        n |= (int(c) << 6);
-        c = line[index++]; c -= 63;
-        n |= int(c);
-      }
-
-      std::vector<typename Graph::Node> nodes;
-      for (int i = 0; i < n; ++i) {
-        nodes.push_back(graph.addNode());
-      }
-
-      int bit = -1;
-      for (int j = 0; j < n; ++j) {
-        for (int i = 0; i < j; ++i) {
-          if (bit == -1) {
-            c = line[index++]; c -= 63;
-            bit = 5;
-          }
-          bool b = (c & (1 << (bit--))) != 0;
-
-          if (b) {
-            graph.addEdge(nodes[i], nodes[j]);
-          }
-        }
-      }
-    }
-    return is;
-  }
-}
-
-#endif
Index: mon/network_simplex.h
===================================================================
--- lemon/network_simplex.h	(revision 978)
+++ 	(revision )
@@ -1,1621 +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_NETWORK_SIMPLEX_H
-#define LEMON_NETWORK_SIMPLEX_H
-
-/// \ingroup min_cost_flow_algs
-///
-/// \file
-/// \brief Network Simplex algorithm for finding a minimum cost flow.
-
-#include <vector>
-#include <limits>
-#include <algorithm>
-
-#include <lemon/core.h>
-#include <lemon/math.h>
-
-namespace lemon {
-
-  /// \addtogroup min_cost_flow_algs
-  /// @{
-
-  /// \brief Implementation of the primal Network Simplex algorithm
-  /// for finding a \ref min_cost_flow "minimum cost flow".
-  ///
-  /// \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.
-  ///
-  /// In general, %NetworkSimplex is the fastest implementation available
-  /// in LEMON for this 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)
-  /// 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 number 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.
-  template <typename GR, typename V = int, typename C = V>
-  class NetworkSimplex
-  {
-  public:
-
-    /// 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 objective function of the problem is unbounded, i.e.
-      /// there is a directed cycle having negative total cost and
-      /// infinite upper bound.
-      UNBOUNDED
-    };
-
-    /// \brief Constants for selecting the type of the supply constraints.
-    ///
-    /// Enum type containing constants for selecting the supply type,
-    /// i.e. the direction of the inequalities in the supply/demand
-    /// constraints of the \ref min_cost_flow "minimum cost flow problem".
-    ///
-    /// The default supply type is \c GEQ, the \c LEQ type can be
-    /// selected using \ref supplyType().
-    /// The equality form is a special case of both supply types.
-    enum SupplyType {
-      /// This option means that there are <em>"greater or equal"</em>
-      /// supply/demand constraints in the definition of the problem.
-      GEQ,
-      /// This option means that there are <em>"less or equal"</em>
-      /// supply/demand constraints in the definition of the problem.
-      LEQ
-    };
-
-    /// \brief Constants for selecting the pivot rule.
-    ///
-    /// Enum type containing constants for selecting the pivot rule for
-    /// the \ref run() function.
-    ///
-    /// \ref NetworkSimplex provides five different pivot rule
-    /// implementations that significantly affect the running time
-    /// of the algorithm.
-    /// By default, \ref BLOCK_SEARCH "Block Search" is used, which
-    /// proved to be the most efficient and the most robust on various
-    /// test inputs.
-    /// 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 next eligible arc is selected in a wraparound fashion
-      /// in every iteration.
-      FIRST_ELIGIBLE,
-
-      /// The \e Best \e Eligible pivot rule.
-      /// The best eligible arc is selected in every iteration.
-      BEST_ELIGIBLE,
-
-      /// The \e Block \e Search pivot rule.
-      /// A specified number of arcs are examined in every iteration
-      /// in a wraparound fashion and the best eligible arc is selected
-      /// from this block.
-      BLOCK_SEARCH,
-
-      /// The \e Candidate \e 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
-      /// the best eligible arc is selected from this list.
-      CANDIDATE_LIST,
-
-      /// The \e Altering \e Candidate \e List pivot rule.
-      /// It is a modified version of the Candidate List method.
-      /// 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<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
-
-    // State constants for arcs
-    enum ArcState {
-      STATE_UPPER = -1,
-      STATE_TREE  =  0,
-      STATE_LOWER =  1
-    };
-
-    typedef std::vector<signed char> StateVector;
-    // Note: vector<signed char> is used instead of vector<ArcState> for
-    // efficiency reasons
-
-  private:
-
-    // Data related to the underlying digraph
-    const GR &_graph;
-    int _node_num;
-    int _arc_num;
-    int _all_arc_num;
-    int _search_arc_num;
-
-    // Parameters of the problem
-    bool _have_lower;
-    SupplyType _stype;
-    Value _sum_supply;
-
-    // Data structures for storing the digraph
-    IntNodeMap _node_id;
-    IntArcMap _arc_id;
-    IntVector _source;
-    IntVector _target;
-    bool _arc_mixing;
-
-    // Node and arc data
-    ValueVector _lower;
-    ValueVector _upper;
-    ValueVector _cap;
-    CostVector _cost;
-    ValueVector _supply;
-    ValueVector _flow;
-    CostVector _pi;
-
-    // Data for storing the spanning tree structure
-    IntVector _parent;
-    IntVector _pred;
-    IntVector _thread;
-    IntVector _rev_thread;
-    IntVector _succ_num;
-    IntVector _last_succ;
-    IntVector _dirty_revs;
-    BoolVector _forward;
-    StateVector _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).
-    ///
-    /// 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:
-
-    // Implementation of the First Eligible pivot rule
-    class FirstEligiblePivotRule
-    {
-    private:
-
-      // References to the NetworkSimplex class
-      const IntVector  &_source;
-      const IntVector  &_target;
-      const CostVector &_cost;
-      const StateVector &_state;
-      const CostVector &_pi;
-      int &_in_arc;
-      int _search_arc_num;
-
-      // Pivot rule data
-      int _next_arc;
-
-    public:
-
-      // Constructor
-      FirstEligiblePivotRule(NetworkSimplex &ns) :
-        _source(ns._source), _target(ns._target),
-        _cost(ns._cost), _state(ns._state), _pi(ns._pi),
-        _in_arc(ns.in_arc), _search_arc_num(ns._search_arc_num),
-        _next_arc(0)
-      {}
-
-      // Find next entering arc
-      bool findEnteringArc() {
-        Cost c;
-        for (int e = _next_arc; e != _search_arc_num; ++e) {
-          c = _state[e] * (_cost[e] + _pi[_source[e]] - _pi[_target[e]]);
-          if (c < 0) {
-            _in_arc = e;
-            _next_arc = e + 1;
-            return true;
-          }
-        }
-        for (int e = 0; e != _next_arc; ++e) {
-          c = _state[e] * (_cost[e] + _pi[_source[e]] - _pi[_target[e]]);
-          if (c < 0) {
-            _in_arc = e;
-            _next_arc = e + 1;
-            return true;
-          }
-        }
-        return false;
-      }
-
-    }; //class FirstEligiblePivotRule
-
-
-    // Implementation of the Best Eligible pivot rule
-    class BestEligiblePivotRule
-    {
-    private:
-
-      // References to the NetworkSimplex class
-      const IntVector  &_source;
-      const IntVector  &_target;
-      const CostVector &_cost;
-      const StateVector &_state;
-      const CostVector &_pi;
-      int &_in_arc;
-      int _search_arc_num;
-
-    public:
-
-      // Constructor
-      BestEligiblePivotRule(NetworkSimplex &ns) :
-        _source(ns._source), _target(ns._target),
-        _cost(ns._cost), _state(ns._state), _pi(ns._pi),
-        _in_arc(ns.in_arc), _search_arc_num(ns._search_arc_num)
-      {}
-
-      // Find next entering arc
-      bool findEnteringArc() {
-        Cost c, min = 0;
-        for (int e = 0; e != _search_arc_num; ++e) {
-          c = _state[e] * (_cost[e] + _pi[_source[e]] - _pi[_target[e]]);
-          if (c < min) {
-            min = c;
-            _in_arc = e;
-          }
-        }
-        return min < 0;
-      }
-
-    }; //class BestEligiblePivotRule
-
-
-    // Implementation of the Block Search pivot rule
-    class BlockSearchPivotRule
-    {
-    private:
-
-      // References to the NetworkSimplex class
-      const IntVector  &_source;
-      const IntVector  &_target;
-      const CostVector &_cost;
-      const StateVector &_state;
-      const CostVector &_pi;
-      int &_in_arc;
-      int _search_arc_num;
-
-      // Pivot rule data
-      int _block_size;
-      int _next_arc;
-
-    public:
-
-      // Constructor
-      BlockSearchPivotRule(NetworkSimplex &ns) :
-        _source(ns._source), _target(ns._target),
-        _cost(ns._cost), _state(ns._state), _pi(ns._pi),
-        _in_arc(ns.in_arc), _search_arc_num(ns._search_arc_num),
-        _next_arc(0)
-      {
-        // The main parameters of the pivot rule
-        const double BLOCK_SIZE_FACTOR = 1.0;
-        const int MIN_BLOCK_SIZE = 10;
-
-        _block_size = std::max( int(BLOCK_SIZE_FACTOR *
-                                    std::sqrt(double(_search_arc_num))),
-                                MIN_BLOCK_SIZE );
-      }
-
-      // Find next entering arc
-      bool findEnteringArc() {
-        Cost c, min = 0;
-        int cnt = _block_size;
-        int e;
-        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;
-          }
-          if (--cnt == 0) {
-            if (min < 0) goto search_end;
-            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) return false;
-
-      search_end:
-        _next_arc = e;
-        return true;
-      }
-
-    }; //class BlockSearchPivotRule
-
-
-    // Implementation of the Candidate List pivot rule
-    class CandidateListPivotRule
-    {
-    private:
-
-      // References to the NetworkSimplex class
-      const IntVector  &_source;
-      const IntVector  &_target;
-      const CostVector &_cost;
-      const StateVector &_state;
-      const CostVector &_pi;
-      int &_in_arc;
-      int _search_arc_num;
-
-      // Pivot rule data
-      IntVector _candidates;
-      int _list_length, _minor_limit;
-      int _curr_length, _minor_count;
-      int _next_arc;
-
-    public:
-
-      /// Constructor
-      CandidateListPivotRule(NetworkSimplex &ns) :
-        _source(ns._source), _target(ns._target),
-        _cost(ns._cost), _state(ns._state), _pi(ns._pi),
-        _in_arc(ns.in_arc), _search_arc_num(ns._search_arc_num),
-        _next_arc(0)
-      {
-        // The main parameters of the pivot rule
-        const double LIST_LENGTH_FACTOR = 0.25;
-        const int MIN_LIST_LENGTH = 10;
-        const double MINOR_LIMIT_FACTOR = 0.1;
-        const int MIN_MINOR_LIMIT = 3;
-
-        _list_length = std::max( int(LIST_LENGTH_FACTOR *
-                                     std::sqrt(double(_search_arc_num))),
-                                 MIN_LIST_LENGTH );
-        _minor_limit = std::max( int(MINOR_LIMIT_FACTOR * _list_length),
-                                 MIN_MINOR_LIMIT );
-        _curr_length = _minor_count = 0;
-        _candidates.resize(_list_length);
-      }
-
-      /// Find next entering arc
-      bool findEnteringArc() {
-        Cost min, c;
-        int e;
-        if (_curr_length > 0 && _minor_count < _minor_limit) {
-          // Minor iteration: select the best eligible arc from the
-          // current candidate list
-          ++_minor_count;
-          min = 0;
-          for (int i = 0; i < _curr_length; ++i) {
-            e = _candidates[i];
-            c = _state[e] * (_cost[e] + _pi[_source[e]] - _pi[_target[e]]);
-            if (c < min) {
-              min = c;
-              _in_arc = e;
-            }
-            else if (c >= 0) {
-              _candidates[i--] = _candidates[--_curr_length];
-            }
-          }
-          if (min < 0) return true;
-        }
-
-        // Major iteration: build a new candidate list
-        min = 0;
-        _curr_length = 0;
-        for (e = _next_arc; e != _search_arc_num; ++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) 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) goto search_end;
-          }
-        }
-        if (_curr_length == 0) return false;
-
-      search_end:
-        _minor_count = 1;
-        _next_arc = e;
-        return true;
-      }
-
-    }; //class CandidateListPivotRule
-
-
-    // Implementation of the Altering Candidate List pivot rule
-    class AlteringListPivotRule
-    {
-    private:
-
-      // References to the NetworkSimplex class
-      const IntVector  &_source;
-      const IntVector  &_target;
-      const CostVector &_cost;
-      const StateVector &_state;
-      const CostVector &_pi;
-      int &_in_arc;
-      int _search_arc_num;
-
-      // Pivot rule data
-      int _block_size, _head_length, _curr_length;
-      int _next_arc;
-      IntVector _candidates;
-      CostVector _cand_cost;
-
-      // Functor class to compare arcs during sort of the candidate list
-      class SortFunc
-      {
-      private:
-        const CostVector &_map;
-      public:
-        SortFunc(const CostVector &map) : _map(map) {}
-        bool operator()(int left, int right) {
-          return _map[left] > _map[right];
-        }
-      };
-
-      SortFunc _sort_func;
-
-    public:
-
-      // Constructor
-      AlteringListPivotRule(NetworkSimplex &ns) :
-        _source(ns._source), _target(ns._target),
-        _cost(ns._cost), _state(ns._state), _pi(ns._pi),
-        _in_arc(ns.in_arc), _search_arc_num(ns._search_arc_num),
-        _next_arc(0), _cand_cost(ns._search_arc_num), _sort_func(_cand_cost)
-      {
-        // The main parameters of the pivot rule
-        const double BLOCK_SIZE_FACTOR = 1.0;
-        const int MIN_BLOCK_SIZE = 10;
-        const double HEAD_LENGTH_FACTOR = 0.1;
-        const int MIN_HEAD_LENGTH = 3;
-
-        _block_size = std::max( int(BLOCK_SIZE_FACTOR *
-                                    std::sqrt(double(_search_arc_num))),
-                                MIN_BLOCK_SIZE );
-        _head_length = std::max( int(HEAD_LENGTH_FACTOR * _block_size),
-                                 MIN_HEAD_LENGTH );
-        _candidates.resize(_head_length + _block_size);
-        _curr_length = 0;
-      }
-
-      // Find next entering arc
-      bool findEnteringArc() {
-        // Check the current candidate list
-        int e;
-        for (int i = 0; i != _curr_length; ++i) {
-          e = _candidates[i];
-          _cand_cost[e] = _state[e] *
-            (_cost[e] + _pi[_source[e]] - _pi[_target[e]]);
-          if (_cand_cost[e] >= 0) {
-            _candidates[i--] = _candidates[--_curr_length];
-          }
-        }
-
-        // Extend the list
-        int cnt = _block_size;
-        int limit = _head_length;
-
-        for (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;
-          }
-          if (--cnt == 0) {
-            if (_curr_length > limit) goto search_end;
-            limit = 0;
-            cnt = _block_size;
-          }
-        }
-        for (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;
-          }
-          if (--cnt == 0) {
-            if (_curr_length > limit) goto search_end;
-            limit = 0;
-            cnt = _block_size;
-          }
-        }
-        if (_curr_length == 0) return false;
-
-      search_end:
-
-        // 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;
-        pop_heap( _candidates.begin(), _candidates.begin() + _curr_length,
-                  _sort_func );
-        _curr_length = std::min(_head_length, _curr_length - 1);
-        return true;
-      }
-
-    }; //class AlteringListPivotRule
-
-  public:
-
-    /// \brief Constructor.
-    ///
-    /// The constructor of the class.
-    ///
-    /// \param graph The digraph the algorithm runs on.
-    /// \param arc_mixing Indicate if the arcs have to be stored in a
-    /// mixed order in the internal data structure.
-    /// In special cases, it could lead to better overall performance,
-    /// but it is usually slower. Therefore it is disabled by default.
-    NetworkSimplex(const GR& graph, bool arc_mixing = false) :
-      _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)
-    {
-      // Check the number 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();
-    }
-
-    /// \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>
-    NetworkSimplex& lowerMap(const LowerMap& map) {
-      _have_lower = true;
-      for (ArcIt a(_graph); a != INVALID; ++a) {
-        _lower[_arc_id[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>
-    NetworkSimplex& upperMap(const UpperMap& map) {
-      for (ArcIt a(_graph); a != INVALID; ++a) {
-        _upper[_arc_id[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>
-    NetworkSimplex& costMap(const CostMap& map) {
-      for (ArcIt a(_graph); a != INVALID; ++a) {
-        _cost[_arc_id[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>
-    NetworkSimplex& 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 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.
-    ///
-    /// \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>
-    NetworkSimplex& 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;
-    }
-
-    /// \brief Set the type of the supply constraints.
-    ///
-    /// This function sets the type of the supply/demand constraints.
-    /// If it is not used before calling \ref run(), the \ref GEQ supply
-    /// type will be used.
-    ///
-    /// For more information, see \ref SupplyType.
-    ///
-    /// \return <tt>(*this)</tt>
-    NetworkSimplex& supplyType(SupplyType supply_type) {
-      _stype = supply_type;
-      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(),
-    /// \ref supplyType().
-    /// For example,
-    /// \code
-    ///   NetworkSimplex<ListDigraph> ns(graph);
-    ///   ns.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 pivot_rule The pivot rule that will be used during the
-    /// algorithm. For more information, see \ref PivotRule.
-    ///
-    /// \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 objective function of the problem is
-    /// unbounded, i.e. there is a directed cycle having negative total
-    /// cost and infinite upper bound.
-    ///
-    /// \see ProblemType, PivotRule
-    /// \see resetParams(), reset()
-    ProblemType run(PivotRule pivot_rule = BLOCK_SEARCH) {
-      if (!init()) return INFEASIBLE;
-      return start(pivot_rule);
-    }
-
-    /// \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(), \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.
-    ///
-    /// For example,
-    /// \code
-    ///   NetworkSimplex<ListDigraph> ns(graph);
-    ///
-    ///   // First run
-    ///   ns.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;
-    ///   ns.costMap(cost).run();
-    ///
-    ///   // Run again from scratch using resetParams()
-    ///   // (the lower bounds will be set to zero on all arcs)
-    ///   ns.resetParams();
-    ///   ns.upperMap(capacity).costMap(cost)
-    ///     .supplyMap(sup).run();
-    /// \endcode
-    ///
-    /// \return <tt>(*this)</tt>
-    ///
-    /// \see reset(), run()
-    NetworkSimplex& resetParams() {
-      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;
-      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);
-      _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
-      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
-        int k = std::max(int(std::sqrt(double(_arc_num))), 10);
-        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 += k) >= _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;
-    }
-
-    /// @}
-
-    /// \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
-    ///   ns.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_id[a];
-        c += Number(_flow[i]) * 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 _flow[_arc_id[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, _flow[_arc_id[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 internal data structures
-    bool init() {
-      if (_node_num == 0) return false;
-
-      // Check the sum of supply values
-      _sum_supply = 0;
-      for (int i = 0; i != _node_num; ++i) {
-        _sum_supply += _supply[i];
-      }
-      if ( !((_stype == GEQ && _sum_supply <= 0) ||
-             (_stype == LEQ && _sum_supply >= 0)) ) return false;
-
-      // Remove non-zero lower bounds
-      if (_have_lower) {
-        for (int i = 0; i != _arc_num; ++i) {
-          Value c = _lower[i];
-          if (c >= 0) {
-            _cap[i] = _upper[i] < MAX ? _upper[i] - c : INF;
-          } else {
-            _cap[i] = _upper[i] < MAX + c ? _upper[i] - c : INF;
-          }
-          _supply[_source[i]] -= c;
-          _supply[_target[i]] += c;
-        }
-      } else {
-        for (int i = 0; i != _arc_num; ++i) {
-          _cap[i] = _upper[i];
-        }
-      }
-
-      // Initialize artifical cost
-      Cost ART_COST;
-      if (std::numeric_limits<Cost>::is_exact) {
-        ART_COST = std::numeric_limits<Cost>::max() / 2 + 1;
-      } else {
-        ART_COST = 0;
-        for (int i = 0; i != _arc_num; ++i) {
-          if (_cost[i] > ART_COST) ART_COST = _cost[i];
-        }
-        ART_COST = (ART_COST + 1) * _node_num;
-      }
-
-      // Initialize arc maps
-      for (int i = 0; i != _arc_num; ++i) {
-        _flow[i] = 0;
-        _state[i] = STATE_LOWER;
-      }
-
-      // Set data for the artificial root node
-      _root = _node_num;
-      _parent[_root] = -1;
-      _pred[_root] = -1;
-      _thread[_root] = 0;
-      _rev_thread[0] = _root;
-      _succ_num[_root] = _node_num + 1;
-      _last_succ[_root] = _root - 1;
-      _supply[_root] = -_sum_supply;
-      _pi[_root] = 0;
-
-      // Add artificial arcs and initialize the spanning tree data structure
-      if (_sum_supply == 0) {
-        // EQ supply constraints
-        _search_arc_num = _arc_num;
-        _all_arc_num = _arc_num + _node_num;
-        for (int u = 0, e = _arc_num; u != _node_num; ++u, ++e) {
-          _parent[u] = _root;
-          _pred[u] = e;
-          _thread[u] = u + 1;
-          _rev_thread[u + 1] = u;
-          _succ_num[u] = 1;
-          _last_succ[u] = u;
-          _cap[e] = INF;
-          _state[e] = STATE_TREE;
-          if (_supply[u] >= 0) {
-            _forward[u] = true;
-            _pi[u] = 0;
-            _source[e] = u;
-            _target[e] = _root;
-            _flow[e] = _supply[u];
-            _cost[e] = 0;
-          } else {
-            _forward[u] = false;
-            _pi[u] = ART_COST;
-            _source[e] = _root;
-            _target[e] = u;
-            _flow[e] = -_supply[u];
-            _cost[e] = ART_COST;
-          }
-        }
-      }
-      else if (_sum_supply > 0) {
-        // LEQ supply constraints
-        _search_arc_num = _arc_num + _node_num;
-        int f = _arc_num + _node_num;
-        for (int u = 0, e = _arc_num; u != _node_num; ++u, ++e) {
-          _parent[u] = _root;
-          _thread[u] = u + 1;
-          _rev_thread[u + 1] = u;
-          _succ_num[u] = 1;
-          _last_succ[u] = u;
-          if (_supply[u] >= 0) {
-            _forward[u] = true;
-            _pi[u] = 0;
-            _pred[u] = e;
-            _source[e] = u;
-            _target[e] = _root;
-            _cap[e] = INF;
-            _flow[e] = _supply[u];
-            _cost[e] = 0;
-            _state[e] = STATE_TREE;
-          } else {
-            _forward[u] = false;
-            _pi[u] = ART_COST;
-            _pred[u] = f;
-            _source[f] = _root;
-            _target[f] = u;
-            _cap[f] = INF;
-            _flow[f] = -_supply[u];
-            _cost[f] = ART_COST;
-            _state[f] = STATE_TREE;
-            _source[e] = u;
-            _target[e] = _root;
-            _cap[e] = INF;
-            _flow[e] = 0;
-            _cost[e] = 0;
-            _state[e] = STATE_LOWER;
-            ++f;
-          }
-        }
-        _all_arc_num = f;
-      }
-      else {
-        // GEQ supply constraints
-        _search_arc_num = _arc_num + _node_num;
-        int f = _arc_num + _node_num;
-        for (int u = 0, e = _arc_num; u != _node_num; ++u, ++e) {
-          _parent[u] = _root;
-          _thread[u] = u + 1;
-          _rev_thread[u + 1] = u;
-          _succ_num[u] = 1;
-          _last_succ[u] = u;
-          if (_supply[u] <= 0) {
-            _forward[u] = false;
-            _pi[u] = 0;
-            _pred[u] = e;
-            _source[e] = _root;
-            _target[e] = u;
-            _cap[e] = INF;
-            _flow[e] = -_supply[u];
-            _cost[e] = 0;
-            _state[e] = STATE_TREE;
-          } else {
-            _forward[u] = true;
-            _pi[u] = -ART_COST;
-            _pred[u] = f;
-            _source[f] = u;
-            _target[f] = _root;
-            _cap[f] = INF;
-            _flow[f] = _supply[u];
-            _state[f] = STATE_TREE;
-            _cost[f] = ART_COST;
-            _source[e] = _root;
-            _target[e] = u;
-            _cap[e] = INF;
-            _flow[e] = 0;
-            _cost[e] = 0;
-            _state[e] = STATE_LOWER;
-            ++f;
-          }
-        }
-        _all_arc_num = f;
-      }
-
-      return true;
-    }
-
-    // Find the join node
-    void findJoinNode() {
-      int u = _source[in_arc];
-      int v = _target[in_arc];
-      while (u != v) {
-        if (_succ_num[u] < _succ_num[v]) {
-          u = _parent[u];
-        } else {
-          v = _parent[v];
-        }
-      }
-      join = u;
-    }
-
-    // Find the leaving arc of the cycle and returns true if the
-    // leaving arc is not the same as the entering arc
-    bool findLeavingArc() {
-      // Initialize first and second nodes according to the direction
-      // of the cycle
-      if (_state[in_arc] == STATE_LOWER) {
-        first  = _source[in_arc];
-        second = _target[in_arc];
-      } else {
-        first  = _target[in_arc];
-        second = _source[in_arc];
-      }
-      delta = _cap[in_arc];
-      int result = 0;
-      Value d;
-      int e;
-
-      // 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 = _forward[u] ?
-          _flow[e] : (_cap[e] >= MAX ? INF : _cap[e] - _flow[e]);
-        if (d < delta) {
-          delta = d;
-          u_out = u;
-          result = 1;
-        }
-      }
-      // 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 = _forward[u] ?
-          (_cap[e] >= MAX ? INF : _cap[e] - _flow[e]) : _flow[e];
-        if (d <= delta) {
-          delta = d;
-          u_out = u;
-          result = 2;
-        }
-      }
-
-      if (result == 1) {
-        u_in = first;
-        v_in = second;
-      } else {
-        u_in = second;
-        v_in = first;
-      }
-      return result != 0;
-    }
-
-    // Change _flow and _state vectors
-    void changeFlow(bool change) {
-      // Augment along the cycle
-      if (delta > 0) {
-        Value val = _state[in_arc] * delta;
-        _flow[in_arc] += val;
-        for (int u = _source[in_arc]; u != join; u = _parent[u]) {
-          _flow[_pred[u]] += _forward[u] ? -val : val;
-        }
-        for (int u = _target[in_arc]; u != join; u = _parent[u]) {
-          _flow[_pred[u]] += _forward[u] ? val : -val;
-        }
-      }
-      // Update the state of the entering and leaving arcs
-      if (change) {
-        _state[in_arc] = STATE_TREE;
-        _state[_pred[u_out]] =
-          (_flow[_pred[u_out]] == 0) ? STATE_LOWER : STATE_UPPER;
-      } else {
-        _state[in_arc] = -_state[in_arc];
-      }
-    }
-
-    // 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];
-      int old_last_succ = _last_succ[u_out];
-      v_out = _parent[u_out];
-
-      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 {
-        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
-      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 (u = v_out; u != up_limit_out && _last_succ[u] == old_last_succ;
-             u = _parent[u]) {
-          _last_succ[u] = old_rev_thread;
-        }
-      } else {
-        for (u = v_out; u != up_limit_out && _last_succ[u] == old_last_succ;
-             u = _parent[u]) {
-          _last_succ[u] = _last_succ[u_out];
-        }
-      }
-
-      // Update _succ_num from v_in to join
-      for (u = v_in; u != join; u = _parent[u]) {
-        _succ_num[u] += old_succ_num;
-      }
-      // Update _succ_num from v_out to join
-      for (u = v_out; u != join; u = _parent[u]) {
-        _succ_num[u] -= old_succ_num;
-      }
-    }
-
-    // Update potentials
-    void updatePotential() {
-      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;
-    }
-
-    // Execute the algorithm
-    ProblemType start(PivotRule pivot_rule) {
-      // Select the pivot rule implementation
-      switch (pivot_rule) {
-        case FIRST_ELIGIBLE:
-          return start<FirstEligiblePivotRule>();
-        case BEST_ELIGIBLE:
-          return start<BestEligiblePivotRule>();
-        case BLOCK_SEARCH:
-          return start<BlockSearchPivotRule>();
-        case CANDIDATE_LIST:
-          return start<CandidateListPivotRule>();
-        case ALTERING_LIST:
-          return start<AlteringListPivotRule>();
-      }
-      return INFEASIBLE; // avoid warning
-    }
-
-    template <typename PivotRuleImpl>
-    ProblemType start() {
-      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;
-        changeFlow(change);
-        if (change) {
-          updateTreeStructure();
-          updatePotential();
-        }
-      }
-
-      // Check feasibility
-      for (int e = _search_arc_num; e != _all_arc_num; ++e) {
-        if (_flow[e] != 0) return INFEASIBLE;
-      }
-
-      // Transform the solution and the supply map to the original form
-      if (_have_lower) {
-        for (int i = 0; i != _arc_num; ++i) {
-          Value c = _lower[i];
-          if (c != 0) {
-            _flow[i] += c;
-            _supply[_source[i]] += c;
-            _supply[_target[i]] -= c;
-          }
-        }
-      }
-
-      // Shift potentials to meet the requirements of the GEQ/LEQ type
-      // optimality conditions
-      if (_sum_supply == 0) {
-        if (_stype == GEQ) {
-          Cost max_pot = -std::numeric_limits<Cost>::max();
-          for (int i = 0; i != _node_num; ++i) {
-            if (_pi[i] > max_pot) max_pot = _pi[i];
-          }
-          if (max_pot > 0) {
-            for (int i = 0; i != _node_num; ++i)
-              _pi[i] -= max_pot;
-          }
-        } else {
-          Cost min_pot = std::numeric_limits<Cost>::max();
-          for (int i = 0; i != _node_num; ++i) {
-            if (_pi[i] < min_pot) min_pot = _pi[i];
-          }
-          if (min_pot < 0) {
-            for (int i = 0; i != _node_num; ++i)
-              _pi[i] -= min_pot;
-          }
-        }
-      }
-
-      return OPTIMAL;
-    }
-
-  }; //class NetworkSimplex
-
-  ///@}
-
-} //namespace lemon
-
-#endif //LEMON_NETWORK_SIMPLEX_H
Index: mon/pairing_heap.h
===================================================================
--- lemon/pairing_heap.h	(revision 752)
+++ 	(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 956)
+++ lemon/path.h	(revision 551)
@@ -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).
@@ -41,5 +41,5 @@
   ///
   /// A structure for representing directed path in a digraph.
-  /// \tparam GR The digraph type in which the path is.
+  /// \tparam _Digraph The digraph type in which the path is.
   ///
   /// In a sense, the path can be treated as a list of arcs. The
@@ -53,9 +53,9 @@
   /// implementation uses two vectors for storing the front and back
   /// insertions.
-  template <typename GR>
+  template <typename _Digraph>
   class Path {
   public:
 
-    typedef GR Digraph;
+    typedef _Digraph Digraph;
     typedef typename Digraph::Arc Arc;
 
@@ -138,5 +138,5 @@
     /// \brief The nth arc.
     ///
-    /// \pre \c n is in the <tt>[0..length() - 1]</tt> range.
+    /// \pre n is in the [0..length() - 1] range
     const Arc& nth(int n) const {
       return n < int(head.size()) ? *(head.rbegin() + n) :
@@ -146,5 +146,5 @@
     /// \brief Initialize arc iterator to point to the nth arc
     ///
-    /// \pre \c n is in the <tt>[0..length() - 1]</tt> range.
+    /// \pre n is in the [0..length() - 1] range
     ArcIt nthIt(int n) const {
       return ArcIt(*this, n);
@@ -229,5 +229,5 @@
   ///
   /// A structure for representing directed path in a digraph.
-  /// \tparam GR The digraph type in which the path is.
+  /// \tparam _Digraph The digraph type in which the path is.
   ///
   /// In a sense, the path can be treated as a list of arcs. The
@@ -241,9 +241,9 @@
   /// then the \c Path type because it use just one vector for the
   /// arcs.
-  template <typename GR>
+  template <typename _Digraph>
   class SimplePath {
   public:
 
-    typedef GR Digraph;
+    typedef _Digraph Digraph;
     typedef typename Digraph::Arc Arc;
 
@@ -330,5 +330,5 @@
     /// \brief The nth arc.
     ///
-    /// \pre \c n is in the <tt>[0..length() - 1]</tt> range.
+    /// \pre n is in the [0..length() - 1] range
     const Arc& nth(int n) const {
       return data[n];
@@ -393,5 +393,5 @@
   ///
   /// A structure for representing directed path in a digraph.
-  /// \tparam GR The digraph type in which the path is.
+  /// \tparam _Digraph The digraph type in which the path is.
   ///
   /// In a sense, the path can be treated as a list of arcs. The
@@ -405,9 +405,9 @@
   /// time. The front and back insertion and erasure is O(1) time
   /// and it can be splited and spliced in O(1) time.
-  template <typename GR>
+  template <typename _Digraph>
   class ListPath {
   public:
 
-    typedef GR Digraph;
+    typedef _Digraph Digraph;
     typedef typename Digraph::Arc Arc;
 
@@ -508,5 +508,5 @@
     ///
     /// This function looks for the nth arc in O(n) time.
-    /// \pre \c n is in the <tt>[0..length() - 1]</tt> range.
+    /// \pre n is in the [0..length() - 1] range
     const Arc& nth(int n) const {
       Node *node = first;
@@ -733,5 +733,5 @@
   ///
   /// A structure for representing directed path in a digraph.
-  /// \tparam GR The digraph type in which the path is.
+  /// \tparam _Digraph The digraph type in which the path is.
   ///
   /// In a sense, the path can be treated as a list of arcs. The
@@ -747,9 +747,9 @@
   /// it is intented to be
   /// used when you want to store a large number of paths.
-  template <typename GR>
+  template <typename _Digraph>
   class StaticPath {
   public:
 
-    typedef GR Digraph;
+    typedef _Digraph Digraph;
     typedef typename Digraph::Arc Arc;
 
@@ -834,5 +834,5 @@
     /// \brief The nth arc.
     ///
-    /// \pre \c n is in the <tt>[0..length() - 1]</tt> range.
+    /// \pre n is in the [0..length() - 1] range
     const Arc& nth(int n) const {
       return arcs[n];
@@ -967,5 +967,5 @@
     };
 
-
+    
     template <typename From, typename To,
               bool revEnable = RevPathTagIndicator<From>::value>
@@ -973,5 +973,5 @@
       static void copy(const From& from, To& to) {
         PathCopySelectorForward<From, To>::copy(from, to);
-      }
+      }      
     };
 
@@ -980,5 +980,5 @@
       static void copy(const From& from, To& to) {
         PathCopySelectorBackward<From, To>::copy(from, to);
-      }
+      }      
     };
 
Index: mon/planarity.h
===================================================================
--- lemon/planarity.h	(revision 956)
+++ 	(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: mon/preflow.h
===================================================================
--- lemon/preflow.h	(revision 985)
+++ 	(revision )
@@ -1,987 +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_PREFLOW_H
-#define LEMON_PREFLOW_H
-
-#include <lemon/tolerance.h>
-#include <lemon/elevator.h>
-
-/// \file
-/// \ingroup max_flow
-/// \brief Implementation of the preflow algorithm.
-
-namespace lemon {
-
-  /// \brief Default traits class of Preflow class.
-  ///
-  /// Default traits class of Preflow class.
-  /// \tparam GR Digraph type.
-  /// \tparam CAP Capacity map type.
-  template <typename GR, typename CAP>
-  struct PreflowDefaultTraits {
-
-    /// \brief The type of the digraph the algorithm runs on.
-    typedef GR Digraph;
-
-    /// \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 CAP CapacityMap;
-
-    /// \brief The type of the flow values.
-    typedef typename CapacityMap::Value Value;
-
-    /// \brief The type of the map that stores the flow values.
-    ///
-    /// 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.
-    ///
-    /// This function instantiates a \ref FlowMap.
-    /// \param digraph The digraph for which we would like to define
-    /// the flow map.
-    static FlowMap* createFlowMap(const Digraph& digraph) {
-      return new FlowMap(digraph);
-    }
-
-    /// \brief The elevator type used by Preflow algorithm.
-    ///
-    /// 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
-
-    /// \brief Instantiates an Elevator.
-    ///
-    /// This function instantiates an \ref Elevator.
-    /// \param digraph The digraph for which we would like to define
-    /// the elevator.
-    /// \param max_level The maximum level of the elevator.
-    static Elevator* createElevator(const Digraph& digraph, int max_level) {
-      return new Elevator(digraph, max_level);
-    }
-
-    /// \brief The tolerance used by the algorithm
-    ///
-    /// The tolerance used by the algorithm to handle inexact computation.
-    typedef lemon::Tolerance<Value> Tolerance;
-
-  };
-
-
-  /// \ingroup max_flow
-  ///
-  /// \brief %Preflow algorithm class.
-  ///
-  /// 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.
-  /// The preflow algorithms are the fastest known maximum
-  /// flow algorithms. The current implementation uses 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$.
-  ///
-  /// The algorithm consists of two phases. After the first phase
-  /// the maximum flow value and the minimum cut is obtained. The
-  /// 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>
-#else
-  template <typename GR,
-            typename CAP = typename GR::template ArcMap<int>,
-            typename TR = PreflowDefaultTraits<GR, CAP> >
-#endif
-  class Preflow {
-  public:
-
-    ///The \ref PreflowDefaultTraits "traits class" of the algorithm.
-    typedef TR Traits;
-    ///The type of the digraph the algorithm runs on.
-    typedef typename Traits::Digraph Digraph;
-    ///The type of the capacity map.
-    typedef typename Traits::CapacityMap CapacityMap;
-    ///The type of the flow values.
-    typedef typename Traits::Value Value;
-
-    ///The type of the flow map.
-    typedef typename Traits::FlowMap FlowMap;
-    ///The type of the elevator.
-    typedef typename Traits::Elevator Elevator;
-    ///The type of the tolerance.
-    typedef typename Traits::Tolerance Tolerance;
-
-  private:
-
-    TEMPLATE_DIGRAPH_TYPEDEFS(Digraph);
-
-    const Digraph& _graph;
-    const CapacityMap* _capacity;
-
-    int _node_num;
-
-    Node _source, _target;
-
-    FlowMap* _flow;
-    bool _local_flow;
-
-    Elevator* _level;
-    bool _local_level;
-
-    typedef typename Digraph::template NodeMap<Value> ExcessMap;
-    ExcessMap* _excess;
-
-    Tolerance _tolerance;
-
-    bool _phase;
-
-
-    void createStructures() {
-      _node_num = countNodes(_graph);
-
-      if (!_flow) {
-        _flow = Traits::createFlowMap(_graph);
-        _local_flow = true;
-      }
-      if (!_level) {
-        _level = Traits::createElevator(_graph, _node_num);
-        _local_level = true;
-      }
-      if (!_excess) {
-        _excess = new ExcessMap(_graph);
-      }
-    }
-
-    void destroyStructures() {
-      if (_local_flow) {
-        delete _flow;
-      }
-      if (_local_level) {
-        delete _level;
-      }
-      if (_excess) {
-        delete _excess;
-      }
-    }
-
-  public:
-
-    typedef Preflow Create;
-
-    ///\name Named Template Parameters
-
-    ///@{
-
-    template <typename T>
-    struct SetFlowMapTraits : public Traits {
-      typedef T FlowMap;
-      static FlowMap *createFlowMap(const Digraph&) {
-        LEMON_ASSERT(false, "FlowMap is not initialized");
-        return 0; // ignore warnings
-      }
-    };
-
-    /// \brief \ref named-templ-param "Named parameter" for setting
-    /// FlowMap type
-    ///
-    /// \ref named-templ-param "Named parameter" for setting FlowMap
-    /// type.
-    template <typename T>
-    struct SetFlowMap
-      : public Preflow<Digraph, CapacityMap, SetFlowMapTraits<T> > {
-      typedef Preflow<Digraph, CapacityMap,
-                      SetFlowMapTraits<T> > Create;
-    };
-
-    template <typename T>
-    struct SetElevatorTraits : public Traits {
-      typedef T Elevator;
-      static Elevator *createElevator(const Digraph&, 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 Preflow<Digraph, CapacityMap, SetElevatorTraits<T> > {
-      typedef Preflow<Digraph, CapacityMap,
-                      SetElevatorTraits<T> > Create;
-    };
-
-    template <typename T>
-    struct SetStandardElevatorTraits : public Traits {
-      typedef T Elevator;
-      static Elevator *createElevator(const Digraph& digraph, int max_level) {
-        return new Elevator(digraph, 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
-    /// digraph 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 Preflow<Digraph, CapacityMap,
-                       SetStandardElevatorTraits<T> > {
-      typedef Preflow<Digraph, CapacityMap,
-                      SetStandardElevatorTraits<T> > Create;
-    };
-
-    /// @}
-
-  protected:
-
-    Preflow() {}
-
-  public:
-
-
-    /// \brief The constructor of the class.
-    ///
-    /// The constructor of the class.
-    /// \param digraph The digraph the algorithm runs on.
-    /// \param capacity The capacity of the arcs.
-    /// \param source The source node.
-    /// \param target The target node.
-    Preflow(const Digraph& digraph, const CapacityMap& capacity,
-            Node source, Node target)
-      : _graph(digraph), _capacity(&capacity),
-        _node_num(0), _source(source), _target(target),
-        _flow(0), _local_flow(false),
-        _level(0), _local_level(false),
-        _excess(0), _tolerance(), _phase() {}
-
-    /// \brief Destructor.
-    ///
-    /// Destructor.
-    ~Preflow() {
-      destroyStructures();
-    }
-
-    /// \brief Sets the capacity map.
-    ///
-    /// Sets the capacity map.
-    /// \return <tt>(*this)</tt>
-    Preflow& capacityMap(const CapacityMap& map) {
-      _capacity = &map;
-      return *this;
-    }
-
-    /// \brief Sets the flow map.
-    ///
-    /// Sets the flow 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>
-    Preflow& flowMap(FlowMap& map) {
-      if (_local_flow) {
-        delete _flow;
-        _local_flow = false;
-      }
-      _flow = &map;
-      return *this;
-    }
-
-    /// \brief Sets the source node.
-    ///
-    /// Sets the source node.
-    /// \return <tt>(*this)</tt>
-    Preflow& source(const Node& node) {
-      _source = node;
-      return *this;
-    }
-
-    /// \brief Sets the target node.
-    ///
-    /// Sets the target node.
-    /// \return <tt>(*this)</tt>
-    Preflow& target(const Node& node) {
-      _target = node;
-      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>
-    Preflow& 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;
-    }
-
-    /// \brief Sets the tolerance used by the algorithm.
-    ///
-    /// Sets the tolerance object used by the algorithm.
-    /// \return <tt>(*this)</tt>
-    Preflow& tolerance(const Tolerance& tolerance) {
-      _tolerance = tolerance;
-      return *this;
-    }
-
-    /// \brief Returns a const reference to the tolerance.
-    ///
-    /// 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 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
-    /// \ref startFirstPhase() and if you need it \ref startSecondPhase().
-
-    ///@{
-
-    /// \brief Initializes the internal data structures.
-    ///
-    /// Initializes the internal data structures and sets the initial
-    /// flow to zero on each arc.
-    void init() {
-      createStructures();
-
-      _phase = true;
-      for (NodeIt n(_graph); n != INVALID; ++n) {
-        (*_excess)[n] = 0;
-      }
-
-      for (ArcIt e(_graph); e != INVALID; ++e) {
-        _flow->set(e, 0);
-      }
-
-      typename Digraph::template NodeMap<bool> reached(_graph, false);
-
-      _level->initStart();
-      _level->initAddItem(_target);
-
-      std::vector<Node> queue;
-      reached[_source] = true;
-
-      queue.push_back(_target);
-      reached[_target] = true;
-      while (!queue.empty()) {
-        _level->initNewLevel();
-        std::vector<Node> nqueue;
-        for (int i = 0; i < int(queue.size()); ++i) {
-          Node n = queue[i];
-          for (InArcIt e(_graph, n); e != INVALID; ++e) {
-            Node u = _graph.source(e);
-            if (!reached[u] && _tolerance.positive((*_capacity)[e])) {
-              reached[u] = true;
-              _level->initAddItem(u);
-              nqueue.push_back(u);
-            }
-          }
-        }
-        queue.swap(nqueue);
-      }
-      _level->initFinish();
-
-      for (OutArcIt e(_graph, _source); e != INVALID; ++e) {
-        if (_tolerance.positive((*_capacity)[e])) {
-          Node u = _graph.target(e);
-          if ((*_level)[u] == _level->maxLevel()) continue;
-          _flow->set(e, (*_capacity)[e]);
-          (*_excess)[u] += (*_capacity)[e];
-          if (u != _target && !_level->active(u)) {
-            _level->activate(u);
-          }
-        }
-      }
-    }
-
-    /// \brief Initializes the internal data structures using the
-    /// given flow map.
-    ///
-    /// Initializes the internal data structures and sets the initial
-    /// flow to the given \c flowMap. The \c flowMap should contain a
-    /// flow or at least a preflow, i.e. at each node excluding the
-    /// source node the incoming flow should greater or equal to the
-    /// outgoing flow.
-    /// \return \c false if the given \c flowMap is not a preflow.
-    template <typename FlowMap>
-    bool init(const FlowMap& flowMap) {
-      createStructures();
-
-      for (ArcIt e(_graph); e != INVALID; ++e) {
-        _flow->set(e, flowMap[e]);
-      }
-
-      for (NodeIt n(_graph); n != INVALID; ++n) {
-        Value excess = 0;
-        for (InArcIt e(_graph, n); e != INVALID; ++e) {
-          excess += (*_flow)[e];
-        }
-        for (OutArcIt e(_graph, n); e != INVALID; ++e) {
-          excess -= (*_flow)[e];
-        }
-        if (excess < 0 && n != _source) return false;
-        (*_excess)[n] = excess;
-      }
-
-      typename Digraph::template NodeMap<bool> reached(_graph, false);
-
-      _level->initStart();
-      _level->initAddItem(_target);
-
-      std::vector<Node> queue;
-      reached[_source] = true;
-
-      queue.push_back(_target);
-      reached[_target] = true;
-      while (!queue.empty()) {
-        _level->initNewLevel();
-        std::vector<Node> nqueue;
-        for (int i = 0; i < int(queue.size()); ++i) {
-          Node n = queue[i];
-          for (InArcIt e(_graph, n); e != INVALID; ++e) {
-            Node u = _graph.source(e);
-            if (!reached[u] &&
-                _tolerance.positive((*_capacity)[e] - (*_flow)[e])) {
-              reached[u] = true;
-              _level->initAddItem(u);
-              nqueue.push_back(u);
-            }
-          }
-          for (OutArcIt e(_graph, n); e != INVALID; ++e) {
-            Node v = _graph.target(e);
-            if (!reached[v] && _tolerance.positive((*_flow)[e])) {
-              reached[v] = true;
-              _level->initAddItem(v);
-              nqueue.push_back(v);
-            }
-          }
-        }
-        queue.swap(nqueue);
-      }
-      _level->initFinish();
-
-      for (OutArcIt e(_graph, _source); e != INVALID; ++e) {
-        Value rem = (*_capacity)[e] - (*_flow)[e];
-        if (_tolerance.positive(rem)) {
-          Node u = _graph.target(e);
-          if ((*_level)[u] == _level->maxLevel()) continue;
-          _flow->set(e, (*_capacity)[e]);
-          (*_excess)[u] += rem;
-          if (u != _target && !_level->active(u)) {
-            _level->activate(u);
-          }
-        }
-      }
-      for (InArcIt e(_graph, _source); e != INVALID; ++e) {
-        Value rem = (*_flow)[e];
-        if (_tolerance.positive(rem)) {
-          Node v = _graph.source(e);
-          if ((*_level)[v] == _level->maxLevel()) continue;
-          _flow->set(e, 0);
-          (*_excess)[v] += rem;
-          if (v != _target && !_level->active(v)) {
-            _level->activate(v);
-          }
-        }
-      }
-      return true;
-    }
-
-    /// \brief Starts the first phase of the preflow algorithm.
-    ///
-    /// The preflow algorithm consists of two phases, this method runs
-    /// the first phase. After the first phase the maximum flow value
-    /// and a minimum value cut can already be computed, although a
-    /// maximum flow is not yet obtained. So after calling this method
-    /// \ref flowValue() returns the value of a maximum flow and \ref
-    /// minCut() returns a minimum cut.
-    /// \pre One of the \ref init() functions must be called before
-    /// using this function.
-    void startFirstPhase() {
-      _phase = true;
-
-      while (true) {
-        int num = _node_num;
-
-        Node n = INVALID;
-        int level = -1;
-
-        while (num > 0) {
-          n = _level->highestActive();
-          if (n == INVALID) goto first_phase_done;
-          level = _level->highestActiveLevel();
-          --num;
-          
-          Value excess = (*_excess)[n];
-          int new_level = _level->maxLevel();
-
-          for (OutArcIt e(_graph, n); e != INVALID; ++e) {
-            Value rem = (*_capacity)[e] - (*_flow)[e];
-            if (!_tolerance.positive(rem)) continue;
-            Node v = _graph.target(e);
-            if ((*_level)[v] < level) {
-              if (!_level->active(v) && v != _target) {
-                _level->activate(v);
-              }
-              if (!_tolerance.less(rem, excess)) {
-                _flow->set(e, (*_flow)[e] + excess);
-                (*_excess)[v] += excess;
-                excess = 0;
-                goto no_more_push_1;
-              } else {
-                excess -= rem;
-                (*_excess)[v] += rem;
-                _flow->set(e, (*_capacity)[e]);
-              }
-            } else if (new_level > (*_level)[v]) {
-              new_level = (*_level)[v];
-            }
-          }
-
-          for (InArcIt e(_graph, n); e != INVALID; ++e) {
-            Value rem = (*_flow)[e];
-            if (!_tolerance.positive(rem)) continue;
-            Node v = _graph.source(e);
-            if ((*_level)[v] < level) {
-              if (!_level->active(v) && v != _target) {
-                _level->activate(v);
-              }
-              if (!_tolerance.less(rem, excess)) {
-                _flow->set(e, (*_flow)[e] - excess);
-                (*_excess)[v] += excess;
-                excess = 0;
-                goto no_more_push_1;
-              } else {
-                excess -= rem;
-                (*_excess)[v] += rem;
-                _flow->set(e, 0);
-              }
-            } else if (new_level > (*_level)[v]) {
-              new_level = (*_level)[v];
-            }
-          }
-
-        no_more_push_1:
-
-          (*_excess)[n] = excess;
-
-          if (excess != 0) {
-            if (new_level + 1 < _level->maxLevel()) {
-              _level->liftHighestActive(new_level + 1);
-            } else {
-              _level->liftHighestActiveToTop();
-            }
-            if (_level->emptyLevel(level)) {
-              _level->liftToTop(level);
-            }
-          } else {
-            _level->deactivate(n);
-          }
-        }
-
-        num = _node_num * 20;
-        while (num > 0) {
-          while (level >= 0 && _level->activeFree(level)) {
-            --level;
-          }
-          if (level == -1) {
-            n = _level->highestActive();
-            level = _level->highestActiveLevel();
-            if (n == INVALID) goto first_phase_done;
-          } else {
-            n = _level->activeOn(level);
-          }
-          --num;
-
-          Value excess = (*_excess)[n];
-          int new_level = _level->maxLevel();
-
-          for (OutArcIt e(_graph, n); e != INVALID; ++e) {
-            Value rem = (*_capacity)[e] - (*_flow)[e];
-            if (!_tolerance.positive(rem)) continue;
-            Node v = _graph.target(e);
-            if ((*_level)[v] < level) {
-              if (!_level->active(v) && v != _target) {
-                _level->activate(v);
-              }
-              if (!_tolerance.less(rem, excess)) {
-                _flow->set(e, (*_flow)[e] + excess);
-                (*_excess)[v] += excess;
-                excess = 0;
-                goto no_more_push_2;
-              } else {
-                excess -= rem;
-                (*_excess)[v] += rem;
-                _flow->set(e, (*_capacity)[e]);
-              }
-            } else if (new_level > (*_level)[v]) {
-              new_level = (*_level)[v];
-            }
-          }
-
-          for (InArcIt e(_graph, n); e != INVALID; ++e) {
-            Value rem = (*_flow)[e];
-            if (!_tolerance.positive(rem)) continue;
-            Node v = _graph.source(e);
-            if ((*_level)[v] < level) {
-              if (!_level->active(v) && v != _target) {
-                _level->activate(v);
-              }
-              if (!_tolerance.less(rem, excess)) {
-                _flow->set(e, (*_flow)[e] - excess);
-                (*_excess)[v] += excess;
-                excess = 0;
-                goto no_more_push_2;
-              } else {
-                excess -= rem;
-                (*_excess)[v] += rem;
-                _flow->set(e, 0);
-              }
-            } else if (new_level > (*_level)[v]) {
-              new_level = (*_level)[v];
-            }
-          }
-
-        no_more_push_2:
-
-          (*_excess)[n] = excess;
-
-          if (excess != 0) {
-            if (new_level + 1 < _level->maxLevel()) {
-              _level->liftActiveOn(level, new_level + 1);
-            } else {
-              _level->liftActiveToTop(level);
-            }
-            if (_level->emptyLevel(level)) {
-              _level->liftToTop(level);
-            }
-          } else {
-            _level->deactivate(n);
-          }
-        }
-      }
-    first_phase_done:;
-    }
-
-    /// \brief Starts the second phase of the preflow algorithm.
-    ///
-    /// The preflow algorithm consists of two phases, this method runs
-    /// the second phase. After calling one of the \ref init() functions
-    /// and \ref startFirstPhase() and then \ref startSecondPhase(),
-    /// \ref flowMap() returns a maximum flow, \ref flowValue() returns the
-    /// value of a maximum flow, \ref minCut() returns a minimum cut
-    /// \pre One of the \ref init() functions and \ref startFirstPhase()
-    /// must be called before using this function.
-    void startSecondPhase() {
-      _phase = false;
-
-      typename Digraph::template NodeMap<bool> reached(_graph);
-      for (NodeIt n(_graph); n != INVALID; ++n) {
-        reached[n] = (*_level)[n] < _level->maxLevel();
-      }
-
-      _level->initStart();
-      _level->initAddItem(_source);
-
-      std::vector<Node> queue;
-      queue.push_back(_source);
-      reached[_source] = true;
-
-      while (!queue.empty()) {
-        _level->initNewLevel();
-        std::vector<Node> nqueue;
-        for (int i = 0; i < int(queue.size()); ++i) {
-          Node n = queue[i];
-          for (OutArcIt e(_graph, n); e != INVALID; ++e) {
-            Node v = _graph.target(e);
-            if (!reached[v] && _tolerance.positive((*_flow)[e])) {
-              reached[v] = true;
-              _level->initAddItem(v);
-              nqueue.push_back(v);
-            }
-          }
-          for (InArcIt e(_graph, n); e != INVALID; ++e) {
-            Node u = _graph.source(e);
-            if (!reached[u] &&
-                _tolerance.positive((*_capacity)[e] - (*_flow)[e])) {
-              reached[u] = true;
-              _level->initAddItem(u);
-              nqueue.push_back(u);
-            }
-          }
-        }
-        queue.swap(nqueue);
-      }
-      _level->initFinish();
-
-      for (NodeIt n(_graph); n != INVALID; ++n) {
-        if (!reached[n]) {
-          _level->dirtyTopButOne(n);
-        } else if ((*_excess)[n] > 0 && _target != n) {
-          _level->activate(n);
-        }
-      }
-
-      Node n;
-      while ((n = _level->highestActive()) != INVALID) {
-        Value excess = (*_excess)[n];
-        int level = _level->highestActiveLevel();
-        int new_level = _level->maxLevel();
-
-        for (OutArcIt e(_graph, n); e != INVALID; ++e) {
-          Value rem = (*_capacity)[e] - (*_flow)[e];
-          if (!_tolerance.positive(rem)) continue;
-          Node v = _graph.target(e);
-          if ((*_level)[v] < level) {
-            if (!_level->active(v) && v != _source) {
-              _level->activate(v);
-            }
-            if (!_tolerance.less(rem, excess)) {
-              _flow->set(e, (*_flow)[e] + excess);
-              (*_excess)[v] += excess;
-              excess = 0;
-              goto no_more_push;
-            } else {
-              excess -= rem;
-              (*_excess)[v] += rem;
-              _flow->set(e, (*_capacity)[e]);
-            }
-          } else if (new_level > (*_level)[v]) {
-            new_level = (*_level)[v];
-          }
-        }
-
-        for (InArcIt e(_graph, n); e != INVALID; ++e) {
-          Value rem = (*_flow)[e];
-          if (!_tolerance.positive(rem)) continue;
-          Node v = _graph.source(e);
-          if ((*_level)[v] < level) {
-            if (!_level->active(v) && v != _source) {
-              _level->activate(v);
-            }
-            if (!_tolerance.less(rem, excess)) {
-              _flow->set(e, (*_flow)[e] - excess);
-              (*_excess)[v] += excess;
-              excess = 0;
-              goto no_more_push;
-            } else {
-              excess -= rem;
-              (*_excess)[v] += rem;
-              _flow->set(e, 0);
-            }
-          } else if (new_level > (*_level)[v]) {
-            new_level = (*_level)[v];
-          }
-        }
-
-      no_more_push:
-
-        (*_excess)[n] = excess;
-
-        if (excess != 0) {
-          if (new_level + 1 < _level->maxLevel()) {
-            _level->liftHighestActive(new_level + 1);
-          } else {
-            // Calculation error
-            _level->liftHighestActiveToTop();
-          }
-          if (_level->emptyLevel(level)) {
-            // Calculation error
-            _level->liftToTop(level);
-          }
-        } else {
-          _level->deactivate(n);
-        }
-
-      }
-    }
-
-    /// \brief Runs the preflow algorithm.
-    ///
-    /// Runs the preflow algorithm.
-    /// \note pf.run() is just a shortcut of the following code.
-    /// \code
-    ///   pf.init();
-    ///   pf.startFirstPhase();
-    ///   pf.startSecondPhase();
-    /// \endcode
-    void run() {
-      init();
-      startFirstPhase();
-      startSecondPhase();
-    }
-
-    /// \brief Runs the preflow algorithm to compute the minimum cut.
-    ///
-    /// Runs the preflow algorithm to compute the minimum cut.
-    /// \note pf.runMinCut() is just a shortcut of the following code.
-    /// \code
-    ///   pf.init();
-    ///   pf.startFirstPhase();
-    /// \endcode
-    void runMinCut() {
-      init();
-      startFirstPhase();
-    }
-
-    /// @}
-
-    /// \name Query Functions
-    /// The results of the preflow algorithm can be obtained using these
-    /// functions.\n
-    /// Either one of the \ref run() "run*()" functions or one of the
-    /// \ref startFirstPhase() "start*()" functions should be called
-    /// before using them.
-
-    ///@{
-
-    /// \brief Returns the value of the maximum flow.
-    ///
-    /// Returns the value of the maximum flow by returning the excess
-    /// of the target node. This value equals to the value of
-    /// the maximum flow already after the first phase of the algorithm.
-    ///
-    /// \pre Either \ref run() or \ref init() must be called before
-    /// using this function.
-    Value flowValue() const {
-      return (*_excess)[_target];
-    }
-
-    /// \brief Returns the flow value on the given arc.
-    ///
-    /// Returns the flow value on the given arc. This method can
-    /// be called after the second phase of the algorithm.
-    ///
-    /// \pre Either \ref run() or \ref init() must be called before
-    /// using this function.
-    Value flow(const Arc& arc) const {
-      return (*_flow)[arc];
-    }
-
-    /// \brief Returns a const reference to the flow map.
-    ///
-    /// Returns a const reference to the arc map storing the found flow.
-    /// This method can be called after the second phase of the algorithm.
-    ///
-    /// \pre Either \ref run() or \ref init() must be called before
-    /// using this function.
-    const FlowMap& flowMap() const {
-      return *_flow;
-    }
-
-    /// \brief Returns \c true when the node is on the source side of the
-    /// minimum cut.
-    ///
-    /// Returns true when the node is on the source side of the found
-    /// minimum cut. This method can be called both after running \ref
-    /// startFirstPhase() and \ref startSecondPhase().
-    ///
-    /// \pre Either \ref run() or \ref init() must be called before
-    /// using this function.
-    bool minCut(const Node& node) const {
-      return ((*_level)[node] == _level->maxLevel()) == _phase;
-    }
-
-    /// \brief Gives back a minimum value cut.
-    ///
-    /// Sets \c cutMap to the characteristic vector of a minimum value
-    /// cut. \c cutMap should be a \ref concepts::WriteMap "writable"
-    /// node map with \c bool (or convertible) value type.
-    ///
-    /// This method can be called both after running \ref startFirstPhase()
-    /// and \ref startSecondPhase(). The result after the second phase
-    /// could be slightly different if inexact computation is used.
-    ///
-    /// \note This function calls \ref minCut() for each node, so it runs in
-    /// O(n) time.
-    ///
-    /// \pre Either \ref run() or \ref init() must be called before
-    /// using this function.
-    template <typename CutMap>
-    void minCutMap(CutMap& cutMap) const {
-      for (NodeIt n(_graph); n != INVALID; ++n) {
-        cutMap.set(n, minCut(n));
-      }
-    }
-
-    /// @}
-  };
-}
-
-#endif
Index: mon/quad_heap.h
===================================================================
--- lemon/quad_heap.h	(revision 929)
+++ 	(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: mon/radix_heap.h
===================================================================
--- lemon/radix_heap.h	(revision 758)
+++ 	(revision )
@@ -1,438 +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_RADIX_HEAP_H
-#define LEMON_RADIX_HEAP_H
-
-///\ingroup heaps
-///\file
-///\brief Radix heap implementation.
-
-#include <vector>
-#include <lemon/error.h>
-
-namespace lemon {
-
-
-  /// \ingroup heaps
-  ///
-  /// \brief Radix heap data structure.
-  ///
-  /// 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.
-  ///
-  /// \tparam IM A read-writable item map with \c int values, used
-  /// internally to handle the cross references.
-  template <typename IM>
-  class RadixHeap {
-
-  public:
-
-    /// Type of the item-int map.
-    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.
-    /// \see RadixHeap
-    class PriorityUnderflowError : public Exception {
-    public:
-      virtual const char* what() const throw() {
-        return "lemon::RadixHeap::PriorityUnderflowError";
-      }
-    };
-
-    /// \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:
-
-    struct RadixItem {
-      int prev, next, box;
-      Item item;
-      int prio;
-      RadixItem(Item _item, int _prio) : item(_item), prio(_prio) {}
-    };
-
-    struct RadixBox {
-      int first;
-      int min, size;
-      RadixBox(int _min, int _size) : first(-1), min(_min), size(_size) {}
-    };
-
-    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)) {
-        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)) {
-        extend();
-      }
-    }
-
-  private:
-
-    bool upper(int box, Prio pr) {
-      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
-    void remove(int index) {
-      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
-    void insert(int box, int index) {
-      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
-    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;
-      remove(index);
-      int box = findUp(_data[index].box, _data[index].prio);
-      insert(box, index);
-    }
-
-    // Find up the proper box for the item with the given priority
-    int findUp(int start, int pr) {
-      while (lower(start, pr)) {
-        if (++start == int(_boxes.size())) {
-          extend();
-        }
-      }
-      return start;
-    }
-
-    // Move an item down into the proper box
-    void bubbleDown(int index) {
-      if (!upper(_data[index].box, _data[index].prio)) return;
-      remove(index);
-      int box = findDown(_data[index].box, _data[index].prio);
-      insert(box, index);
-    }
-
-    // Find down the proper box for the item with the given priority
-    int findDown(int start, int pr) {
-      while (upper(start, pr)) {
-        if (--start < 0) throw PriorityUnderflowError();
-      }
-      return start;
-    }
-
-    // Find the first non-empty box
-    int findFirst() {
-      int first = 0;
-      while (_boxes[first].first == -1) ++first;
-      return first;
-    }
-
-    // Gives back the minimum priority of the given 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;
-      }
-      return min;
-    }
-
-    // Rearrange the items of the heap and make the first box non-empty
-    void moveDown() {
-      int box = findFirst();
-      if (box == 0) return;
-      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;
-      while (curr != -1) {
-        next = _data[curr].next;
-        bubbleDown(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;
-        } else {
-          _boxes[_data[index].box].first = index;
-        }
-        if (_data[index].next != -1) {
-          _data[_data[index].next].prev = index;
-        }
-        _iim[_data[index].item] = index;
-      }
-      _data.pop_back();
-    }
-
-  public:
-
-    /// \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.
-    /// \warning This method may throw an \c UnderFlowPriorityException.
-    void push(const Item &i, const Prio &p) {
-      int n = _data.size();
-      _iim.set(i, n);
-      _data.push_back(RadixItem(i, p));
-      while (lower(_boxes.size() - 1, p)) {
-        extend();
-      }
-      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.
-    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.
-    Prio prio() const {
-      const_cast<RadixHeap<ItemIntMap>&>(*this).moveDown();
-      return _data[_boxes[0].first].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() {
-      moveDown();
-      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.
-    void erase(const Item &i) {
-      int index = _iim[i];
-      _iim[i] = POST_HEAP;
-      remove(index);
-      relocateLast(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.
-    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.
-    /// \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];
-      if( idx < 0 ) {
-        push(i, p);
-      }
-      else if( p >= _data[idx].prio ) {
-        _data[idx].prio = p;
-        bubbleUp(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.
-    /// \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.
-    /// \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.
-    /// \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;
-      }
-    }
-
-  }; // class RadixHeap
-
-} // namespace lemon
-
-#endif // LEMON_RADIX_HEAP_H
Index: mon/radix_sort.h
===================================================================
--- lemon/radix_sort.h	(revision 606)
+++ 	(revision )
@@ -1,487 +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 RADIX_SORT_H
-#define RADIX_SORT_H
-
-/// \ingroup auxalg
-/// \file
-/// \brief Radix sort
-///
-/// Linear time sorting algorithms
-
-#include <vector>
-#include <limits>
-#include <iterator>
-#include <algorithm>
-
-namespace lemon {
-
-  namespace _radix_sort_bits {
-
-    template <typename Value>
-    struct Identity {
-      const Value& operator()(const Value& val) {
-        return val;
-      }
-    };
-
-
-    template <typename Value, typename Iterator, typename Functor>
-    Iterator radixSortPartition(Iterator first, Iterator last,
-                                Functor functor, Value mask) {
-      while (first != last && !(functor(*first) & mask)) {
-        ++first;
-      }
-      if (first == last) {
-        return first;
-      }
-      --last;
-      while (first != last && (functor(*last) & mask)) {
-        --last;
-      }
-      if (first == last) {
-        return first;
-      }
-      std::iter_swap(first, last);
-      ++first;
-      if (!(first < last)) {
-        return first;
-      }
-      while (true) {
-        while (!(functor(*first) & mask)) {
-          ++first;
-        }
-        --last;
-        while (functor(*last) & mask) {
-          --last;
-        }
-        if (!(first < last)) {
-          return first;
-        }
-        std::iter_swap(first, last);
-        ++first;
-      }
-    }
-
-    template <typename Iterator, typename Functor>
-    Iterator radixSortSignPartition(Iterator first, Iterator last,
-                                    Functor functor) {
-      while (first != last && functor(*first) < 0) {
-        ++first;
-      }
-      if (first == last) {
-        return first;
-      }
-      --last;
-      while (first != last && functor(*last) >= 0) {
-        --last;
-      }
-      if (first == last) {
-        return first;
-      }
-      std::iter_swap(first, last);
-      ++first;
-      if (!(first < last)) {
-        return first;
-      }
-      while (true) {
-        while (functor(*first) < 0) {
-          ++first;
-        }
-        --last;
-        while (functor(*last) >= 0) {
-          --last;
-        }
-        if (!(first < last)) {
-          return first;
-        }
-        std::iter_swap(first, last);
-        ++first;
-      }
-    }
-
-    template <typename Value, typename Iterator, typename Functor>
-    void radixIntroSort(Iterator first, Iterator last,
-                        Functor functor, Value mask) {
-      while (mask != 0 && last - first > 1) {
-        Iterator cut = radixSortPartition(first, last, functor, mask);
-        mask >>= 1;
-        radixIntroSort(first, cut, functor, mask);
-        first = cut;
-      }
-    }
-
-    template <typename Value, typename Iterator, typename Functor>
-    void radixSignedSort(Iterator first, Iterator last, Functor functor) {
-
-      Iterator cut = radixSortSignPartition(first, last, functor);
-
-      Value mask;
-      int max_digit;
-      Iterator it;
-
-      mask = ~0; max_digit = 0;
-      for (it = first; it != cut; ++it) {
-        while ((mask & functor(*it)) != mask) {
-          ++max_digit;
-          mask <<= 1;
-        }
-      }
-      radixIntroSort(first, cut, functor, 1 << max_digit);
-
-      mask = 0; max_digit = 0;
-      for (it = cut; it != last; ++it) {
-        while ((mask | functor(*it)) != mask) {
-          ++max_digit;
-          mask <<= 1; mask |= 1;
-        }
-      }
-      radixIntroSort(cut, last, functor, 1 << max_digit);
-    }
-
-    template <typename Value, typename Iterator, typename Functor>
-    void radixUnsignedSort(Iterator first, Iterator last, Functor functor) {
-
-      Value mask = 0;
-      int max_digit = 0;
-
-      Iterator it;
-      for (it = first; it != last; ++it) {
-        while ((mask | functor(*it)) != mask) {
-          ++max_digit;
-          mask <<= 1; mask |= 1;
-        }
-      }
-      radixIntroSort(first, last, functor, 1 << max_digit);
-    }
-
-
-    template <typename Value,
-              bool sign = std::numeric_limits<Value>::is_signed >
-    struct RadixSortSelector {
-      template <typename Iterator, typename Functor>
-      static void sort(Iterator first, Iterator last, Functor functor) {
-        radixSignedSort<Value>(first, last, functor);
-      }
-    };
-
-    template <typename Value>
-    struct RadixSortSelector<Value, false> {
-      template <typename Iterator, typename Functor>
-      static void sort(Iterator first, Iterator last, Functor functor) {
-        radixUnsignedSort<Value>(first, last, functor);
-      }
-    };
-
-  }
-
-  /// \ingroup auxalg
-  ///
-  /// \brief Sorts the STL compatible range into ascending order.
-  ///
-  /// The \c radixSort sorts an STL compatible range into ascending
-  /// order.  The radix sort algorithm can sort items which are mapped
-  /// to integers with an adaptable unary function \c functor and the
-  /// order will be ascending according to these mapped values.
-  ///
-  /// It is also possible to use a normal function instead
-  /// of the functor object. If the functor is not given it will use
-  /// the identity function instead.
-  ///
-  /// This is a special quick sort algorithm where the pivot
-  /// values to split the items are choosen to be 2<sup>k</sup>
-  /// for each \c k.
-  /// Therefore, the time complexity of the algorithm is O(log(c)*n) and
-  /// it uses O(log(c)) additional space, where \c c is the maximal value
-  /// and \c n is the number of the items in the container.
-  ///
-  /// \param first The begin of the given range.
-  /// \param last The end of the given range.
-  /// \param functor An adaptible unary function or a normal function
-  /// which maps the items to any integer type which can be either
-  /// signed or unsigned.
-  ///
-  /// \sa stableRadixSort()
-  template <typename Iterator, typename Functor>
-  void radixSort(Iterator first, Iterator last, Functor functor) {
-    using namespace _radix_sort_bits;
-    typedef typename Functor::result_type Value;
-    RadixSortSelector<Value>::sort(first, last, functor);
-  }
-
-  template <typename Iterator, typename Value, typename Key>
-  void radixSort(Iterator first, Iterator last, Value (*functor)(Key)) {
-    using namespace _radix_sort_bits;
-    RadixSortSelector<Value>::sort(first, last, functor);
-  }
-
-  template <typename Iterator, typename Value, typename Key>
-  void radixSort(Iterator first, Iterator last, Value& (*functor)(Key)) {
-    using namespace _radix_sort_bits;
-    RadixSortSelector<Value>::sort(first, last, functor);
-  }
-
-  template <typename Iterator, typename Value, typename Key>
-  void radixSort(Iterator first, Iterator last, Value (*functor)(Key&)) {
-    using namespace _radix_sort_bits;
-    RadixSortSelector<Value>::sort(first, last, functor);
-  }
-
-  template <typename Iterator, typename Value, typename Key>
-  void radixSort(Iterator first, Iterator last, Value& (*functor)(Key&)) {
-    using namespace _radix_sort_bits;
-    RadixSortSelector<Value>::sort(first, last, functor);
-  }
-
-  template <typename Iterator>
-  void radixSort(Iterator first, Iterator last) {
-    using namespace _radix_sort_bits;
-    typedef typename std::iterator_traits<Iterator>::value_type Value;
-    RadixSortSelector<Value>::sort(first, last, Identity<Value>());
-  }
-
-  namespace _radix_sort_bits {
-
-    template <typename Value>
-    unsigned char valueByte(Value value, int byte) {
-      return value >> (std::numeric_limits<unsigned char>::digits * byte);
-    }
-
-    template <typename Functor, typename Key>
-    void stableRadixIntroSort(Key *first, Key *last, Key *target,
-                              int byte, Functor functor) {
-      const int size =
-        unsigned(std::numeric_limits<unsigned char>::max()) + 1;
-      std::vector<int> counter(size);
-      for (int i = 0; i < size; ++i) {
-        counter[i] = 0;
-      }
-      Key *it = first;
-      while (first != last) {
-        ++counter[valueByte(functor(*first), byte)];
-        ++first;
-      }
-      int prev, num = 0;
-      for (int i = 0; i < size; ++i) {
-        prev = num;
-        num += counter[i];
-        counter[i] = prev;
-      }
-      while (it != last) {
-        target[counter[valueByte(functor(*it), byte)]++] = *it;
-        ++it;
-      }
-    }
-
-    template <typename Functor, typename Key>
-    void signedStableRadixIntroSort(Key *first, Key *last, Key *target,
-                                    int byte, Functor functor) {
-      const int size =
-        unsigned(std::numeric_limits<unsigned char>::max()) + 1;
-      std::vector<int> counter(size);
-      for (int i = 0; i < size; ++i) {
-        counter[i] = 0;
-      }
-      Key *it = first;
-      while (first != last) {
-        counter[valueByte(functor(*first), byte)]++;
-        ++first;
-      }
-      int prev, num = 0;
-      for (int i = size / 2; i < size; ++i) {
-        prev = num;
-        num += counter[i];
-        counter[i] = prev;
-      }
-      for (int i = 0; i < size / 2; ++i) {
-        prev = num;
-        num += counter[i];
-        counter[i] = prev;
-      }
-      while (it != last) {
-        target[counter[valueByte(functor(*it), byte)]++] = *it;
-        ++it;
-      }
-    }
-
-
-    template <typename Value, typename Iterator, typename Functor>
-    void stableRadixSignedSort(Iterator first, Iterator last, Functor functor) {
-      if (first == last) return;
-      typedef typename std::iterator_traits<Iterator>::value_type Key;
-      typedef std::allocator<Key> Allocator;
-      Allocator allocator;
-
-      int length = std::distance(first, last);
-      Key* buffer = allocator.allocate(2 * length);
-      try {
-        bool dir = true;
-        std::copy(first, last, buffer);
-        for (int i = 0; i < int(sizeof(Value)) - 1; ++i) {
-          if (dir) {
-            stableRadixIntroSort(buffer, buffer + length, buffer + length,
-                                 i, functor);
-          } else {
-            stableRadixIntroSort(buffer + length, buffer + 2 * length, buffer,
-                                 i, functor);
-          }
-          dir = !dir;
-        }
-        if (dir) {
-          signedStableRadixIntroSort(buffer, buffer + length, buffer + length,
-                                     sizeof(Value) - 1, functor);
-          std::copy(buffer + length, buffer + 2 * length, first);
-        }        else {
-          signedStableRadixIntroSort(buffer + length, buffer + 2 * length,
-                                     buffer, sizeof(Value) - 1, functor);
-          std::copy(buffer, buffer + length, first);
-        }
-      } catch (...) {
-        allocator.deallocate(buffer, 2 * length);
-        throw;
-      }
-      allocator.deallocate(buffer, 2 * length);
-    }
-
-    template <typename Value, typename Iterator, typename Functor>
-    void stableRadixUnsignedSort(Iterator first, Iterator last,
-                                 Functor functor) {
-      if (first == last) return;
-      typedef typename std::iterator_traits<Iterator>::value_type Key;
-      typedef std::allocator<Key> Allocator;
-      Allocator allocator;
-
-      int length = std::distance(first, last);
-      Key *buffer = allocator.allocate(2 * length);
-      try {
-        bool dir = true;
-        std::copy(first, last, buffer);
-        for (int i = 0; i < int(sizeof(Value)); ++i) {
-          if (dir) {
-            stableRadixIntroSort(buffer, buffer + length,
-                                 buffer + length, i, functor);
-          } else {
-            stableRadixIntroSort(buffer + length, buffer + 2 * length,
-                                 buffer, i, functor);
-          }
-          dir = !dir;
-        }
-        if (dir) {
-          std::copy(buffer, buffer + length, first);
-        }        else {
-          std::copy(buffer + length, buffer + 2 * length, first);
-        }
-      } catch (...) {
-        allocator.deallocate(buffer, 2 * length);
-        throw;
-      }
-      allocator.deallocate(buffer, 2 * length);
-    }
-
-
-
-    template <typename Value,
-              bool sign = std::numeric_limits<Value>::is_signed >
-    struct StableRadixSortSelector {
-      template <typename Iterator, typename Functor>
-      static void sort(Iterator first, Iterator last, Functor functor) {
-        stableRadixSignedSort<Value>(first, last, functor);
-      }
-    };
-
-    template <typename Value>
-    struct StableRadixSortSelector<Value, false> {
-      template <typename Iterator, typename Functor>
-      static void sort(Iterator first, Iterator last, Functor functor) {
-        stableRadixUnsignedSort<Value>(first, last, functor);
-      }
-    };
-
-  }
-
-  /// \ingroup auxalg
-  ///
-  /// \brief Sorts the STL compatible range into ascending order in a stable
-  /// way.
-  ///
-  /// This function sorts an STL compatible range into ascending
-  /// order according to an integer mapping in the same as radixSort() does.
-  ///
-  /// This sorting algorithm is stable, i.e. the order of two equal
-  /// elements remains the same after the sorting.
-  ///
-  /// This sort algorithm  use a radix forward sort on the
-  /// bytes of the integer number. The algorithm sorts the items
-  /// byte-by-byte. First, it counts how many times a byte value occurs
-  /// in the container, then it copies the corresponding items to
-  /// another container in asceding order in O(n) time.
-  ///
-  /// The time complexity of the algorithm is O(log(c)*n) and
-  /// it uses O(n) additional space, where \c c is the
-  /// maximal value and \c n is the number of the items in the
-  /// container.
-  ///
-
-  /// \param first The begin of the given range.
-  /// \param last The end of the given range.
-  /// \param functor An adaptible unary function or a normal function
-  /// which maps the items to any integer type which can be either
-  /// signed or unsigned.
-  /// \sa radixSort()
-  template <typename Iterator, typename Functor>
-  void stableRadixSort(Iterator first, Iterator last, Functor functor) {
-    using namespace _radix_sort_bits;
-    typedef typename Functor::result_type Value;
-    StableRadixSortSelector<Value>::sort(first, last, functor);
-  }
-
-  template <typename Iterator, typename Value, typename Key>
-  void stableRadixSort(Iterator first, Iterator last, Value (*functor)(Key)) {
-    using namespace _radix_sort_bits;
-    StableRadixSortSelector<Value>::sort(first, last, functor);
-  }
-
-  template <typename Iterator, typename Value, typename Key>
-  void stableRadixSort(Iterator first, Iterator last, Value& (*functor)(Key)) {
-    using namespace _radix_sort_bits;
-    StableRadixSortSelector<Value>::sort(first, last, functor);
-  }
-
-  template <typename Iterator, typename Value, typename Key>
-  void stableRadixSort(Iterator first, Iterator last, Value (*functor)(Key&)) {
-    using namespace _radix_sort_bits;
-    StableRadixSortSelector<Value>::sort(first, last, functor);
-  }
-
-  template <typename Iterator, typename Value, typename Key>
-  void stableRadixSort(Iterator first, Iterator last, Value& (*functor)(Key&)) {
-    using namespace _radix_sort_bits;
-    StableRadixSortSelector<Value>::sort(first, last, functor);
-  }
-
-  template <typename Iterator>
-  void stableRadixSort(Iterator first, Iterator last) {
-    using namespace _radix_sort_bits;
-    typedef typename std::iterator_traits<Iterator>::value_type Value;
-    StableRadixSortSelector<Value>::sort(first, last, Identity<Value>());
-  }
-
-}
-
-#endif
Index: lemon/random.cc
===================================================================
--- lemon/random.cc	(revision 463)
+++ lemon/random.cc	(revision 209)
@@ -3,5 +3,5 @@
  * This file is a part of LEMON, a generic C++ optimization library.
  *
- * Copyright (C) 2003-2009
+ * Copyright (C) 2003-2008
  * Egervary Jeno Kombinatorikus Optimalizalasi Kutatocsoport
  * (Egervary Research Group on Combinatorial Optimization, EGRES).
Index: lemon/random.h
===================================================================
--- lemon/random.h	(revision 631)
+++ lemon/random.h	(revision 517)
@@ -3,5 +3,5 @@
  * This file is a part of LEMON, a generic C++ optimization library.
  *
- * Copyright (C) 2003-2009
+ * Copyright (C) 2003-2008
  * Egervary Jeno Kombinatorikus Optimalizalasi Kutatocsoport
  * (Egervary Research Group on Combinatorial Optimization, EGRES).
@@ -531,4 +531,8 @@
     /// @{
 
+    ///\name Initialization
+    ///
+    /// @{
+
     /// \brief Default constructor
     ///
@@ -604,5 +608,5 @@
     /// function with the <tt>/dev/urandom</tt> file. If it does not success,
     /// it uses the \c seedFromTime().
-    /// \return Currently always \c true.
+    /// \return Currently always true.
     bool seed() {
 #ifndef WIN32
@@ -625,5 +629,5 @@
     /// \param file The source file
     /// \param offset The offset, from the file read.
-    /// \return \c true when the seeding successes.
+    /// \return True when the seeding successes.
 #ifndef WIN32
     bool seedFromFile(const std::string& file = "/dev/urandom", int offset = 0)
@@ -646,5 +650,5 @@
     /// current process id and the current time for initialize the
     /// random sequence.
-    /// \return Currently always \c true.
+    /// \return Currently always true.
     bool seedFromTime() {
 #ifndef WIN32
@@ -660,5 +664,5 @@
     /// @}
 
-    ///\name Uniform Distributions
+    ///\name Uniform distributions
     ///
     /// @{
@@ -676,4 +680,10 @@
       return real<double>();
     }
+
+    /// @}
+
+    ///\name Uniform distributions
+    ///
+    /// @{
 
     /// \brief Returns a random real number from the range [0, 1)
@@ -731,4 +741,6 @@
       return _random_bits::IntConversion<Number, Word>::convert(core);
     }
+
+    /// @}
 
     unsigned int uinteger() {
@@ -763,9 +775,10 @@
     /// @}
 
-    ///\name Non-uniform Distributions
-    ///
+    ///\name Non-uniform distributions
+    ///
+
     ///@{
 
-    /// \brief Returns a random bool with given probability of true result.
+    /// \brief Returns a random bool
     ///
     /// It returns a random bool with given probability of true result.
@@ -774,7 +787,7 @@
     }
 
-    /// Standard normal (Gauss) distribution
-
-    /// Standard normal (Gauss) distribution.
+    /// Standard Gauss distribution
+
+    /// Standard Gauss distribution.
     /// \note The Cartesian form of the Box-Muller
     /// transformation is used to generate a random normal distribution.
@@ -789,51 +802,11 @@
       return std::sqrt(-2*std::log(S)/S)*V1;
     }
-    /// Normal (Gauss) distribution with given mean and standard deviation
-
-    /// Normal (Gauss) distribution with given mean and standard deviation.
+    /// Gauss distribution with given mean and standard deviation
+
+    /// Gauss distribution with given mean and standard deviation.
     /// \sa gauss()
     double gauss(double mean,double std_dev)
     {
       return gauss()*std_dev+mean;
-    }
-
-    /// Lognormal distribution
-
-    /// Lognormal distribution. The parameters are the mean and the standard
-    /// deviation of <tt>exp(X)</tt>.
-    ///
-    double lognormal(double n_mean,double n_std_dev)
-    {
-      return std::exp(gauss(n_mean,n_std_dev));
-    }
-    /// Lognormal distribution
-
-    /// Lognormal distribution. The parameter is an <tt>std::pair</tt> of
-    /// the mean and the standard deviation of <tt>exp(X)</tt>.
-    ///
-    double lognormal(const std::pair<double,double> &params)
-    {
-      return std::exp(gauss(params.first,params.second));
-    }
-    /// Compute the lognormal parameters from mean and standard deviation
-
-    /// This function computes the lognormal parameters from mean and
-    /// standard deviation. The return value can direcly be passed to
-    /// lognormal().
-    std::pair<double,double> lognormalParamsFromMD(double mean,
-                                                   double std_dev)
-    {
-      double fr=std_dev/mean;
-      fr*=fr;
-      double lg=std::log(1+fr);
-      return std::pair<double,double>(std::log(mean)-lg/2.0,std::sqrt(lg));
-    }
-    /// Lognormal distribution with given mean and standard deviation
-
-    /// Lognormal distribution with given mean and standard deviation.
-    ///
-    double lognormalMD(double mean,double std_dev)
-    {
-      return lognormal(lognormalParamsFromMD(mean,std_dev));
     }
 
@@ -939,6 +912,7 @@
     ///@}
 
-    ///\name Two Dimensional Distributions
-    ///
+    ///\name Two dimensional distributions
+    ///
+
     ///@{
 
@@ -957,5 +931,5 @@
       return dim2::Point<double>(V1,V2);
     }
-    /// A kind of two dimensional normal (Gauss) distribution
+    /// A kind of two dimensional Gauss distribution
 
     /// This function provides a turning symmetric two-dimensional distribution.
Index: lemon/smart_graph.h
===================================================================
--- lemon/smart_graph.h	(revision 956)
+++ lemon/smart_graph.h	(revision 313)
@@ -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).
@@ -33,5 +33,8 @@
 
   class SmartDigraph;
-
+  ///Base of SmartDigraph
+
+  ///Base of SmartDigraph
+  ///
   class SmartDigraphBase {
   protected:
@@ -53,5 +56,5 @@
   public:
 
-    typedef SmartDigraphBase Digraph;
+    typedef SmartDigraphBase Graph;
 
     class Node;
@@ -65,5 +68,5 @@
 
     typedef True NodeNumTag;
-    typedef True ArcNumTag;
+    typedef True EdgeNumTag;
 
     int nodeNum() const { return nodes.size(); }
@@ -185,26 +188,30 @@
   ///\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 conforms to the \ref concepts::Digraph "Digraph concept" with
+  ///an important extra feature that its maps are real \ref
+  ///concepts::ReferenceMap "reference map"s.
   ///
-  ///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 {
+  public:
+
     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 +226,77 @@
     ///Add a new node to the digraph.
 
-    ///This function adds a new node to the digraph.
-    ///\return The new node.
+    /// \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) {
+    ///\return the new arc.
+    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.
@@ -269,38 +306,8 @@
       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(int i=nodes[b._id].first_out;i!=-1;i++) arcs[i].source=b._id;
       if(connect) addArc(n,b);
       return b;
     }
-
-    ///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 +335,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 +360,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 +374,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 +388,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()
       {
@@ -410,5 +421,5 @@
   public:
 
-    typedef SmartGraphBase Graph;
+    typedef SmartGraphBase Digraph;
 
     class Node;
@@ -454,6 +465,6 @@
 
     public:
-      operator Edge() const {
-        return _id != -1 ? edgeFromId(_id / 2) : INVALID;
+      operator Edge() const { 
+        return _id != -1 ? edgeFromId(_id / 2) : INVALID; 
       }
 
@@ -470,11 +481,4 @@
       : nodes(), arcs() {}
 
-    typedef True NodeNumTag;
-    typedef True EdgeNumTag;
-    typedef True ArcNumTag;
-
-    int nodeNum() const { return nodes.size(); }
-    int edgeNum() const { return arcs.size() / 2; }
-    int arcNum() const { return arcs.size(); }
 
     int maxNodeId() const { return nodes.size()-1; }
@@ -500,5 +504,5 @@
     }
 
-    static void next(Node& node) {
+    void next(Node& node) const {
       --node._id;
     }
@@ -508,5 +512,5 @@
     }
 
-    static void next(Arc& arc) {
+    void next(Arc& arc) const {
       --arc._id;
     }
@@ -516,5 +520,5 @@
     }
 
-    static void next(Edge& arc) {
+    void next(Edge& arc) const {
       --arc._id;
     }
@@ -613,30 +617,37 @@
   /// \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>.
+  /// Except from this it 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.
+  /// It also has an
+  /// important extra feature that
+  /// its maps are real \ref concepts::ReferenceMap "reference map"s.
   ///
-  /// This class provides constant time counting for nodes, edges and arcs.
+  /// \sa concepts::Graph.
   ///
-  /// \sa concepts::Graph
-  /// \sa SmartDigraph
   class SmartGraph : public ExtendedSmartGraphBase {
+  private:
+
+    ///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 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 &) {}
+
+  public:
+
     typedef ExtendedSmartGraphBase Parent;
 
-  private:
-    /// Graphs are \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.
-    void operator=(const SmartGraph &) {}
-
-  public:
-
     /// Constructor
 
@@ -645,74 +656,53 @@
     SmartGraph() {}
 
-    /// \brief Add a new node to the graph.
-    ///
-    /// This function adds a new node to the graph.
-    /// \return The new node.
+    ///Add a new node to the graph.
+
+    /// \return the new node.
+    ///
     Node addNode() { return Parent::addNode(); }
 
-    /// \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:
@@ -739,6 +729,6 @@
         dir.push_back(arcFromId(n-1));
         Parent::notifier(Arc()).erase(dir);
-        nodes[arcs[n-1].target].first_out=arcs[n].next_out;
-        nodes[arcs[n].target].first_out=arcs[n-1].next_out;
+        nodes[arcs[n].target].first_out=arcs[n].next_out;
+        nodes[arcs[n-1].target].first_out=arcs[n-1].next_out;
         arcs.pop_back();
         arcs.pop_back();
@@ -754,20 +744,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 +770,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: mon/soplex.cc
===================================================================
--- lemon/soplex.cc	(revision 956)
+++ 	(revision )
@@ -1,465 +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 <lemon/soplex.h>
-
-#include <soplex.h>
-#include <spxout.h>
-
-
-///\file
-///\brief Implementation of the LEMON-SOPLEX lp solver interface.
-namespace lemon {
-
-  SoplexLp::SoplexLp() {
-    soplex = new soplex::SoPlex;
-    messageLevel(MESSAGE_NOTHING);
-  }
-
-  SoplexLp::~SoplexLp() {
-    delete soplex;
-  }
-
-  SoplexLp::SoplexLp(const SoplexLp& lp) {
-    rows = lp.rows;
-    cols = lp.cols;
-
-    soplex = new soplex::SoPlex;
-    (*static_cast<soplex::SPxLP*>(soplex)) = *(lp.soplex);
-
-    _col_names = lp._col_names;
-    _col_names_ref = lp._col_names_ref;
-
-    _row_names = lp._row_names;
-    _row_names_ref = lp._row_names_ref;
-
-    messageLevel(MESSAGE_NOTHING);
-  }
-
-  void SoplexLp::_clear_temporals() {
-    _primal_values.clear();
-    _dual_values.clear();
-  }
-
-  SoplexLp* SoplexLp::newSolver() const {
-    SoplexLp* newlp = new SoplexLp();
-    return newlp;
-  }
-
-  SoplexLp* SoplexLp::cloneSolver() const {
-    SoplexLp* newlp = new SoplexLp(*this);
-    return newlp;
-  }
-
-  const char* SoplexLp::_solverName() const { return "SoplexLp"; }
-
-  int SoplexLp::_addCol() {
-    soplex::LPCol c;
-    c.setLower(-soplex::infinity);
-    c.setUpper(soplex::infinity);
-    soplex->addCol(c);
-
-    _col_names.push_back(std::string());
-
-    return soplex->nCols() - 1;
-  }
-
-  int SoplexLp::_addRow() {
-    soplex::LPRow r;
-    r.setLhs(-soplex::infinity);
-    r.setRhs(soplex::infinity);
-    soplex->addRow(r);
-
-    _row_names.push_back(std::string());
-
-    return soplex->nRows() - 1;
-  }
-
-  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) {
-    soplex->removeCol(i);
-    _col_names_ref.erase(_col_names[i]);
-    _col_names[i] = _col_names.back();
-    _col_names_ref[_col_names.back()] = i;
-    _col_names.pop_back();
-  }
-
-  void SoplexLp::_eraseRow(int i) {
-    soplex->removeRow(i);
-    _row_names_ref.erase(_row_names[i]);
-    _row_names[i] = _row_names.back();
-    _row_names_ref[_row_names.back()] = i;
-    _row_names.pop_back();
-  }
-
-  void SoplexLp::_eraseColId(int i) {
-    cols.eraseIndex(i);
-    cols.relocateIndex(i, cols.maxIndex());
-  }
-  void SoplexLp::_eraseRowId(int i) {
-    rows.eraseIndex(i);
-    rows.relocateIndex(i, rows.maxIndex());
-  }
-
-  void SoplexLp::_getColName(int c, std::string &name) const {
-    name = _col_names[c];
-  }
-
-  void SoplexLp::_setColName(int c, const std::string &name) {
-    _col_names_ref.erase(_col_names[c]);
-    _col_names[c] = name;
-    if (!name.empty()) {
-      _col_names_ref.insert(std::make_pair(name, c));
-    }
-  }
-
-  int SoplexLp::_colByName(const std::string& name) const {
-    std::map<std::string, int>::const_iterator it =
-      _col_names_ref.find(name);
-    if (it != _col_names_ref.end()) {
-      return it->second;
-    } else {
-      return -1;
-    }
-  }
-
-  void SoplexLp::_getRowName(int r, std::string &name) const {
-    name = _row_names[r];
-  }
-
-  void SoplexLp::_setRowName(int r, const std::string &name) {
-    _row_names_ref.erase(_row_names[r]);
-    _row_names[r] = name;
-    if (!name.empty()) {
-      _row_names_ref.insert(std::make_pair(name, r));
-    }
-  }
-
-  int SoplexLp::_rowByName(const std::string& name) const {
-    std::map<std::string, int>::const_iterator it =
-      _row_names_ref.find(name);
-    if (it != _row_names_ref.end()) {
-      return it->second;
-    } else {
-      return -1;
-    }
-  }
-
-
-  void SoplexLp::_setRowCoeffs(int i, ExprIterator b, ExprIterator e) {
-    for (int j = 0; j < soplex->nCols(); ++j) {
-      soplex->changeElement(i, j, 0.0);
-    }
-    for(ExprIterator it = b; it != e; ++it) {
-      soplex->changeElement(i, it->first, it->second);
-    }
-  }
-
-  void SoplexLp::_getRowCoeffs(int i, InsertIterator b) const {
-    const soplex::SVector& vec = soplex->rowVector(i);
-    for (int k = 0; k < vec.size(); ++k) {
-      *b = std::make_pair(vec.index(k), vec.value(k));
-      ++b;
-    }
-  }
-
-  void SoplexLp::_setColCoeffs(int j, ExprIterator b, ExprIterator e) {
-    for (int i = 0; i < soplex->nRows(); ++i) {
-      soplex->changeElement(i, j, 0.0);
-    }
-    for(ExprIterator it = b; it != e; ++it) {
-      soplex->changeElement(it->first, j, it->second);
-    }
-  }
-
-  void SoplexLp::_getColCoeffs(int i, InsertIterator b) const {
-    const soplex::SVector& vec = soplex->colVector(i);
-    for (int k = 0; k < vec.size(); ++k) {
-      *b = std::make_pair(vec.index(k), vec.value(k));
-      ++b;
-    }
-  }
-
-  void SoplexLp::_setCoeff(int i, int j, Value value) {
-    soplex->changeElement(i, j, value);
-  }
-
-  SoplexLp::Value SoplexLp::_getCoeff(int i, int j) const {
-    return soplex->rowVector(i)[j];
-  }
-
-  void SoplexLp::_setColLowerBound(int i, Value value) {
-    LEMON_ASSERT(value != INF, "Invalid bound");
-    soplex->changeLower(i, value != -INF ? value : -soplex::infinity);
-  }
-
-  SoplexLp::Value SoplexLp::_getColLowerBound(int i) const {
-    double value = soplex->lower(i);
-    return value != -soplex::infinity ? value : -INF;
-  }
-
-  void SoplexLp::_setColUpperBound(int i, Value value) {
-    LEMON_ASSERT(value != -INF, "Invalid bound");
-    soplex->changeUpper(i, value != INF ? value : soplex::infinity);
-  }
-
-  SoplexLp::Value SoplexLp::_getColUpperBound(int i) const {
-    double value = soplex->upper(i);
-    return value != soplex::infinity ? value : INF;
-  }
-
-  void SoplexLp::_setRowLowerBound(int i, Value lb) {
-    LEMON_ASSERT(lb != INF, "Invalid bound");
-    soplex->changeRange(i, lb != -INF ? lb : -soplex::infinity, soplex->rhs(i));
-  }
-
-  SoplexLp::Value SoplexLp::_getRowLowerBound(int i) const {
-    double res = soplex->lhs(i);
-    return res == -soplex::infinity ? -INF : res;
-  }
-
-  void SoplexLp::_setRowUpperBound(int i, Value ub) {
-    LEMON_ASSERT(ub != -INF, "Invalid bound");
-    soplex->changeRange(i, soplex->lhs(i), ub != INF ? ub : soplex::infinity);
-  }
-
-  SoplexLp::Value SoplexLp::_getRowUpperBound(int i) const {
-    double res = soplex->rhs(i);
-    return res == soplex::infinity ? INF : res;
-  }
-
-  void SoplexLp::_setObjCoeffs(ExprIterator b, ExprIterator e) {
-    for (int j = 0; j < soplex->nCols(); ++j) {
-      soplex->changeObj(j, 0.0);
-    }
-    for (ExprIterator it = b; it != e; ++it) {
-      soplex->changeObj(it->first, it->second);
-    }
-  }
-
-  void SoplexLp::_getObjCoeffs(InsertIterator b) const {
-    for (int j = 0; j < soplex->nCols(); ++j) {
-      Value coef = soplex->obj(j);
-      if (coef != 0.0) {
-        *b = std::make_pair(j, coef);
-        ++b;
-      }
-    }
-  }
-
-  void SoplexLp::_setObjCoeff(int i, Value obj_coef) {
-    soplex->changeObj(i, obj_coef);
-  }
-
-  SoplexLp::Value SoplexLp::_getObjCoeff(int i) const {
-    return soplex->obj(i);
-  }
-
-  SoplexLp::SolveExitStatus SoplexLp::_solve() {
-
-    _clear_temporals();
-
-    _applyMessageLevel();
-
-    soplex::SPxSolver::Status status = soplex->solve();
-
-    switch (status) {
-    case soplex::SPxSolver::OPTIMAL:
-    case soplex::SPxSolver::INFEASIBLE:
-    case soplex::SPxSolver::UNBOUNDED:
-      return SOLVED;
-    default:
-      return UNSOLVED;
-    }
-  }
-
-  SoplexLp::Value SoplexLp::_getPrimal(int i) const {
-    if (_primal_values.empty()) {
-      _primal_values.resize(soplex->nCols());
-      soplex::Vector pv(_primal_values.size(), &_primal_values.front());
-      soplex->getPrimal(pv);
-    }
-    return _primal_values[i];
-  }
-
-  SoplexLp::Value SoplexLp::_getDual(int i) const {
-    if (_dual_values.empty()) {
-      _dual_values.resize(soplex->nRows());
-      soplex::Vector dv(_dual_values.size(), &_dual_values.front());
-      soplex->getDual(dv);
-    }
-    return _dual_values[i];
-  }
-
-  SoplexLp::Value SoplexLp::_getPrimalValue() const {
-    return soplex->objValue();
-  }
-
-  SoplexLp::VarStatus SoplexLp::_getColStatus(int i) const {
-    switch (soplex->getBasisColStatus(i)) {
-    case soplex::SPxSolver::BASIC:
-      return BASIC;
-    case soplex::SPxSolver::ON_UPPER:
-      return UPPER;
-    case soplex::SPxSolver::ON_LOWER:
-      return LOWER;
-    case soplex::SPxSolver::FIXED:
-      return FIXED;
-    case soplex::SPxSolver::ZERO:
-      return FREE;
-    default:
-      LEMON_ASSERT(false, "Wrong column status");
-      return VarStatus();
-    }
-  }
-
-  SoplexLp::VarStatus SoplexLp::_getRowStatus(int i) const {
-    switch (soplex->getBasisRowStatus(i)) {
-    case soplex::SPxSolver::BASIC:
-      return BASIC;
-    case soplex::SPxSolver::ON_UPPER:
-      return UPPER;
-    case soplex::SPxSolver::ON_LOWER:
-      return LOWER;
-    case soplex::SPxSolver::FIXED:
-      return FIXED;
-    case soplex::SPxSolver::ZERO:
-      return FREE;
-    default:
-      LEMON_ASSERT(false, "Wrong row status");
-      return VarStatus();
-    }
-  }
-
-  SoplexLp::Value SoplexLp::_getPrimalRay(int i) const {
-    if (_primal_ray.empty()) {
-      _primal_ray.resize(soplex->nCols());
-      soplex::Vector pv(_primal_ray.size(), &_primal_ray.front());
-      soplex->getDualfarkas(pv);
-    }
-    return _primal_ray[i];
-  }
-
-  SoplexLp::Value SoplexLp::_getDualRay(int i) const {
-    if (_dual_ray.empty()) {
-      _dual_ray.resize(soplex->nRows());
-      soplex::Vector dv(_dual_ray.size(), &_dual_ray.front());
-      soplex->getDualfarkas(dv);
-    }
-    return _dual_ray[i];
-  }
-
-  SoplexLp::ProblemType SoplexLp::_getPrimalType() const {
-    switch (soplex->status()) {
-    case soplex::SPxSolver::OPTIMAL:
-      return OPTIMAL;
-    case soplex::SPxSolver::UNBOUNDED:
-      return UNBOUNDED;
-    case soplex::SPxSolver::INFEASIBLE:
-      return INFEASIBLE;
-    default:
-      return UNDEFINED;
-    }
-  }
-
-  SoplexLp::ProblemType SoplexLp::_getDualType() const {
-    switch (soplex->status()) {
-    case soplex::SPxSolver::OPTIMAL:
-      return OPTIMAL;
-    case soplex::SPxSolver::UNBOUNDED:
-      return UNBOUNDED;
-    case soplex::SPxSolver::INFEASIBLE:
-      return INFEASIBLE;
-    default:
-      return UNDEFINED;
-    }
-  }
-
-  void SoplexLp::_setSense(Sense sense) {
-    switch (sense) {
-    case MIN:
-      soplex->changeSense(soplex::SPxSolver::MINIMIZE);
-      break;
-    case MAX:
-      soplex->changeSense(soplex::SPxSolver::MAXIMIZE);
-    }
-  }
-
-  SoplexLp::Sense SoplexLp::_getSense() const {
-    switch (soplex->spxSense()) {
-    case soplex::SPxSolver::MAXIMIZE:
-      return MAX;
-    case soplex::SPxSolver::MINIMIZE:
-      return MIN;
-    default:
-      LEMON_ASSERT(false, "Wrong sense.");
-      return SoplexLp::Sense();
-    }
-  }
-
-  void SoplexLp::_clear() {
-    soplex->clear();
-    _col_names.clear();
-    _col_names_ref.clear();
-    _row_names.clear();
-    _row_names_ref.clear();
-    cols.clear();
-    rows.clear();
-    _clear_temporals();
-  }
-
-  void SoplexLp::_messageLevel(MessageLevel level) {
-    switch (level) {
-    case MESSAGE_NOTHING:
-      _message_level = -1;
-      break;
-    case MESSAGE_ERROR:
-      _message_level = soplex::SPxOut::ERROR;
-      break;
-    case MESSAGE_WARNING:
-      _message_level = soplex::SPxOut::WARNING;
-      break;
-    case MESSAGE_NORMAL:
-      _message_level = soplex::SPxOut::INFO2;
-      break;
-    case MESSAGE_VERBOSE:
-      _message_level = soplex::SPxOut::DEBUG;
-      break;
-    }
-  }
-
-  void SoplexLp::_applyMessageLevel() {
-    soplex::Param::setVerbose(_message_level);
-  }
-
-} //namespace lemon
-
Index: mon/soplex.h
===================================================================
--- lemon/soplex.h	(revision 956)
+++ 	(revision )
@@ -1,158 +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_SOPLEX_H
-#define LEMON_SOPLEX_H
-
-///\file
-///\brief Header of the LEMON-SOPLEX lp solver interface.
-
-#include <vector>
-#include <string>
-
-#include <lemon/lp_base.h>
-
-// Forward declaration
-namespace soplex {
-  class SoPlex;
-}
-
-namespace lemon {
-
-  /// \ingroup lp_group
-  ///
-  /// \brief Interface for the SOPLEX solver
-  ///
-  /// This class implements an interface for the SoPlex LP solver.
-  /// The SoPlex library is an object oriented lp solver library
-  /// developed at the Konrad-Zuse-Zentrum für Informationstechnik
-  /// Berlin (ZIB). You can find detailed information about it at the
-  /// <tt>http://soplex.zib.de</tt> address.
-  class SoplexLp : public LpSolver {
-  private:
-
-    soplex::SoPlex* soplex;
-
-    std::vector<std::string> _col_names;
-    std::map<std::string, int> _col_names_ref;
-
-    std::vector<std::string> _row_names;
-    std::map<std::string, int> _row_names_ref;
-
-  private:
-
-    // these values cannot be retrieved element by element
-    mutable std::vector<Value> _primal_values;
-    mutable std::vector<Value> _dual_values;
-
-    mutable std::vector<Value> _primal_ray;
-    mutable std::vector<Value> _dual_ray;
-
-    void _clear_temporals();
-
-  public:
-
-    /// \e
-    SoplexLp();
-    /// \e
-    SoplexLp(const SoplexLp&);
-    /// \e
-    ~SoplexLp();
-    /// \e
-    virtual SoplexLp* newSolver() const;
-    /// \e
-    virtual SoplexLp* cloneSolver() const;
-
-  protected:
-
-    virtual const char* _solverName() const;
-
-    virtual int _addCol();
-    virtual int _addRow();
-    virtual int _addRow(Value l, ExprIterator b, ExprIterator e, Value u);
-
-    virtual void _eraseCol(int i);
-    virtual void _eraseRow(int i);
-
-    virtual void _eraseColId(int i);
-    virtual void _eraseRowId(int i);
-
-    virtual void _getColName(int col, std::string& name) const;
-    virtual void _setColName(int col, const std::string& name);
-    virtual int _colByName(const std::string& name) const;
-
-    virtual void _getRowName(int row, std::string& name) const;
-    virtual void _setRowName(int row, const std::string& name);
-    virtual int _rowByName(const std::string& name) const;
-
-    virtual void _setRowCoeffs(int i, ExprIterator b, ExprIterator e);
-    virtual void _getRowCoeffs(int i, InsertIterator b) const;
-
-    virtual void _setColCoeffs(int i, ExprIterator b, ExprIterator e);
-    virtual void _getColCoeffs(int i, InsertIterator b) const;
-
-    virtual void _setCoeff(int row, int col, Value value);
-    virtual Value _getCoeff(int row, int col) const;
-
-    virtual void _setColLowerBound(int i, Value value);
-    virtual Value _getColLowerBound(int i) const;
-    virtual void _setColUpperBound(int i, Value value);
-    virtual Value _getColUpperBound(int i) const;
-
-    virtual void _setRowLowerBound(int i, Value value);
-    virtual Value _getRowLowerBound(int i) const;
-    virtual void _setRowUpperBound(int i, Value value);
-    virtual Value _getRowUpperBound(int i) const;
-
-    virtual void _setObjCoeffs(ExprIterator b, ExprIterator e);
-    virtual void _getObjCoeffs(InsertIterator b) const;
-
-    virtual void _setObjCoeff(int i, Value obj_coef);
-    virtual Value _getObjCoeff(int i) const;
-
-    virtual void _setSense(Sense sense);
-    virtual Sense _getSense() const;
-
-    virtual SolveExitStatus _solve();
-    virtual Value _getPrimal(int i) const;
-    virtual Value _getDual(int i) const;
-
-    virtual Value _getPrimalValue() const;
-
-    virtual Value _getPrimalRay(int i) const;
-    virtual Value _getDualRay(int i) const;
-
-    virtual VarStatus _getColStatus(int i) const;
-    virtual VarStatus _getRowStatus(int i) const;
-
-    virtual ProblemType _getPrimalType() const;
-    virtual ProblemType _getDualType() const;
-
-    virtual void _clear();
-
-    void _messageLevel(MessageLevel m);
-    void _applyMessageLevel();
-
-    int _message_level;
-
-  };
-
-} //END OF NAMESPACE LEMON
-
-#endif //LEMON_SOPLEX_H
-
Index: mon/static_graph.h
===================================================================
--- lemon/static_graph.h	(revision 956)
+++ 	(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: mon/suurballe.h
===================================================================
--- lemon/suurballe.h	(revision 956)
+++ 	(revision )
@@ -1,776 +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_SUURBALLE_H
-#define LEMON_SUURBALLE_H
-
-///\ingroup shortest_path
-///\file
-///\brief An algorithm for finding arc-disjoint paths between two
-/// nodes having minimum total length.
-
-#include <vector>
-#include <limits>
-#include <lemon/bin_heap.h>
-#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
-  /// @{
-
-  /// \brief Algorithm for finding arc-disjoint paths between two nodes
-  /// having minimum total length.
-  ///
-  /// \ref lemon::Suurballe "Suurballe" implements an algorithm for
-  /// finding arc-disjoint paths having minimum total length (cost)
-  /// from a given source node to a given target node in a digraph.
-  ///
-  /// Note that this problem is a special case of the \ref min_cost_flow
-  /// "minimum cost flow problem". This implementation is actually an
-  /// efficient specialized version of the \ref CapacityScaling
-  /// "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
-  /// algorithms.
-  ///
-  /// \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>.
-  ///
-  /// \warning Length values should be \e non-negative.
-  ///
-  /// \note For finding \e node-disjoint paths, this algorithm can be used
-  /// along with the \ref SplitNodes adaptor.
-#ifdef DOXYGEN
-  template <typename GR, typename LEN, typename TR>
-#else
-  template < typename GR,
-             typename LEN = typename GR::template ArcMap<int>,
-             typename TR = SuurballeDefaultTraits<GR, LEN> >
-#endif
-  class Suurballe
-  {
-    TEMPLATE_DIGRAPH_TYPEDEFS(GR);
-
-    typedef ConstMap<Arc, int> ConstArcMap;
-    typedef typename GR::template NodeMap<Arc> PredMap;
-
-  public:
-
-    /// The type of the digraph.
-    typedef typename TR::Digraph Digraph;
-    /// The type of the length map.
-    typedef typename TR::LengthMap LengthMap;
-    /// The type of the lengths.
-    typedef typename TR::Length Length;
-
-    /// The type of the flow map.
-    typedef typename TR::FlowMap FlowMap;
-    /// The type of the potential map.
-    typedef typename TR::PotentialMap PotentialMap;
-    /// 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;
-
-  private:
-
-    // ResidualDijkstra is a special implementation of the
-    // Dijkstra algorithm for finding shortest paths in the
-    // residual network with respect to the reduced arc lengths
-    // and modifying the node potentials according to the
-    // distance of the nodes.
-    class ResidualDijkstra
-    {
-    private:
-
-      const Digraph &_graph;
-      const LengthMap &_length;
-      const FlowMap &_flow;
-      PotentialMap &_pi;
-      PredMap &_pred;
-      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() {
-        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(), dn;
-          _dist[u] = heap.prio();
-          _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)) {
-              case Heap::PRE_HEAP:
-                heap.push(v, d + _length[e]);
-                _pred[v] = e;
-                break;
-              case Heap::IN_HEAP:
-                dn = d + _length[e];
-                if (dn < heap[v]) {
-                  heap.decrease(v, dn);
-                  _pred[v] = e;
-                }
-                break;
-              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;
-              }
-            }
-          }
-
-          // Traverse incoming arcs
-          for (InArcIt e(_graph, u); e != INVALID; ++e) {
-            if (_flow[e] == 1) {
-              v = _graph.source(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;
-              }
-            }
-          }
-        }
-        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;
-      }
-
-    }; //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:
-
-    // The digraph the algorithm runs on
-    const Digraph &_graph;
-    // The length map
-    const LengthMap &_length;
-
-    // Arc map of the current flow
-    FlowMap *_flow;
-    bool _local_flow;
-    // Node map of the current potentials
-    PotentialMap *_potential;
-    bool _local_potential;
-
-    // The source node
-    Node _s;
-    // The target node
-    Node _t;
-
-    // Container to store the found paths
-    std::vector<Path> _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() {}
-
-  public:
-
-    /// \brief Constructor.
-    ///
-    /// Constructor.
-    ///
-    /// \param graph The digraph the algorithm runs on.
-    /// \param length The length (cost) values of the arcs.
-    Suurballe( const Digraph &graph,
-               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)
-    {}
-
-    /// Destructor.
-    ~Suurballe() {
-      if (_local_flow) delete _flow;
-      if (_local_potential) delete _potential;
-      delete _init_dist;
-      delete _init_pred;
-    }
-
-    /// \brief Set the flow map.
-    ///
-    /// This function sets the flow map.
-    /// If it is not used before calling \ref run() or \ref init(),
-    /// an instance will be allocated automatically. The destructor
-    /// deallocates this automatically allocated map, of course.
-    ///
-    /// The found flow contains only 0 and 1 values, since it is the
-    /// union of the found arc-disjoint paths.
-    ///
-    /// \return <tt>(*this)</tt>
-    Suurballe& flowMap(FlowMap &map) {
-      if (_local_flow) {
-        delete _flow;
-        _local_flow = false;
-      }
-      _flow = &map;
-      return *this;
-    }
-
-    /// \brief Set the potential map.
-    ///
-    /// This function sets the potential map.
-    /// If it is not used before calling \ref run() or \ref init(),
-    /// an instance will be allocated automatically. The destructor
-    /// deallocates this automatically allocated map, of course.
-    ///
-    /// The node potentials provide the dual solution of the underlying
-    /// \ref min_cost_flow "minimum cost flow problem".
-    ///
-    /// \return <tt>(*this)</tt>
-    Suurballe& potentialMap(PotentialMap &map) {
-      if (_local_potential) {
-        delete _potential;
-        _local_potential = false;
-      }
-      _potential = &map;
-      return *this;
-    }
-
-    /// \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
-    /// If you only need the flow that is the union of the found
-    /// arc-disjoint paths, then you may call findFlow() instead of
-    /// start().
-
-    /// @{
-
-    /// \brief Run the algorithm.
-    ///
-    /// This function runs the algorithm.
-    ///
-    /// \param s The source node.
-    /// \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.run(s, t, k)</tt> is
-    /// just a shortcut of the following code.
-    /// \code
-    ///   s.init(s);
-    ///   s.start(t, k);
-    /// \endcode
-    int run(const Node& s, const Node& t, int k = 2) {
-      init(s);
-      start(t, k);
-      return _path_num;
-    }
-
-    /// \brief Initialize the algorithm.
-    ///
-    /// This function initializes the algorithm with the given source node.
-    ///
-    /// \param s The source node.
-    void init(const Node& s) {
-      _s = s;
-
-      // Initialize maps
-      if (!_flow) {
-        _flow = new FlowMap(_graph);
-        _local_flow = true;
-      }
-      if (!_potential) {
-        _potential = new PotentialMap(_graph);
-        _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;
-    }
-
-    /// \brief Execute the algorithm to find an optimal flow.
-    ///
-    /// This function executes the successive shortest path algorithm to
-    /// find a minimum cost flow, which is the union of \c k (or less)
-    /// arc-disjoint paths.
-    ///
-    /// \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
-    /// the source node to the given node \c t in the digraph.
-    /// Otherwise it returns the number of arc-disjoint paths found.
-    ///
-    /// \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;
-      }
-
-      // Find shortest paths
-      while (_path_num < k) {
-        // Run Dijkstra
-        if (!dijkstra.run(_path_num)) break;
-        ++_path_num;
-
-        // Set the flow along the found shortest path
-        Node u = _t;
-        Arc e;
-        while ((e = _pred[u]) != INVALID) {
-          if (u == _graph.target(e)) {
-            (*_flow)[e] = 1;
-            u = _graph.source(e);
-          } else {
-            (*_flow)[e] = 0;
-            u = _graph.target(e);
-          }
-        }
-      }
-      return _path_num;
-    }
-
-    /// \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.
-    ///
-    /// \pre \ref init() and \ref findFlow() must be called before using
-    /// this function.
-    void findPaths() {
-      FlowMap res_flow(_graph);
-      for(ArcIt a(_graph); a != INVALID; ++a) res_flow[a] = (*_flow)[a];
-
-      _paths.clear();
-      _paths.resize(_path_num);
-      for (int i = 0; i < _path_num; ++i) {
-        Node n = _s;
-        while (n != _t) {
-          OutArcIt e(_graph, n);
-          for ( ; res_flow[e] == 0; ++e) ;
-          n = _graph.target(e);
-          _paths[i].addBack(e);
-          res_flow[e] = 0;
-        }
-      }
-    }
-
-    /// @}
-
-    /// \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 length of the found paths.
-    ///
-    /// This function returns the total length of the found paths, i.e.
-    /// the total cost of the found flow.
-    /// The complexity of the function is O(e).
-    ///
-    /// \pre \ref run() or \ref findFlow() must be called before using
-    /// this function.
-    Length totalLength() const {
-      Length c = 0;
-      for (ArcIt e(_graph); e != INVALID; ++e)
-        c += (*_flow)[e] * _length[e];
-      return c;
-    }
-
-    /// \brief Return the flow value on the given arc.
-    ///
-    /// This function returns the flow value on the given arc.
-    /// It is \c 1 if the arc is involved in one of the found arc-disjoint
-    /// paths, otherwise it is \c 0.
-    ///
-    /// \pre \ref run() or \ref findFlow() must be called before using
-    /// this function.
-    int flow(const Arc& arc) const {
-      return (*_flow)[arc];
-    }
-
-    /// \brief Return a const reference to an arc map storing the
-    /// found flow.
-    ///
-    /// This function returns a const reference to an arc map storing
-    /// the flow that is the union of the found arc-disjoint paths.
-    ///
-    /// \pre \ref run() or \ref findFlow() must be called before using
-    /// this function.
-    const FlowMap& flowMap() const {
-      return *_flow;
-    }
-
-    /// \brief Return the potential of the given node.
-    ///
-    /// This function returns the potential of the given node.
-    /// The node potentials provide the dual solution of the
-    /// underlying \ref min_cost_flow "minimum cost flow problem".
-    ///
-    /// \pre \ref run() or \ref findFlow() must be called before using
-    /// this function.
-    Length potential(const Node& node) const {
-      return (*_potential)[node];
-    }
-
-    /// \brief Return a const reference to a node map storing the
-    /// found potentials (the dual solution).
-    ///
-    /// This function returns a const reference to a node map storing
-    /// the found potentials that provide the dual solution of the
-    /// underlying \ref min_cost_flow "minimum cost flow problem".
-    ///
-    /// \pre \ref run() or \ref findFlow() must be called before using
-    /// this function.
-    const PotentialMap& potentialMap() const {
-      return *_potential;
-    }
-
-    /// \brief Return the number of the found paths.
-    ///
-    /// This function returns the number of the found paths.
-    ///
-    /// \pre \ref run() or \ref findFlow() must be called before using
-    /// this function.
-    int pathNum() const {
-      return _path_num;
-    }
-
-    /// \brief Return a const reference to the specified path.
-    ///
-    /// This function returns a const reference to the specified path.
-    ///
-    /// \param i The function returns the <tt>i</tt>-th path.
-    /// \c i must be between \c 0 and <tt>%pathNum()-1</tt>.
-    ///
-    /// \pre \ref run() or \ref findPaths() must be called before using
-    /// this function.
-    const Path& path(int i) const {
-      return _paths[i];
-    }
-
-    /// @}
-
-  }; //class Suurballe
-
-  ///@}
-
-} //namespace lemon
-
-#endif //LEMON_SUURBALLE_H
Index: lemon/time_measure.h
===================================================================
--- lemon/time_measure.h	(revision 833)
+++ lemon/time_measure.h	(revision 528)
@@ -3,5 +3,5 @@
  * This file is a part of LEMON, a generic C++ optimization library.
  *
- * Copyright (C) 2003-2009
+ * Copyright (C) 2003-2008
  * Egervary Jeno Kombinatorikus Optimalizalasi Kutatocsoport
  * (Egervary Research Group on Combinatorial Optimization, EGRES).
@@ -288,5 +288,5 @@
     Timer(bool run=true) :_running(run) {_reset();}
 
-    ///\name Control the State of the Timer
+    ///\name Control the state of the timer
     ///Basically a Timer can be either running or stopped,
     ///but it provides a bit finer control on the execution.
@@ -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
@@ -396,5 +396,5 @@
     ///@}
 
-    ///\name Query Functions for the Ellapsed Time
+    ///\name Query Functions for the ellapsed time
 
     ///@{
Index: lemon/tolerance.h
===================================================================
--- lemon/tolerance.h	(revision 564)
+++ lemon/tolerance.h	(revision 516)
@@ -3,5 +3,5 @@
  * This file is a part of LEMON, a generic C++ optimization library.
  *
- * Copyright (C) 2003-2009
+ * Copyright (C) 2003-2008
  * Egervary Jeno Kombinatorikus Optimalizalasi Kutatocsoport
  * (Egervary Research Group on Combinatorial Optimization, EGRES).
Index: lemon/unionfind.h
===================================================================
--- lemon/unionfind.h	(revision 956)
+++ lemon/unionfind.h	(revision 460)
@@ -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).
@@ -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
@@ -52,11 +52,9 @@
   /// \pre You need to add all the elements by the \ref insert()
   /// method.
-  template <typename IM>
+  template <typename _ItemIntMap>
   class UnionFind {
   public:
 
-    ///\e
-    typedef IM ItemIntMap;
-    ///\e
+    typedef _ItemIntMap ItemIntMap;
     typedef typename ItemIntMap::Key Item;
 
@@ -173,11 +171,9 @@
   /// method.
   ///
-  template <typename IM>
+  template <typename _ItemIntMap>
   class UnionFindEnum {
   public:
 
-    ///\e
-    typedef IM ItemIntMap;
-    ///\e
+    typedef _ItemIntMap ItemIntMap;
     typedef typename ItemIntMap::Key Item;
 
@@ -632,11 +628,9 @@
   /// \pre You need to add all the elements by the \ref insert()
   /// method.
-  template <typename IM>
+  template <typename _ItemIntMap>
   class ExtendFindEnum {
   public:
 
-    ///\e
-    typedef IM ItemIntMap;
-    ///\e
+    typedef _ItemIntMap ItemIntMap;
     typedef typename ItemIntMap::Key Item;
 
@@ -740,5 +734,5 @@
     void clear() {
       items.clear();
-      classes.clear();
+      classes.clear;
       firstClass = firstFreeClass = firstFreeItem = -1;
     }
@@ -955,16 +949,16 @@
   /// \pre You need to add all the elements by the \ref insert()
   /// method.
-  template <typename V, typename IM, typename Comp = std::less<V> >
+  ///
+  template <typename _Value, typename _ItemIntMap,
+            typename _Comp = std::less<_Value> >
   class HeapUnionFind {
   public:
 
-    ///\e
-    typedef V Value;
-    ///\e
-    typedef typename IM::Key Item;
-    ///\e
-    typedef IM ItemIntMap;
-    ///\e
-    typedef Comp Compare;
+    typedef _Value Value;
+    typedef typename _ItemIntMap::Key Item;
+
+    typedef _ItemIntMap ItemIntMap;
+
+    typedef _Comp Comp;
 
   private:
@@ -1196,5 +1190,5 @@
               popLeft(nodes[jd].next);
               pushRight(jd, ld);
-              if (less(ld, nodes[jd].left) ||
+              if (less(ld, nodes[jd].left) || 
                   nodes[ld].item == nodes[pd].item) {
                 nodes[jd].item = nodes[ld].item;
@@ -1289,13 +1283,4 @@
         first_free_class(-1), first_free_node(-1) {}
 
-    /// \brief Clears the union-find data structure
-    ///
-    /// Erase each item from the data structure.
-    void clear() {
-      nodes.clear();
-      classes.clear();
-      first_free_node = first_free_class = first_class = -1;
-    }
-
     /// \brief Insert a new node into a new component.
     ///
@@ -1617,5 +1602,5 @@
     /// \brief Gives back the priority of the current item.
     ///
-    /// Gives back the priority of the current item.
+    /// \return Gives back the priority of the current item.
     const Value& operator[](const Item& item) const {
       return nodes[index[item]].prio;
@@ -1662,5 +1647,5 @@
     /// \brief Gives back the minimum priority of the class.
     ///
-    /// Gives back the minimum priority of the class.
+    /// \return Gives back the minimum priority of the class.
     const Value& classPrio(int cls) const {
       return nodes[~(classes[cls].parent)].prio;
@@ -1676,7 +1661,7 @@
     /// \brief Gives back a representant item of the class.
     ///
-    /// Gives back a representant item of the class.
     /// The representant is indpendent from the priorities of the
     /// items.
+    /// \return Gives back a representant item of the class.
     const Item& classRep(int id) const {
       int parent = classes[id].parent;
Index: lx_check_coin.m4
===================================================================
--- m4/lx_check_coin.m4	(revision 796)
+++ 	(revision )
@@ -1,136 +1,0 @@
-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 674)
+++ m4/lx_check_cplex.m4	(revision 540)
@@ -63,8 +63,4 @@
     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
Index: m4/lx_check_glpk.m4
===================================================================
--- m4/lx_check_glpk.m4	(revision 674)
+++ m4/lx_check_glpk.m4	(revision 540)
@@ -43,9 +43,4 @@
       }
 
-      #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)
       {
@@ -66,8 +61,4 @@
     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
Index: m4/lx_check_soplex.m4
===================================================================
--- m4/lx_check_soplex.m4	(revision 674)
+++ m4/lx_check_soplex.m4	(revision 540)
@@ -21,5 +21,5 @@
       SOPLEX_CXXFLAGS="-I$with_soplex_includedir"
     elif test x"$with_soplex" != x"yes"; then
-      SOPLEX_CXXFLAGS="-I$with_soplex/src"
+      SOPLEX_CXXFLAGS="-I$with_soplex/include"
     fi
 
@@ -39,5 +39,5 @@
 
     lx_soplex_test_prog='
-      #include <soplex.h>
+      #include <soplex/soplex.h>
 
       int main(int argc, char** argv)
@@ -57,6 +57,4 @@
     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
Index: ripts/Makefile.am
===================================================================
--- scripts/Makefile.am	(revision 840)
+++ 	(revision )
@@ -1,7 +1,0 @@
-EXTRA_DIST += \
-	scripts/bib2dox.py \
-	scripts/bootstrap.sh \
-	scripts/chg-len.py \
-	scripts/mk-release.sh \
-	scripts/unify-sources.sh \
-	scripts/valgrind-wrapper.sh
Index: ripts/bib2dox.py
===================================================================
--- scripts/bib2dox.py	(revision 905)
+++ 	(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: ripts/bootstrap.sh
===================================================================
--- scripts/bootstrap.sh	(revision 923)
+++ 	(revision )
@@ -1,157 +1,0 @@
-#!/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.
-
-
-if [ ! -f ~/.lemon-bootstrap ]; then
-    echo 'Create ~/.lemon-bootstrap'.
-    cat >~/.lemon-bootstrap <<EOF
-#
-# Default settings for bootstraping the LEMON source code repository
-#
-EOF
-fi
-
-source ~/.lemon-bootstrap
-if [ -f ../../../.lemon-bootstrap ]; then source ../../../.lemon-bootstrap; fi
-if [ -f ../../.lemon-bootstrap ]; then source ../../.lemon-bootstrap; fi
-if [ -f ../.lemon-bootstrap ]; then source ../.lemon-bootstrap; fi
-if [ -f ./.lemon-bootstrap ]; then source ./.lemon-bootstrap; fi
-
-
-function augment_config() { 
-    if [ "x${!1}" == "x" ]; then
-        eval $1=$2
-        echo Add "'$1'" to '~/.lemon-bootstrap'.
-        echo >>~/.lemon-bootstrap
-        echo $3 >>~/.lemon-bootstrap
-        echo $1=$2 >>~/.lemon-bootstrap
-    fi
-}
-
-augment_config LEMON_INSTALL_PREFIX /usr/local \
-    "# LEMON installation prefix"
-
-augment_config GLPK_PREFIX /usr/local/ \
-    "# GLPK installation root prefix"
-
-augment_config COIN_OR_PREFIX /usr/local/coin-or \
-    "# COIN-OR installation root prefix (used for CLP/CBC)"
-
-augment_config SOPLEX_PREFIX /usr/local/soplex \
-    "# Soplex build prefix"
-
-
-function ask() {
-echo -n "$1 [$2]? "
-read _an
-if [ "x$_an" == "x" ]; then
-    ret="$2"
-else
-    ret=$_an
-fi
-}
-
-function yesorno() {
-    ret='rossz'
-    while [ "$ret" != "y" -a "$ret" != "n" -a "$ret" != "yes" -a "$ret" != "no" ]; do
-        ask "$1" "$2"
-    done
-    if [ "$ret" != "y" -a "$ret" != "yes" ]; then
-        return 1
-    else
-        return 0
-    fi
-}
-
-if yesorno "External build" "n"
-then
-    CONFIGURE_PATH=".."
-else
-    CONFIGURE_PATH="."
-    if yesorno "Autoreconf" "y"
-    then
-        AUTORE=yes
-    else
-        AUTORE=no
-    fi
-fi
-
-if yesorno "Optimize" "n" 
-then
-    opt_flags=' -O2'
-else
-    opt_flags=''
-fi
-
-if yesorno "Stop on warning" "y" 
-then
-    werror_flags=' -Werror'
-else
-    werror_flags=''
-fi
-
-cxx_flags="CXXFLAGS=-ggdb$opt_flags$werror_flags"
-
-if yesorno "Check with valgrind" "n" 
-then
-    valgrind_flags=' --enable-valgrind'
-else
-    valgrind_flags=''
-fi
-
-if [ -f ${GLPK_PREFIX}/include/glpk.h ]; then
-    if yesorno "Use GLPK" "y"
-    then
-        glpk_flag="--with-glpk=$GLPK_PREFIX"
-    else
-        glpk_flag="--without-glpk"
-    fi
-else
-    glpk_flag="--without-glpk"        
-fi
-
-if [ -f ${COIN_OR_PREFIX}/include/coin/config_coinutils.h ]; then
-    if yesorno "Use COIN-OR (CBC/CLP)" "n"
-    then
-        coin_flag="--with-coin=$COIN_OR_PREFIX"
-    else
-        coin_flag="--without-coin"
-    fi
-else
-    coin_flag="--without-coin"        
-fi
-
-if [ -f ${SOPLEX_PREFIX}/src/soplex.h ]; then
-    if yesorno "Use Soplex" "n"
-    then
-        soplex_flag="--with-soplex=$SOPLEX_PREFIX"
-    else
-        soplex_flag="--without-soplex"
-    fi
-else
-    soplex_flag="--without-soplex"
-fi
-
-if [ "x$AUTORE" == "xyes" ]; then
-    autoreconf -vif;
-fi
-${CONFIGURE_PATH}/configure --prefix=$LEMON_INSTALL_PREFIX \
-$valgrind_flags \
-"$cxx_flags" \
-$glpk_flag \
-$coin_flag \
-$soplex_flag \
-$*
Index: scripts/chg-len.py
===================================================================
--- scripts/chg-len.py	(revision 780)
+++ scripts/chg-len.py	(revision 284)
@@ -1,24 +1,6 @@
 #! /usr/bin/env python
-#
-# 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.
 
 import sys
-
-from mercurial import ui, hg
-from mercurial import util
-
-util.rcpath = lambda : []
+import os
 
 if len(sys.argv)>1 and sys.argv[1] in ["-h","--help"]:
@@ -28,19 +10,31 @@
 """
     exit(0)
+plist = os.popen("HGRCPATH='' hg parents --template='{rev}\n'").readlines()
+if len(plist)>1:
+    print "You are in the process of merging"
+    exit(1)
+PAR = int(plist[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()]
+f = os.popen("HGRCPATH='' hg log -r 0:tip --template='{rev} {parents}\n'").\
+    readlines()
+REV = -1
+lengths=[]
+for l in f:
+    REV+=1
+    s = l.split()
+    rev = int(s[0])
+    if REV != rev:
+        print "Something is seriously wrong"
+        exit(1)
+    if len(s) == 1:
+        par1 = par2 = rev - 1
+    elif len(s) == 2:
+        par1 = par2 = int(s[1].split(":")[0])
     else:
-        p0=-1
-    if len(p)>1 and p[1]:
-        p1=lengths[p[1].rev()]
+        par1 = int(s[1].split(":")[0])
+        par2 = int(s[2].split(":")[0])
+    if rev == 0:
+        lengths.append(0)
     else:
-        p1=-1
-    lengths[i]=max(p0,p1)+1
-print lengths[N]
+        lengths.append(max(lengths[par1],lengths[par2])+1)
+print lengths[PAR]
Index: scripts/mk-release.sh
===================================================================
--- scripts/mk-release.sh	(revision 780)
+++ scripts/mk-release.sh	(revision 536)
@@ -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.
 
 set -e
@@ -29,5 +15,5 @@
 
 autoreconf -vif
-./configure
+./configure --enable-demo
 
 make
Index: scripts/unify-sources.sh
===================================================================
--- scripts/unify-sources.sh	(revision 780)
+++ scripts/unify-sources.sh	(revision 208)
@@ -1,213 +1,10 @@
 #!/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`
+YEAR=`date +2003-%Y`
 HGROOT=`hg root`
 
-function hg_year() {
-    if [ -n "$(hg st $1)" ]; then
-        echo $YEAR
-    else
-        hg log -l 1 --template='{date|isodate}\n' $1 |
-        cut -d '-' -f 1
-    fi
-}
-
-# file enumaration modes
-
-function all_files() {
-    hg status -a -m -c |
-    cut -d ' ' -f 2 | grep -E '(\.(cc|h|dox)$|Makefile\.am$)' |
-    while read file; do echo $HGROOT/$file; done
-}
-
-function modified_files() {
-    hg status -a -m |
-    cut -d ' ' -f 2 | grep -E  '(\.(cc|h|dox)$|Makefile\.am$)' |
-    while read file; do echo $HGROOT/$file; done
-}
-
-function changed_files() {
-    {
-        if [ -n "$HG_PARENT1" ]
-        then
-            hg status --rev $HG_PARENT1:$HG_NODE -a -m
-        fi
-        if [ -n "$HG_PARENT2" ]
-        then
-            hg status --rev $HG_PARENT2:$HG_NODE -a -m
-        fi
-    } | cut -d ' ' -f 2 | grep -E '(\.(cc|h|dox)$|Makefile\.am$)' | 
-    sort | uniq |
-    while read file; do echo $HGROOT/$file; done
-}
-
-function given_files() {
-    for file in $GIVEN_FILES
-    do
-	echo $file
-    done
-}
-
-# actions
-
-function update_action() {
-    if ! diff -q $1 $2 >/dev/null
-    then
-	echo -n " [$3 updated]"
-	rm $2
-	mv $1 $2
-	CHANGED=YES
-    fi
-}
-
-function update_warning() {
-    echo -n " [$2 warning]"
-    WARNED=YES
-}
-
-function update_init() {
-    echo Update source files...
-    TOTAL_FILES=0
-    CHANGED_FILES=0
-    WARNED_FILES=0
-}
-
-function update_done() {
-    echo $CHANGED_FILES out of $TOTAL_FILES files has been changed.
-    echo $WARNED_FILES out of $TOTAL_FILES files triggered warnings.
-}
-
-function update_begin() {
-    ((TOTAL_FILES++))
-    CHANGED=NO
-    WARNED=NO
-}
-
-function update_end() {
-    if [ $CHANGED == YES ]
-    then
-	((++CHANGED_FILES))
-    fi
-    if [ $WARNED == YES ]
-    then
-	((++WARNED_FILES))
-    fi
-}
-
-function check_action() {
-    if [ "$3" == 'tabs' ]
-    then
-        if echo $2 | grep -q -v -E 'Makefile\.am$'
-        then
-            PATTERN=$(echo -e '\t')
-        else
-            PATTERN='        '
-        fi
-    elif [ "$3" == 'trailing spaces' ]
-    then
-        PATTERN='\ +$'
-    else
-        PATTERN='*'
-    fi
-
-    if ! diff -q $1 $2 >/dev/null
-    then
-        if [ "$PATTERN" == '*' ]
-        then
-            diff $1 $2 | grep '^[0-9]' | sed "s|^\(.*\)c.*$|$2:\1: check failed: $3|g" |
-              sed "s/:\([0-9]*\),\([0-9]*\):\(.*\)$/:\1:\3 (until line \2)/g"
-        else
-            grep -n -E "$PATTERN" $2 | sed "s|^\([0-9]*\):.*$|$2:\1: check failed: $3|g"
-        fi
-        FAILED=YES
-    fi
-}
-
-function check_warning() {
-    if [ "$2" == 'long lines' ]
-    then
-        grep -n -E '.{81,}' $1 | sed "s|^\([0-9]*\):.*$|$1:\1: warning: $2|g"
-    else
-        echo "$1: warning: $2"
-    fi
-    WARNED=YES
-}
-
-function check_init() {
-    echo Check source files...
-    FAILED_FILES=0
-    WARNED_FILES=0
-    TOTAL_FILES=0
-}
-
-function check_done() {
-    echo $FAILED_FILES out of $TOTAL_FILES files has been failed.
-    echo $WARNED_FILES out of $TOTAL_FILES files triggered warnings.
-
-    if [ $WARNED_FILES -gt 0 -o $FAILED_FILES -gt 0 ]
-    then
-	if [ "$WARNING" == 'INTERACTIVE' ]
-	then
-	    echo -n "Are the files with errors/warnings acceptable? (yes/no) "
-	    while read answer
-	    do
-		if [ "$answer" == 'yes' ]
-		then
-		    return 0
-		elif [ "$answer" == 'no' ]
-		then
-		    return 1
-		fi
-		echo -n "Are the files with errors/warnings acceptable? (yes/no) "
-	    done
-	elif [ "$WARNING" == 'WERROR' ]
-	then
-	    return 1
-	fi
-    fi
-}
-
-function check_begin() {
-    ((TOTAL_FILES++))
-    FAILED=NO
-    WARNED=NO
-}
-
-function check_end() {
-    if [ $FAILED == YES ]
-    then
-	((++FAILED_FILES))
-    fi
-    if [ $WARNED == YES ]
-    then
-	((++WARNED_FILES))
-    fi
-}
-
-
-
-# checks
-
-function header_check() {
-    if echo $1 | grep -q -E 'Makefile\.am$'
-    then
-	return
-    fi
-
+function update_header() {
     TMP_FILE=`mktemp`
+    FILE_NAME=$1
 
     (echo "/* -*- mode: C++; indent-tabs-mode: nil; -*-
@@ -215,5 +12,5 @@
  * This file is a part of LEMON, a generic C++ optimization library.
  *
- * Copyright (C) 2003-"$(hg_year $1)"
+ * Copyright (C) "$YEAR"
  * Egervary Jeno Kombinatorikus Optimalizalasi Kutatocsoport
  * (Egervary Research Group on Combinatorial Optimization, EGRES).
@@ -229,5 +26,5 @@
  */
 "
-    awk 'BEGIN { pm=0; }
+	awk 'BEGIN { pm=0; }
      pm==3 { print }
      /\/\* / && pm==0 { pm=1;}
@@ -235,156 +32,103 @@
      /\*\// && pm==1 { pm=2;}
     ' $1
-    ) >$TMP_FILE
+	) >$TMP_FILE
 
-    "$ACTION"_action "$TMP_FILE" "$1" header
+    HEADER_CH=`diff -q $TMP_FILE $FILE_NAME >/dev/null&&echo NO||echo YES`
+
+    rm $FILE_NAME
+    mv $TMP_FILE $FILE_NAME
 }
 
-function tabs_check() {
-    if echo $1 | grep -q -v -E 'Makefile\.am$'
-    then
-        OLD_PATTERN=$(echo -e '\t')
-        NEW_PATTERN='        '
-    else
-        OLD_PATTERN='        '
-        NEW_PATTERN=$(echo -e '\t')
-    fi
+function update_tabs() {
     TMP_FILE=`mktemp`
-    cat $1 | sed -e "s/$OLD_PATTERN/$NEW_PATTERN/g" >$TMP_FILE
+    FILE_NAME=$1
 
-    "$ACTION"_action "$TMP_FILE" "$1" 'tabs'
+    cat $1 |
+    sed -e 's/\t/        /g' >$TMP_FILE
+
+    TABS_CH=`diff -q $TMP_FILE $FILE_NAME >/dev/null&&echo NO||echo YES`
+
+    rm $FILE_NAME
+    mv $TMP_FILE $FILE_NAME
 }
 
-function spaces_check() {
+function remove_trailing_space() {
     TMP_FILE=`mktemp`
-    cat $1 | sed -e 's/ \+$//g' >$TMP_FILE
+    FILE_NAME=$1
 
-    "$ACTION"_action "$TMP_FILE" "$1" 'trailing spaces'
+    cat $1 |
+    sed -e 's/ \+$//g' >$TMP_FILE
+
+    SPACES_CH=`diff -q $TMP_FILE $FILE_NAME >/dev/null&&echo NO||echo YES`
+
+    rm $FILE_NAME
+    mv $TMP_FILE $FILE_NAME
 }
 
-function long_lines_check() {
-    if cat $1 | grep -q -E '.{81,}'
+function long_line_test() {
+    cat $1 |grep -q -E '.{81,}'
+}
+
+function update_file() {
+    echo -n '    update' $i ...
+
+    update_header $1
+    update_tabs $1
+    remove_trailing_space $1
+
+    CHANGED=NO;
+    if [[ $HEADER_CH = YES ]];
     then
-	"$ACTION"_warning $1 'long lines'
+	echo -n '  [header updated]'
+	CHANGED=YES;
+    fi
+    if [[ $TABS_CH = YES ]];
+    then
+	echo -n ' [tabs removed]'
+	CHANGED=YES;
+    fi
+    if [[ $SPACES_CH = YES ]];
+    then
+	echo -n ' [trailing spaces removed]'
+	CHANGED=YES;
+    fi
+    if long_line_test $1 ;
+    then
+	echo -n ' [LONG LINES]'
+	((LONG_LINE_FILES++))
+    fi
+    echo
+    if [[ $CHANGED = YES ]];
+    then
+	((CHANGED_FILES++))
     fi
 }
 
-# process the file
-
-function process_file() {
-    if [ "$ACTION" == 'update' ]
-    then
-        echo -n "    $ACTION $1..."
-    else
-        echo "	  $ACTION $1..."
-    fi
-
-    CHECKING="header tabs spaces long_lines"
-
-    "$ACTION"_begin $1
-    for check in $CHECKING
+CHANGED_FILES=0
+TOTAL_FILES=0
+LONG_LINE_FILES=0
+if [ $# == 0 ]; then
+    echo Update all source files...
+    for i in `hg manifest|grep -E  '\.(cc|h|dox)$'`
     do
-	"$check"_check $1
+	update_file $HGROOT/$i
+	((TOTAL_FILES++))
     done
-    "$ACTION"_end $1
-    if [ "$ACTION" == 'update' ]
-    then
-        echo
-    fi
-}
-
-function process_all {
-    "$ACTION"_init
-    while read file
+    echo '  done.'
+else
+    for i in $*
     do
-	process_file $file
-    done < <($FILES)
-    "$ACTION"_done
-}
-
-while [ $# -gt 0 ]
-do
-    
-    if [ "$1" == '--help' ] || [ "$1" == '-h' ]
-    then
-	echo -n \
-"Usage:
-  $0 [OPTIONS] [files]
-Options:
-  --dry-run|-n
-     Check the files, but do not modify them.
-  --interactive|-i
-     If --dry-run is specified and the checker emits warnings,
-     then the user is asked if the warnings should be considered
-     errors.
-  --werror|-w
-     Make all warnings into errors.
-  --all|-a
-     Check all source files in the repository.
-  --modified|-m
-     Check only the modified (and new) source files. This option is
-     useful to check the modification before making a commit.
-  --changed|-c
-     Check only the changed source files compared to the parent(s) of
-     the current hg node.  This option is useful as hg hook script.
-     To automatically check all your changes before making a commit,
-     add the following section to the appropriate .hg/hgrc file.
-
-       [hooks]
-       pretxncommit.checksources = scripts/unify-sources.sh -c -n -i
-
-  --help|-h
-     Print this help message.
-  files
-     The files to check/unify. If no file names are given, the modified
-     source files will be checked/unified (just like using the
-     --modified|-m option).
-"
-        exit 0
-    elif [ "$1" == '--dry-run' ] || [ "$1" == '-n' ]
-    then
-	[ -n "$ACTION" ] && echo "Conflicting action options" >&2 && exit 1
-	ACTION=check
-    elif [ "$1" == "--all" ] || [ "$1" == '-a' ]
-    then
-	[ -n "$FILES" ] && echo "Conflicting target options" >&2 && exit 1
-	FILES=all_files
-    elif [ "$1" == "--changed" ] || [ "$1" == '-c' ]
-    then
-	[ -n "$FILES" ] && echo "Conflicting target options" >&2 && exit 1
-	FILES=changed_files
-    elif [ "$1" == "--modified" ] || [ "$1" == '-m' ]
-    then
-	[ -n "$FILES" ] && echo "Conflicting target options" >&2 && exit 1
-	FILES=modified_files
-    elif [ "$1" == "--interactive" ] || [ "$1" == "-i" ]
-    then
-	[ -n "$WARNING" ] && echo "Conflicting warning options" >&2 && exit 1
-	WARNING='INTERACTIVE'
-    elif [ "$1" == "--werror" ] || [ "$1" == "-w" ]
-    then
-	[ -n "$WARNING" ] && echo "Conflicting warning options" >&2 && exit 1
-	WARNING='WERROR'
-    elif [ $(echo x$1 | cut -c 2) == '-' ]
-    then
-	echo "Invalid option $1" >&2 && exit 1
-    else
-	[ -n "$FILES" ] && echo "Invalid option $1" >&2 && exit 1
-	GIVEN_FILES=$@
-	FILES=given_files
-	break
-    fi
-    
-    shift
-done
-
-if [ -z $FILES ]
-then
-    FILES=modified_files
+	update_file $i
+	((TOTAL_FILES++))
+    done
 fi
-
-if [ -z $ACTION ]
-then
-    ACTION=update
+echo $CHANGED_FILES out of $TOTAL_FILES files has been changed.
+if [[ $LONG_LINE_FILES -gt 1 ]]; then
+    echo
+    echo WARNING: $LONG_LINE_FILES files contains long lines!    
+    echo
+elif [[ $LONG_LINE_FILES -gt 0 ]]; then
+    echo
+    echo WARNING: a file contains long lines!
+    echo
 fi
-
-process_all
Index: ripts/valgrind-wrapper.sh
===================================================================
--- scripts/valgrind-wrapper.sh	(revision 840)
+++ 	(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 953)
+++ test/CMakeLists.txt	(revision 539)
@@ -1,17 +1,11 @@
 INCLUDE_DIRECTORIES(
-  ${PROJECT_SOURCE_DIR}
+  ${CMAKE_SOURCE_DIR}
   ${PROJECT_BINARY_DIR}
 )
 
-LINK_DIRECTORIES(
-  ${PROJECT_BINARY_DIR}/lemon
-)
+LINK_DIRECTORIES(${CMAKE_BINARY_DIR}/lemon)
 
 SET(TESTS
-  adaptors_test
-  bellman_ford_test
   bfs_test
-  circulation_test
-  connectivity_test
   counter_test
   dfs_test
@@ -19,101 +13,15 @@
   dijkstra_test
   dim_test
-  edge_set_test
   error_test
-  euler_test
-  fractional_matching_test
-  gomory_hu_test
   graph_copy_test
   graph_test
   graph_utils_test
-  hao_orlin_test
   heap_test
   kruskal_test
   maps_test
-  matching_test
-  min_cost_arborescence_test
-  min_cost_flow_test
-  min_mean_cycle_test
+  random_test
   path_test
-  planarity_test
-  preflow_test
-  radix_sort_test
-  random_test
-  suurballe_test
   time_measure_test
-  unionfind_test
-)
-
-IF(LEMON_HAVE_LP)
-  ADD_EXECUTABLE(lp_test lp_test.cc)
-  SET(LP_TEST_LIBS lemon)
-
-  IF(LEMON_HAVE_GLPK)
-    SET(LP_TEST_LIBS ${LP_TEST_LIBS} ${GLPK_LIBRARIES})
-  ENDIF()
-  IF(LEMON_HAVE_CPLEX)
-    SET(LP_TEST_LIBS ${LP_TEST_LIBS} ${CPLEX_LIBRARIES})
-  ENDIF()
-  IF(LEMON_HAVE_CLP)
-    SET(LP_TEST_LIBS ${LP_TEST_LIBS} ${COIN_CLP_LIBRARIES})
-  ENDIF()
-
-  TARGET_LINK_LIBRARIES(lp_test ${LP_TEST_LIBS})
-  ADD_TEST(lp_test lp_test)
-
-  IF(WIN32 AND LEMON_HAVE_GLPK)
-    GET_TARGET_PROPERTY(TARGET_LOC lp_test LOCATION)
-    GET_FILENAME_COMPONENT(TARGET_PATH ${TARGET_LOC} PATH)
-    ADD_CUSTOM_COMMAND(TARGET lp_test POST_BUILD
-      COMMAND ${CMAKE_COMMAND} -E copy ${GLPK_BIN_DIR}/glpk.dll ${TARGET_PATH}
-      COMMAND ${CMAKE_COMMAND} -E copy ${GLPK_BIN_DIR}/libltdl3.dll ${TARGET_PATH}
-      COMMAND ${CMAKE_COMMAND} -E copy ${GLPK_BIN_DIR}/zlib1.dll ${TARGET_PATH}
-    )
-  ENDIF()
-
-  IF(WIN32 AND LEMON_HAVE_CPLEX)
-    GET_TARGET_PROPERTY(TARGET_LOC lp_test LOCATION)
-    GET_FILENAME_COMPONENT(TARGET_PATH ${TARGET_LOC} PATH)
-    ADD_CUSTOM_COMMAND(TARGET lp_test POST_BUILD
-      COMMAND ${CMAKE_COMMAND} -E copy ${CPLEX_BIN_DIR}/cplex91.dll ${TARGET_PATH}
-    )
-  ENDIF()
-ENDIF()
-
-IF(LEMON_HAVE_MIP)
-  ADD_EXECUTABLE(mip_test mip_test.cc)
-  SET(MIP_TEST_LIBS lemon)
-
-  IF(LEMON_HAVE_GLPK)
-    SET(MIP_TEST_LIBS ${MIP_TEST_LIBS} ${GLPK_LIBRARIES})
-  ENDIF()
-  IF(LEMON_HAVE_CPLEX)
-    SET(MIP_TEST_LIBS ${MIP_TEST_LIBS} ${CPLEX_LIBRARIES})
-  ENDIF()
-  IF(LEMON_HAVE_CBC)
-    SET(MIP_TEST_LIBS ${MIP_TEST_LIBS} ${COIN_CBC_LIBRARIES})
-  ENDIF()
-
-  TARGET_LINK_LIBRARIES(mip_test ${MIP_TEST_LIBS})
-  ADD_TEST(mip_test mip_test)
-
-  IF(WIN32 AND LEMON_HAVE_GLPK)
-    GET_TARGET_PROPERTY(TARGET_LOC mip_test LOCATION)
-    GET_FILENAME_COMPONENT(TARGET_PATH ${TARGET_LOC} PATH)
-    ADD_CUSTOM_COMMAND(TARGET mip_test POST_BUILD
-      COMMAND ${CMAKE_COMMAND} -E copy ${GLPK_BIN_DIR}/glpk.dll ${TARGET_PATH}
-      COMMAND ${CMAKE_COMMAND} -E copy ${GLPK_BIN_DIR}/libltdl3.dll ${TARGET_PATH}
-      COMMAND ${CMAKE_COMMAND} -E copy ${GLPK_BIN_DIR}/zlib1.dll ${TARGET_PATH}
-    )
-  ENDIF()
-
-  IF(WIN32 AND LEMON_HAVE_CPLEX)
-    GET_TARGET_PROPERTY(TARGET_LOC mip_test LOCATION)
-    GET_FILENAME_COMPONENT(TARGET_PATH ${TARGET_LOC} PATH)
-    ADD_CUSTOM_COMMAND(TARGET mip_test POST_BUILD
-      COMMAND ${CMAKE_COMMAND} -E copy ${CPLEX_BIN_DIR}/cplex91.dll ${TARGET_PATH}
-    )
-  ENDIF()
-ENDIF()
+  unionfind_test)
 
 FOREACH(TEST_NAME ${TESTS})
@@ -121,3 +29,3 @@
   TARGET_LINK_LIBRARIES(${TEST_NAME} lemon)
   ADD_TEST(${TEST_NAME} ${TEST_NAME})
-ENDFOREACH()
+ENDFOREACH(TEST_NAME)
Index: test/Makefile.am
===================================================================
--- test/Makefile.am	(revision 953)
+++ test/Makefile.am	(revision 228)
@@ -1,6 +1,2 @@
-if USE_VALGRIND
-TESTS_ENVIRONMENT=$(top_srcdir)/scripts/valgrind-wrapper.sh
-endif
-
 EXTRA_DIST += \
 	test/CMakeLists.txt
@@ -8,71 +4,37 @@
 noinst_HEADERS += \
 	test/graph_test.h \
-	test/test_tools.h
+        test/test_tools.h
 
 check_PROGRAMS += \
-	test/adaptors_test \
-	test/bellman_ford_test \
 	test/bfs_test \
-	test/circulation_test \
-	test/connectivity_test \
-	test/counter_test \
+        test/counter_test \
 	test/dfs_test \
 	test/digraph_test \
 	test/dijkstra_test \
-	test/dim_test \
-	test/edge_set_test \
+        test/dim_test \
 	test/error_test \
-	test/euler_test \
-	test/fractional_matching_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/maps_test \
-	test/matching_test \
-	test/min_cost_arborescence_test \
-	test/min_cost_flow_test \
-	test/min_mean_cycle_test \
-	test/path_test \
-	test/planarity_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/maps_test \
+        test/random_test \
+        test/path_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_bellman_ford_test_SOURCES = test/bellman_ford_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_fractional_matching_test_SOURCES = test/fractional_matching_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
@@ -80,17 +42,6 @@
 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_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_min_mean_cycle_test_SOURCES = test/min_mean_cycle_test.cc
 test_path_test_SOURCES = test/path_test.cc
-test_planarity_test_SOURCES = test/planarity_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
Index: st/adaptors_test.cc
===================================================================
--- test/adaptors_test.cc	(revision 550)
+++ 	(revision )
@@ -1,1463 +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 <limits>
-
-#include <lemon/list_graph.h>
-#include <lemon/grid_graph.h>
-#include <lemon/bfs.h>
-#include <lemon/path.h>
-
-#include <lemon/concepts/digraph.h>
-#include <lemon/concepts/graph.h>
-#include <lemon/concepts/graph_components.h>
-#include <lemon/concepts/maps.h>
-#include <lemon/concept_check.h>
-
-#include <lemon/adaptors.h>
-
-#include "test/test_tools.h"
-#include "test/graph_test.h"
-
-using namespace lemon;
-
-void checkReverseDigraph() {
-  // Check concepts
-  checkConcept<concepts::Digraph, ReverseDigraph<concepts::Digraph> >();
-  checkConcept<concepts::Digraph, ReverseDigraph<ListDigraph> >();
-  checkConcept<concepts::AlterableDigraphComponent<>,
-               ReverseDigraph<ListDigraph> >();
-  checkConcept<concepts::ExtendableDigraphComponent<>,
-               ReverseDigraph<ListDigraph> >();
-  checkConcept<concepts::ErasableDigraphComponent<>,
-               ReverseDigraph<ListDigraph> >();
-  checkConcept<concepts::ClearableDigraphComponent<>,
-               ReverseDigraph<ListDigraph> >();
-
-  // Create a digraph and an adaptor
-  typedef ListDigraph Digraph;
-  typedef ReverseDigraph<Digraph> Adaptor;
-
-  Digraph digraph;
-  Adaptor adaptor(digraph);
-
-  // Add nodes and arcs to the original digraph
-  Digraph::Node n1 = digraph.addNode();
-  Digraph::Node n2 = digraph.addNode();
-  Digraph::Node n3 = digraph.addNode();
-
-  Digraph::Arc a1 = digraph.addArc(n1, n2);
-  Digraph::Arc a2 = digraph.addArc(n1, n3);
-  Digraph::Arc a3 = digraph.addArc(n2, n3);
-
-  // Check the adaptor
-  checkGraphNodeList(adaptor, 3);
-  checkGraphArcList(adaptor, 3);
-  checkGraphConArcList(adaptor, 3);
-
-  checkGraphOutArcList(adaptor, n1, 0);
-  checkGraphOutArcList(adaptor, n2, 1);
-  checkGraphOutArcList(adaptor, n3, 2);
-
-  checkGraphInArcList(adaptor, n1, 2);
-  checkGraphInArcList(adaptor, n2, 1);
-  checkGraphInArcList(adaptor, n3, 0);
-
-  checkNodeIds(adaptor);
-  checkArcIds(adaptor);
-
-  checkGraphNodeMap(adaptor);
-  checkGraphArcMap(adaptor);
-
-  // Check the orientation of the arcs
-  for (Adaptor::ArcIt a(adaptor); a != INVALID; ++a) {
-    check(adaptor.source(a) == digraph.target(a), "Wrong reverse");
-    check(adaptor.target(a) == digraph.source(a), "Wrong reverse");
-  }
-
-  // Add and erase nodes and arcs in the digraph through the adaptor
-  Adaptor::Node n4 = adaptor.addNode();
-
-  Adaptor::Arc a4 = adaptor.addArc(n4, n3);
-  Adaptor::Arc a5 = adaptor.addArc(n2, n4);
-  Adaptor::Arc a6 = adaptor.addArc(n2, n4);
-  Adaptor::Arc a7 = adaptor.addArc(n1, n4);
-  Adaptor::Arc a8 = adaptor.addArc(n1, n2);
-
-  adaptor.erase(a1);
-  adaptor.erase(n3);
-
-  // Check the adaptor
-  checkGraphNodeList(adaptor, 3);
-  checkGraphArcList(adaptor, 4);
-  checkGraphConArcList(adaptor, 4);
-
-  checkGraphOutArcList(adaptor, n1, 2);
-  checkGraphOutArcList(adaptor, n2, 2);
-  checkGraphOutArcList(adaptor, n4, 0);
-
-  checkGraphInArcList(adaptor, n1, 0);
-  checkGraphInArcList(adaptor, n2, 1);
-  checkGraphInArcList(adaptor, n4, 3);
-
-  checkNodeIds(adaptor);
-  checkArcIds(adaptor);
-
-  checkGraphNodeMap(adaptor);
-  checkGraphArcMap(adaptor);
-
-  // Check the digraph
-  checkGraphNodeList(digraph, 3);
-  checkGraphArcList(digraph, 4);
-  checkGraphConArcList(digraph, 4);
-
-  checkGraphOutArcList(digraph, n1, 0);
-  checkGraphOutArcList(digraph, n2, 1);
-  checkGraphOutArcList(digraph, n4, 3);
-
-  checkGraphInArcList(digraph, n1, 2);
-  checkGraphInArcList(digraph, n2, 2);
-  checkGraphInArcList(digraph, n4, 0);
-
-  checkNodeIds(digraph);
-  checkArcIds(digraph);
-
-  checkGraphNodeMap(digraph);
-  checkGraphArcMap(digraph);
-
-  // Check the conversion of nodes and arcs
-  Digraph::Node nd = n4;
-  nd = n4;
-  Adaptor::Node na = n1;
-  na = n2;
-  Digraph::Arc ad = a4;
-  ad = a5;
-  Adaptor::Arc aa = a1;
-  aa = a2;
-}
-
-void checkSubDigraph() {
-  // Check concepts
-  checkConcept<concepts::Digraph, SubDigraph<concepts::Digraph> >();
-  checkConcept<concepts::Digraph, SubDigraph<ListDigraph> >();
-  checkConcept<concepts::AlterableDigraphComponent<>,
-               SubDigraph<ListDigraph> >();
-  checkConcept<concepts::ExtendableDigraphComponent<>,
-               SubDigraph<ListDigraph> >();
-  checkConcept<concepts::ErasableDigraphComponent<>,
-               SubDigraph<ListDigraph> >();
-  checkConcept<concepts::ClearableDigraphComponent<>,
-               SubDigraph<ListDigraph> >();
-
-  // Create a digraph and an adaptor
-  typedef ListDigraph Digraph;
-  typedef Digraph::NodeMap<bool> NodeFilter;
-  typedef Digraph::ArcMap<bool> ArcFilter;
-  typedef SubDigraph<Digraph, NodeFilter, ArcFilter> Adaptor;
-
-  Digraph digraph;
-  NodeFilter node_filter(digraph);
-  ArcFilter arc_filter(digraph);
-  Adaptor adaptor(digraph, node_filter, arc_filter);
-
-  // Add nodes and arcs to the original digraph and the adaptor
-  Digraph::Node n1 = digraph.addNode();
-  Digraph::Node n2 = digraph.addNode();
-  Adaptor::Node n3 = adaptor.addNode();
-
-  node_filter[n1] = node_filter[n2] = node_filter[n3] = true;
-
-  Digraph::Arc a1 = digraph.addArc(n1, n2);
-  Digraph::Arc a2 = digraph.addArc(n1, n3);
-  Adaptor::Arc a3 = adaptor.addArc(n2, n3);
-
-  arc_filter[a1] = arc_filter[a2] = arc_filter[a3] = true;
-
-  checkGraphNodeList(adaptor, 3);
-  checkGraphArcList(adaptor, 3);
-  checkGraphConArcList(adaptor, 3);
-
-  checkGraphOutArcList(adaptor, n1, 2);
-  checkGraphOutArcList(adaptor, n2, 1);
-  checkGraphOutArcList(adaptor, n3, 0);
-
-  checkGraphInArcList(adaptor, n1, 0);
-  checkGraphInArcList(adaptor, n2, 1);
-  checkGraphInArcList(adaptor, n3, 2);
-
-  checkNodeIds(adaptor);
-  checkArcIds(adaptor);
-
-  checkGraphNodeMap(adaptor);
-  checkGraphArcMap(adaptor);
-
-  // Hide an arc
-  adaptor.status(a2, false);
-  adaptor.disable(a3);
-  if (!adaptor.status(a3)) adaptor.enable(a3);
-
-  checkGraphNodeList(adaptor, 3);
-  checkGraphArcList(adaptor, 2);
-  checkGraphConArcList(adaptor, 2);
-
-  checkGraphOutArcList(adaptor, n1, 1);
-  checkGraphOutArcList(adaptor, n2, 1);
-  checkGraphOutArcList(adaptor, n3, 0);
-
-  checkGraphInArcList(adaptor, n1, 0);
-  checkGraphInArcList(adaptor, n2, 1);
-  checkGraphInArcList(adaptor, n3, 1);
-
-  checkNodeIds(adaptor);
-  checkArcIds(adaptor);
-
-  checkGraphNodeMap(adaptor);
-  checkGraphArcMap(adaptor);
-
-  // Hide a node
-  adaptor.status(n1, false);
-  adaptor.disable(n3);
-  if (!adaptor.status(n3)) adaptor.enable(n3);
-
-  checkGraphNodeList(adaptor, 2);
-  checkGraphArcList(adaptor, 1);
-  checkGraphConArcList(adaptor, 1);
-
-  checkGraphOutArcList(adaptor, n2, 1);
-  checkGraphOutArcList(adaptor, n3, 0);
-
-  checkGraphInArcList(adaptor, n2, 0);
-  checkGraphInArcList(adaptor, n3, 1);
-
-  checkNodeIds(adaptor);
-  checkArcIds(adaptor);
-
-  checkGraphNodeMap(adaptor);
-  checkGraphArcMap(adaptor);
-
-  // Hide all nodes and arcs
-  node_filter[n1] = node_filter[n2] = node_filter[n3] = false;
-  arc_filter[a1] = arc_filter[a2] = arc_filter[a3] = false;
-
-  checkGraphNodeList(adaptor, 0);
-  checkGraphArcList(adaptor, 0);
-  checkGraphConArcList(adaptor, 0);
-
-  checkNodeIds(adaptor);
-  checkArcIds(adaptor);
-
-  checkGraphNodeMap(adaptor);
-  checkGraphArcMap(adaptor);
-
-  // Check the conversion of nodes and arcs
-  Digraph::Node nd = n3;
-  nd = n3;
-  Adaptor::Node na = n1;
-  na = n2;
-  Digraph::Arc ad = a3;
-  ad = a3;
-  Adaptor::Arc aa = a1;
-  aa = a2;
-}
-
-void checkFilterNodes1() {
-  // Check concepts
-  checkConcept<concepts::Digraph, FilterNodes<concepts::Digraph> >();
-  checkConcept<concepts::Digraph, FilterNodes<ListDigraph> >();
-  checkConcept<concepts::AlterableDigraphComponent<>,
-               FilterNodes<ListDigraph> >();
-  checkConcept<concepts::ExtendableDigraphComponent<>,
-               FilterNodes<ListDigraph> >();
-  checkConcept<concepts::ErasableDigraphComponent<>,
-               FilterNodes<ListDigraph> >();
-  checkConcept<concepts::ClearableDigraphComponent<>,
-               FilterNodes<ListDigraph> >();
-
-  // Create a digraph and an adaptor
-  typedef ListDigraph Digraph;
-  typedef Digraph::NodeMap<bool> NodeFilter;
-  typedef FilterNodes<Digraph, NodeFilter> Adaptor;
-
-  Digraph digraph;
-  NodeFilter node_filter(digraph);
-  Adaptor adaptor(digraph, node_filter);
-
-  // Add nodes and arcs to the original digraph and the adaptor
-  Digraph::Node n1 = digraph.addNode();
-  Digraph::Node n2 = digraph.addNode();
-  Adaptor::Node n3 = adaptor.addNode();
-
-  node_filter[n1] = node_filter[n2] = node_filter[n3] = true;
-
-  Digraph::Arc a1 = digraph.addArc(n1, n2);
-  Digraph::Arc a2 = digraph.addArc(n1, n3);
-  Adaptor::Arc a3 = adaptor.addArc(n2, n3);
-
-  checkGraphNodeList(adaptor, 3);
-  checkGraphArcList(adaptor, 3);
-  checkGraphConArcList(adaptor, 3);
-
-  checkGraphOutArcList(adaptor, n1, 2);
-  checkGraphOutArcList(adaptor, n2, 1);
-  checkGraphOutArcList(adaptor, n3, 0);
-
-  checkGraphInArcList(adaptor, n1, 0);
-  checkGraphInArcList(adaptor, n2, 1);
-  checkGraphInArcList(adaptor, n3, 2);
-
-  checkNodeIds(adaptor);
-  checkArcIds(adaptor);
-
-  checkGraphNodeMap(adaptor);
-  checkGraphArcMap(adaptor);
-
-  // Hide a node
-  adaptor.status(n1, false);
-  adaptor.disable(n3);
-  if (!adaptor.status(n3)) adaptor.enable(n3);
-
-  checkGraphNodeList(adaptor, 2);
-  checkGraphArcList(adaptor, 1);
-  checkGraphConArcList(adaptor, 1);
-
-  checkGraphOutArcList(adaptor, n2, 1);
-  checkGraphOutArcList(adaptor, n3, 0);
-
-  checkGraphInArcList(adaptor, n2, 0);
-  checkGraphInArcList(adaptor, n3, 1);
-
-  checkNodeIds(adaptor);
-  checkArcIds(adaptor);
-
-  checkGraphNodeMap(adaptor);
-  checkGraphArcMap(adaptor);
-
-  // Hide all nodes
-  node_filter[n1] = node_filter[n2] = node_filter[n3] = false;
-
-  checkGraphNodeList(adaptor, 0);
-  checkGraphArcList(adaptor, 0);
-  checkGraphConArcList(adaptor, 0);
-
-  checkNodeIds(adaptor);
-  checkArcIds(adaptor);
-
-  checkGraphNodeMap(adaptor);
-  checkGraphArcMap(adaptor);
-
-  // Check the conversion of nodes and arcs
-  Digraph::Node nd = n3;
-  nd = n3;
-  Adaptor::Node na = n1;
-  na = n2;
-  Digraph::Arc ad = a3;
-  ad = a3;
-  Adaptor::Arc aa = a1;
-  aa = a2;
-}
-
-void checkFilterArcs() {
-  // Check concepts
-  checkConcept<concepts::Digraph, FilterArcs<concepts::Digraph> >();
-  checkConcept<concepts::Digraph, FilterArcs<ListDigraph> >();
-  checkConcept<concepts::AlterableDigraphComponent<>,
-               FilterArcs<ListDigraph> >();
-  checkConcept<concepts::ExtendableDigraphComponent<>,
-               FilterArcs<ListDigraph> >();
-  checkConcept<concepts::ErasableDigraphComponent<>,
-               FilterArcs<ListDigraph> >();
-  checkConcept<concepts::ClearableDigraphComponent<>,
-               FilterArcs<ListDigraph> >();
-
-  // Create a digraph and an adaptor
-  typedef ListDigraph Digraph;
-  typedef Digraph::ArcMap<bool> ArcFilter;
-  typedef FilterArcs<Digraph, ArcFilter> Adaptor;
-
-  Digraph digraph;
-  ArcFilter arc_filter(digraph);
-  Adaptor adaptor(digraph, arc_filter);
-
-  // Add nodes and arcs to the original digraph and the adaptor
-  Digraph::Node n1 = digraph.addNode();
-  Digraph::Node n2 = digraph.addNode();
-  Adaptor::Node n3 = adaptor.addNode();
-
-  Digraph::Arc a1 = digraph.addArc(n1, n2);
-  Digraph::Arc a2 = digraph.addArc(n1, n3);
-  Adaptor::Arc a3 = adaptor.addArc(n2, n3);
-
-  arc_filter[a1] = arc_filter[a2] = arc_filter[a3] = true;
-
-  checkGraphNodeList(adaptor, 3);
-  checkGraphArcList(adaptor, 3);
-  checkGraphConArcList(adaptor, 3);
-
-  checkGraphOutArcList(adaptor, n1, 2);
-  checkGraphOutArcList(adaptor, n2, 1);
-  checkGraphOutArcList(adaptor, n3, 0);
-
-  checkGraphInArcList(adaptor, n1, 0);
-  checkGraphInArcList(adaptor, n2, 1);
-  checkGraphInArcList(adaptor, n3, 2);
-
-  checkNodeIds(adaptor);
-  checkArcIds(adaptor);
-
-  checkGraphNodeMap(adaptor);
-  checkGraphArcMap(adaptor);
-
-  // Hide an arc
-  adaptor.status(a2, false);
-  adaptor.disable(a3);
-  if (!adaptor.status(a3)) adaptor.enable(a3);
-
-  checkGraphNodeList(adaptor, 3);
-  checkGraphArcList(adaptor, 2);
-  checkGraphConArcList(adaptor, 2);
-
-  checkGraphOutArcList(adaptor, n1, 1);
-  checkGraphOutArcList(adaptor, n2, 1);
-  checkGraphOutArcList(adaptor, n3, 0);
-
-  checkGraphInArcList(adaptor, n1, 0);
-  checkGraphInArcList(adaptor, n2, 1);
-  checkGraphInArcList(adaptor, n3, 1);
-
-  checkNodeIds(adaptor);
-  checkArcIds(adaptor);
-
-  checkGraphNodeMap(adaptor);
-  checkGraphArcMap(adaptor);
-
-  // Hide all arcs
-  arc_filter[a1] = arc_filter[a2] = arc_filter[a3] = false;
-
-  checkGraphNodeList(adaptor, 3);
-  checkGraphArcList(adaptor, 0);
-  checkGraphConArcList(adaptor, 0);
-
-  checkNodeIds(adaptor);
-  checkArcIds(adaptor);
-
-  checkGraphNodeMap(adaptor);
-  checkGraphArcMap(adaptor);
-
-  // Check the conversion of nodes and arcs
-  Digraph::Node nd = n3;
-  nd = n3;
-  Adaptor::Node na = n1;
-  na = n2;
-  Digraph::Arc ad = a3;
-  ad = a3;
-  Adaptor::Arc aa = a1;
-  aa = a2;
-}
-
-void checkUndirector() {
-  // Check concepts
-  checkConcept<concepts::Graph, Undirector<concepts::Digraph> >();
-  checkConcept<concepts::Graph, Undirector<ListDigraph> >();
-  checkConcept<concepts::AlterableGraphComponent<>,
-               Undirector<ListDigraph> >();
-  checkConcept<concepts::ExtendableGraphComponent<>,
-               Undirector<ListDigraph> >();
-  checkConcept<concepts::ErasableGraphComponent<>,
-               Undirector<ListDigraph> >();
-  checkConcept<concepts::ClearableGraphComponent<>,
-               Undirector<ListDigraph> >();
-
-
-  // Create a digraph and an adaptor
-  typedef ListDigraph Digraph;
-  typedef Undirector<Digraph> Adaptor;
-
-  Digraph digraph;
-  Adaptor adaptor(digraph);
-
-  // Add nodes and arcs/edges to the original digraph and the adaptor
-  Digraph::Node n1 = digraph.addNode();
-  Digraph::Node n2 = digraph.addNode();
-  Adaptor::Node n3 = adaptor.addNode();
-
-  Digraph::Arc a1 = digraph.addArc(n1, n2);
-  Digraph::Arc a2 = digraph.addArc(n1, n3);
-  Adaptor::Edge e3 = adaptor.addEdge(n2, n3);
-
-  // Check the original digraph
-  checkGraphNodeList(digraph, 3);
-  checkGraphArcList(digraph, 3);
-  checkGraphConArcList(digraph, 3);
-
-  checkGraphOutArcList(digraph, n1, 2);
-  checkGraphOutArcList(digraph, n2, 1);
-  checkGraphOutArcList(digraph, n3, 0);
-
-  checkGraphInArcList(digraph, n1, 0);
-  checkGraphInArcList(digraph, n2, 1);
-  checkGraphInArcList(digraph, n3, 2);
-
-  checkNodeIds(digraph);
-  checkArcIds(digraph);
-
-  checkGraphNodeMap(digraph);
-  checkGraphArcMap(digraph);
-
-  // Check the adaptor
-  checkGraphNodeList(adaptor, 3);
-  checkGraphArcList(adaptor, 6);
-  checkGraphEdgeList(adaptor, 3);
-  checkGraphConArcList(adaptor, 6);
-  checkGraphConEdgeList(adaptor, 3);
-
-  checkGraphIncEdgeArcLists(adaptor, n1, 2);
-  checkGraphIncEdgeArcLists(adaptor, n2, 2);
-  checkGraphIncEdgeArcLists(adaptor, n3, 2);
-
-  checkNodeIds(adaptor);
-  checkArcIds(adaptor);
-  checkEdgeIds(adaptor);
-
-  checkGraphNodeMap(adaptor);
-  checkGraphArcMap(adaptor);
-  checkGraphEdgeMap(adaptor);
-
-  // Check the edges of the adaptor
-  for (Adaptor::EdgeIt e(adaptor); e != INVALID; ++e) {
-    check(adaptor.u(e) == digraph.source(e), "Wrong undir");
-    check(adaptor.v(e) == digraph.target(e), "Wrong undir");
-  }
-
-  // Check CombinedArcMap
-  typedef Adaptor::CombinedArcMap
-    <Digraph::ArcMap<int>, Digraph::ArcMap<int> > IntCombinedMap;
-  typedef Adaptor::CombinedArcMap
-    <Digraph::ArcMap<bool>, Digraph::ArcMap<bool> > BoolCombinedMap;
-  checkConcept<concepts::ReferenceMap<Adaptor::Arc, int, int&, const int&>,
-    IntCombinedMap>();
-  checkConcept<concepts::ReferenceMap<Adaptor::Arc, bool, bool&, const bool&>,
-    BoolCombinedMap>();
-
-  Digraph::ArcMap<int> fw_map(digraph), bk_map(digraph);
-  for (Digraph::ArcIt a(digraph); a != INVALID; ++a) {
-    fw_map[a] = digraph.id(a);
-    bk_map[a] = -digraph.id(a);
-  }
-
-  Adaptor::CombinedArcMap<Digraph::ArcMap<int>, Digraph::ArcMap<int> >
-    comb_map(fw_map, bk_map);
-  for (Adaptor::ArcIt a(adaptor); a != INVALID; ++a) {
-    if (adaptor.source(a) == digraph.source(a)) {
-      check(comb_map[a] == fw_map[a], "Wrong combined map");
-    } else {
-      check(comb_map[a] == bk_map[a], "Wrong combined map");
-    }
-  }
-
-  // Check the conversion of nodes and arcs/edges
-  Digraph::Node nd = n3;
-  nd = n3;
-  Adaptor::Node na = n1;
-  na = n2;
-  Digraph::Arc ad = e3;
-  ad = e3;
-  Adaptor::Edge ea = a1;
-  ea = a2;
-}
-
-void checkResidualDigraph() {
-  // Check concepts
-  checkConcept<concepts::Digraph, ResidualDigraph<concepts::Digraph> >();
-  checkConcept<concepts::Digraph, ResidualDigraph<ListDigraph> >();
-
-  // Create a digraph and an adaptor
-  typedef ListDigraph Digraph;
-  typedef Digraph::ArcMap<int> IntArcMap;
-  typedef ResidualDigraph<Digraph, IntArcMap> Adaptor;
-
-  Digraph digraph;
-  IntArcMap capacity(digraph), flow(digraph);
-  Adaptor adaptor(digraph, capacity, flow);
-
-  Digraph::Node n1 = digraph.addNode();
-  Digraph::Node n2 = digraph.addNode();
-  Digraph::Node n3 = digraph.addNode();
-  Digraph::Node n4 = digraph.addNode();
-
-  Digraph::Arc a1 = digraph.addArc(n1, n2);
-  Digraph::Arc a2 = digraph.addArc(n1, n3);
-  Digraph::Arc a3 = digraph.addArc(n1, n4);
-  Digraph::Arc a4 = digraph.addArc(n2, n3);
-  Digraph::Arc a5 = digraph.addArc(n2, n4);
-  Digraph::Arc a6 = digraph.addArc(n3, n4);
-
-  capacity[a1] = 8;
-  capacity[a2] = 6;
-  capacity[a3] = 4;
-  capacity[a4] = 4;
-  capacity[a5] = 6;
-  capacity[a6] = 10;
-
-  // Check the adaptor with various flow values
-  for (Digraph::ArcIt a(digraph); a != INVALID; ++a) {
-    flow[a] = 0;
-  }
-
-  checkGraphNodeList(adaptor, 4);
-  checkGraphArcList(adaptor, 6);
-  checkGraphConArcList(adaptor, 6);
-
-  checkGraphOutArcList(adaptor, n1, 3);
-  checkGraphOutArcList(adaptor, n2, 2);
-  checkGraphOutArcList(adaptor, n3, 1);
-  checkGraphOutArcList(adaptor, n4, 0);
-
-  checkGraphInArcList(adaptor, n1, 0);
-  checkGraphInArcList(adaptor, n2, 1);
-  checkGraphInArcList(adaptor, n3, 2);
-  checkGraphInArcList(adaptor, n4, 3);
-
-  for (Digraph::ArcIt a(digraph); a != INVALID; ++a) {
-    flow[a] = capacity[a] / 2;
-  }
-
-  checkGraphNodeList(adaptor, 4);
-  checkGraphArcList(adaptor, 12);
-  checkGraphConArcList(adaptor, 12);
-
-  checkGraphOutArcList(adaptor, n1, 3);
-  checkGraphOutArcList(adaptor, n2, 3);
-  checkGraphOutArcList(adaptor, n3, 3);
-  checkGraphOutArcList(adaptor, n4, 3);
-
-  checkGraphInArcList(adaptor, n1, 3);
-  checkGraphInArcList(adaptor, n2, 3);
-  checkGraphInArcList(adaptor, n3, 3);
-  checkGraphInArcList(adaptor, n4, 3);
-
-  checkNodeIds(adaptor);
-  checkArcIds(adaptor);
-
-  checkGraphNodeMap(adaptor);
-  checkGraphArcMap(adaptor);
-
-  for (Digraph::ArcIt a(digraph); a != INVALID; ++a) {
-    flow[a] = capacity[a];
-  }
-
-  checkGraphNodeList(adaptor, 4);
-  checkGraphArcList(adaptor, 6);
-  checkGraphConArcList(adaptor, 6);
-
-  checkGraphOutArcList(adaptor, n1, 0);
-  checkGraphOutArcList(adaptor, n2, 1);
-  checkGraphOutArcList(adaptor, n3, 2);
-  checkGraphOutArcList(adaptor, n4, 3);
-
-  checkGraphInArcList(adaptor, n1, 3);
-  checkGraphInArcList(adaptor, n2, 2);
-  checkGraphInArcList(adaptor, n3, 1);
-  checkGraphInArcList(adaptor, n4, 0);
-
-  // Saturate all backward arcs
-  // (set the flow to zero on all forward arcs)
-  for (Adaptor::ArcIt a(adaptor); a != INVALID; ++a) {
-    if (adaptor.backward(a))
-      adaptor.augment(a, adaptor.residualCapacity(a));
-  }
-
-  checkGraphNodeList(adaptor, 4);
-  checkGraphArcList(adaptor, 6);
-  checkGraphConArcList(adaptor, 6);
-
-  checkGraphOutArcList(adaptor, n1, 3);
-  checkGraphOutArcList(adaptor, n2, 2);
-  checkGraphOutArcList(adaptor, n3, 1);
-  checkGraphOutArcList(adaptor, n4, 0);
-
-  checkGraphInArcList(adaptor, n1, 0);
-  checkGraphInArcList(adaptor, n2, 1);
-  checkGraphInArcList(adaptor, n3, 2);
-  checkGraphInArcList(adaptor, n4, 3);
-
-  // Find maximum flow by augmenting along shortest paths
-  int flow_value = 0;
-  Adaptor::ResidualCapacity res_cap(adaptor);
-  while (true) {
-
-    Bfs<Adaptor> bfs(adaptor);
-    bfs.run(n1, n4);
-
-    if (!bfs.reached(n4)) break;
-
-    Path<Adaptor> p = bfs.path(n4);
-
-    int min = std::numeric_limits<int>::max();
-    for (Path<Adaptor>::ArcIt a(p); a != INVALID; ++a) {
-      if (res_cap[a] < min) min = res_cap[a];
-    }
-
-    for (Path<Adaptor>::ArcIt a(p); a != INVALID; ++a) {
-      adaptor.augment(a, min);
-    }
-    flow_value += min;
-  }
-
-  check(flow_value == 18, "Wrong flow with res graph adaptor");
-
-  // Check forward() and backward()
-  for (Adaptor::ArcIt a(adaptor); a != INVALID; ++a) {
-    check(adaptor.forward(a) != adaptor.backward(a),
-          "Wrong forward() or backward()");
-    check((adaptor.forward(a) && adaptor.forward(Digraph::Arc(a)) == a) ||
-          (adaptor.backward(a) && adaptor.backward(Digraph::Arc(a)) == a),
-          "Wrong forward() or backward()");
-  }
-
-  // Check the conversion of nodes and arcs
-  Digraph::Node nd = Adaptor::NodeIt(adaptor);
-  nd = ++Adaptor::NodeIt(adaptor);
-  Adaptor::Node na = n1;
-  na = n2;
-  Digraph::Arc ad = Adaptor::ArcIt(adaptor);
-  ad = ++Adaptor::ArcIt(adaptor);
-}
-
-void checkSplitNodes() {
-  // Check concepts
-  checkConcept<concepts::Digraph, SplitNodes<concepts::Digraph> >();
-  checkConcept<concepts::Digraph, SplitNodes<ListDigraph> >();
-
-  // Create a digraph and an adaptor
-  typedef ListDigraph Digraph;
-  typedef SplitNodes<Digraph> Adaptor;
-
-  Digraph digraph;
-  Adaptor adaptor(digraph);
-
-  Digraph::Node n1 = digraph.addNode();
-  Digraph::Node n2 = digraph.addNode();
-  Digraph::Node n3 = digraph.addNode();
-
-  Digraph::Arc a1 = digraph.addArc(n1, n2);
-  Digraph::Arc a2 = digraph.addArc(n1, n3);
-  Digraph::Arc a3 = digraph.addArc(n2, n3);
-
-  checkGraphNodeList(adaptor, 6);
-  checkGraphArcList(adaptor, 6);
-  checkGraphConArcList(adaptor, 6);
-
-  checkGraphOutArcList(adaptor, adaptor.inNode(n1), 1);
-  checkGraphOutArcList(adaptor, adaptor.outNode(n1), 2);
-  checkGraphOutArcList(adaptor, adaptor.inNode(n2), 1);
-  checkGraphOutArcList(adaptor, adaptor.outNode(n2), 1);
-  checkGraphOutArcList(adaptor, adaptor.inNode(n3), 1);
-  checkGraphOutArcList(adaptor, adaptor.outNode(n3), 0);
-
-  checkGraphInArcList(adaptor, adaptor.inNode(n1), 0);
-  checkGraphInArcList(adaptor, adaptor.outNode(n1), 1);
-  checkGraphInArcList(adaptor, adaptor.inNode(n2), 1);
-  checkGraphInArcList(adaptor, adaptor.outNode(n2), 1);
-  checkGraphInArcList(adaptor, adaptor.inNode(n3), 2);
-  checkGraphInArcList(adaptor, adaptor.outNode(n3), 1);
-
-  checkNodeIds(adaptor);
-  checkArcIds(adaptor);
-
-  checkGraphNodeMap(adaptor);
-  checkGraphArcMap(adaptor);
-
-  // Check split
-  for (Adaptor::ArcIt a(adaptor); a != INVALID; ++a) {
-    if (adaptor.origArc(a)) {
-      Digraph::Arc oa = a;
-      check(adaptor.source(a) == adaptor.outNode(digraph.source(oa)),
-            "Wrong split");
-      check(adaptor.target(a) == adaptor.inNode(digraph.target(oa)),
-            "Wrong split");
-    } else {
-      Digraph::Node on = a;
-      check(adaptor.source(a) == adaptor.inNode(on), "Wrong split");
-      check(adaptor.target(a) == adaptor.outNode(on), "Wrong split");
-    }
-  }
-
-  // Check combined node map
-  typedef Adaptor::CombinedNodeMap
-    <Digraph::NodeMap<int>, Digraph::NodeMap<int> > IntCombinedNodeMap;
-  typedef Adaptor::CombinedNodeMap
-    <Digraph::NodeMap<bool>, Digraph::NodeMap<bool> > BoolCombinedNodeMap;
-  checkConcept<concepts::ReferenceMap<Adaptor::Node, int, int&, const int&>,
-    IntCombinedNodeMap>();
-//checkConcept<concepts::ReferenceMap<Adaptor::Node, bool, bool&, const bool&>,
-//  BoolCombinedNodeMap>();
-  checkConcept<concepts::ReadWriteMap<Adaptor::Node, bool>,
-    BoolCombinedNodeMap>();
-
-  Digraph::NodeMap<int> in_map(digraph), out_map(digraph);
-  for (Digraph::NodeIt n(digraph); n != INVALID; ++n) {
-    in_map[n] = digraph.id(n);
-    out_map[n] = -digraph.id(n);
-  }
-
-  Adaptor::CombinedNodeMap<Digraph::NodeMap<int>, Digraph::NodeMap<int> >
-    node_map(in_map, out_map);
-  for (Adaptor::NodeIt n(adaptor); n != INVALID; ++n) {
-    if (adaptor.inNode(n)) {
-      check(node_map[n] == in_map[n], "Wrong combined node map");
-    } else {
-      check(node_map[n] == out_map[n], "Wrong combined node map");
-    }
-  }
-
-  // Check combined arc map
-  typedef Adaptor::CombinedArcMap
-    <Digraph::ArcMap<int>, Digraph::NodeMap<int> > IntCombinedArcMap;
-  typedef Adaptor::CombinedArcMap
-    <Digraph::ArcMap<bool>, Digraph::NodeMap<bool> > BoolCombinedArcMap;
-  checkConcept<concepts::ReferenceMap<Adaptor::Arc, int, int&, const int&>,
-    IntCombinedArcMap>();
-//checkConcept<concepts::ReferenceMap<Adaptor::Arc, bool, bool&, const bool&>,
-//  BoolCombinedArcMap>();
-  checkConcept<concepts::ReadWriteMap<Adaptor::Arc, bool>,
-    BoolCombinedArcMap>();
-
-  Digraph::ArcMap<int> a_map(digraph);
-  for (Digraph::ArcIt a(digraph); a != INVALID; ++a) {
-    a_map[a] = digraph.id(a);
-  }
-
-  Adaptor::CombinedArcMap<Digraph::ArcMap<int>, Digraph::NodeMap<int> >
-    arc_map(a_map, out_map);
-  for (Digraph::ArcIt a(digraph); a != INVALID; ++a) {
-    check(arc_map[adaptor.arc(a)] == a_map[a],  "Wrong combined arc map");
-  }
-  for (Digraph::NodeIt n(digraph); n != INVALID; ++n) {
-    check(arc_map[adaptor.arc(n)] == out_map[n],  "Wrong combined arc map");
-  }
-
-  // Check the conversion of nodes
-  Digraph::Node nd = adaptor.inNode(n1);
-  check (nd == n1, "Wrong node conversion");
-  nd = adaptor.outNode(n2);
-  check (nd == n2, "Wrong node conversion");
-}
-
-void checkSubGraph() {
-  // Check concepts
-  checkConcept<concepts::Graph, SubGraph<concepts::Graph> >();
-  checkConcept<concepts::Graph, SubGraph<ListGraph> >();
-  checkConcept<concepts::AlterableGraphComponent<>,
-               SubGraph<ListGraph> >();
-  checkConcept<concepts::ExtendableGraphComponent<>,
-               SubGraph<ListGraph> >();
-  checkConcept<concepts::ErasableGraphComponent<>,
-               SubGraph<ListGraph> >();
-  checkConcept<concepts::ClearableGraphComponent<>,
-               SubGraph<ListGraph> >();
-
-  // Create a graph and an adaptor
-  typedef ListGraph Graph;
-  typedef Graph::NodeMap<bool> NodeFilter;
-  typedef Graph::EdgeMap<bool> EdgeFilter;
-  typedef SubGraph<Graph, NodeFilter, EdgeFilter> Adaptor;
-
-  Graph graph;
-  NodeFilter node_filter(graph);
-  EdgeFilter edge_filter(graph);
-  Adaptor adaptor(graph, node_filter, edge_filter);
-
-  // Add nodes and edges to the original graph and the adaptor
-  Graph::Node n1 = graph.addNode();
-  Graph::Node n2 = graph.addNode();
-  Adaptor::Node n3 = adaptor.addNode();
-  Adaptor::Node n4 = adaptor.addNode();
-
-  node_filter[n1] = node_filter[n2] = node_filter[n3] = node_filter[n4] = true;
-
-  Graph::Edge e1 = graph.addEdge(n1, n2);
-  Graph::Edge e2 = graph.addEdge(n1, n3);
-  Adaptor::Edge e3 = adaptor.addEdge(n2, n3);
-  Adaptor::Edge e4 = adaptor.addEdge(n3, n4);
-
-  edge_filter[e1] = edge_filter[e2] = edge_filter[e3] = edge_filter[e4] = true;
-
-  checkGraphNodeList(adaptor, 4);
-  checkGraphArcList(adaptor, 8);
-  checkGraphEdgeList(adaptor, 4);
-  checkGraphConArcList(adaptor, 8);
-  checkGraphConEdgeList(adaptor, 4);
-
-  checkGraphIncEdgeArcLists(adaptor, n1, 2);
-  checkGraphIncEdgeArcLists(adaptor, n2, 2);
-  checkGraphIncEdgeArcLists(adaptor, n3, 3);
-  checkGraphIncEdgeArcLists(adaptor, n4, 1);
-
-  checkNodeIds(adaptor);
-  checkArcIds(adaptor);
-  checkEdgeIds(adaptor);
-
-  checkGraphNodeMap(adaptor);
-  checkGraphArcMap(adaptor);
-  checkGraphEdgeMap(adaptor);
-
-  // Hide an edge
-  adaptor.status(e2, false);
-  adaptor.disable(e3);
-  if (!adaptor.status(e3)) adaptor.enable(e3);
-
-  checkGraphNodeList(adaptor, 4);
-  checkGraphArcList(adaptor, 6);
-  checkGraphEdgeList(adaptor, 3);
-  checkGraphConArcList(adaptor, 6);
-  checkGraphConEdgeList(adaptor, 3);
-
-  checkGraphIncEdgeArcLists(adaptor, n1, 1);
-  checkGraphIncEdgeArcLists(adaptor, n2, 2);
-  checkGraphIncEdgeArcLists(adaptor, n3, 2);
-  checkGraphIncEdgeArcLists(adaptor, n4, 1);
-
-  checkNodeIds(adaptor);
-  checkArcIds(adaptor);
-  checkEdgeIds(adaptor);
-
-  checkGraphNodeMap(adaptor);
-  checkGraphArcMap(adaptor);
-  checkGraphEdgeMap(adaptor);
-
-  // Hide a node
-  adaptor.status(n1, false);
-  adaptor.disable(n3);
-  if (!adaptor.status(n3)) adaptor.enable(n3);
-
-  checkGraphNodeList(adaptor, 3);
-  checkGraphArcList(adaptor, 4);
-  checkGraphEdgeList(adaptor, 2);
-  checkGraphConArcList(adaptor, 4);
-  checkGraphConEdgeList(adaptor, 2);
-
-  checkGraphIncEdgeArcLists(adaptor, n2, 1);
-  checkGraphIncEdgeArcLists(adaptor, n3, 2);
-  checkGraphIncEdgeArcLists(adaptor, n4, 1);
-
-  checkNodeIds(adaptor);
-  checkArcIds(adaptor);
-  checkEdgeIds(adaptor);
-
-  checkGraphNodeMap(adaptor);
-  checkGraphArcMap(adaptor);
-  checkGraphEdgeMap(adaptor);
-
-  // Hide all nodes and edges
-  node_filter[n1] = node_filter[n2] = node_filter[n3] = node_filter[n4] = false;
-  edge_filter[e1] = edge_filter[e2] = edge_filter[e3] = edge_filter[e4] = false;
-
-  checkGraphNodeList(adaptor, 0);
-  checkGraphArcList(adaptor, 0);
-  checkGraphEdgeList(adaptor, 0);
-  checkGraphConArcList(adaptor, 0);
-  checkGraphConEdgeList(adaptor, 0);
-
-  checkNodeIds(adaptor);
-  checkArcIds(adaptor);
-  checkEdgeIds(adaptor);
-
-  checkGraphNodeMap(adaptor);
-  checkGraphArcMap(adaptor);
-  checkGraphEdgeMap(adaptor);
-
-  // Check the conversion of nodes and edges
-  Graph::Node ng = n3;
-  ng = n4;
-  Adaptor::Node na = n1;
-  na = n2;
-  Graph::Edge eg = e3;
-  eg = e4;
-  Adaptor::Edge ea = e1;
-  ea = e2;
-}
-
-void checkFilterNodes2() {
-  // Check concepts
-  checkConcept<concepts::Graph, FilterNodes<concepts::Graph> >();
-  checkConcept<concepts::Graph, FilterNodes<ListGraph> >();
-  checkConcept<concepts::AlterableGraphComponent<>,
-               FilterNodes<ListGraph> >();
-  checkConcept<concepts::ExtendableGraphComponent<>,
-               FilterNodes<ListGraph> >();
-  checkConcept<concepts::ErasableGraphComponent<>,
-               FilterNodes<ListGraph> >();
-  checkConcept<concepts::ClearableGraphComponent<>,
-               FilterNodes<ListGraph> >();
-
-  // Create a graph and an adaptor
-  typedef ListGraph Graph;
-  typedef Graph::NodeMap<bool> NodeFilter;
-  typedef FilterNodes<Graph, NodeFilter> Adaptor;
-
-  // Add nodes and edges to the original graph and the adaptor
-  Graph graph;
-  NodeFilter node_filter(graph);
-  Adaptor adaptor(graph, node_filter);
-
-  Graph::Node n1 = graph.addNode();
-  Graph::Node n2 = graph.addNode();
-  Adaptor::Node n3 = adaptor.addNode();
-  Adaptor::Node n4 = adaptor.addNode();
-
-  node_filter[n1] = node_filter[n2] = node_filter[n3] = node_filter[n4] = true;
-
-  Graph::Edge e1 = graph.addEdge(n1, n2);
-  Graph::Edge e2 = graph.addEdge(n1, n3);
-  Adaptor::Edge e3 = adaptor.addEdge(n2, n3);
-  Adaptor::Edge e4 = adaptor.addEdge(n3, n4);
-
-  checkGraphNodeList(adaptor, 4);
-  checkGraphArcList(adaptor, 8);
-  checkGraphEdgeList(adaptor, 4);
-  checkGraphConArcList(adaptor, 8);
-  checkGraphConEdgeList(adaptor, 4);
-
-  checkGraphIncEdgeArcLists(adaptor, n1, 2);
-  checkGraphIncEdgeArcLists(adaptor, n2, 2);
-  checkGraphIncEdgeArcLists(adaptor, n3, 3);
-  checkGraphIncEdgeArcLists(adaptor, n4, 1);
-
-  checkNodeIds(adaptor);
-  checkArcIds(adaptor);
-  checkEdgeIds(adaptor);
-
-  checkGraphNodeMap(adaptor);
-  checkGraphArcMap(adaptor);
-  checkGraphEdgeMap(adaptor);
-
-  // Hide a node
-  adaptor.status(n1, false);
-  adaptor.disable(n3);
-  if (!adaptor.status(n3)) adaptor.enable(n3);
-
-  checkGraphNodeList(adaptor, 3);
-  checkGraphArcList(adaptor, 4);
-  checkGraphEdgeList(adaptor, 2);
-  checkGraphConArcList(adaptor, 4);
-  checkGraphConEdgeList(adaptor, 2);
-
-  checkGraphIncEdgeArcLists(adaptor, n2, 1);
-  checkGraphIncEdgeArcLists(adaptor, n3, 2);
-  checkGraphIncEdgeArcLists(adaptor, n4, 1);
-
-  checkNodeIds(adaptor);
-  checkArcIds(adaptor);
-  checkEdgeIds(adaptor);
-
-  checkGraphNodeMap(adaptor);
-  checkGraphArcMap(adaptor);
-  checkGraphEdgeMap(adaptor);
-
-  // Hide all nodes
-  node_filter[n1] = node_filter[n2] = node_filter[n3] = node_filter[n4] = false;
-
-  checkGraphNodeList(adaptor, 0);
-  checkGraphArcList(adaptor, 0);
-  checkGraphEdgeList(adaptor, 0);
-  checkGraphConArcList(adaptor, 0);
-  checkGraphConEdgeList(adaptor, 0);
-
-  checkNodeIds(adaptor);
-  checkArcIds(adaptor);
-  checkEdgeIds(adaptor);
-
-  checkGraphNodeMap(adaptor);
-  checkGraphArcMap(adaptor);
-  checkGraphEdgeMap(adaptor);
-
-  // Check the conversion of nodes and edges
-  Graph::Node ng = n3;
-  ng = n4;
-  Adaptor::Node na = n1;
-  na = n2;
-  Graph::Edge eg = e3;
-  eg = e4;
-  Adaptor::Edge ea = e1;
-  ea = e2;
-}
-
-void checkFilterEdges() {
-  // Check concepts
-  checkConcept<concepts::Graph, FilterEdges<concepts::Graph> >();
-  checkConcept<concepts::Graph, FilterEdges<ListGraph> >();
-  checkConcept<concepts::AlterableGraphComponent<>,
-               FilterEdges<ListGraph> >();
-  checkConcept<concepts::ExtendableGraphComponent<>,
-               FilterEdges<ListGraph> >();
-  checkConcept<concepts::ErasableGraphComponent<>,
-               FilterEdges<ListGraph> >();
-  checkConcept<concepts::ClearableGraphComponent<>,
-               FilterEdges<ListGraph> >();
-
-  // Create a graph and an adaptor
-  typedef ListGraph Graph;
-  typedef Graph::EdgeMap<bool> EdgeFilter;
-  typedef FilterEdges<Graph, EdgeFilter> Adaptor;
-
-  Graph graph;
-  EdgeFilter edge_filter(graph);
-  Adaptor adaptor(graph, edge_filter);
-
-  // Add nodes and edges to the original graph and the adaptor
-  Graph::Node n1 = graph.addNode();
-  Graph::Node n2 = graph.addNode();
-  Adaptor::Node n3 = adaptor.addNode();
-  Adaptor::Node n4 = adaptor.addNode();
-
-  Graph::Edge e1 = graph.addEdge(n1, n2);
-  Graph::Edge e2 = graph.addEdge(n1, n3);
-  Adaptor::Edge e3 = adaptor.addEdge(n2, n3);
-  Adaptor::Edge e4 = adaptor.addEdge(n3, n4);
-
-  edge_filter[e1] = edge_filter[e2] = edge_filter[e3] = edge_filter[e4] = true;
-
-  checkGraphNodeList(adaptor, 4);
-  checkGraphArcList(adaptor, 8);
-  checkGraphEdgeList(adaptor, 4);
-  checkGraphConArcList(adaptor, 8);
-  checkGraphConEdgeList(adaptor, 4);
-
-  checkGraphIncEdgeArcLists(adaptor, n1, 2);
-  checkGraphIncEdgeArcLists(adaptor, n2, 2);
-  checkGraphIncEdgeArcLists(adaptor, n3, 3);
-  checkGraphIncEdgeArcLists(adaptor, n4, 1);
-
-  checkNodeIds(adaptor);
-  checkArcIds(adaptor);
-  checkEdgeIds(adaptor);
-
-  checkGraphNodeMap(adaptor);
-  checkGraphArcMap(adaptor);
-  checkGraphEdgeMap(adaptor);
-
-  // Hide an edge
-  adaptor.status(e2, false);
-  adaptor.disable(e3);
-  if (!adaptor.status(e3)) adaptor.enable(e3);
-
-  checkGraphNodeList(adaptor, 4);
-  checkGraphArcList(adaptor, 6);
-  checkGraphEdgeList(adaptor, 3);
-  checkGraphConArcList(adaptor, 6);
-  checkGraphConEdgeList(adaptor, 3);
-
-  checkGraphIncEdgeArcLists(adaptor, n1, 1);
-  checkGraphIncEdgeArcLists(adaptor, n2, 2);
-  checkGraphIncEdgeArcLists(adaptor, n3, 2);
-  checkGraphIncEdgeArcLists(adaptor, n4, 1);
-
-  checkNodeIds(adaptor);
-  checkArcIds(adaptor);
-  checkEdgeIds(adaptor);
-
-  checkGraphNodeMap(adaptor);
-  checkGraphArcMap(adaptor);
-  checkGraphEdgeMap(adaptor);
-
-  // Hide all edges
-  edge_filter[e1] = edge_filter[e2] = edge_filter[e3] = edge_filter[e4] = false;
-
-  checkGraphNodeList(adaptor, 4);
-  checkGraphArcList(adaptor, 0);
-  checkGraphEdgeList(adaptor, 0);
-  checkGraphConArcList(adaptor, 0);
-  checkGraphConEdgeList(adaptor, 0);
-
-  checkNodeIds(adaptor);
-  checkArcIds(adaptor);
-  checkEdgeIds(adaptor);
-
-  checkGraphNodeMap(adaptor);
-  checkGraphArcMap(adaptor);
-  checkGraphEdgeMap(adaptor);
-
-  // Check the conversion of nodes and edges
-  Graph::Node ng = n3;
-  ng = n4;
-  Adaptor::Node na = n1;
-  na = n2;
-  Graph::Edge eg = e3;
-  eg = e4;
-  Adaptor::Edge ea = e1;
-  ea = e2;
-}
-
-void checkOrienter() {
-  // Check concepts
-  checkConcept<concepts::Digraph, Orienter<concepts::Graph> >();
-  checkConcept<concepts::Digraph, Orienter<ListGraph> >();
-  checkConcept<concepts::AlterableDigraphComponent<>,
-               Orienter<ListGraph> >();
-  checkConcept<concepts::ExtendableDigraphComponent<>,
-               Orienter<ListGraph> >();
-  checkConcept<concepts::ErasableDigraphComponent<>,
-               Orienter<ListGraph> >();
-  checkConcept<concepts::ClearableDigraphComponent<>,
-               Orienter<ListGraph> >();
-
-  // Create a graph and an adaptor
-  typedef ListGraph Graph;
-  typedef ListGraph::EdgeMap<bool> DirMap;
-  typedef Orienter<Graph> Adaptor;
-
-  Graph graph;
-  DirMap dir(graph);
-  Adaptor adaptor(graph, dir);
-
-  // Add nodes and edges to the original graph and the adaptor
-  Graph::Node n1 = graph.addNode();
-  Graph::Node n2 = graph.addNode();
-  Adaptor::Node n3 = adaptor.addNode();
-
-  Graph::Edge e1 = graph.addEdge(n1, n2);
-  Graph::Edge e2 = graph.addEdge(n1, n3);
-  Adaptor::Arc e3 = adaptor.addArc(n2, n3);
-
-  dir[e1] = dir[e2] = dir[e3] = true;
-
-  // Check the original graph
-  checkGraphNodeList(graph, 3);
-  checkGraphArcList(graph, 6);
-  checkGraphConArcList(graph, 6);
-  checkGraphEdgeList(graph, 3);
-  checkGraphConEdgeList(graph, 3);
-
-  checkGraphIncEdgeArcLists(graph, n1, 2);
-  checkGraphIncEdgeArcLists(graph, n2, 2);
-  checkGraphIncEdgeArcLists(graph, n3, 2);
-
-  checkNodeIds(graph);
-  checkArcIds(graph);
-  checkEdgeIds(graph);
-
-  checkGraphNodeMap(graph);
-  checkGraphArcMap(graph);
-  checkGraphEdgeMap(graph);
-
-  // Check the adaptor
-  checkGraphNodeList(adaptor, 3);
-  checkGraphArcList(adaptor, 3);
-  checkGraphConArcList(adaptor, 3);
-
-  checkGraphOutArcList(adaptor, n1, 2);
-  checkGraphOutArcList(adaptor, n2, 1);
-  checkGraphOutArcList(adaptor, n3, 0);
-
-  checkGraphInArcList(adaptor, n1, 0);
-  checkGraphInArcList(adaptor, n2, 1);
-  checkGraphInArcList(adaptor, n3, 2);
-
-  checkNodeIds(adaptor);
-  checkArcIds(adaptor);
-
-  checkGraphNodeMap(adaptor);
-  checkGraphArcMap(adaptor);
-
-  // Check direction changing
-  {
-    dir[e1] = true;
-    Adaptor::Node u = adaptor.source(e1);
-    Adaptor::Node v = adaptor.target(e1);
-
-    dir[e1] = false;
-    check (u == adaptor.target(e1), "Wrong dir");
-    check (v == adaptor.source(e1), "Wrong dir");
-
-    check ((u == n1 && v == n2) || (u == n2 && v == n1), "Wrong dir");
-    dir[e1] = n1 == u;
-  }
-
-  {
-    dir[e2] = true;
-    Adaptor::Node u = adaptor.source(e2);
-    Adaptor::Node v = adaptor.target(e2);
-
-    dir[e2] = false;
-    check (u == adaptor.target(e2), "Wrong dir");
-    check (v == adaptor.source(e2), "Wrong dir");
-
-    check ((u == n1 && v == n3) || (u == n3 && v == n1), "Wrong dir");
-    dir[e2] = n3 == u;
-  }
-
-  {
-    dir[e3] = true;
-    Adaptor::Node u = adaptor.source(e3);
-    Adaptor::Node v = adaptor.target(e3);
-
-    dir[e3] = false;
-    check (u == adaptor.target(e3), "Wrong dir");
-    check (v == adaptor.source(e3), "Wrong dir");
-
-    check ((u == n2 && v == n3) || (u == n3 && v == n2), "Wrong dir");
-    dir[e3] = n2 == u;
-  }
-
-  // Check the adaptor again
-  checkGraphNodeList(adaptor, 3);
-  checkGraphArcList(adaptor, 3);
-  checkGraphConArcList(adaptor, 3);
-
-  checkGraphOutArcList(adaptor, n1, 1);
-  checkGraphOutArcList(adaptor, n2, 1);
-  checkGraphOutArcList(adaptor, n3, 1);
-
-  checkGraphInArcList(adaptor, n1, 1);
-  checkGraphInArcList(adaptor, n2, 1);
-  checkGraphInArcList(adaptor, n3, 1);
-
-  checkNodeIds(adaptor);
-  checkArcIds(adaptor);
-
-  checkGraphNodeMap(adaptor);
-  checkGraphArcMap(adaptor);
-
-  // Check reverseArc()
-  adaptor.reverseArc(e2);
-  adaptor.reverseArc(e3);
-  adaptor.reverseArc(e2);
-
-  checkGraphNodeList(adaptor, 3);
-  checkGraphArcList(adaptor, 3);
-  checkGraphConArcList(adaptor, 3);
-
-  checkGraphOutArcList(adaptor, n1, 1);
-  checkGraphOutArcList(adaptor, n2, 0);
-  checkGraphOutArcList(adaptor, n3, 2);
-
-  checkGraphInArcList(adaptor, n1, 1);
-  checkGraphInArcList(adaptor, n2, 2);
-  checkGraphInArcList(adaptor, n3, 0);
-
-  // Check the conversion of nodes and arcs/edges
-  Graph::Node ng = n3;
-  ng = n3;
-  Adaptor::Node na = n1;
-  na = n2;
-  Graph::Edge eg = e3;
-  eg = e3;
-  Adaptor::Arc aa = e1;
-  aa = e2;
-}
-
-void checkCombiningAdaptors() {
-  // Create a grid graph
-  GridGraph graph(2,2);
-  GridGraph::Node n1 = graph(0,0);
-  GridGraph::Node n2 = graph(0,1);
-  GridGraph::Node n3 = graph(1,0);
-  GridGraph::Node n4 = graph(1,1);
-
-  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;
-
-  // Apply several adaptors on the grid graph
-  typedef SplitNodes<Orienter< const GridGraph, GridGraph::EdgeMap<bool> > >
-    SplitGridGraph;
-  typedef Undirector<const SplitGridGraph> USplitGridGraph;
-  checkConcept<concepts::Digraph, SplitGridGraph>();
-  checkConcept<concepts::Graph, USplitGridGraph>();
-
-  SplitGridGraph adaptor = splitNodes(orienter(graph, dir_map));
-  USplitGridGraph uadaptor = undirector(adaptor);
-
-  // Check adaptor
-  checkGraphNodeList(adaptor, 8);
-  checkGraphArcList(adaptor, 8);
-  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);
-
-  checkNodeIds(adaptor);
-  checkArcIds(adaptor);
-
-  checkGraphNodeMap(adaptor);
-  checkGraphArcMap(adaptor);
-
-  // Check uadaptor
-  checkGraphNodeList(uadaptor, 8);
-  checkGraphEdgeList(uadaptor, 8);
-  checkGraphArcList(uadaptor, 16);
-  checkGraphConEdgeList(uadaptor, 8);
-  checkGraphConArcList(uadaptor, 16);
-
-  checkNodeIds(uadaptor);
-  checkEdgeIds(uadaptor);
-  checkArcIds(uadaptor);
-
-  checkGraphNodeMap(uadaptor);
-  checkGraphEdgeMap(uadaptor);
-  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);
-}
-
-int main(int, const char **) {
-  // Check the digraph adaptors (using ListDigraph)
-  checkReverseDigraph();
-  checkSubDigraph();
-  checkFilterNodes1();
-  checkFilterArcs();
-  checkUndirector();
-  checkResidualDigraph();
-  checkSplitNodes();
-
-  // Check the graph adaptors (using ListGraph)
-  checkSubGraph();
-  checkFilterNodes2();
-  checkFilterEdges();
-  checkOrienter();
-
-  // Combine adaptors (using GridGraph)
-  checkCombiningAdaptors();
-
-  return 0;
-}
Index: st/bellman_ford_test.cc
===================================================================
--- test/bellman_ford_test.cc	(revision 960)
+++ 	(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 956)
+++ test/bfs_test.cc	(revision 293)
@@ -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).
@@ -59,16 +59,14 @@
 
   Digraph G;
-  Node s, t, n;
+  Node s, t;
   Arc e;
-  int l, i;
+  int l;
   bool b;
   BType::DistMap d(G);
   BType::PredMap p(G);
   Path<Digraph> pp;
-  concepts::ReadMap<Node,bool> nm;
 
   {
     BType bfs_test(G);
-    const BType& const_bfs_test = bfs_test;
 
     bfs_test.run(s);
@@ -76,24 +74,11 @@
     bfs_test.run();
 
-    bfs_test.init();
-    bfs_test.addSource(s);
-    n = bfs_test.processNextNode();
-    n = bfs_test.processNextNode(t, b);
-    n = bfs_test.processNextNode(nm, n);
-    n = const_bfs_test.nextNode();
-    b = const_bfs_test.emptyQueue();
-    i = const_bfs_test.queueSize();
-
-    bfs_test.start();
-    bfs_test.start(t);
-    bfs_test.start(nm);
-
-    l  = const_bfs_test.dist(t);
-    e  = const_bfs_test.predArc(t);
-    s  = const_bfs_test.predNode(t);
-    b  = const_bfs_test.reached(t);
-    d  = const_bfs_test.distMap();
-    p  = const_bfs_test.predMap();
-    pp = const_bfs_test.path(t);
+    l  = bfs_test.dist(t);
+    e  = bfs_test.predArc(t);
+    s  = bfs_test.predNode(t);
+    b  = bfs_test.reached(t);
+    d  = bfs_test.distMap();
+    p  = bfs_test.predMap();
+    pp = bfs_test.path(t);
   }
   {
@@ -102,35 +87,11 @@
       ::SetDistMap<concepts::ReadWriteMap<Node,int> >
       ::SetReachedMap<concepts::ReadWriteMap<Node,bool> >
+      ::SetProcessedMap<concepts::WriteMap<Node,bool> >
       ::SetStandardProcessedMap
-      ::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)
-      .distMap(dist_map)
-      .reachedMap(reached_map)
-      .processedMap(processed_map);
 
     bfs_test.run(s);
     bfs_test.run(s,t);
     bfs_test.run();
-
-    bfs_test.init();
-    bfs_test.addSource(s);
-    n = bfs_test.processNextNode();
-    n = bfs_test.processNextNode(t, b);
-    n = bfs_test.processNextNode(nm, n);
-    n = bfs_test.nextNode();
-    b = bfs_test.emptyQueue();
-    i = bfs_test.queueSize();
-
-    bfs_test.start();
-    bfs_test.start(t);
-    bfs_test.start(nm);
 
     l  = bfs_test.dist(t);
Index: st/circulation_test.cc
===================================================================
--- test/circulation_test.cc	(revision 956)
+++ 	(revision )
@@ -1,168 +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/list_graph.h>
-#include <lemon/circulation.h>
-#include <lemon/lgf_reader.h>
-#include <lemon/concepts/digraph.h>
-#include <lemon/concepts/maps.h>
-
-using namespace lemon;
-
-char test_lgf[] =
-  "@nodes\n"
-  "label\n"
-  "0\n"
-  "1\n"
-  "2\n"
-  "3\n"
-  "4\n"
-  "5\n"
-  "@arcs\n"
-  "     lcap  ucap\n"
-  "0 1  2  10\n"
-  "0 2  2  6\n"
-  "1 3  4  7\n"
-  "1 4  0  5\n"
-  "2 4  1  3\n"
-  "3 5  3  8\n"
-  "4 5  3  7\n"
-  "@attributes\n"
-  "source 0\n"
-  "sink   5\n";
-
-void checkCirculationCompile()
-{
-  typedef int VType;
-  typedef concepts::Digraph Digraph;
-
-  typedef Digraph::Node Node;
-  typedef Digraph::Arc Arc;
-  typedef concepts::ReadMap<Arc,VType> CapMap;
-  typedef concepts::ReadMap<Node,VType> SupplyMap;
-  typedef concepts::ReadWriteMap<Arc,VType> FlowMap;
-  typedef concepts::WriteMap<Node,bool> BarrierMap;
-
-  typedef Elevator<Digraph, Digraph::Node> Elev;
-  typedef LinkedElevator<Digraph, Digraph::Node> LinkedElev;
-
-  Digraph g;
-  Node n;
-  Arc a;
-  CapMap lcap, ucap;
-  SupplyMap supply;
-  FlowMap flow;
-  BarrierMap bar;
-  VType v;
-  bool b;
-
-  typedef Circulation<Digraph, CapMap, CapMap, SupplyMap>
-            ::SetFlowMap<FlowMap>
-            ::SetElevator<Elev>
-            ::SetStandardElevator<LinkedElev>
-            ::Create CirculationType;
-  CirculationType circ_test(g, lcap, ucap, supply);
-  const CirculationType& const_circ_test = circ_test;
-
-  circ_test
-    .lowerMap(lcap)
-    .upperMap(ucap)
-    .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();
-  circ_test.greedyInit();
-  circ_test.start();
-  circ_test.run();
-
-  v = const_circ_test.flow(a);
-  const FlowMap& fm = const_circ_test.flowMap();
-  b = const_circ_test.barrier(n);
-  const_circ_test.barrierMap(bar);
-
-  ignore_unused_variable_warning(fm);
-}
-
-template <class G, class LM, class UM, class DM>
-void checkCirculation(const G& g, const LM& lm, const UM& um,
-                      const DM& dm, bool find)
-{
-  Circulation<G, LM, UM, DM> circ(g, lm, um, dm);
-  bool ret = circ.run();
-  if (find) {
-    check(ret, "A feasible solution should have been found.");
-    check(circ.checkFlow(), "The found flow is corrupt.");
-    check(!circ.checkBarrier(), "A barrier should not have been found.");
-  } else {
-    check(!ret, "A feasible solution should not have been found.");
-    check(circ.checkBarrier(), "The found barrier is corrupt.");
-  }
-}
-
-int main (int, char*[])
-{
-  typedef ListDigraph Digraph;
-  DIGRAPH_TYPEDEFS(Digraph);
-
-  Digraph g;
-  IntArcMap lo(g), up(g);
-  IntNodeMap delta(g, 0);
-  Node s, t;
-
-  std::istringstream input(test_lgf);
-  DigraphReader<Digraph>(g,input).
-    arcMap("lcap", lo).
-    arcMap("ucap", up).
-    node("source",s).
-    node("sink",t).
-    run();
-
-  delta[s] = 7; delta[t] = -7;
-  checkCirculation(g, lo, up, delta, true);
-
-  delta[s] = 13; delta[t] = -13;
-  checkCirculation(g, lo, up, delta, true);
-
-  delta[s] = 6; delta[t] = -6;
-  checkCirculation(g, lo, up, delta, false);
-
-  delta[s] = 14; delta[t] = -14;
-  checkCirculation(g, lo, up, delta, false);
-
-  delta[s] = 7; delta[t] = -13;
-  checkCirculation(g, lo, up, delta, true);
-
-  delta[s] = 5; delta[t] = -15;
-  checkCirculation(g, lo, up, delta, true);
-
-  delta[s] = 10; delta[t] = -11;
-  checkCirculation(g, lo, up, delta, true);
-
-  delta[s] = 11; delta[t] = -10;
-  checkCirculation(g, lo, up, delta, false);
-
-  return 0;
-}
Index: st/connectivity_test.cc
===================================================================
--- test/connectivity_test.cc	(revision 956)
+++ 	(revision )
@@ -1,297 +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/connectivity.h>
-#include <lemon/list_graph.h>
-#include <lemon/adaptors.h>
-
-#include "test_tools.h"
-
-using namespace lemon;
-
-
-int main()
-{
-  typedef ListDigraph Digraph;
-  typedef Undirector<Digraph> Graph;
-
-  {
-    Digraph d;
-    Digraph::NodeMap<int> order(d);
-    Graph g(d);
-
-    check(stronglyConnected(d), "The empty digraph is strongly connected");
-    check(countStronglyConnectedComponents(d) == 0,
-          "The empty digraph has 0 strongly connected component");
-    check(connected(g), "The empty graph is connected");
-    check(countConnectedComponents(g) == 0,
-          "The empty graph has 0 connected component");
-
-    check(biNodeConnected(g), "The empty graph is bi-node-connected");
-    check(countBiNodeConnectedComponents(g) == 0,
-          "The empty graph has 0 bi-node-connected component");
-    check(biEdgeConnected(g), "The empty graph is bi-edge-connected");
-    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.");
-    check(loopFree(d), "The empty digraph is loop-free.");
-    check(parallelFree(d), "The empty digraph is parallel-free.");
-    check(simpleGraph(d), "The empty digraph is simple.");
-
-    check(acyclic(g), "The empty graph is acyclic.");
-    check(tree(g), "The empty graph is tree.");
-    check(bipartite(g), "The empty graph is bipartite.");
-    check(loopFree(g), "The empty graph is loop-free.");
-    check(parallelFree(g), "The empty graph is parallel-free.");
-    check(simpleGraph(g), "The empty graph is simple.");
-  }
-
-  {
-    Digraph d;
-    Digraph::NodeMap<int> order(d);
-    Graph g(d);
-    Digraph::Node n = d.addNode();
-
-    check(stronglyConnected(d), "This digraph is strongly connected");
-    check(countStronglyConnectedComponents(d) == 1,
-          "This digraph has 1 strongly connected component");
-    check(connected(g), "This graph is connected");
-    check(countConnectedComponents(g) == 1,
-          "This graph has 1 connected component");
-
-    check(biNodeConnected(g), "This graph is bi-node-connected");
-    check(countBiNodeConnectedComponents(g) == 0,
-          "This graph has 0 bi-node-connected component");
-    check(biEdgeConnected(g), "This graph is bi-edge-connected");
-    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.");
-    check(loopFree(d), "This digraph is loop-free.");
-    check(parallelFree(d), "This digraph is parallel-free.");
-    check(simpleGraph(d), "This digraph is simple.");
-
-    check(acyclic(g), "This graph is acyclic.");
-    check(tree(g), "This graph is tree.");
-    check(bipartite(g), "This graph is bipartite.");
-    check(loopFree(g), "This graph is loop-free.");
-    check(parallelFree(g), "This graph is parallel-free.");
-    check(simpleGraph(g), "This graph is simple.");
-  }
-
-  {
-    Digraph d;
-    Digraph::NodeMap<int> order(d);
-    Graph g(d);
-
-    Digraph::Node n1 = d.addNode();
-    Digraph::Node n2 = d.addNode();
-    Digraph::Node n3 = d.addNode();
-    Digraph::Node n4 = d.addNode();
-    Digraph::Node n5 = d.addNode();
-    Digraph::Node n6 = d.addNode();
-
-    d.addArc(n1, n3);
-    d.addArc(n3, n2);
-    d.addArc(n2, n1);
-    d.addArc(n4, n2);
-    d.addArc(n4, n3);
-    d.addArc(n5, n6);
-    d.addArc(n6, n5);
-
-    check(!stronglyConnected(d), "This digraph is not strongly connected");
-    check(countStronglyConnectedComponents(d) == 3,
-          "This digraph has 3 strongly connected components");
-    check(!connected(g), "This graph is not connected");
-    check(countConnectedComponents(g) == 2,
-          "This graph has 2 connected components");
-
-    check(!dag(d), "This digraph is not DAG.");
-    check(!checkedTopologicalSort(d, order), "This digraph is not DAG.");
-    check(loopFree(d), "This digraph is loop-free.");
-    check(parallelFree(d), "This digraph is parallel-free.");
-    check(simpleGraph(d), "This digraph is simple.");
-
-    check(!acyclic(g), "This graph is not acyclic.");
-    check(!tree(g), "This graph is not tree.");
-    check(!bipartite(g), "This graph is not bipartite.");
-    check(loopFree(g), "This graph is loop-free.");
-    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();
-    Digraph::Node n3 = d.addNode();
-    Digraph::Node n4 = d.addNode();
-    Digraph::Node n5 = d.addNode();
-    Digraph::Node n6 = d.addNode();
-    Digraph::Node n7 = d.addNode();
-    Digraph::Node n8 = d.addNode();
-
-    d.addArc(n1, n2);
-    d.addArc(n5, n1);
-    d.addArc(n2, n8);
-    d.addArc(n8, n5);
-    d.addArc(n6, n4);
-    d.addArc(n4, n6);
-    d.addArc(n2, n5);
-    d.addArc(n1, n8);
-    d.addArc(n6, n7);
-    d.addArc(n7, n6);
-
-    check(!stronglyConnected(d), "This digraph is not strongly connected");
-    check(countStronglyConnectedComponents(d) == 3,
-          "This digraph has 3 strongly connected components");
-    Digraph::NodeMap<int> scomp1(d);
-    check(stronglyConnectedComponents(d, scomp1) == 3,
-          "This digraph has 3 strongly connected components");
-    check(scomp1[n1] != scomp1[n3] && scomp1[n1] != scomp1[n4] &&
-          scomp1[n3] != scomp1[n4], "Wrong stronglyConnectedComponents()");
-    check(scomp1[n1] == scomp1[n2] && scomp1[n1] == scomp1[n5] &&
-          scomp1[n1] == scomp1[n8], "Wrong stronglyConnectedComponents()");
-    check(scomp1[n4] == scomp1[n6] && scomp1[n4] == scomp1[n7],
-          "Wrong stronglyConnectedComponents()");
-    Digraph::ArcMap<bool> scut1(d, false);
-    check(stronglyConnectedCutArcs(d, scut1) == 0,
-          "This digraph has 0 strongly connected cut arc.");
-    for (Digraph::ArcIt a(d); a != INVALID; ++a) {
-      check(!scut1[a], "Wrong stronglyConnectedCutArcs()");
-    }
-
-    check(!connected(g), "This graph is not connected");
-    check(countConnectedComponents(g) == 3,
-          "This graph has 3 connected components");
-    Graph::NodeMap<int> comp(g);
-    check(connectedComponents(g, comp) == 3,
-          "This graph has 3 connected components");
-    check(comp[n1] != comp[n3] && comp[n1] != comp[n4] &&
-          comp[n3] != comp[n4], "Wrong connectedComponents()");
-    check(comp[n1] == comp[n2] && comp[n1] == comp[n5] &&
-          comp[n1] == comp[n8], "Wrong connectedComponents()");
-    check(comp[n4] == comp[n6] && comp[n4] == comp[n7],
-          "Wrong connectedComponents()");
-
-    cutarcs[d.addArc(n3, n1)] = true;
-    cutarcs[d.addArc(n3, n5)] = true;
-    cutarcs[d.addArc(n3, n8)] = true;
-    cutarcs[d.addArc(n8, n6)] = true;
-    cutarcs[d.addArc(n8, n7)] = true;
-
-    check(!stronglyConnected(d), "This digraph is not strongly connected");
-    check(countStronglyConnectedComponents(d) == 3,
-          "This digraph has 3 strongly connected components");
-    Digraph::NodeMap<int> scomp2(d);
-    check(stronglyConnectedComponents(d, scomp2) == 3,
-          "This digraph has 3 strongly connected components");
-    check(scomp2[n3] == 0, "Wrong stronglyConnectedComponents()");
-    check(scomp2[n1] == 1 && scomp2[n2] == 1 && scomp2[n5] == 1 &&
-          scomp2[n8] == 1, "Wrong stronglyConnectedComponents()");
-    check(scomp2[n4] == 2 && scomp2[n6] == 2 && scomp2[n7] == 2,
-          "Wrong stronglyConnectedComponents()");
-    Digraph::ArcMap<bool> scut2(d, false);
-    check(stronglyConnectedCutArcs(d, scut2) == 5,
-          "This digraph has 5 strongly connected cut arcs.");
-    for (Digraph::ArcIt a(d); a != INVALID; ++a) {
-      check(scut2[a] == cutarcs[a], "Wrong stronglyConnectedCutArcs()");
-    }
-  }
-
-  {
-    // DAG example for topological sort from the book New Algorithms
-    // (T. H. Cormen, C. E. Leiserson, R. L. Rivest, C. Stein)
-    Digraph d;
-    Digraph::NodeMap<int> order(d);
-
-    Digraph::Node belt = d.addNode();
-    Digraph::Node trousers = d.addNode();
-    Digraph::Node necktie = d.addNode();
-    Digraph::Node coat = d.addNode();
-    Digraph::Node socks = d.addNode();
-    Digraph::Node shirt = d.addNode();
-    Digraph::Node shoe = d.addNode();
-    Digraph::Node watch = d.addNode();
-    Digraph::Node pants = d.addNode();
-
-    d.addArc(socks, shoe);
-    d.addArc(pants, shoe);
-    d.addArc(pants, trousers);
-    d.addArc(trousers, shoe);
-    d.addArc(trousers, belt);
-    d.addArc(belt, coat);
-    d.addArc(shirt, belt);
-    d.addArc(shirt, necktie);
-    d.addArc(necktie, coat);
-
-    check(dag(d), "This digraph is DAG.");
-    topologicalSort(d, order);
-    for (Digraph::ArcIt a(d); a != INVALID; ++a) {
-      check(order[d.source(a)] < order[d.target(a)],
-            "Wrong topologicalSort()");
-    }
-  }
-
-  {
-    ListGraph g;
-    ListGraph::NodeMap<bool> map(g);
-
-    ListGraph::Node n1 = g.addNode();
-    ListGraph::Node n2 = g.addNode();
-    ListGraph::Node n3 = g.addNode();
-    ListGraph::Node n4 = g.addNode();
-    ListGraph::Node n5 = g.addNode();
-    ListGraph::Node n6 = g.addNode();
-    ListGraph::Node n7 = g.addNode();
-
-    g.addEdge(n1, n3);
-    g.addEdge(n1, n4);
-    g.addEdge(n2, n5);
-    g.addEdge(n3, n6);
-    g.addEdge(n4, n6);
-    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()");
-    check(map[n3] == map[n4] && map[n3] == map[n5],
-          "Wrong bipartitePartitions()");
-  }
-
-  return 0;
-}
Index: test/counter_test.cc
===================================================================
--- test/counter_test.cc	(revision 605)
+++ test/counter_test.cc	(revision 209)
@@ -3,5 +3,5 @@
  * This file is a part of LEMON, a generic C++ optimization library.
  *
- * Copyright (C) 2003-2009
+ * Copyright (C) 2003-2008
  * Egervary Jeno Kombinatorikus Optimalizalasi Kutatocsoport
  * (Egervary Research Group on Combinatorial Optimization, EGRES).
@@ -19,7 +19,4 @@
 #include <lemon/counter.h>
 #include <vector>
-#include <sstream>
-
-#include "test/test_tools.h"
 
 using namespace lemon;
@@ -27,76 +24,52 @@
 template <typename T>
 void bubbleSort(std::vector<T>& v) {
-  std::stringstream s1, s2, s3;
-  {
-    Counter op("Bubble Sort - Operations: ", s1);
-    Counter::SubCounter as(op, "Assignments: ", s2);
-    Counter::SubCounter co(op, "Comparisons: ", s3);
-    for (int i = v.size()-1; i > 0; --i) {
-      for (int j = 0; j < i; ++j) {
-        if (v[j] > v[j+1]) {
-          T tmp = v[j];
-          v[j] = v[j+1];
-          v[j+1] = tmp;
-          as += 3;
-        }
-        ++co;
+  Counter op("Bubble Sort - Operations: ");
+  Counter::NoSubCounter as(op, "Assignments: ");
+  Counter::NoSubCounter co(op, "Comparisons: ");
+  for (int i = v.size()-1; i > 0; --i) {
+    for (int j = 0; j < i; ++j) {
+      if (v[j] > v[j+1]) {
+        T tmp = v[j];
+        v[j] = v[j+1];
+        v[j+1] = tmp;
+        as += 3;
       }
+      ++co;
     }
   }
-  check(s1.str() == "Bubble Sort - Operations: 102\n", "Wrong counter");
-  check(s2.str() == "Assignments: 57\n", "Wrong subcounter");
-  check(s3.str() == "Comparisons: 45\n", "Wrong subcounter");
 }
 
 template <typename T>
 void insertionSort(std::vector<T>& v) {
-  std::stringstream s1, s2, s3;
-  {
-    Counter op("Insertion Sort - Operations: ", s1);
-    Counter::SubCounter as(op, "Assignments: ", s2);
-    Counter::SubCounter co(op, "Comparisons: ", s3);
-    for (int i = 1; i < int(v.size()); ++i) {
-      T value = v[i];
-      ++as;
-      int j = i;
-      while (j > 0 && v[j-1] > value) {
-        v[j] = v[j-1];
-        --j;
-        ++co; ++as;
-      }
-      v[j] = value;
-      ++as;
+  Counter op("Insertion Sort - Operations: ");
+  Counter::NoSubCounter as(op, "Assignments: ");
+  Counter::NoSubCounter co(op, "Comparisons: ");
+  for (int i = 1; i < int(v.size()); ++i) {
+    T value = v[i];
+    ++as;
+    int j = i;
+    while (j > 0 && v[j-1] > value) {
+      v[j] = v[j-1];
+      --j;
+      ++co; ++as;
     }
+    v[j] = value;
+    ++as;
   }
-  check(s1.str() == "Insertion Sort - Operations: 56\n", "Wrong counter");
-  check(s2.str() == "Assignments: 37\n", "Wrong subcounter");
-  check(s3.str() == "Comparisons: 19\n", "Wrong subcounter");
 }
 
 template <typename MyCounter>
-void counterTest(bool output) {
-  std::stringstream s1, s2, s3;
-  {
-    MyCounter c("Main Counter: ", s1);
-    c++;
-    typename MyCounter::SubCounter d(c, "SubCounter: ", s2);
-    d++;
-    typename MyCounter::SubCounter::NoSubCounter e(d, "SubSubCounter: ", s3);
-    e++;
-    d+=3;
-    c-=4;
-    e-=2;
-    c.reset(2);
-    c.reset();
-  }
-  if (output) {
-    check(s1.str() == "Main Counter: 3\n", "Wrong Counter");
-    check(s2.str() == "SubCounter: 3\n", "Wrong SubCounter");
-    check(s3.str() == "", "Wrong NoSubCounter");
-  } else {
-    check(s1.str() == "", "Wrong NoCounter");
-    check(s2.str() == "", "Wrong SubCounter");
-    check(s3.str() == "", "Wrong NoSubCounter");
-  }
+void counterTest() {
+  MyCounter c("Main Counter: ");
+  c++;
+  typename MyCounter::SubCounter d(c, "SubCounter: ");
+  d++;
+  typename MyCounter::SubCounter::NoSubCounter e(d, "SubSubCounter: ");
+  e++;
+  d+=3;
+  c-=4;
+  e-=2;
+  c.reset(2);
+  c.reset();
 }
 
@@ -108,6 +81,6 @@
 int main()
 {
-  counterTest<Counter>(true);
-  counterTest<NoCounter>(false);
+  counterTest<Counter>();
+  counterTest<NoCounter>();
 
   std::vector<int> x(10);
Index: test/dfs_test.cc
===================================================================
--- test/dfs_test.cc	(revision 956)
+++ test/dfs_test.cc	(revision 1007)
@@ -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).
@@ -51,5 +51,8 @@
   "@attributes\n"
   "source 0\n"
-  "target 5\n";
+  "target 5\n"
+  "source1 6\n"
+  "target1 3\n";
+
 
 void checkDfsCompile()
@@ -63,14 +66,12 @@
   Node s, t;
   Arc e;
-  int l, i;
+  int l;
   bool b;
   DType::DistMap d(G);
   DType::PredMap p(G);
   Path<Digraph> pp;
-  concepts::ReadMap<Arc,bool> am;
 
   {
     DType dfs_test(G);
-    const DType& const_dfs_test = dfs_test;
 
     dfs_test.run(s);
@@ -78,22 +79,11 @@
     dfs_test.run();
 
-    dfs_test.init();
-    dfs_test.addSource(s);
-    e = dfs_test.processNextArc();
-    e = const_dfs_test.nextArc();
-    b = const_dfs_test.emptyQueue();
-    i = const_dfs_test.queueSize();
-
-    dfs_test.start();
-    dfs_test.start(t);
-    dfs_test.start(am);
-
-    l  = const_dfs_test.dist(t);
-    e  = const_dfs_test.predArc(t);
-    s  = const_dfs_test.predNode(t);
-    b  = const_dfs_test.reached(t);
-    d  = const_dfs_test.distMap();
-    p  = const_dfs_test.predMap();
-    pp = const_dfs_test.path(t);
+    l  = dfs_test.dist(t);
+    e  = dfs_test.predArc(t);
+    s  = dfs_test.predNode(t);
+    b  = dfs_test.reached(t);
+    d  = dfs_test.distMap();
+    p  = dfs_test.predMap();
+    pp = dfs_test.path(t);
   }
   {
@@ -102,33 +92,11 @@
       ::SetDistMap<concepts::ReadWriteMap<Node,int> >
       ::SetReachedMap<concepts::ReadWriteMap<Node,bool> >
+      ::SetProcessedMap<concepts::WriteMap<Node,bool> >
       ::SetStandardProcessedMap
-      ::SetProcessedMap<concepts::WriteMap<Node,bool> >
       ::Create dfs_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;
-
-    dfs_test
-      .predMap(pred_map)
-      .distMap(dist_map)
-      .reachedMap(reached_map)
-      .processedMap(processed_map);
 
     dfs_test.run(s);
     dfs_test.run(s,t);
     dfs_test.run();
-    dfs_test.init();
-
-    dfs_test.addSource(s);
-    e = dfs_test.processNextArc();
-    e = dfs_test.nextArc();
-    b = dfs_test.emptyQueue();
-    i = dfs_test.queueSize();
-
-    dfs_test.start();
-    dfs_test.start(t);
-    dfs_test.start(am);
 
     l  = dfs_test.dist(t);
@@ -180,4 +148,5 @@
   Digraph G;
   Node s, t;
+  Node s1, t1;
 
   std::istringstream input(test_lgf);
@@ -185,4 +154,6 @@
     node("source", s).
     node("target", t).
+    node("source1", s1).
+    node("target1", t1).
     run();
 
@@ -211,4 +182,9 @@
 
   {
+  Dfs<Digraph> dfs(G);
+  check(dfs.run(s1,t1) && dfs.reached(t1),"Node 3 is reachable from Node 6.");
+  }
+  
+  {
     NullMap<Node,Arc> myPredMap;
     dfs(G).predMap(myPredMap).run(s);
Index: test/digraph_test.cc
===================================================================
--- test/digraph_test.cc	(revision 956)
+++ test/digraph_test.cc	(revision 228)
@@ -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).
@@ -20,6 +20,6 @@
 #include <lemon/list_graph.h>
 #include <lemon/smart_graph.h>
-#include <lemon/static_graph.h>
-#include <lemon/full_graph.h>
+//#include <lemon/full_graph.h>
+//#include <lemon/hypercube_graph.h>
 
 #include "test_tools.h"
@@ -30,5 +30,5 @@
 
 template <class Digraph>
-void checkDigraphBuild() {
+void checkDigraph() {
   TEMPLATE_DIGRAPH_TYPEDEFS(Digraph);
   Digraph G;
@@ -36,7 +36,4 @@
   checkGraphNodeList(G, 0);
   checkGraphArcList(G, 0);
-
-  G.reserveNode(3);
-  G.reserveArc(4);
 
   Node
@@ -62,206 +59,5 @@
   checkGraphConArcList(G, 1);
 
-  Arc a2 = G.addArc(n2, n1),
-      a3 = G.addArc(n2, n3),
-      a4 = G.addArc(n2, n3);
-
-  checkGraphNodeList(G, 3);
-  checkGraphArcList(G, 4);
-
-  checkGraphOutArcList(G, n1, 1);
-  checkGraphOutArcList(G, n2, 3);
-  checkGraphOutArcList(G, n3, 0);
-
-  checkGraphInArcList(G, n1, 1);
-  checkGraphInArcList(G, n2, 1);
-  checkGraphInArcList(G, n3, 2);
-
-  checkGraphConArcList(G, 4);
-
-  checkNodeIds(G);
-  checkArcIds(G);
-  checkGraphNodeMap(G);
-  checkGraphArcMap(G);
-}
-
-template <class Digraph>
-void checkDigraphSplit() {
-  TEMPLATE_DIGRAPH_TYPEDEFS(Digraph);
-
-  Digraph G;
-  Node n1 = G.addNode(), n2 = G.addNode(), n3 = G.addNode();
-  Arc a1 = G.addArc(n1, n2), a2 = G.addArc(n2, n1),
-      a3 = G.addArc(n2, n3), a4 = G.addArc(n2, n3);
-
-  Node n4 = G.split(n2);
-
-  check(G.target(OutArcIt(G, n2)) == n4 &&
-        G.source(InArcIt(G, n4)) == n2,
-        "Wrong split.");
-
-  checkGraphNodeList(G, 4);
-  checkGraphArcList(G, 5);
-
-  checkGraphOutArcList(G, n1, 1);
-  checkGraphOutArcList(G, n2, 1);
-  checkGraphOutArcList(G, n3, 0);
-  checkGraphOutArcList(G, n4, 3);
-
-  checkGraphInArcList(G, n1, 1);
-  checkGraphInArcList(G, n2, 1);
-  checkGraphInArcList(G, n3, 2);
-  checkGraphInArcList(G, n4, 1);
-
-  checkGraphConArcList(G, 5);
-}
-
-template <class Digraph>
-void checkDigraphAlter() {
-  TEMPLATE_DIGRAPH_TYPEDEFS(Digraph);
-
-  Digraph G;
-  Node n1 = G.addNode(), n2 = G.addNode(),
-       n3 = G.addNode(), n4 = G.addNode();
-  Arc a1 = G.addArc(n1, n2), a2 = G.addArc(n4, n1),
-      a3 = G.addArc(n4, n3), a4 = G.addArc(n4, n3),
-      a5 = G.addArc(n2, n4);
-
-  checkGraphNodeList(G, 4);
-  checkGraphArcList(G, 5);
-
-  // Check changeSource() and changeTarget()
-  G.changeTarget(a4, n1);
-
-  checkGraphNodeList(G, 4);
-  checkGraphArcList(G, 5);
-
-  checkGraphOutArcList(G, n1, 1);
-  checkGraphOutArcList(G, n2, 1);
-  checkGraphOutArcList(G, n3, 0);
-  checkGraphOutArcList(G, n4, 3);
-
-  checkGraphInArcList(G, n1, 2);
-  checkGraphInArcList(G, n2, 1);
-  checkGraphInArcList(G, n3, 1);
-  checkGraphInArcList(G, n4, 1);
-
-  checkGraphConArcList(G, 5);
-
-  G.changeSource(a4, n3);
-
-  checkGraphNodeList(G, 4);
-  checkGraphArcList(G, 5);
-
-  checkGraphOutArcList(G, n1, 1);
-  checkGraphOutArcList(G, n2, 1);
-  checkGraphOutArcList(G, n3, 1);
-  checkGraphOutArcList(G, n4, 2);
-
-  checkGraphInArcList(G, n1, 2);
-  checkGraphInArcList(G, n2, 1);
-  checkGraphInArcList(G, n3, 1);
-  checkGraphInArcList(G, n4, 1);
-
-  checkGraphConArcList(G, 5);
-
-  // Check contract()
-  G.contract(n2, n4, false);
-
-  checkGraphNodeList(G, 3);
-  checkGraphArcList(G, 5);
-
-  checkGraphOutArcList(G, n1, 1);
-  checkGraphOutArcList(G, n2, 3);
-  checkGraphOutArcList(G, n3, 1);
-
-  checkGraphInArcList(G, n1, 2);
-  checkGraphInArcList(G, n2, 2);
-  checkGraphInArcList(G, n3, 1);
-
-  checkGraphConArcList(G, 5);
-
-  G.contract(n2, n1);
-
-  checkGraphNodeList(G, 2);
-  checkGraphArcList(G, 3);
-
-  checkGraphOutArcList(G, n2, 2);
-  checkGraphOutArcList(G, n3, 1);
-
-  checkGraphInArcList(G, n2, 2);
-  checkGraphInArcList(G, n3, 1);
-
-  checkGraphConArcList(G, 3);
-}
-
-template <class Digraph>
-void checkDigraphErase() {
-  TEMPLATE_DIGRAPH_TYPEDEFS(Digraph);
-
-  Digraph G;
-  Node n1 = G.addNode(), n2 = G.addNode(),
-       n3 = G.addNode(), n4 = G.addNode();
-  Arc a1 = G.addArc(n1, n2), a2 = G.addArc(n4, n1),
-      a3 = G.addArc(n4, n3), a4 = G.addArc(n3, n1),
-      a5 = G.addArc(n2, n4);
-
-  // Check arc deletion
-  G.erase(a1);
-
-  checkGraphNodeList(G, 4);
-  checkGraphArcList(G, 4);
-
-  checkGraphOutArcList(G, n1, 0);
-  checkGraphOutArcList(G, n2, 1);
-  checkGraphOutArcList(G, n3, 1);
-  checkGraphOutArcList(G, n4, 2);
-
-  checkGraphInArcList(G, n1, 2);
-  checkGraphInArcList(G, n2, 0);
-  checkGraphInArcList(G, n3, 1);
-  checkGraphInArcList(G, n4, 1);
-
-  checkGraphConArcList(G, 4);
-
-  // Check node deletion
-  G.erase(n4);
-
-  checkGraphNodeList(G, 3);
-  checkGraphArcList(G, 1);
-
-  checkGraphOutArcList(G, n1, 0);
-  checkGraphOutArcList(G, n2, 0);
-  checkGraphOutArcList(G, n3, 1);
-  checkGraphOutArcList(G, n4, 0);
-
-  checkGraphInArcList(G, n1, 1);
-  checkGraphInArcList(G, n2, 0);
-  checkGraphInArcList(G, n3, 0);
-  checkGraphInArcList(G, n4, 0);
-
-  checkGraphConArcList(G, 1);
-}
-
-
-template <class Digraph>
-void checkDigraphSnapshot() {
-  TEMPLATE_DIGRAPH_TYPEDEFS(Digraph);
-
-  Digraph G;
-  Node n1 = G.addNode(), n2 = G.addNode(), n3 = G.addNode();
-  Arc a1 = G.addArc(n1, n2), a2 = G.addArc(n2, n1),
-      a3 = G.addArc(n2, n3), a4 = G.addArc(n2, n3);
-
-  typename Digraph::Snapshot snapshot(G);
-
-  Node n = G.addNode();
-  G.addArc(n3, n);
-  G.addArc(n, n3);
-
-  checkGraphNodeList(G, 4);
-  checkGraphArcList(G, 6);
-
-  snapshot.restore();
-
+  Arc a2 = G.addArc(n2, n1), a3 = G.addArc(n2, n3), a4 = G.addArc(n2, n3);
   checkGraphNodeList(G, 3);
   checkGraphArcList(G, 4);
@@ -282,22 +78,6 @@
   checkGraphArcMap(G);
 
-  G.addNode();
-  snapshot.save(G);
+}
 
-  G.addArc(G.addNode(), G.addNode());
-
-  snapshot.restore();
-  snapshot.save(G);
-
-  checkGraphNodeList(G, 4);
-  checkGraphArcList(G, 4);
-
-  G.addArc(G.addNode(), G.addNode());
-
-  snapshot.restore();
-
-  checkGraphNodeList(G, 4);
-  checkGraphArcList(G, 4);
-}
 
 void checkConcepts() {
@@ -330,11 +110,10 @@
     checkConcept<ClearableDigraphComponent<>, SmartDigraph>();
   }
-  { // Checking StaticDigraph
-    checkConcept<Digraph, StaticDigraph>();
-    checkConcept<ClearableDigraphComponent<>, StaticDigraph>();
-  }
-  { // Checking FullDigraph
-    checkConcept<Digraph, FullDigraph>();
-  }
+//  { // Checking FullDigraph
+//    checkConcept<Digraph, FullDigraph>();
+//  }
+//  { // Checking HyperCubeDigraph
+//    checkConcept<Digraph, HyperCubeDigraph>();
+//  }
 }
 
@@ -389,168 +168,12 @@
 }
 
-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);
-  checkGraphArcList(G, num * num);
-
-  for (NodeIt n(G); n != INVALID; ++n) {
-    checkGraphOutArcList(G, n, num);
-    checkGraphInArcList(G, n, num);
-  }
-
-  checkGraphConArcList(G, num * num);
-
-  checkNodeIds(G);
-  checkArcIds(G);
-  checkGraphNodeMap(G);
-  checkGraphArcMap(G);
-
-  for (int i = 0; i < G.nodeNum(); ++i) {
-    check(G.index(G(i)) == i, "Wrong index");
-  }
-
-  for (NodeIt s(G); s != INVALID; ++s) {
-    for (NodeIt t(G); t != INVALID; ++t) {
-      Arc a = G.arc(s, t);
-      check(G.source(a) == s && G.target(a) == t, "Wrong arc lookup");
-    }
-  }
-}
-
 void checkDigraphs() {
   { // Checking ListDigraph
-    checkDigraphBuild<ListDigraph>();
-    checkDigraphSplit<ListDigraph>();
-    checkDigraphAlter<ListDigraph>();
-    checkDigraphErase<ListDigraph>();
-    checkDigraphSnapshot<ListDigraph>();
+    checkDigraph<ListDigraph>();
     checkDigraphValidityErase<ListDigraph>();
   }
   { // Checking SmartDigraph
-    checkDigraphBuild<SmartDigraph>();
-    checkDigraphSplit<SmartDigraph>();
-    checkDigraphSnapshot<SmartDigraph>();
+    checkDigraph<SmartDigraph>();
     checkDigraphValidity<SmartDigraph>();
-  }
-  { // Checking StaticDigraph
-    checkStaticDigraph();
-  }
-  { // Checking FullDigraph
-    checkFullDigraph(8);
   }
 }
Index: test/dijkstra_test.cc
===================================================================
--- test/dijkstra_test.cc	(revision 956)
+++ test/dijkstra_test.cc	(revision 412)
@@ -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).
@@ -61,8 +61,7 @@
 
   Digraph G;
-  Node s, t, n;
+  Node s, t;
   Arc e;
   VType l;
-  int i;
   bool b;
   DType::DistMap d(G);
@@ -70,34 +69,18 @@
   LengthMap length;
   Path<Digraph> pp;
-  concepts::ReadMap<Node,bool> nm;
 
   {
     DType dijkstra_test(G,length);
-    const DType& const_dijkstra_test = dijkstra_test;
 
     dijkstra_test.run(s);
     dijkstra_test.run(s,t);
 
-    dijkstra_test.init();
-    dijkstra_test.addSource(s);
-    dijkstra_test.addSource(s, 1);
-    n = dijkstra_test.processNextNode();
-    n = const_dijkstra_test.nextNode();
-    b = const_dijkstra_test.emptyQueue();
-    i = const_dijkstra_test.queueSize();
-
-    dijkstra_test.start();
-    dijkstra_test.start(t);
-    dijkstra_test.start(nm);
-
-    l  = const_dijkstra_test.dist(t);
-    e  = const_dijkstra_test.predArc(t);
-    s  = const_dijkstra_test.predNode(t);
-    b  = const_dijkstra_test.reached(t);
-    b  = const_dijkstra_test.processed(t);
-    d  = const_dijkstra_test.distMap();
-    p  = const_dijkstra_test.predMap();
-    pp = const_dijkstra_test.path(t);
-    l  = const_dijkstra_test.currentDist(t);
+    l  = dijkstra_test.dist(t);
+    e  = dijkstra_test.predArc(t);
+    s  = dijkstra_test.predNode(t);
+    b  = dijkstra_test.reached(t);
+    d  = dijkstra_test.distMap();
+    p  = dijkstra_test.predMap();
+    pp = dijkstra_test.path(t);
   }
   {
@@ -105,40 +88,13 @@
       ::SetPredMap<concepts::ReadWriteMap<Node,Arc> >
       ::SetDistMap<concepts::ReadWriteMap<Node,VType> >
+      ::SetProcessedMap<concepts::WriteMap<Node,bool> >
       ::SetStandardProcessedMap
-      ::SetProcessedMap<concepts::WriteMap<Node,bool> >
       ::SetOperationTraits<DijkstraDefaultOperationTraits<VType> >
       ::SetHeap<BinHeap<VType, concepts::ReadWriteMap<Node,int> > >
       ::SetStandardHeap<BinHeap<VType, concepts::ReadWriteMap<Node,int> > >
-      ::SetHeap<BinHeap<VType, concepts::ReadWriteMap<Node,int> >,
-                concepts::ReadWriteMap<Node,int> >
       ::Create dijkstra_test(G,length);
-
-    LengthMap length_map;
-    concepts::ReadWriteMap<Node,Arc> pred_map;
-    concepts::ReadWriteMap<Node,VType> dist_map;
-    concepts::WriteMap<Node,bool> processed_map;
-    concepts::ReadWriteMap<Node,int> heap_cross_ref;
-    BinHeap<VType, concepts::ReadWriteMap<Node,int> > heap(heap_cross_ref);
-
-    dijkstra_test
-      .lengthMap(length_map)
-      .predMap(pred_map)
-      .distMap(dist_map)
-      .processedMap(processed_map)
-      .heap(heap, heap_cross_ref);
 
     dijkstra_test.run(s);
     dijkstra_test.run(s,t);
-
-    dijkstra_test.addSource(s);
-    dijkstra_test.addSource(s, 1);
-    n = dijkstra_test.processNextNode();
-    n = dijkstra_test.nextNode();
-    b = dijkstra_test.emptyQueue();
-    i = dijkstra_test.queueSize();
-
-    dijkstra_test.start();
-    dijkstra_test.start(t);
-    dijkstra_test.start(nm);
 
     l  = dijkstra_test.dist(t);
@@ -146,7 +102,5 @@
     s  = dijkstra_test.predNode(t);
     b  = dijkstra_test.reached(t);
-    b  = dijkstra_test.processed(t);
     pp = dijkstra_test.path(t);
-    l  = dijkstra_test.currentDist(t);
   }
 
Index: test/dim_test.cc
===================================================================
--- test/dim_test.cc	(revision 463)
+++ test/dim_test.cc	(revision 253)
@@ -3,5 +3,5 @@
  * This file is a part of LEMON, a generic C++ optimization library.
  *
- * Copyright (C) 2003-2009
+ * Copyright (C) 2003-2008
  * Egervary Jeno Kombinatorikus Optimalizalasi Kutatocsoport
  * (Egervary Research Group on Combinatorial Optimization, EGRES).
Index: st/edge_set_test.cc
===================================================================
--- test/edge_set_test.cc	(revision 956)
+++ 	(revision )
@@ -1,380 +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 <vector>
-
-#include <lemon/concepts/digraph.h>
-#include <lemon/concepts/graph.h>
-#include <lemon/concept_check.h>
-
-#include <lemon/list_graph.h>
-
-#include <lemon/edge_set.h>
-
-#include "graph_test.h"
-#include "test_tools.h"
-
-using namespace lemon;
-
-void checkSmartArcSet() {
-  checkConcept<concepts::Digraph, SmartArcSet<ListDigraph> >();
-
-  typedef ListDigraph Digraph;
-  typedef SmartArcSet<Digraph> ArcSet;
-
-  Digraph digraph;
-  Digraph::Node
-    n1 = digraph.addNode(),
-    n2 = digraph.addNode();
-
-  Digraph::Arc ga1 = digraph.addArc(n1, n2);
-
-  ArcSet arc_set(digraph);
-
-  Digraph::Arc ga2 = digraph.addArc(n2, n1);
-
-  checkGraphNodeList(arc_set, 2);
-  checkGraphArcList(arc_set, 0);
-
-  Digraph::Node
-    n3 = digraph.addNode();
-  checkGraphNodeList(arc_set, 3);
-  checkGraphArcList(arc_set, 0);
-
-  ArcSet::Arc a1 = arc_set.addArc(n1, n2);
-  check(arc_set.source(a1) == n1 && arc_set.target(a1) == n2, "Wrong arc");
-  checkGraphNodeList(arc_set, 3);
-  checkGraphArcList(arc_set, 1);
-
-  checkGraphOutArcList(arc_set, n1, 1);
-  checkGraphOutArcList(arc_set, n2, 0);
-  checkGraphOutArcList(arc_set, n3, 0);
-
-  checkGraphInArcList(arc_set, n1, 0);
-  checkGraphInArcList(arc_set, n2, 1);
-  checkGraphInArcList(arc_set, n3, 0);
-
-  checkGraphConArcList(arc_set, 1);
-
-  ArcSet::Arc a2 = arc_set.addArc(n2, n1),
-    a3 = arc_set.addArc(n2, n3),
-    a4 = arc_set.addArc(n2, n3);
-  checkGraphNodeList(arc_set, 3);
-  checkGraphArcList(arc_set, 4);
-
-  checkGraphOutArcList(arc_set, n1, 1);
-  checkGraphOutArcList(arc_set, n2, 3);
-  checkGraphOutArcList(arc_set, n3, 0);
-
-  checkGraphInArcList(arc_set, n1, 1);
-  checkGraphInArcList(arc_set, n2, 1);
-  checkGraphInArcList(arc_set, n3, 2);
-
-  checkGraphConArcList(arc_set, 4);
-
-  checkNodeIds(arc_set);
-  checkArcIds(arc_set);
-  checkGraphNodeMap(arc_set);
-  checkGraphArcMap(arc_set);
-
-  check(arc_set.valid(), "Wrong validity");
-  digraph.erase(n1);
-  check(!arc_set.valid(), "Wrong validity");
-}
-
-void checkListArcSet() {
-  checkConcept<concepts::Digraph, SmartArcSet<ListDigraph> >();
-
-  typedef ListDigraph Digraph;
-  typedef ListArcSet<Digraph> ArcSet;
-
-  Digraph digraph;
-  Digraph::Node
-    n1 = digraph.addNode(),
-    n2 = digraph.addNode();
-
-  Digraph::Arc ga1 = digraph.addArc(n1, n2);
-
-  ArcSet arc_set(digraph);
-
-  Digraph::Arc ga2 = digraph.addArc(n2, n1);
-
-  checkGraphNodeList(arc_set, 2);
-  checkGraphArcList(arc_set, 0);
-
-  Digraph::Node
-    n3 = digraph.addNode();
-  checkGraphNodeList(arc_set, 3);
-  checkGraphArcList(arc_set, 0);
-
-  ArcSet::Arc a1 = arc_set.addArc(n1, n2);
-  check(arc_set.source(a1) == n1 && arc_set.target(a1) == n2, "Wrong arc");
-  checkGraphNodeList(arc_set, 3);
-  checkGraphArcList(arc_set, 1);
-
-  checkGraphOutArcList(arc_set, n1, 1);
-  checkGraphOutArcList(arc_set, n2, 0);
-  checkGraphOutArcList(arc_set, n3, 0);
-
-  checkGraphInArcList(arc_set, n1, 0);
-  checkGraphInArcList(arc_set, n2, 1);
-  checkGraphInArcList(arc_set, n3, 0);
-
-  checkGraphConArcList(arc_set, 1);
-
-  ArcSet::Arc a2 = arc_set.addArc(n2, n1),
-    a3 = arc_set.addArc(n2, n3),
-    a4 = arc_set.addArc(n2, n3);
-  checkGraphNodeList(arc_set, 3);
-  checkGraphArcList(arc_set, 4);
-
-  checkGraphOutArcList(arc_set, n1, 1);
-  checkGraphOutArcList(arc_set, n2, 3);
-  checkGraphOutArcList(arc_set, n3, 0);
-
-  checkGraphInArcList(arc_set, n1, 1);
-  checkGraphInArcList(arc_set, n2, 1);
-  checkGraphInArcList(arc_set, n3, 2);
-
-  checkGraphConArcList(arc_set, 4);
-
-  checkNodeIds(arc_set);
-  checkArcIds(arc_set);
-  checkGraphNodeMap(arc_set);
-  checkGraphArcMap(arc_set);
-
-  digraph.erase(n1);
-
-  checkGraphNodeList(arc_set, 2);
-  checkGraphArcList(arc_set, 2);
-
-  checkGraphOutArcList(arc_set, n2, 2);
-  checkGraphOutArcList(arc_set, n3, 0);
-
-  checkGraphInArcList(arc_set, n2, 0);
-  checkGraphInArcList(arc_set, n3, 2);
-
-  checkNodeIds(arc_set);
-  checkArcIds(arc_set);
-  checkGraphNodeMap(arc_set);
-  checkGraphArcMap(arc_set);
-
-  checkGraphConArcList(arc_set, 2);
-}
-
-void checkSmartEdgeSet() {
-  checkConcept<concepts::Digraph, SmartEdgeSet<ListDigraph> >();
-
-  typedef ListDigraph Digraph;
-  typedef SmartEdgeSet<Digraph> EdgeSet;
-
-  Digraph digraph;
-  Digraph::Node
-    n1 = digraph.addNode(),
-    n2 = digraph.addNode();
-
-  Digraph::Arc ga1 = digraph.addArc(n1, n2);
-
-  EdgeSet edge_set(digraph);
-
-  Digraph::Arc ga2 = digraph.addArc(n2, n1);
-
-  checkGraphNodeList(edge_set, 2);
-  checkGraphArcList(edge_set, 0);
-  checkGraphEdgeList(edge_set, 0);
-
-  Digraph::Node
-    n3 = digraph.addNode();
-  checkGraphNodeList(edge_set, 3);
-  checkGraphArcList(edge_set, 0);
-  checkGraphEdgeList(edge_set, 0);
-
-  EdgeSet::Edge e1 = edge_set.addEdge(n1, n2);
-  check((edge_set.u(e1) == n1 && edge_set.v(e1) == n2) ||
-        (edge_set.v(e1) == n1 && edge_set.u(e1) == n2), "Wrong edge");
-  checkGraphNodeList(edge_set, 3);
-  checkGraphArcList(edge_set, 2);
-  checkGraphEdgeList(edge_set, 1);
-
-  checkGraphOutArcList(edge_set, n1, 1);
-  checkGraphOutArcList(edge_set, n2, 1);
-  checkGraphOutArcList(edge_set, n3, 0);
-
-  checkGraphInArcList(edge_set, n1, 1);
-  checkGraphInArcList(edge_set, n2, 1);
-  checkGraphInArcList(edge_set, n3, 0);
-
-  checkGraphIncEdgeList(edge_set, n1, 1);
-  checkGraphIncEdgeList(edge_set, n2, 1);
-  checkGraphIncEdgeList(edge_set, n3, 0);
-
-  checkGraphConEdgeList(edge_set, 1);
-  checkGraphConArcList(edge_set, 2);
-
-  EdgeSet::Edge e2 = edge_set.addEdge(n2, n1),
-    e3 = edge_set.addEdge(n2, n3),
-    e4 = edge_set.addEdge(n2, n3);
-  checkGraphNodeList(edge_set, 3);
-  checkGraphEdgeList(edge_set, 4);
-
-  checkGraphOutArcList(edge_set, n1, 2);
-  checkGraphOutArcList(edge_set, n2, 4);
-  checkGraphOutArcList(edge_set, n3, 2);
-
-  checkGraphInArcList(edge_set, n1, 2);
-  checkGraphInArcList(edge_set, n2, 4);
-  checkGraphInArcList(edge_set, n3, 2);
-
-  checkGraphIncEdgeList(edge_set, n1, 2);
-  checkGraphIncEdgeList(edge_set, n2, 4);
-  checkGraphIncEdgeList(edge_set, n3, 2);
-
-  checkGraphConEdgeList(edge_set, 4);
-  checkGraphConArcList(edge_set, 8);
-
-  checkArcDirections(edge_set);
-
-  checkNodeIds(edge_set);
-  checkArcIds(edge_set);
-  checkEdgeIds(edge_set);
-  checkGraphNodeMap(edge_set);
-  checkGraphArcMap(edge_set);
-  checkGraphEdgeMap(edge_set);
-
-  check(edge_set.valid(), "Wrong validity");
-  digraph.erase(n1);
-  check(!edge_set.valid(), "Wrong validity");
-}
-
-void checkListEdgeSet() {
-  checkConcept<concepts::Digraph, ListEdgeSet<ListDigraph> >();
-
-  typedef ListDigraph Digraph;
-  typedef ListEdgeSet<Digraph> EdgeSet;
-
-  Digraph digraph;
-  Digraph::Node
-    n1 = digraph.addNode(),
-    n2 = digraph.addNode();
-
-  Digraph::Arc ga1 = digraph.addArc(n1, n2);
-
-  EdgeSet edge_set(digraph);
-
-  Digraph::Arc ga2 = digraph.addArc(n2, n1);
-
-  checkGraphNodeList(edge_set, 2);
-  checkGraphArcList(edge_set, 0);
-  checkGraphEdgeList(edge_set, 0);
-
-  Digraph::Node
-    n3 = digraph.addNode();
-  checkGraphNodeList(edge_set, 3);
-  checkGraphArcList(edge_set, 0);
-  checkGraphEdgeList(edge_set, 0);
-
-  EdgeSet::Edge e1 = edge_set.addEdge(n1, n2);
-  check((edge_set.u(e1) == n1 && edge_set.v(e1) == n2) ||
-        (edge_set.v(e1) == n1 && edge_set.u(e1) == n2), "Wrong edge");
-  checkGraphNodeList(edge_set, 3);
-  checkGraphArcList(edge_set, 2);
-  checkGraphEdgeList(edge_set, 1);
-
-  checkGraphOutArcList(edge_set, n1, 1);
-  checkGraphOutArcList(edge_set, n2, 1);
-  checkGraphOutArcList(edge_set, n3, 0);
-
-  checkGraphInArcList(edge_set, n1, 1);
-  checkGraphInArcList(edge_set, n2, 1);
-  checkGraphInArcList(edge_set, n3, 0);
-
-  checkGraphIncEdgeList(edge_set, n1, 1);
-  checkGraphIncEdgeList(edge_set, n2, 1);
-  checkGraphIncEdgeList(edge_set, n3, 0);
-
-  checkGraphConEdgeList(edge_set, 1);
-  checkGraphConArcList(edge_set, 2);
-
-  EdgeSet::Edge e2 = edge_set.addEdge(n2, n1),
-    e3 = edge_set.addEdge(n2, n3),
-    e4 = edge_set.addEdge(n2, n3);
-  checkGraphNodeList(edge_set, 3);
-  checkGraphEdgeList(edge_set, 4);
-
-  checkGraphOutArcList(edge_set, n1, 2);
-  checkGraphOutArcList(edge_set, n2, 4);
-  checkGraphOutArcList(edge_set, n3, 2);
-
-  checkGraphInArcList(edge_set, n1, 2);
-  checkGraphInArcList(edge_set, n2, 4);
-  checkGraphInArcList(edge_set, n3, 2);
-
-  checkGraphIncEdgeList(edge_set, n1, 2);
-  checkGraphIncEdgeList(edge_set, n2, 4);
-  checkGraphIncEdgeList(edge_set, n3, 2);
-
-  checkGraphConEdgeList(edge_set, 4);
-  checkGraphConArcList(edge_set, 8);
-
-  checkArcDirections(edge_set);
-
-  checkNodeIds(edge_set);
-  checkArcIds(edge_set);
-  checkEdgeIds(edge_set);
-  checkGraphNodeMap(edge_set);
-  checkGraphArcMap(edge_set);
-  checkGraphEdgeMap(edge_set);
-
-  digraph.erase(n1);
-
-  checkGraphNodeList(edge_set, 2);
-  checkGraphArcList(edge_set, 4);
-  checkGraphEdgeList(edge_set, 2);
-
-  checkGraphOutArcList(edge_set, n2, 2);
-  checkGraphOutArcList(edge_set, n3, 2);
-
-  checkGraphInArcList(edge_set, n2, 2);
-  checkGraphInArcList(edge_set, n3, 2);
-
-  checkGraphIncEdgeList(edge_set, n2, 2);
-  checkGraphIncEdgeList(edge_set, n3, 2);
-
-  checkNodeIds(edge_set);
-  checkArcIds(edge_set);
-  checkEdgeIds(edge_set);
-  checkGraphNodeMap(edge_set);
-  checkGraphArcMap(edge_set);
-  checkGraphEdgeMap(edge_set);
-
-  checkGraphConEdgeList(edge_set, 2);
-  checkGraphConArcList(edge_set, 4);
-
-}
-
-
-int main() {
-
-  checkSmartArcSet();
-  checkListArcSet();
-  checkSmartEdgeSet();
-  checkListEdgeSet();
-
-  return 0;
-}
Index: test/error_test.cc
===================================================================
--- test/error_test.cc	(revision 463)
+++ test/error_test.cc	(revision 277)
@@ -3,5 +3,5 @@
  * This file is a part of LEMON, a generic C++ optimization library.
  *
- * Copyright (C) 2003-2009
+ * Copyright (C) 2003-2008
  * Egervary Jeno Kombinatorikus Optimalizalasi Kutatocsoport
  * (Egervary Research Group on Combinatorial Optimization, EGRES).
Index: st/euler_test.cc
===================================================================
--- test/euler_test.cc	(revision 956)
+++ 	(revision )
@@ -1,223 +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/euler.h>
-#include <lemon/list_graph.h>
-#include <lemon/adaptors.h>
-#include "test_tools.h"
-
-using namespace lemon;
-
-template <typename Digraph>
-void checkDiEulerIt(const Digraph& g,
-                    const typename Digraph::Node& start = INVALID)
-{
-  typename Digraph::template ArcMap<int> visitationNumber(g, 0);
-
-  DiEulerIt<Digraph> e(g, start);
-  if (e == INVALID) return;
-  typename Digraph::Node firstNode = g.source(e);
-  typename Digraph::Node lastNode = g.target(e);
-  if (start != INVALID) {
-    check(firstNode == start, "checkDiEulerIt: Wrong first node");
-  }
-
-  for (; e != INVALID; ++e) {
-    if (e != INVALID) lastNode = g.target(e);
-    ++visitationNumber[e];
-  }
-
-  check(firstNode == lastNode,
-      "checkDiEulerIt: First and last nodes are not the same");
-
-  for (typename Digraph::ArcIt a(g); a != INVALID; ++a)
-  {
-    check(visitationNumber[a] == 1,
-        "checkDiEulerIt: Not visited or multiple times visited arc found");
-  }
-}
-
-template <typename Graph>
-void checkEulerIt(const Graph& g,
-                  const typename Graph::Node& start = INVALID)
-{
-  typename Graph::template EdgeMap<int> visitationNumber(g, 0);
-
-  EulerIt<Graph> e(g, start);
-  if (e == INVALID) return;
-  typename Graph::Node firstNode = g.source(typename Graph::Arc(e));
-  typename Graph::Node lastNode = g.target(typename Graph::Arc(e));
-  if (start != INVALID) {
-    check(firstNode == start, "checkEulerIt: Wrong first node");
-  }
-
-  for (; e != INVALID; ++e) {
-    if (e != INVALID) lastNode = g.target(typename Graph::Arc(e));
-    ++visitationNumber[e];
-  }
-
-  check(firstNode == lastNode,
-      "checkEulerIt: First and last nodes are not the same");
-
-  for (typename Graph::EdgeIt e(g); e != INVALID; ++e)
-  {
-    check(visitationNumber[e] == 1,
-        "checkEulerIt: Not visited or multiple times visited edge found");
-  }
-}
-
-int main()
-{
-  typedef ListDigraph Digraph;
-  typedef Undirector<Digraph> Graph;
-
-  {
-    Digraph d;
-    Graph g(d);
-
-    checkDiEulerIt(d);
-    checkDiEulerIt(g);
-    checkEulerIt(g);
-
-    check(eulerian(d), "This graph is Eulerian");
-    check(eulerian(g), "This graph is Eulerian");
-  }
-  {
-    Digraph d;
-    Graph g(d);
-    Digraph::Node n = d.addNode();
-
-    checkDiEulerIt(d);
-    checkDiEulerIt(g);
-    checkEulerIt(g);
-
-    check(eulerian(d), "This graph is Eulerian");
-    check(eulerian(g), "This graph is Eulerian");
-  }
-  {
-    Digraph d;
-    Graph g(d);
-    Digraph::Node n = d.addNode();
-    d.addArc(n, n);
-
-    checkDiEulerIt(d);
-    checkDiEulerIt(g);
-    checkEulerIt(g);
-
-    check(eulerian(d), "This graph is Eulerian");
-    check(eulerian(g), "This graph is Eulerian");
-  }
-  {
-    Digraph d;
-    Graph g(d);
-    Digraph::Node n1 = d.addNode();
-    Digraph::Node n2 = d.addNode();
-    Digraph::Node n3 = d.addNode();
-
-    d.addArc(n1, n2);
-    d.addArc(n2, n1);
-    d.addArc(n2, n3);
-    d.addArc(n3, n2);
-
-    checkDiEulerIt(d);
-    checkDiEulerIt(d, n2);
-    checkDiEulerIt(g);
-    checkDiEulerIt(g, n2);
-    checkEulerIt(g);
-    checkEulerIt(g, n2);
-
-    check(eulerian(d), "This graph is Eulerian");
-    check(eulerian(g), "This graph is Eulerian");
-  }
-  {
-    Digraph d;
-    Graph g(d);
-    Digraph::Node n1 = d.addNode();
-    Digraph::Node n2 = d.addNode();
-    Digraph::Node n3 = d.addNode();
-    Digraph::Node n4 = d.addNode();
-    Digraph::Node n5 = d.addNode();
-    Digraph::Node n6 = d.addNode();
-
-    d.addArc(n1, n2);
-    d.addArc(n2, n4);
-    d.addArc(n1, n3);
-    d.addArc(n3, n4);
-    d.addArc(n4, n1);
-    d.addArc(n3, n5);
-    d.addArc(n5, n2);
-    d.addArc(n4, n6);
-    d.addArc(n2, n6);
-    d.addArc(n6, n1);
-    d.addArc(n6, n3);
-
-    checkDiEulerIt(d);
-    checkDiEulerIt(d, n1);
-    checkDiEulerIt(d, n5);
-
-    checkDiEulerIt(g);
-    checkDiEulerIt(g, n1);
-    checkDiEulerIt(g, n5);
-    checkEulerIt(g);
-    checkEulerIt(g, n1);
-    checkEulerIt(g, n5);
-
-    check(eulerian(d), "This graph is Eulerian");
-    check(eulerian(g), "This graph is Eulerian");
-  }
-  {
-    Digraph d;
-    Graph g(d);
-    Digraph::Node n0 = d.addNode();
-    Digraph::Node n1 = d.addNode();
-    Digraph::Node n2 = d.addNode();
-    Digraph::Node n3 = d.addNode();
-    Digraph::Node n4 = d.addNode();
-    Digraph::Node n5 = d.addNode();
-
-    d.addArc(n1, n2);
-    d.addArc(n2, n3);
-    d.addArc(n3, n1);
-
-    checkDiEulerIt(d);
-    checkDiEulerIt(d, n2);
-
-    checkDiEulerIt(g);
-    checkDiEulerIt(g, n2);
-    checkEulerIt(g);
-    checkEulerIt(g, n2);
-
-    check(!eulerian(d), "This graph is not Eulerian");
-    check(!eulerian(g), "This graph is not Eulerian");
-  }
-  {
-    Digraph d;
-    Graph g(d);
-    Digraph::Node n1 = d.addNode();
-    Digraph::Node n2 = d.addNode();
-    Digraph::Node n3 = d.addNode();
-
-    d.addArc(n1, n2);
-    d.addArc(n2, n3);
-
-    check(!eulerian(d), "This graph is not Eulerian");
-    check(!eulerian(g), "This graph is not Eulerian");
-  }
-
-  return 0;
-}
Index: st/fractional_matching_test.cc
===================================================================
--- test/fractional_matching_test.cc	(revision 956)
+++ 	(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: st/gomory_hu_test.cc
===================================================================
--- test/gomory_hu_test.cc	(revision 956)
+++ 	(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 <iostream>
-
-#include "test_tools.h"
-#include <lemon/smart_graph.h>
-#include <lemon/concepts/graph.h>
-#include <lemon/concepts/maps.h>
-#include <lemon/lgf_reader.h>
-#include <lemon/gomory_hu.h>
-#include <cstdlib>
-
-using namespace std;
-using namespace lemon;
-
-typedef SmartGraph Graph;
-
-char test_lgf[] =
-  "@nodes\n"
-  "label\n"
-  "0\n"
-  "1\n"
-  "2\n"
-  "3\n"
-  "4\n"
-  "@arcs\n"
-  "     label capacity\n"
-  "0 1  0     1\n"
-  "1 2  1     1\n"
-  "2 3  2     1\n"
-  "0 3  4     5\n"
-  "0 3  5     10\n"
-  "0 3  6     7\n"
-  "4 2  7     1\n"
-  "@attributes\n"
-  "source 0\n"
-  "target 3\n";
-
-void checkGomoryHuCompile()
-{
-  typedef int Value;
-  typedef concepts::Graph Graph;
-
-  typedef Graph::Node Node;
-  typedef Graph::Edge Edge;
-  typedef concepts::ReadMap<Edge, Value> CapMap;
-  typedef concepts::ReadWriteMap<Node, bool> CutMap;
-
-  Graph g;
-  Node n;
-  CapMap cap;
-  CutMap cut;
-  Value v;
-  int d;
-
-  GomoryHu<Graph, CapMap> gh_test(g, cap);
-  const GomoryHu<Graph, CapMap>&
-    const_gh_test = gh_test;
-
-  gh_test.run();
-
-  n = const_gh_test.predNode(n);
-  v = const_gh_test.predValue(n);
-  d = const_gh_test.rootDist(n);
-  v = const_gh_test.minCutValue(n, n);
-  v = const_gh_test.minCutMap(n, n, cut);
-}
-
-GRAPH_TYPEDEFS(Graph);
-typedef Graph::EdgeMap<int> IntEdgeMap;
-typedef Graph::NodeMap<bool> BoolNodeMap;
-
-int cutValue(const Graph& graph, const BoolNodeMap& cut,
-             const IntEdgeMap& capacity) {
-
-  int sum = 0;
-  for (EdgeIt e(graph); e != INVALID; ++e) {
-    Node s = graph.u(e);
-    Node t = graph.v(e);
-
-    if (cut[s] != cut[t]) {
-      sum += capacity[e];
-    }
-  }
-  return sum;
-}
-
-
-int main() {
-  Graph graph;
-  IntEdgeMap capacity(graph);
-
-  std::istringstream input(test_lgf);
-  GraphReader<Graph>(graph, input).
-    edgeMap("capacity", capacity).run();
-
-  GomoryHu<Graph> ght(graph, capacity);
-  ght.run();
-
-  for (NodeIt u(graph); u != INVALID; ++u) {
-    for (NodeIt v(graph); v != u; ++v) {
-      Preflow<Graph, IntEdgeMap> pf(graph, capacity, u, v);
-      pf.runMinCut();
-      BoolNodeMap cm(graph);
-      ght.minCutMap(u, v, cm);
-      check(pf.flowValue() == ght.minCutValue(u, v), "Wrong cut 1");
-      check(cm[u] != cm[v], "Wrong cut 2");
-      check(pf.flowValue() == cutValue(graph, cm, capacity), "Wrong cut 3");
-
-      int sum=0;
-      for(GomoryHu<Graph>::MinCutEdgeIt a(ght, u, v);a!=INVALID;++a)
-        sum+=capacity[a];
-      check(sum == ght.minCutValue(u, v), "Problem with MinCutEdgeIt");
-
-      sum=0;
-      for(GomoryHu<Graph>::MinCutNodeIt n(ght, u, v,true);n!=INVALID;++n)
-        sum++;
-      for(GomoryHu<Graph>::MinCutNodeIt n(ght, u, v,false);n!=INVALID;++n)
-        sum++;
-      check(sum == countNodes(graph), "Problem with MinCutNodeIt");
-    }
-  }
-
-  return 0;
-}
Index: test/graph_copy_test.cc
===================================================================
--- test/graph_copy_test.cc	(revision 984)
+++ test/graph_copy_test.cc	(revision 980)
@@ -3,5 +3,5 @@
  * This file is a part of LEMON, a generic C++ optimization library.
  *
- * Copyright (C) 2003-2009
+ * Copyright (C) 2003-2008
  * Egervary Jeno Kombinatorikus Optimalizalasi Kutatocsoport
  * (Egervary Research Group on Combinatorial Optimization, EGRES).
Index: test/graph_test.cc
===================================================================
--- test/graph_test.cc	(revision 956)
+++ test/graph_test.cc	(revision 228)
@@ -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).
@@ -20,7 +20,6 @@
 #include <lemon/list_graph.h>
 #include <lemon/smart_graph.h>
-#include <lemon/full_graph.h>
-#include <lemon/grid_graph.h>
-#include <lemon/hypercube_graph.h>
+// #include <lemon/full_graph.h>
+// #include <lemon/grid_graph.h>
 
 #include "test_tools.h"
@@ -31,5 +30,5 @@
 
 template <class Graph>
-void checkGraphBuild() {
+void checkGraph() {
   TEMPLATE_GRAPH_TYPEDEFS(Graph);
 
@@ -37,8 +36,4 @@
   checkGraphNodeList(G, 0);
   checkGraphEdgeList(G, 0);
-  checkGraphArcList(G, 0);
-
-  G.reserveNode(3);
-  G.reserveEdge(3);
 
   Node
@@ -48,34 +43,46 @@
   checkGraphNodeList(G, 3);
   checkGraphEdgeList(G, 0);
-  checkGraphArcList(G, 0);
 
   Edge e1 = G.addEdge(n1, n2);
   check((G.u(e1) == n1 && G.v(e1) == n2) || (G.u(e1) == n2 && G.v(e1) == n1),
         "Wrong edge");
-
   checkGraphNodeList(G, 3);
+  checkGraphArcList(G, 2);
   checkGraphEdgeList(G, 1);
-  checkGraphArcList(G, 2);
-
-  checkGraphIncEdgeArcLists(G, n1, 1);
-  checkGraphIncEdgeArcLists(G, n2, 1);
-  checkGraphIncEdgeArcLists(G, n3, 0);
-
+
+  checkGraphOutArcList(G, n1, 1);
+  checkGraphOutArcList(G, n2, 1);
+  checkGraphOutArcList(G, n3, 0);
+
+  checkGraphInArcList(G, n1, 1);
+  checkGraphInArcList(G, n2, 1);
+  checkGraphInArcList(G, n3, 0);
+
+  checkGraphIncEdgeList(G, n1, 1);
+  checkGraphIncEdgeList(G, n2, 1);
+  checkGraphIncEdgeList(G, n3, 0);
+
+  checkGraphConArcList(G, 2);
   checkGraphConEdgeList(G, 1);
-  checkGraphConArcList(G, 2);
-
-  Edge e2 = G.addEdge(n2, n1),
-       e3 = G.addEdge(n2, n3);
-
+
+  Edge e2 = G.addEdge(n2, n1), e3 = G.addEdge(n2, n3);
   checkGraphNodeList(G, 3);
+  checkGraphArcList(G, 6);
   checkGraphEdgeList(G, 3);
-  checkGraphArcList(G, 6);
-
-  checkGraphIncEdgeArcLists(G, n1, 2);
-  checkGraphIncEdgeArcLists(G, n2, 3);
-  checkGraphIncEdgeArcLists(G, n3, 1);
-
+
+  checkGraphOutArcList(G, n1, 2);
+  checkGraphOutArcList(G, n2, 3);
+  checkGraphOutArcList(G, n3, 1);
+
+  checkGraphInArcList(G, n1, 2);
+  checkGraphInArcList(G, n2, 3);
+  checkGraphInArcList(G, n3, 1);
+
+  checkGraphIncEdgeList(G, n1, 2);
+  checkGraphIncEdgeList(G, n2, 3);
+  checkGraphIncEdgeList(G, n3, 1);
+
+  checkGraphConArcList(G, 6);
   checkGraphConEdgeList(G, 3);
-  checkGraphConArcList(G, 6);
 
   checkArcDirections(G);
@@ -89,244 +96,4 @@
 }
 
-template <class Graph>
-void checkGraphAlter() {
-  TEMPLATE_GRAPH_TYPEDEFS(Graph);
-
-  Graph G;
-  Node n1 = G.addNode(), n2 = G.addNode(),
-       n3 = G.addNode(), n4 = G.addNode();
-  Edge e1 = G.addEdge(n1, n2), e2 = G.addEdge(n2, n1),
-       e3 = G.addEdge(n2, n3), e4 = G.addEdge(n1, n4),
-       e5 = G.addEdge(n4, n3);
-
-  checkGraphNodeList(G, 4);
-  checkGraphEdgeList(G, 5);
-  checkGraphArcList(G, 10);
-
-  // Check changeU() and changeV()
-  if (G.u(e2) == n2) {
-    G.changeU(e2, n3);
-  } else {
-    G.changeV(e2, n3);
-  }
-
-  checkGraphNodeList(G, 4);
-  checkGraphEdgeList(G, 5);
-  checkGraphArcList(G, 10);
-
-  checkGraphIncEdgeArcLists(G, n1, 3);
-  checkGraphIncEdgeArcLists(G, n2, 2);
-  checkGraphIncEdgeArcLists(G, n3, 3);
-  checkGraphIncEdgeArcLists(G, n4, 2);
-
-  checkGraphConEdgeList(G, 5);
-  checkGraphConArcList(G, 10);
-
-  if (G.u(e2) == n1) {
-    G.changeU(e2, n2);
-  } else {
-    G.changeV(e2, n2);
-  }
-
-  checkGraphNodeList(G, 4);
-  checkGraphEdgeList(G, 5);
-  checkGraphArcList(G, 10);
-
-  checkGraphIncEdgeArcLists(G, n1, 2);
-  checkGraphIncEdgeArcLists(G, n2, 3);
-  checkGraphIncEdgeArcLists(G, n3, 3);
-  checkGraphIncEdgeArcLists(G, n4, 2);
-
-  checkGraphConEdgeList(G, 5);
-  checkGraphConArcList(G, 10);
-
-  // Check contract()
-  G.contract(n1, n4, false);
-
-  checkGraphNodeList(G, 3);
-  checkGraphEdgeList(G, 5);
-  checkGraphArcList(G, 10);
-
-  checkGraphIncEdgeArcLists(G, n1, 4);
-  checkGraphIncEdgeArcLists(G, n2, 3);
-  checkGraphIncEdgeArcLists(G, n3, 3);
-
-  checkGraphConEdgeList(G, 5);
-  checkGraphConArcList(G, 10);
-
-  G.contract(n2, n3);
-
-  checkGraphNodeList(G, 2);
-  checkGraphEdgeList(G, 3);
-  checkGraphArcList(G, 6);
-
-  checkGraphIncEdgeArcLists(G, n1, 4);
-  checkGraphIncEdgeArcLists(G, n2, 2);
-
-  checkGraphConEdgeList(G, 3);
-  checkGraphConArcList(G, 6);
-}
-
-template <class Graph>
-void checkGraphErase() {
-  TEMPLATE_GRAPH_TYPEDEFS(Graph);
-
-  Graph G;
-  Node n1 = G.addNode(), n2 = G.addNode(),
-       n3 = G.addNode(), n4 = G.addNode();
-  Edge e1 = G.addEdge(n1, n2), e2 = G.addEdge(n2, n1),
-       e3 = G.addEdge(n2, n3), e4 = G.addEdge(n1, n4),
-       e5 = G.addEdge(n4, n3);
-
-  // Check edge deletion
-  G.erase(e2);
-
-  checkGraphNodeList(G, 4);
-  checkGraphEdgeList(G, 4);
-  checkGraphArcList(G, 8);
-
-  checkGraphIncEdgeArcLists(G, n1, 2);
-  checkGraphIncEdgeArcLists(G, n2, 2);
-  checkGraphIncEdgeArcLists(G, n3, 2);
-  checkGraphIncEdgeArcLists(G, n4, 2);
-
-  checkGraphConEdgeList(G, 4);
-  checkGraphConArcList(G, 8);
-
-  // Check node deletion
-  G.erase(n3);
-
-  checkGraphNodeList(G, 3);
-  checkGraphEdgeList(G, 2);
-  checkGraphArcList(G, 4);
-
-  checkGraphIncEdgeArcLists(G, n1, 2);
-  checkGraphIncEdgeArcLists(G, n2, 1);
-  checkGraphIncEdgeArcLists(G, n4, 1);
-
-  checkGraphConEdgeList(G, 2);
-  checkGraphConArcList(G, 4);
-}
-
-
-template <class Graph>
-void checkGraphSnapshot() {
-  TEMPLATE_GRAPH_TYPEDEFS(Graph);
-
-  Graph G;
-  Node n1 = G.addNode(), n2 = G.addNode(), n3 = G.addNode();
-  Edge e1 = G.addEdge(n1, n2), e2 = G.addEdge(n2, n1),
-       e3 = G.addEdge(n2, n3);
-
-  checkGraphNodeList(G, 3);
-  checkGraphEdgeList(G, 3);
-  checkGraphArcList(G, 6);
-
-  typename Graph::Snapshot snapshot(G);
-
-  Node n = G.addNode();
-  G.addEdge(n3, n);
-  G.addEdge(n, n3);
-  G.addEdge(n3, n2);
-
-  checkGraphNodeList(G, 4);
-  checkGraphEdgeList(G, 6);
-  checkGraphArcList(G, 12);
-
-  snapshot.restore();
-
-  checkGraphNodeList(G, 3);
-  checkGraphEdgeList(G, 3);
-  checkGraphArcList(G, 6);
-
-  checkGraphIncEdgeArcLists(G, n1, 2);
-  checkGraphIncEdgeArcLists(G, n2, 3);
-  checkGraphIncEdgeArcLists(G, n3, 1);
-
-  checkGraphConEdgeList(G, 3);
-  checkGraphConArcList(G, 6);
-
-  checkNodeIds(G);
-  checkEdgeIds(G);
-  checkArcIds(G);
-  checkGraphNodeMap(G);
-  checkGraphEdgeMap(G);
-  checkGraphArcMap(G);
-
-  G.addNode();
-  snapshot.save(G);
-
-  G.addEdge(G.addNode(), G.addNode());
-
-  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);
-}
-
-void checkFullGraph(int num) {
-  typedef FullGraph Graph;
-  GRAPH_TYPEDEFS(Graph);
-
-  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);
-
-  for (NodeIt n(G); n != INVALID; ++n) {
-    checkGraphOutArcList(G, n, num - 1);
-    checkGraphInArcList(G, n, num - 1);
-    checkGraphIncEdgeList(G, n, num - 1);
-  }
-
-  checkGraphConArcList(G, num * (num - 1));
-  checkGraphConEdgeList(G, num * (num - 1) / 2);
-
-  checkArcDirections(G);
-
-  checkNodeIds(G);
-  checkArcIds(G);
-  checkEdgeIds(G);
-  checkGraphNodeMap(G);
-  checkGraphArcMap(G);
-  checkGraphEdgeMap(G);
-
-
-  for (int i = 0; i < G.nodeNum(); ++i) {
-    check(G.index(G(i)) == i, "Wrong index");
-  }
-
-  for (NodeIt u(G); u != INVALID; ++u) {
-    for (NodeIt v(G); v != INVALID; ++v) {
-      Edge e = G.edge(u, v);
-      Arc a = G.arc(u, v);
-      if (u == v) {
-        check(e == INVALID, "Wrong edge lookup");
-        check(a == INVALID, "Wrong arc lookup");
-      } else {
-        check((G.u(e) == u && G.v(e) == v) ||
-              (G.u(e) == v && G.v(e) == u), "Wrong edge lookup");
-        check(G.source(a) == u && G.target(a) == v, "Wrong arc lookup");
-      }
-    }
-  }
-}
-
 void checkConcepts() {
   { // Checking graph components
@@ -358,13 +125,12 @@
     checkConcept<ClearableGraphComponent<>, SmartGraph>();
   }
-  { // Checking FullGraph
-    checkConcept<Graph, FullGraph>();
-  }
-  { // Checking GridGraph
-    checkConcept<Graph, GridGraph>();
-  }
-  { // Checking HypercubeGraph
-    checkConcept<Graph, HypercubeGraph>();
-  }
+//  { // Checking FullGraph
+//    checkConcept<Graph, FullGraph>();
+//    checkGraphIterators<FullGraph>();
+//  }
+//  { // Checking GridGraph
+//    checkConcept<Graph, GridGraph>();
+//    checkGraphIterators<GridGraph>();
+//  }
 }
 
@@ -423,170 +189,68 @@
 }
 
-void checkGridGraph(int width, int height) {
-  typedef GridGraph Graph;
-  GRAPH_TYPEDEFS(Graph);
-  Graph G(width, height);
-
-  check(G.width() == width, "Wrong column number");
-  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) {
-      check(G.col(G(i, j)) == i, "Wrong column");
-      check(G.row(G(i, j)) == j, "Wrong row");
-      check(G.pos(G(i, j)).x == i, "Wrong column");
-      check(G.pos(G(i, j)).y == j, "Wrong row");
-    }
-  }
-
-  for (int j = 0; j < height; ++j) {
-    for (int i = 0; i < width - 1; ++i) {
-      check(G.source(G.right(G(i, j))) == G(i, j), "Wrong right");
-      check(G.target(G.right(G(i, j))) == G(i + 1, j), "Wrong right");
-    }
-    check(G.right(G(width - 1, j)) == INVALID, "Wrong right");
-  }
-
-  for (int j = 0; j < height; ++j) {
-    for (int i = 1; i < width; ++i) {
-      check(G.source(G.left(G(i, j))) == G(i, j), "Wrong left");
-      check(G.target(G.left(G(i, j))) == G(i - 1, j), "Wrong left");
-    }
-    check(G.left(G(0, j)) == INVALID, "Wrong left");
-  }
-
-  for (int i = 0; i < width; ++i) {
-    for (int j = 0; j < height - 1; ++j) {
-      check(G.source(G.up(G(i, j))) == G(i, j), "Wrong up");
-      check(G.target(G.up(G(i, j))) == G(i, j + 1), "Wrong up");
-    }
-    check(G.up(G(i, height - 1)) == INVALID, "Wrong up");
-  }
-
-  for (int i = 0; i < width; ++i) {
-    for (int j = 1; j < height; ++j) {
-      check(G.source(G.down(G(i, j))) == G(i, j), "Wrong down");
-      check(G.target(G.down(G(i, j))) == G(i, j - 1), "Wrong down");
-    }
-    check(G.down(G(i, 0)) == INVALID, "Wrong down");
-  }
-
-  checkGraphNodeList(G, width * height);
-  checkGraphEdgeList(G, width * (height - 1) + (width - 1) * height);
-  checkGraphArcList(G, 2 * (width * (height - 1) + (width - 1) * height));
-
-  for (NodeIt n(G); n != INVALID; ++n) {
-    int nb = 4;
-    if (G.col(n) == 0) --nb;
-    if (G.col(n) == width - 1) --nb;
-    if (G.row(n) == 0) --nb;
-    if (G.row(n) == height - 1) --nb;
-
-    checkGraphOutArcList(G, n, nb);
-    checkGraphInArcList(G, n, nb);
-    checkGraphIncEdgeList(G, n, nb);
-  }
-
-  checkArcDirections(G);
-
-  checkGraphConArcList(G, 2 * (width * (height - 1) + (width - 1) * height));
-  checkGraphConEdgeList(G, width * (height - 1) + (width - 1) * height);
-
-  checkNodeIds(G);
-  checkArcIds(G);
-  checkEdgeIds(G);
-  checkGraphNodeMap(G);
-  checkGraphArcMap(G);
-  checkGraphEdgeMap(G);
-
-}
-
-void checkHypercubeGraph(int dim) {
-  GRAPH_TYPEDEFS(HypercubeGraph);
-
-  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)));
-  checkGraphArcList(G, dim * (1 << dim));
-
-  Node n = G.nodeFromId(dim);
-
-  for (NodeIt n(G); n != INVALID; ++n) {
-    checkGraphIncEdgeList(G, n, dim);
-    for (IncEdgeIt e(G, n); e != INVALID; ++e) {
-      check( (G.u(e) == n &&
-              G.id(G.v(e)) == (G.id(n) ^ (1 << G.dimension(e)))) ||
-             (G.v(e) == n &&
-              G.id(G.u(e)) == (G.id(n) ^ (1 << G.dimension(e)))),
-             "Wrong edge or wrong dimension");
-    }
-
-    checkGraphOutArcList(G, n, dim);
-    for (OutArcIt a(G, n); a != INVALID; ++a) {
-      check(G.source(a) == n &&
-            G.id(G.target(a)) == (G.id(n) ^ (1 << G.dimension(a))),
-            "Wrong arc or wrong dimension");
-    }
-
-    checkGraphInArcList(G, n, dim);
-    for (InArcIt a(G, n); a != INVALID; ++a) {
-      check(G.target(a) == n &&
-            G.id(G.source(a)) == (G.id(n) ^ (1 << G.dimension(a))),
-            "Wrong arc or wrong dimension");
-    }
-  }
-
-  checkGraphConArcList(G, (1 << dim) * dim);
-  checkGraphConEdgeList(G, dim * (1 << (dim-1)));
-
-  checkArcDirections(G);
-
-  checkNodeIds(G);
-  checkArcIds(G);
-  checkEdgeIds(G);
-  checkGraphNodeMap(G);
-  checkGraphArcMap(G);
-  checkGraphEdgeMap(G);
-}
+// void checkGridGraph(const GridGraph& g, int w, int h) {
+//   check(g.width() == w, "Wrong width");
+//   check(g.height() == h, "Wrong height");
+
+//   for (int i = 0; i < w; ++i) {
+//     for (int j = 0; j < h; ++j) {
+//       check(g.col(g(i, j)) == i, "Wrong col");
+//       check(g.row(g(i, j)) == j, "Wrong row");
+//     }
+//   }
+
+//   for (int i = 0; i < w; ++i) {
+//     for (int j = 0; j < h - 1; ++j) {
+//       check(g.source(g.down(g(i, j))) == g(i, j), "Wrong down");
+//       check(g.target(g.down(g(i, j))) == g(i, j + 1), "Wrong down");
+//     }
+//     check(g.down(g(i, h - 1)) == INVALID, "Wrong down");
+//   }
+
+//   for (int i = 0; i < w; ++i) {
+//     for (int j = 1; j < h; ++j) {
+//       check(g.source(g.up(g(i, j))) == g(i, j), "Wrong up");
+//       check(g.target(g.up(g(i, j))) == g(i, j - 1), "Wrong up");
+//     }
+//     check(g.up(g(i, 0)) == INVALID, "Wrong up");
+//   }
+
+//   for (int j = 0; j < h; ++j) {
+//     for (int i = 0; i < w - 1; ++i) {
+//       check(g.source(g.right(g(i, j))) == g(i, j), "Wrong right");
+//       check(g.target(g.right(g(i, j))) == g(i + 1, j), "Wrong right");
+//     }
+//     check(g.right(g(w - 1, j)) == INVALID, "Wrong right");
+//   }
+
+//   for (int j = 0; j < h; ++j) {
+//     for (int i = 1; i < w; ++i) {
+//       check(g.source(g.left(g(i, j))) == g(i, j), "Wrong left");
+//       check(g.target(g.left(g(i, j))) == g(i - 1, j), "Wrong left");
+//     }
+//     check(g.left(g(0, j)) == INVALID, "Wrong left");
+//   }
+// }
 
 void checkGraphs() {
   { // Checking ListGraph
-    checkGraphBuild<ListGraph>();
-    checkGraphAlter<ListGraph>();
-    checkGraphErase<ListGraph>();
-    checkGraphSnapshot<ListGraph>();
+    checkGraph<ListGraph>();
     checkGraphValidityErase<ListGraph>();
   }
   { // Checking SmartGraph
-    checkGraphBuild<SmartGraph>();
-    checkGraphSnapshot<SmartGraph>();
+    checkGraph<SmartGraph>();
     checkGraphValidity<SmartGraph>();
   }
-  { // Checking FullGraph
-    checkFullGraph(7);
-    checkFullGraph(8);
-  }
-  { // Checking GridGraph
-    checkGridGraph(5, 8);
-    checkGridGraph(8, 5);
-    checkGridGraph(5, 5);
-    checkGridGraph(0, 0);
-    checkGridGraph(1, 1);
-  }
-  { // Checking HypercubeGraph
-    checkHypercubeGraph(1);
-    checkHypercubeGraph(2);
-    checkHypercubeGraph(3);
-    checkHypercubeGraph(4);
-  }
+//   { // Checking FullGraph
+//     FullGraph g(5);
+//     checkGraphNodeList(g, 5);
+//     checkGraphEdgeList(g, 10);
+//   }
+//   { // Checking GridGraph
+//     GridGraph g(5, 6);
+//     checkGraphNodeList(g, 30);
+//     checkGraphEdgeList(g, 49);
+//     checkGridGraph(g, 5, 6);
+//   }
 }
 
Index: test/graph_test.h
===================================================================
--- test/graph_test.h	(revision 463)
+++ test/graph_test.h	(revision 263)
@@ -3,5 +3,5 @@
  * This file is a part of LEMON, a generic C++ optimization library.
  *
- * Copyright (C) 2003-2009
+ * Copyright (C) 2003-2008
  * Egervary Jeno Kombinatorikus Optimalizalasi Kutatocsoport
  * (Egervary Research Group on Combinatorial Optimization, EGRES).
@@ -115,13 +115,4 @@
     check(e==INVALID,"Wrong IncEdge list linking.");
     check(countIncEdges(G,n)==cnt,"Wrong IncEdge number.");
-  }
-
-  template <class Graph>
-  void checkGraphIncEdgeArcLists(const Graph &G, typename Graph::Node n,
-                                 int cnt)
-  {
-    checkGraphIncEdgeList(G, n, cnt);
-    checkGraphOutArcList(G, n, cnt);
-    checkGraphInArcList(G, n, cnt);
   }
 
Index: test/graph_utils_test.cc
===================================================================
--- test/graph_utils_test.cc	(revision 619)
+++ test/graph_utils_test.cc	(revision 220)
@@ -3,5 +3,5 @@
  * This file is a part of LEMON, a generic C++ optimization library.
  *
- * Copyright (C) 2003-2009
+ * Copyright (C) 2003-2008
  * Egervary Jeno Kombinatorikus Optimalizalasi Kutatocsoport
  * (Egervary Research Group on Combinatorial Optimization, EGRES).
@@ -39,6 +39,6 @@
       digraph.addNode();
     }
-    RangeIdMap<Digraph, Node> nodes(digraph);
-    typename RangeIdMap<Digraph, Node>::InverseMap invNodes(nodes);
+    DescriptorMap<Digraph, Node> nodes(digraph);
+    typename DescriptorMap<Digraph, Node>::InverseMap invNodes(nodes);
     for (int i = 0; i < 100; ++i) {
       int src = rnd[invNodes.size()];
@@ -47,5 +47,5 @@
     }
     typename Digraph::template ArcMap<bool> found(digraph, false);
-    RangeIdMap<Digraph, Arc> arcs(digraph);
+    DescriptorMap<Digraph, Arc> arcs(digraph);
     for (NodeIt src(digraph); src != INVALID; ++src) {
       for (NodeIt trg(digraph); trg != INVALID; ++trg) {
@@ -114,6 +114,6 @@
     graph.addNode();
   }
-  RangeIdMap<Graph, Node> nodes(graph);
-  typename RangeIdMap<Graph, Node>::InverseMap invNodes(nodes);
+  DescriptorMap<Graph, Node> nodes(graph);
+  typename DescriptorMap<Graph, Node>::InverseMap invNodes(nodes);
   for (int i = 0; i < 100; ++i) {
     int src = rnd[invNodes.size()];
@@ -122,5 +122,5 @@
   }
   typename Graph::template EdgeMap<int> found(graph, 0);
-  RangeIdMap<Graph, Edge> edges(graph);
+  DescriptorMap<Graph, Edge> edges(graph);
   for (NodeIt src(graph); src != INVALID; ++src) {
     for (NodeIt trg(graph); trg != INVALID; ++trg) {
Index: st/hao_orlin_test.cc
===================================================================
--- test/hao_orlin_test.cc	(revision 956)
+++ 	(revision )
@@ -1,163 +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/digraph.h>
-#include <lemon/concepts/maps.h>
-#include <lemon/lgf_reader.h>
-#include <lemon/hao_orlin.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"
-  "5 4  4    4    4   \n"
-  "2 3  1    6    6   \n"
-  "4 0  1    6    6   \n";
-
-void checkHaoOrlinCompile()
-{
-  typedef int Value;
-  typedef concepts::Digraph Digraph;
-
-  typedef Digraph::Node Node;
-  typedef Digraph::Arc Arc;
-  typedef concepts::ReadMap<Arc, Value> CapMap;
-  typedef concepts::WriteMap<Node, bool> CutMap;
-
-  Digraph g;
-  Node n;
-  CapMap cap;
-  CutMap cut;
-  Value v;
-
-  HaoOrlin<Digraph, CapMap> ho_test(g, cap);
-  const HaoOrlin<Digraph, CapMap>&
-    const_ho_test = ho_test;
-
-  ho_test.init();
-  ho_test.init(n);
-  ho_test.calculateOut();
-  ho_test.calculateIn();
-  ho_test.run();
-  ho_test.run(n);
-
-  v = const_ho_test.minCutValue();
-  v = const_ho_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::ArcIt a(graph); a != INVALID; ++a) {
-    if (cut[graph.source(a)] && !cut[graph.target(a)])
-      sum += cap[a];
-  }
-  return sum;
-}
-
-int main() {
-  SmartDigraph graph;
-  SmartDigraph::ArcMap<int> cap1(graph), cap2(graph), cap3(graph);
-  SmartDigraph::NodeMap<bool> cut(graph);
-
-  istringstream input(lgf);
-  digraphReader(graph, input)
-    .arcMap("cap1", cap1)
-    .arcMap("cap2", cap2)
-    .arcMap("cap3", cap3)
-    .run();
-
-  {
-    HaoOrlin<SmartDigraph> ho(graph, cap1);
-    ho.run();
-    ho.minCutMap(cut);
-
-    check(ho.minCutValue() == 1, "Wrong cut value");
-    check(ho.minCutValue() == cutValue(graph, cap1, cut), "Wrong cut value");
-  }
-  {
-    HaoOrlin<SmartDigraph> ho(graph, cap2);
-    ho.run();
-    ho.minCutMap(cut);
-
-    check(ho.minCutValue() == 1, "Wrong cut value");
-    check(ho.minCutValue() == cutValue(graph, cap2, cut), "Wrong cut value");
-  }
-  {
-    HaoOrlin<SmartDigraph> ho(graph, cap3);
-    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");
-  }
-  {
-    HaoOrlin<UGraph, SmartDigraph::ArcMap<int> > ho(ugraph, cap2);
-    ho.run();
-    ho.minCutMap(cut);
-
-    check(ho.minCutValue() == 5, "Wrong cut value");
-    check(ho.minCutValue() == cutValue(ugraph, cap2, cut), "Wrong cut value");
-  }
-  {
-    HaoOrlin<UGraph, SmartDigraph::ArcMap<int> > ho(ugraph, cap3);
-    ho.run();
-    ho.minCutMap(cut);
-
-    check(ho.minCutValue() == 5, "Wrong cut value");
-    check(ho.minCutValue() == cutValue(ugraph, cap3, cut), "Wrong cut value");
-  }
-
-  return 0;
-}
Index: test/heap_test.cc
===================================================================
--- test/heap_test.cc	(revision 929)
+++ test/heap_test.cc	(revision 293)
@@ -3,5 +3,5 @@
  * This file is a part of LEMON, a generic C++ optimization library.
  *
- * Copyright (C) 2003-2009
+ * Copyright (C) 2003-2008
  * Egervary Jeno Kombinatorikus Optimalizalasi Kutatocsoport
  * (Egervary Research Group on Combinatorial Optimization, EGRES).
@@ -26,4 +26,5 @@
 
 #include <lemon/smart_graph.h>
+
 #include <lemon/lgf_reader.h>
 #include <lemon/dijkstra.h>
@@ -31,11 +32,4 @@
 
 #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>
 
 #include "test_tools.h"
@@ -93,7 +87,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 +98,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 +110,5 @@
 
   std::vector<int> v(test_len);
+
   for (int i = 0; i < test_len; ++i) {
     v[i] = test_seq[i];
@@ -124,8 +121,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 +142,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 +151,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 +173,4 @@
     run();
 
-  // BinHeap
   {
     typedef BinHeap<Prio, ItemIntMap> IntHeap;
@@ -186,91 +184,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;
-    checkConcept<Heap<Prio, ItemIntMap>, IntHeap>();
-    heapSortTest<IntHeap>();
-    heapIncreaseTest<IntHeap>();
-
-    typedef FibHeap<Prio, IntNodeMap > NodeHeap;
-    checkConcept<Heap<Prio, IntNodeMap >, NodeHeap>();
-    dijkstraHeapTest<NodeHeap>(digraph, length, source);
-  }
-
-  // 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;
-    checkConcept<Heap<Prio, ItemIntMap>, IntHeap>();
-    heapSortTest<IntHeap>();
-    heapIncreaseTest<IntHeap>();
-
-    typedef RadixHeap<IntNodeMap > NodeHeap;
-    checkConcept<Heap<Prio, IntNodeMap >, NodeHeap>();
-    dijkstraHeapTest<NodeHeap>(digraph, length, source);
-  }
-
-  // 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;
-    checkConcept<Heap<Prio, ItemIntMap>, IntHeap>();
-    heapSortTest<IntHeap>();
-    heapIncreaseTest<IntHeap>();
-
-    typedef BucketHeap<IntNodeMap > NodeHeap;
-    checkConcept<Heap<Prio, IntNodeMap >, NodeHeap>();
-    dijkstraHeapTest<NodeHeap>(digraph, length, source);
-
-    typedef SimpleBucketHeap<ItemIntMap> SimpleIntHeap;
-    heapSortTest<SimpleIntHeap>();
-  }
-
   return 0;
 }
Index: test/kruskal_test.cc
===================================================================
--- test/kruskal_test.cc	(revision 628)
+++ test/kruskal_test.cc	(revision 209)
@@ -3,5 +3,5 @@
  * This file is a part of LEMON, a generic C++ optimization library.
  *
- * Copyright (C) 2003-2009
+ * Copyright (C) 2003-2008
  * Egervary Jeno Kombinatorikus Optimalizalasi Kutatocsoport
  * (Egervary Research Group on Combinatorial Optimization, EGRES).
@@ -100,14 +100,14 @@
         "Total cost should be 10");
 
-  edge_cost_map[e1] = -10;
-  edge_cost_map[e2] = -9;
-  edge_cost_map[e3] = -8;
-  edge_cost_map[e4] = -7;
-  edge_cost_map[e5] = -6;
-  edge_cost_map[e6] = -5;
-  edge_cost_map[e7] = -4;
-  edge_cost_map[e8] = -3;
-  edge_cost_map[e9] = -2;
-  edge_cost_map[e10] = -1;
+  edge_cost_map.set(e1, -10);
+  edge_cost_map.set(e2, -9);
+  edge_cost_map.set(e3, -8);
+  edge_cost_map.set(e4, -7);
+  edge_cost_map.set(e5, -6);
+  edge_cost_map.set(e6, -5);
+  edge_cost_map.set(e7, -4);
+  edge_cost_map.set(e8, -3);
+  edge_cost_map.set(e9, -2);
+  edge_cost_map.set(e10, -1);
 
   vector<Edge> tree_edge_vec(5);
Index: st/lp_test.cc
===================================================================
--- test/lp_test.cc	(revision 678)
+++ 	(revision )
@@ -1,419 +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 <sstream>
-#include <lemon/lp_skeleton.h>
-#include "test_tools.h"
-#include <lemon/tolerance.h>
-
-#include <lemon/config.h>
-
-#ifdef LEMON_HAVE_GLPK
-#include <lemon/glpk.h>
-#endif
-
-#ifdef LEMON_HAVE_CPLEX
-#include <lemon/cplex.h>
-#endif
-
-#ifdef LEMON_HAVE_SOPLEX
-#include <lemon/soplex.h>
-#endif
-
-#ifdef LEMON_HAVE_CLP
-#include <lemon/clp.h>
-#endif
-
-using namespace lemon;
-
-void lpTest(LpSolver& lp)
-{
-
-  typedef LpSolver LP;
-
-  std::vector<LP::Col> x(10);
-  //  for(int i=0;i<10;i++) x.push_back(lp.addCol());
-  lp.addColSet(x);
-  lp.colLowerBound(x,1);
-  lp.colUpperBound(x,1);
-  lp.colBounds(x,1,2);
-
-  std::vector<LP::Col> y(10);
-  lp.addColSet(y);
-
-  lp.colLowerBound(y,1);
-  lp.colUpperBound(y,1);
-  lp.colBounds(y,1,2);
-
-  std::map<int,LP::Col> z;
-
-  z.insert(std::make_pair(12,INVALID));
-  z.insert(std::make_pair(2,INVALID));
-  z.insert(std::make_pair(7,INVALID));
-  z.insert(std::make_pair(5,INVALID));
-
-  lp.addColSet(z);
-
-  lp.colLowerBound(z,1);
-  lp.colUpperBound(z,1);
-  lp.colBounds(z,1,2);
-
-  {
-    LP::Expr e,f,g;
-    LP::Col p1,p2,p3,p4,p5;
-    LP::Constr c;
-
-    p1=lp.addCol();
-    p2=lp.addCol();
-    p3=lp.addCol();
-    p4=lp.addCol();
-    p5=lp.addCol();
-
-    e[p1]=2;
-    *e=12;
-    e[p1]+=2;
-    *e+=12;
-    e[p1]-=2;
-    *e-=12;
-
-    e=2;
-    e=2.2;
-    e=p1;
-    e=f;
-
-    e+=2;
-    e+=2.2;
-    e+=p1;
-    e+=f;
-
-    e-=2;
-    e-=2.2;
-    e-=p1;
-    e-=f;
-
-    e*=2;
-    e*=2.2;
-    e/=2;
-    e/=2.2;
-
-    e=((p1+p2)+(p1-p2)+(p1+12)+(12+p1)+(p1-12)+(12-p1)+
-       (f+12)+(12+f)+(p1+f)+(f+p1)+(f+g)+
-       (f-12)+(12-f)+(p1-f)+(f-p1)+(f-g)+
-       2.2*f+f*2.2+f/2.2+
-       2*f+f*2+f/2+
-       2.2*p1+p1*2.2+p1/2.2+
-       2*p1+p1*2+p1/2
-       );
-
-
-    c = (e  <= f  );
-    c = (e  <= 2.2);
-    c = (e  <= 2  );
-    c = (e  <= p1 );
-    c = (2.2<= f  );
-    c = (2  <= f  );
-    c = (p1 <= f  );
-    c = (p1 <= p2 );
-    c = (p1 <= 2.2);
-    c = (p1 <= 2  );
-    c = (2.2<= p2 );
-    c = (2  <= p2 );
-
-    c = (e  >= f  );
-    c = (e  >= 2.2);
-    c = (e  >= 2  );
-    c = (e  >= p1 );
-    c = (2.2>= f  );
-    c = (2  >= f  );
-    c = (p1 >= f  );
-    c = (p1 >= p2 );
-    c = (p1 >= 2.2);
-    c = (p1 >= 2  );
-    c = (2.2>= p2 );
-    c = (2  >= p2 );
-
-    c = (e  == f  );
-    c = (e  == 2.2);
-    c = (e  == 2  );
-    c = (e  == p1 );
-    c = (2.2== f  );
-    c = (2  == f  );
-    c = (p1 == f  );
-    //c = (p1 == p2 );
-    c = (p1 == 2.2);
-    c = (p1 == 2  );
-    c = (2.2== p2 );
-    c = (2  == p2 );
-
-    c = ((2 <= e) <= 3);
-    c = ((2 <= p1) <= 3);
-
-    c = ((2 >= e) >= 3);
-    c = ((2 >= p1) >= 3);
-
-    e[x[3]]=2;
-    e[x[3]]=4;
-    e[x[3]]=1;
-    *e=12;
-
-    lp.addRow(-LP::INF,e,23);
-    lp.addRow(-LP::INF,3.0*(x[1]+x[2]/2)-x[3],23);
-    lp.addRow(-LP::INF,3.0*(x[1]+x[2]*2-5*x[3]+12-x[4]/3)+2*x[4]-4,23);
-
-    lp.addRow(x[1]+x[3]<=x[5]-3);
-    lp.addRow((-7<=x[1]+x[3]-12)<=3);
-    lp.addRow(x[1]<=x[5]);
-
-    std::ostringstream buf;
-
-
-    e=((p1+p2)+(p1-0.99*p2));
-    //e.prettyPrint(std::cout);
-    //(e<=2).prettyPrint(std::cout);
-    double tolerance=0.001;
-    e.simplify(tolerance);
-    buf << "Coeff. of p2 should be 0.01";
-    check(e[p2]>0, buf.str());
-
-    tolerance=0.02;
-    e.simplify(tolerance);
-    buf << "Coeff. of p2 should be 0";
-    check(const_cast<const LpSolver::Expr&>(e)[p2]==0, buf.str());
-
-    //Test for clone/new
-    LP* lpnew = lp.newSolver();
-    LP* lpclone = lp.cloneSolver();
-    delete lpnew;
-    delete lpclone;
-
-  }
-
-  {
-    LP::DualExpr e,f,g;
-    LP::Row p1 = INVALID, p2 = INVALID, p3 = INVALID,
-      p4 = INVALID, p5 = INVALID;
-
-    e[p1]=2;
-    e[p1]+=2;
-    e[p1]-=2;
-
-    e=p1;
-    e=f;
-
-    e+=p1;
-    e+=f;
-
-    e-=p1;
-    e-=f;
-
-    e*=2;
-    e*=2.2;
-    e/=2;
-    e/=2.2;
-
-    e=((p1+p2)+(p1-p2)+
-       (p1+f)+(f+p1)+(f+g)+
-       (p1-f)+(f-p1)+(f-g)+
-       2.2*f+f*2.2+f/2.2+
-       2*f+f*2+f/2+
-       2.2*p1+p1*2.2+p1/2.2+
-       2*p1+p1*2+p1/2
-       );
-  }
-
-}
-
-void solveAndCheck(LpSolver& lp, LpSolver::ProblemType stat,
-                   double exp_opt) {
-  using std::string;
-  lp.solve();
-
-  std::ostringstream buf;
-  buf << "PrimalType should be: " << int(stat) << int(lp.primalType());
-
-  check(lp.primalType()==stat, buf.str());
-
-  if (stat ==  LpSolver::OPTIMAL) {
-    std::ostringstream sbuf;
-    sbuf << "Wrong optimal value (" << lp.primal() <<") with "
-         << lp.solverName() <<"\n     the right optimum is " << exp_opt;
-    check(std::abs(lp.primal()-exp_opt) < 1e-3, sbuf.str());
-  }
-}
-
-void aTest(LpSolver & lp)
-{
-  typedef LpSolver LP;
-
- //The following example is very simple
-
-  typedef LpSolver::Row Row;
-  typedef LpSolver::Col Col;
-
-
-  Col x1 = lp.addCol();
-  Col x2 = lp.addCol();
-
-
-  //Constraints
-  Row upright=lp.addRow(x1+2*x2 <=1);
-  lp.addRow(x1+x2 >=-1);
-  lp.addRow(x1-x2 <=1);
-  lp.addRow(x1-x2 >=-1);
-  //Nonnegativity of the variables
-  lp.colLowerBound(x1, 0);
-  lp.colLowerBound(x2, 0);
-  //Objective function
-  lp.obj(x1+x2);
-
-  lp.sense(lp.MAX);
-
-  //Testing the problem retrieving routines
-  check(lp.objCoeff(x1)==1,"First term should be 1 in the obj function!");
-  check(lp.sense() == lp.MAX,"This is a maximization!");
-  check(lp.coeff(upright,x1)==1,"The coefficient in question is 1!");
-  check(lp.colLowerBound(x1)==0,
-        "The lower bound for variable x1 should be 0.");
-  check(lp.colUpperBound(x1)==LpSolver::INF,
-        "The upper bound for variable x1 should be infty.");
-  check(lp.rowLowerBound(upright) == -LpSolver::INF,
-        "The lower bound for the first row should be -infty.");
-  check(lp.rowUpperBound(upright)==1,
-        "The upper bound for the first row should be 1.");
-  LpSolver::Expr e = lp.row(upright);
-  check(e[x1] == 1, "The first coefficient should 1.");
-  check(e[x2] == 2, "The second coefficient should 1.");
-
-  lp.row(upright, x1+x2 <=1);
-  e = lp.row(upright);
-  check(e[x1] == 1, "The first coefficient should 1.");
-  check(e[x2] == 1, "The second coefficient should 1.");
-
-  LpSolver::DualExpr de = lp.col(x1);
-  check(  de[upright] == 1, "The first coefficient should 1.");
-
-  LpSolver* clp = lp.cloneSolver();
-
-  //Testing the problem retrieving routines
-  check(clp->objCoeff(x1)==1,"First term should be 1 in the obj function!");
-  check(clp->sense() == clp->MAX,"This is a maximization!");
-  check(clp->coeff(upright,x1)==1,"The coefficient in question is 1!");
-  //  std::cout<<lp.colLowerBound(x1)<<std::endl;
-  check(clp->colLowerBound(x1)==0,
-        "The lower bound for variable x1 should be 0.");
-  check(clp->colUpperBound(x1)==LpSolver::INF,
-        "The upper bound for variable x1 should be infty.");
-
-  check(lp.rowLowerBound(upright)==-LpSolver::INF,
-        "The lower bound for the first row should be -infty.");
-  check(lp.rowUpperBound(upright)==1,
-        "The upper bound for the first row should be 1.");
-  e = clp->row(upright);
-  check(e[x1] == 1, "The first coefficient should 1.");
-  check(e[x2] == 1, "The second coefficient should 1.");
-
-  de = clp->col(x1);
-  check(de[upright] == 1, "The first coefficient should 1.");
-
-  delete clp;
-
-  //Maximization of x1+x2
-  //over the triangle with vertices (0,0) (0,1) (1,0)
-  double expected_opt=1;
-  solveAndCheck(lp, LpSolver::OPTIMAL, expected_opt);
-
-  //Minimization
-  lp.sense(lp.MIN);
-  expected_opt=0;
-  solveAndCheck(lp, LpSolver::OPTIMAL, expected_opt);
-
-  //Vertex (-1,0) instead of (0,0)
-  lp.colLowerBound(x1, -LpSolver::INF);
-  expected_opt=-1;
-  solveAndCheck(lp, LpSolver::OPTIMAL, expected_opt);
-
-  //Erase one constraint and return to maximization
-  lp.erase(upright);
-  lp.sense(lp.MAX);
-  expected_opt=LpSolver::INF;
-  solveAndCheck(lp, LpSolver::UNBOUNDED, expected_opt);
-
-  //Infeasibilty
-  lp.addRow(x1+x2 <=-2);
-  solveAndCheck(lp, LpSolver::INFEASIBLE, expected_opt);
-
-}
-
-template<class LP>
-void cloneTest()
-{
-  //Test for clone/new
-
-  LP* lp = new LP();
-  LP* lpnew = lp->newSolver();
-  LP* lpclone = lp->cloneSolver();
-  delete lp;
-  delete lpnew;
-  delete lpclone;
-}
-
-int main()
-{
-  LpSkeleton lp_skel;
-  lpTest(lp_skel);
-
-#ifdef LEMON_HAVE_GLPK
-  {
-    GlpkLp lp_glpk1,lp_glpk2;
-    lpTest(lp_glpk1);
-    aTest(lp_glpk2);
-    cloneTest<GlpkLp>();
-  }
-#endif
-
-#ifdef LEMON_HAVE_CPLEX
-  try {
-    CplexLp lp_cplex1,lp_cplex2;
-    lpTest(lp_cplex1);
-    aTest(lp_cplex2);
-    cloneTest<CplexLp>();
-  } catch (CplexEnv::LicenseError& error) {
-    check(false, error.what());
-  }
-#endif
-
-#ifdef LEMON_HAVE_SOPLEX
-  {
-    SoplexLp lp_soplex1,lp_soplex2;
-    lpTest(lp_soplex1);
-    aTest(lp_soplex2);
-    cloneTest<SoplexLp>();
-  }
-#endif
-
-#ifdef LEMON_HAVE_CLP
-  {
-    ClpLp lp_clp1,lp_clp2;
-    lpTest(lp_clp1);
-    aTest(lp_clp2);
-    cloneTest<ClpLp>();
-  }
-#endif
-
-  return 0;
-}
Index: test/maps_test.cc
===================================================================
--- test/maps_test.cc	(revision 956)
+++ test/maps_test.cc	(revision 210)
@@ -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).
@@ -23,9 +23,4 @@
 #include <lemon/concepts/maps.h>
 #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 +34,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 +52,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;
@@ -197,5 +171,5 @@
     typedef ComposeMap<DoubleMap, ReadMap<B,A> > CompMap;
     checkConcept<ReadMap<B,double>, CompMap>();
-    CompMap map1 = CompMap(DoubleMap(),ReadMap<B,A>());
+    CompMap map1(DoubleMap(),ReadMap<B,A>());
     CompMap map2 = composeMap(DoubleMap(), ReadMap<B,A>());
 
@@ -210,5 +184,5 @@
     typedef CombineMap<DoubleMap, DoubleMap, std::plus<double> > CombMap;
     checkConcept<ReadMap<A,double>, CombMap>();
-    CombMap map1 = CombMap(DoubleMap(), DoubleMap());
+    CombMap map1(DoubleMap(), DoubleMap());
     CombMap map2 = combineMap(DoubleMap(), DoubleMap(), std::plus<double>());
 
@@ -222,10 +196,9 @@
     checkConcept<ReadMap<A,B>, FunctorToMap<F> >();
     FunctorToMap<F> map1;
-    FunctorToMap<F> map2 = FunctorToMap<F>(F());
+    FunctorToMap<F> map2(F());
     B b = functorToMap(F())[A()];
 
     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(ReadMap<A,B>());
 
     check(functorToMap(&func)[A()] == 3,
@@ -356,8 +329,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,620 +348,4 @@
           it != map2.end(); ++it )
       check(v1[i++] == *it, "Something is wrong with LoggerBoolMap");
-
-    typedef ListDigraph Graph;
-    DIGRAPH_TYPEDEFS(Graph);
-    Graph 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');
-
-    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");
-    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();
-    check(*it++ == 'A' && *it++ == 'B' && *it++ == 'C' &&
-          it == map.endValue(), "Wrong value iterator");
-  }
-
-  // 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;
-    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;
-    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;
-    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()");
   }
 
Index: st/matching_test.cc
===================================================================
--- test/matching_test.cc	(revision 956)
+++ 	(revision )
@@ -1,448 +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/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 = 3;
-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",
-};
-
-void checkMaxMatchingCompile()
-{
-  typedef concepts::Graph Graph;
-  typedef Graph::Node Node;
-  typedef Graph::Edge Edge;
-  typedef Graph::EdgeMap<bool> MatMap;
-
-  Graph g;
-  Node n;
-  Edge e;
-  MatMap mat(g);
-
-  MaxMatching<Graph> mat_test(g);
-  const MaxMatching<Graph>&
-    const_mat_test = mat_test;
-
-  mat_test.init();
-  mat_test.greedyInit();
-  mat_test.matchingInit(mat);
-  mat_test.startSparse();
-  mat_test.startDense();
-  mat_test.run();
-
-  const_mat_test.matchingSize();
-  const_mat_test.matching(e);
-  const_mat_test.matching(n);
-  const MaxMatching<Graph>::MatchingMap& mmap =
-    const_mat_test.matchingMap();
-  e = mmap[n];
-  const_mat_test.mate(n);
-
-  MaxMatching<Graph>::Status stat =
-    const_mat_test.status(n);
-  const MaxMatching<Graph>::StatusMap& smap =
-    const_mat_test.statusMap();
-  stat = smap[n];
-  const_mat_test.barrier(n);
-}
-
-void checkMaxWeightedMatchingCompile()
-{
-  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);
-
-  MaxWeightedMatching<Graph> mat_test(g, w);
-  const MaxWeightedMatching<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 MaxWeightedMatching<Graph>::MatchingMap& mmap =
-    const_mat_test.matchingMap();
-  e = mmap[n];
-  const_mat_test.mate(n);
-
-  int k = 0;
-  const_mat_test.dualValue();
-  const_mat_test.nodeValue(n);
-  const_mat_test.blossomNum();
-  const_mat_test.blossomSize(k);
-  const_mat_test.blossomValue(k);
-}
-
-void checkMaxWeightedPerfectMatchingCompile()
-{
-  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);
-
-  MaxWeightedPerfectMatching<Graph> mat_test(g, w);
-  const MaxWeightedPerfectMatching<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 MaxWeightedPerfectMatching<Graph>::MatchingMap& mmap =
-    const_mat_test.matchingMap();
-  e = mmap[n];
-  const_mat_test.mate(n);
-
-  int k = 0;
-  const_mat_test.dualValue();
-  const_mat_test.nodeValue(n);
-  const_mat_test.blossomNum();
-  const_mat_test.blossomSize(k);
-  const_mat_test.blossomValue(k);
-}
-
-void checkMatching(const SmartGraph& graph,
-                   const MaxMatching<SmartGraph>& mm) {
-  int num = 0;
-
-  IntNodeMap comp_index(graph);
-  UnionFind<IntNodeMap> comp(comp_index);
-
-  int barrier_num = 0;
-
-  for (NodeIt n(graph); n != INVALID; ++n) {
-    check(mm.status(n) == MaxMatching<SmartGraph>::EVEN ||
-          mm.matching(n) != INVALID, "Wrong Gallai-Edmonds decomposition");
-    if (mm.status(n) == MaxMatching<SmartGraph>::ODD) {
-      ++barrier_num;
-    } else {
-      comp.insert(n);
-    }
-  }
-
-  for (EdgeIt e(graph); e != INVALID; ++e) {
-    if (mm.matching(e)) {
-      check(e == mm.matching(graph.u(e)), "Wrong matching");
-      check(e == mm.matching(graph.v(e)), "Wrong matching");
-      ++num;
-    }
-    check(mm.status(graph.u(e)) != MaxMatching<SmartGraph>::EVEN ||
-          mm.status(graph.v(e)) != MaxMatching<SmartGraph>::MATCHED,
-          "Wrong Gallai-Edmonds decomposition");
-
-    check(mm.status(graph.v(e)) != MaxMatching<SmartGraph>::EVEN ||
-          mm.status(graph.u(e)) != MaxMatching<SmartGraph>::MATCHED,
-          "Wrong Gallai-Edmonds decomposition");
-
-    if (mm.status(graph.u(e)) != MaxMatching<SmartGraph>::ODD &&
-        mm.status(graph.v(e)) != MaxMatching<SmartGraph>::ODD) {
-      comp.join(graph.u(e), graph.v(e));
-    }
-  }
-
-  std::set<int> comp_root;
-  int odd_comp_num = 0;
-  for (NodeIt n(graph); n != INVALID; ++n) {
-    if (mm.status(n) != MaxMatching<SmartGraph>::ODD) {
-      int root = comp.find(n);
-      if (comp_root.find(root) == comp_root.end()) {
-        comp_root.insert(root);
-        if (comp.size(n) % 2 == 1) {
-          ++odd_comp_num;
-        }
-      }
-    }
-  }
-
-  check(mm.matchingSize() == num, "Wrong matching");
-  check(2 * num == countNodes(graph) - (odd_comp_num - barrier_num),
-         "Wrong matching");
-  return;
-}
-
-void checkWeightedMatching(const SmartGraph& graph,
-                   const SmartGraph::EdgeMap<int>& weight,
-                   const MaxWeightedMatching<SmartGraph>& mwm) {
-  for (SmartGraph::EdgeIt e(graph); e != INVALID; ++e) {
-    if (graph.u(e) == graph.v(e)) continue;
-    int rw = mwm.nodeValue(graph.u(e)) + mwm.nodeValue(graph.v(e));
-
-    for (int i = 0; i < mwm.blossomNum(); ++i) {
-      bool s = false, t = false;
-      for (MaxWeightedMatching<SmartGraph>::BlossomIt n(mwm, i);
-           n != INVALID; ++n) {
-        if (graph.u(e) == n) s = true;
-        if (graph.v(e) == n) t = true;
-      }
-      if (s == true && t == true) {
-        rw += mwm.blossomValue(i);
-      }
-    }
-    rw -= weight[e] * mwm.dualScale;
-
-    check(rw >= 0, "Negative reduced weight");
-    check(rw == 0 || !mwm.matching(e),
-          "Non-zero reduced weight on matching edge");
-  }
-
-  int pv = 0;
-  for (SmartGraph::NodeIt n(graph); n != INVALID; ++n) {
-    if (mwm.matching(n) != INVALID) {
-      check(mwm.nodeValue(n) >= 0, "Invalid node value");
-      pv += weight[mwm.matching(n)];
-      SmartGraph::Node o = graph.target(mwm.matching(n));
-      check(mwm.mate(n) == o, "Invalid matching");
-      check(mwm.matching(n) == graph.oppositeArc(mwm.matching(o)),
-            "Invalid matching");
-    } else {
-      check(mwm.mate(n) == INVALID, "Invalid matching");
-      check(mwm.nodeValue(n) == 0, "Invalid matching");
-    }
-  }
-
-  int dv = 0;
-  for (SmartGraph::NodeIt n(graph); n != INVALID; ++n) {
-    dv += mwm.nodeValue(n);
-  }
-
-  for (int i = 0; i < mwm.blossomNum(); ++i) {
-    check(mwm.blossomValue(i) >= 0, "Invalid blossom value");
-    check(mwm.blossomSize(i) % 2 == 1, "Even blossom size");
-    dv += mwm.blossomValue(i) * ((mwm.blossomSize(i) - 1) / 2);
-  }
-
-  check(pv * mwm.dualScale == dv * 2, "Wrong duality");
-
-  return;
-}
-
-void checkWeightedPerfectMatching(const SmartGraph& graph,
-                          const SmartGraph::EdgeMap<int>& weight,
-                          const MaxWeightedPerfectMatching<SmartGraph>& mwpm) {
-  for (SmartGraph::EdgeIt e(graph); e != INVALID; ++e) {
-    if (graph.u(e) == graph.v(e)) continue;
-    int rw = mwpm.nodeValue(graph.u(e)) + mwpm.nodeValue(graph.v(e));
-
-    for (int i = 0; i < mwpm.blossomNum(); ++i) {
-      bool s = false, t = false;
-      for (MaxWeightedPerfectMatching<SmartGraph>::BlossomIt n(mwpm, i);
-           n != INVALID; ++n) {
-        if (graph.u(e) == n) s = true;
-        if (graph.v(e) == n) t = true;
-      }
-      if (s == true && t == true) {
-        rw += mwpm.blossomValue(i);
-      }
-    }
-    rw -= weight[e] * mwpm.dualScale;
-
-    check(rw >= 0, "Negative reduced weight");
-    check(rw == 0 || !mwpm.matching(e),
-          "Non-zero reduced weight on matching edge");
-  }
-
-  int pv = 0;
-  for (SmartGraph::NodeIt n(graph); n != INVALID; ++n) {
-    check(mwpm.matching(n) != INVALID, "Non perfect");
-    pv += weight[mwpm.matching(n)];
-    SmartGraph::Node o = graph.target(mwpm.matching(n));
-    check(mwpm.mate(n) == o, "Invalid matching");
-    check(mwpm.matching(n) == graph.oppositeArc(mwpm.matching(o)),
-          "Invalid matching");
-  }
-
-  int dv = 0;
-  for (SmartGraph::NodeIt n(graph); n != INVALID; ++n) {
-    dv += mwpm.nodeValue(n);
-  }
-
-  for (int i = 0; i < mwpm.blossomNum(); ++i) {
-    check(mwpm.blossomValue(i) >= 0, "Invalid blossom value");
-    check(mwpm.blossomSize(i) % 2 == 1, "Even blossom size");
-    dv += mwpm.blossomValue(i) * ((mwpm.blossomSize(i) - 1) / 2);
-  }
-
-  check(pv * mwpm.dualScale == dv * 2, "Wrong duality");
-
-  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;
-    {
-      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);
-      }
-    }
-  }
-
-  return 0;
-}
Index: st/min_cost_arborescence_test.cc
===================================================================
--- test/min_cost_arborescence_test.cc	(revision 956)
+++ 	(revision )
@@ -1,206 +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 <set>
-#include <vector>
-#include <iterator>
-
-#include <lemon/smart_graph.h>
-#include <lemon/min_cost_arborescence.h>
-#include <lemon/lgf_reader.h>
-#include <lemon/concepts/digraph.h>
-
-#include "test_tools.h"
-
-using namespace lemon;
-using namespace std;
-
-const char test_lgf[] =
-  "@nodes\n"
-  "label\n"
-  "0\n"
-  "1\n"
-  "2\n"
-  "3\n"
-  "4\n"
-  "5\n"
-  "6\n"
-  "7\n"
-  "8\n"
-  "9\n"
-  "@arcs\n"
-  "     label  cost\n"
-  "1 8  0      107\n"
-  "0 3  1      70\n"
-  "2 1  2      46\n"
-  "4 1  3      28\n"
-  "4 4  4      91\n"
-  "3 9  5      76\n"
-  "9 8  6      61\n"
-  "8 1  7      39\n"
-  "9 8  8      74\n"
-  "8 0  9      39\n"
-  "4 3  10     45\n"
-  "2 2  11     34\n"
-  "0 1  12     100\n"
-  "6 3  13     95\n"
-  "4 1  14     22\n"
-  "1 1  15     31\n"
-  "7 2  16     51\n"
-  "2 6  17     29\n"
-  "8 3  18     115\n"
-  "6 9  19     32\n"
-  "1 1  20     60\n"
-  "0 3  21     40\n"
-  "@attributes\n"
-  "source 0\n";
-
-
-void checkMinCostArborescenceCompile()
-{
-  typedef double VType;
-  typedef concepts::Digraph Digraph;
-  typedef concepts::ReadMap<Digraph::Arc, VType> CostMap;
-  typedef Digraph::Node Node;
-  typedef Digraph::Arc Arc;
-  typedef concepts::WriteMap<Digraph::Arc, bool> ArbMap;
-  typedef concepts::ReadWriteMap<Digraph::Node, Digraph::Arc> PredMap;
-
-  typedef MinCostArborescence<Digraph, CostMap>::
-            SetArborescenceMap<ArbMap>::
-            SetPredMap<PredMap>::Create MinCostArbType;
-
-  Digraph g;
-  Node s, n;
-  Arc e;
-  VType c;
-  bool b;
-  int i;
-  CostMap cost;
-  ArbMap arb;
-  PredMap pred;
-
-  MinCostArbType mcarb_test(g, cost);
-  const MinCostArbType& const_mcarb_test = mcarb_test;
-
-  mcarb_test
-    .arborescenceMap(arb)
-    .predMap(pred)
-    .run(s);
-
-  mcarb_test.init();
-  mcarb_test.addSource(s);
-  mcarb_test.start();
-  n = mcarb_test.processNextNode();
-  b = const_mcarb_test.emptyQueue();
-  i = const_mcarb_test.queueSize();
-
-  c = const_mcarb_test.arborescenceCost();
-  b = const_mcarb_test.arborescence(e);
-  e = const_mcarb_test.pred(n);
-  const MinCostArbType::ArborescenceMap &am =
-    const_mcarb_test.arborescenceMap();
-  const MinCostArbType::PredMap &pm =
-    const_mcarb_test.predMap();
-  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);
-}
-
-int main() {
-  typedef SmartDigraph Digraph;
-  DIGRAPH_TYPEDEFS(Digraph);
-
-  typedef Digraph::ArcMap<double> CostMap;
-
-  Digraph digraph;
-  CostMap cost(digraph);
-  Node source;
-
-  std::istringstream is(test_lgf);
-  digraphReader(digraph, is).
-    arcMap("cost", cost).
-    node("source", source).run();
-
-  MinCostArborescence<Digraph, CostMap> mca(digraph, cost);
-  mca.run(source);
-
-  vector<pair<double, set<Node> > > dualSolution(mca.dualNum());
-
-  for (int i = 0; i < mca.dualNum(); ++i) {
-    dualSolution[i].first = mca.dualValue(i);
-    for (MinCostArborescence<Digraph, CostMap>::DualIt it(mca, i);
-         it != INVALID; ++it) {
-      dualSolution[i].second.insert(it);
-    }
-  }
-
-  for (ArcIt it(digraph); it != INVALID; ++it) {
-    if (mca.reached(digraph.source(it))) {
-      double sum = 0.0;
-      for (int i = 0; i < int(dualSolution.size()); ++i) {
-        if (dualSolution[i].second.find(digraph.target(it))
-            != dualSolution[i].second.end() &&
-            dualSolution[i].second.find(digraph.source(it))
-            == dualSolution[i].second.end()) {
-          sum += dualSolution[i].first;
-        }
-      }
-      if (mca.arborescence(it)) {
-        check(sum == cost[it], "Invalid dual solution");
-      }
-      check(sum <= cost[it], "Invalid dual solution");
-    }
-  }
-
-
-  check(mca.dualValue() == mca.arborescenceCost(), "Invalid dual solution");
-
-  check(mca.reached(source), "Invalid arborescence");
-  for (ArcIt a(digraph); a != INVALID; ++a) {
-    check(!mca.reached(digraph.source(a)) ||
-          mca.reached(digraph.target(a)), "Invalid arborescence");
-  }
-
-  for (NodeIt n(digraph); n != INVALID; ++n) {
-    if (!mca.reached(n)) continue;
-    int cnt = 0;
-    for (InArcIt a(digraph, n); a != INVALID; ++a) {
-      if (mca.arborescence(a)) {
-        check(mca.pred(n) == a, "Invalid arborescence");
-        ++cnt;
-      }
-    }
-    check((n == source ? cnt == 0 : cnt == 1), "Invalid arborescence");
-  }
-
-  Digraph::ArcMap<bool> arborescence(digraph);
-  check(mca.arborescenceCost() ==
-        minCostArborescence(digraph, cost, source, arborescence),
-        "Wrong result of the function interface");
-
-  return 0;
-}
Index: st/min_cost_flow_test.cc
===================================================================
--- test/min_cost_flow_test.cc	(revision 956)
+++ 	(revision )
@@ -1,542 +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 <fstream>
-#include <limits>
-
-#include <lemon/list_graph.h>
-#include <lemon/lgf_reader.h>
-
-#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>
-
-#include "test_tools.h"
-
-using namespace lemon;
-
-// Test networks
-char test_lgf[] =
-  "@nodes\n"
-  "label  sup1 sup2 sup3 sup4 sup5 sup6\n"
-  "    1    20   27    0   30   20   30\n"
-  "    2    -4    0    0    0   -8   -3\n"
-  "    3     0    0    0    0    0    0\n"
-  "    4     0    0    0    0    0    0\n"
-  "    5     9    0    0    0    6   11\n"
-  "    6    -6    0    0    0   -5   -6\n"
-  "    7     0    0    0    0    0    0\n"
-  "    8     0    0    0    0    0    3\n"
-  "    9     3    0    0    0    0    0\n"
-  "   10    -2    0    0    0   -7   -2\n"
-  "   11     0    0    0    0  -10    0\n"
-  "   12   -20  -27    0  -30  -30  -20\n"
-  "\n"
-  "@arcs\n"
-  "       cost  cap low1 low2 low3\n"
-  " 1  2    70   11    0    8    8\n"
-  " 1  3   150    3    0    1    0\n"
-  " 1  4    80   15    0    2    2\n"
-  " 2  8    80   12    0    0    0\n"
-  " 3  5   140    5    0    3    1\n"
-  " 4  6    60   10    0    1    0\n"
-  " 4  7    80    2    0    0    0\n"
-  " 4  8   110    3    0    0    0\n"
-  " 5  7    60   14    0    0    0\n"
-  " 5 11   120   12    0    0    0\n"
-  " 6  3     0    3    0    0    0\n"
-  " 6  9   140    4    0    0    0\n"
-  " 6 10    90    8    0    0    0\n"
-  " 7  1    30    5    0    0   -5\n"
-  " 8 12    60   16    0    4    3\n"
-  " 9 12    50    6    0    0    0\n"
-  "10 12    70   13    0    5    2\n"
-  "10  2   100    7    0    0    0\n"
-  "10  7    60   10    0    0   -3\n"
-  "11 10    20   14    0    6  -20\n"
-  "12 11    30   10    0    0  -10\n"
-  "\n"
-  "@attributes\n"
-  "source 1\n"
-  "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 {
-  EQ,
-  GEQ,
-  LEQ
-};
-
-
-// Check the interface of an MCF algorithm
-template <typename GR, typename Value, typename Cost>
-class McfClassConcept
-{
-public:
-
-  template <typename MCF>
-  struct Constraints {
-    void constraints() {
-      checkConcept<concepts::Digraph, GR>();
-
-      const Constraints& me = *this;
-
-      MCF mcf(me.g);
-      const MCF& const_mcf = mcf;
-
-      b = mcf.reset().resetParams()
-             .lowerMap(me.lower)
-             .upperMap(me.upper)
-             .costMap(me.cost)
-             .supplyMap(me.sup)
-             .stSupply(me.n, me.n, me.k)
-             .run();
-
-      c = const_mcf.totalCost();
-      x = const_mcf.template totalCost<double>();
-      v = const_mcf.flow(me.a);
-      c = const_mcf.potential(me.n);
-      const_mcf.flowMap(fm);
-      const_mcf.potentialMap(pm);
-    }
-
-    typedef typename GR::Node Node;
-    typedef typename GR::Arc Arc;
-    typedef concepts::ReadMap<Node, Value> NM;
-    typedef concepts::ReadMap<Arc, Value> VAM;
-    typedef concepts::ReadMap<Arc, Cost> CAM;
-    typedef concepts::WriteMap<Arc, Value> FlowMap;
-    typedef concepts::WriteMap<Node, Cost> PotMap;
-
-    GR g;
-    VAM lower;
-    VAM upper;
-    CAM cost;
-    NM sup;
-    Node n;
-    Arc a;
-    Value k;
-
-    FlowMap fm;
-    PotMap pm;
-    bool b;
-    double x;
-    typename MCF::Value v;
-    typename MCF::Cost c;
-  };
-
-};
-
-
-// Check the feasibility of the given flow (primal soluiton)
-template < typename GR, typename LM, typename UM,
-           typename SM, typename FM >
-bool checkFlow( const GR& gr, const LM& lower, const UM& upper,
-                const SM& supply, const FM& flow,
-                SupplyType type = EQ )
-{
-  TEMPLATE_DIGRAPH_TYPEDEFS(GR);
-
-  for (ArcIt e(gr); e != INVALID; ++e) {
-    if (flow[e] < lower[e] || flow[e] > upper[e]) return false;
-  }
-
-  for (NodeIt n(gr); n != INVALID; ++n) {
-    typename SM::Value sum = 0;
-    for (OutArcIt e(gr, n); e != INVALID; ++e)
-      sum += flow[e];
-    for (InArcIt e(gr, n); e != INVALID; ++e)
-      sum -= flow[e];
-    bool b = (type ==  EQ && sum == supply[n]) ||
-             (type == GEQ && sum >= supply[n]) ||
-             (type == LEQ && sum <= supply[n]);
-    if (!b) return false;
-  }
-
-  return true;
-}
-
-// Check the feasibility of the given potentials (dual soluiton)
-// using the "Complementary Slackness" optimality condition
-template < typename GR, typename LM, typename UM,
-           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 PM& pi, SupplyType type )
-{
-  TEMPLATE_DIGRAPH_TYPEDEFS(GR);
-
-  bool opt = true;
-  for (ArcIt e(gr); opt && e != INVALID; ++e) {
-    typename CM::Value red_cost =
-      cost[e] + pi[gr.source(e)] - pi[gr.target(e)];
-    opt = red_cost == 0 ||
-          (red_cost > 0 && flow[e] == lower[e]) ||
-          (red_cost < 0 && flow[e] == upper[e]);
-  }
-
-  for (NodeIt n(gr); opt && n != INVALID; ++n) {
-    typename SM::Value sum = 0;
-    for (OutArcIt e(gr, n); e != INVALID; ++e)
-      sum += flow[e];
-    for (InArcIt e(gr, n); e != INVALID; ++e)
-      sum -= flow[e];
-    if (type != LEQ) {
-      opt = (pi[n] <= 0) && (sum == supply[n] || pi[n] == 0);
-    } else {
-      opt = (pi[n] >= 0) && (sum == supply[n] || pi[n] == 0);
-    }
-  }
-
-  return opt;
-}
-
-// Check whether the dual cost is equal to the primal cost
-template < typename GR, typename LM, typename UM,
-           typename CM, typename SM, typename PM >
-bool checkDualCost( const GR& gr, const LM& lower, const UM& upper,
-                    const CM& cost, const SM& supply, const PM& pi,
-                    typename CM::Value total )
-{
-  TEMPLATE_DIGRAPH_TYPEDEFS(GR);
-
-  typename CM::Value dual_cost = 0;
-  SM red_supply(gr);
-  for (NodeIt n(gr); n != INVALID; ++n) {
-    red_supply[n] = supply[n];
-  }
-  for (ArcIt a(gr); a != INVALID; ++a) {
-    if (lower[a] != 0) {
-      dual_cost += lower[a] * cost[a];
-      red_supply[gr.source(a)] -= lower[a];
-      red_supply[gr.target(a)] += lower[a];
-    }
-  }
-
-  for (NodeIt n(gr); n != INVALID; ++n) {
-    dual_cost -= red_supply[n] * pi[n];
-  }
-  for (ArcIt a(gr); a != INVALID; ++a) {
-    typename CM::Value red_cost =
-      cost[a] + pi[gr.source(a)] - pi[gr.target(a)];
-    dual_cost -= (upper[a] - lower[a]) * std::max(-red_cost, 0);
-  }
-
-  return dual_cost == total;
-}
-
-// Run a minimum cost flow algorithm and check the results
-template < typename MCF, typename GR,
-           typename LM, typename UM,
-           typename CM, typename SM,
-           typename PT >
-void checkMcf( const MCF& mcf, PT mcf_result,
-               const GR& gr, const LM& lower, const UM& upper,
-               const CM& cost, const SM& supply,
-               PT result, bool optimal, typename CM::Value total,
-               const std::string &test_id = "",
-               SupplyType type = EQ )
-{
-  check(mcf_result == result, "Wrong result " + test_id);
-  if (optimal) {
-    typename GR::template ArcMap<typename SM::Value> flow(gr);
-    typename GR::template NodeMap<typename CM::Value> pi(gr);
-    mcf.flowMap(flow);
-    mcf.potentialMap(pi);
-    check(checkFlow(gr, lower, upper, supply, flow, type),
-          "The flow is not feasible " + test_id);
-    check(mcf.totalCost() == total, "The flow is not optimal " + test_id);
-    check(checkPotential(gr, lower, upper, cost, supply, flow, pi, type),
-          "Wrong potentials " + test_id);
-    check(checkDualCost(gr, lower, upper, cost, supply, pi, total),
-          "Wrong dual cost " + test_id);
-  }
-}
-
-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
-  std::istringstream input(test_lgf);
-  DigraphReader<Digraph>(gr, input)
-    .arcMap("cost", c)
-    .arcMap("cap", u)
-    .arcMap("low1", l1)
-    .arcMap("low2", l2)
-    .arcMap("low3", l3)
-    .nodeMap("sup1", s1)
-    .nodeMap("sup2", s2)
-    .nodeMap("sup3", s3)
-    .nodeMap("sup4", s4)
-    .nodeMap("sup5", s5)
-    .nodeMap("sup6", s6)
-    .node("source", v)
-    .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
-  {
-    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
-  {
-    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");
-  }
-
-  return 0;
-}
Index: st/min_mean_cycle_test.cc
===================================================================
--- test/min_mean_cycle_test.cc	(revision 956)
+++ 	(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/mip_test.cc
===================================================================
--- test/mip_test.cc	(revision 795)
+++ 	(revision )
@@ -1,159 +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 "test_tools.h"
-
-#include <lemon/config.h>
-
-#ifdef LEMON_HAVE_CPLEX
-#include <lemon/cplex.h>
-#endif
-
-#ifdef LEMON_HAVE_GLPK
-#include <lemon/glpk.h>
-#endif
-
-#ifdef LEMON_HAVE_CBC
-#include <lemon/cbc.h>
-#endif
-
-
-using namespace lemon;
-
-void solveAndCheck(MipSolver& mip, MipSolver::ProblemType stat,
-                   double exp_opt) {
-  using std::string;
-
-  mip.solve();
-  //int decimal,sign;
-  std::ostringstream buf;
-  buf << "Type should be: " << int(stat)<<" and it is "<<int(mip.type());
-
-
-  //  itoa(stat,buf1, 10);
-  check(mip.type()==stat, buf.str());
-
-  if (stat ==  MipSolver::OPTIMAL) {
-    std::ostringstream sbuf;
-    sbuf << "Wrong optimal value ("<< mip.solValue()
-         <<" instead of " << exp_opt << ")";
-    check(std::abs(mip.solValue()-exp_opt) < 1e-3, sbuf.str());
-    //+ecvt(exp_opt,2)
-  }
-}
-
-void aTest(MipSolver& mip)
-{
-  //The following example is very simple
-
-
-  typedef MipSolver::Row Row;
-  typedef MipSolver::Col Col;
-
-
-  Col x1 = mip.addCol();
-  Col x2 = mip.addCol();
-
-
-  //Objective function
-  mip.obj(x1);
-
-  mip.max();
-
-  //Unconstrained optimization
-  mip.solve();
-  //Check it out!
-
-  //Constraints
-  mip.addRow(2 * x1 + x2 <= 2);
-  Row y2 = mip.addRow(x1 - 2 * x2 <= 0);
-
-  //Nonnegativity of the variable x1
-  mip.colLowerBound(x1, 0);
-
-
-  //Maximization of x1
-  //over the triangle with vertices (0,0),(4/5,2/5),(0,2)
-  double expected_opt=4.0/5.0;
-  solveAndCheck(mip, MipSolver::OPTIMAL, expected_opt);
-
-
-  //Restrict x2 to integer
-  mip.colType(x2,MipSolver::INTEGER);
-  expected_opt=1.0/2.0;
-  solveAndCheck(mip, MipSolver::OPTIMAL, expected_opt);
-
-
-  //Restrict both to integer
-  mip.colType(x1,MipSolver::INTEGER);
-  expected_opt=0;
-  solveAndCheck(mip, MipSolver::OPTIMAL, expected_opt);
-
-  //Erase a variable
-  mip.erase(x2);
-  mip.rowUpperBound(y2, 8);
-  expected_opt=1;
-  solveAndCheck(mip, MipSolver::OPTIMAL, expected_opt);
-
-}
-
-
-template<class MIP>
-void cloneTest()
-{
-
-  MIP* mip = new MIP();
-  MIP* mipnew = mip->newSolver();
-  MIP* mipclone = mip->cloneSolver();
-  delete mip;
-  delete mipnew;
-  delete mipclone;
-}
-
-int main()
-{
-
-#ifdef LEMON_HAVE_GLPK
-  {
-    GlpkMip mip1;
-    aTest(mip1);
-    cloneTest<GlpkMip>();
-  }
-#endif
-
-#ifdef LEMON_HAVE_CPLEX
-  try {
-    CplexMip mip2;
-    aTest(mip2);
-    cloneTest<CplexMip>();
-  } catch (CplexEnv::LicenseError& error) {
-    check(false, error.what());
-  }
-#endif
-
-#ifdef LEMON_HAVE_CBC
-  {
-    CbcMip mip1;
-    aTest(mip1);
-    cloneTest<CbcMip>();
-  }
-#endif
-
-  return 0;
-
-}
Index: test/path_test.cc
===================================================================
--- test/path_test.cc	(revision 463)
+++ test/path_test.cc	(revision 209)
@@ -3,5 +3,5 @@
  * This file is a part of LEMON, a generic C++ optimization library.
  *
- * Copyright (C) 2003-2009
+ * Copyright (C) 2003-2008
  * Egervary Jeno Kombinatorikus Optimalizalasi Kutatocsoport
  * (Egervary Research Group on Combinatorial Optimization, EGRES).
Index: st/planarity_test.cc
===================================================================
--- test/planarity_test.cc	(revision 862)
+++ 	(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: st/preflow_test.cc
===================================================================
--- test/preflow_test.cc	(revision 956)
+++ 	(revision )
@@ -1,250 +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/preflow.h>
-#include <lemon/concepts/digraph.h>
-#include <lemon/concepts/maps.h>
-#include <lemon/lgf_reader.h>
-#include <lemon/elevator.h>
-
-using namespace lemon;
-
-char test_lgf[] =
-  "@nodes\n"
-  "label\n"
-  "0\n"
-  "1\n"
-  "2\n"
-  "3\n"
-  "4\n"
-  "5\n"
-  "6\n"
-  "7\n"
-  "8\n"
-  "9\n"
-  "@arcs\n"
-  "    label capacity\n"
-  "0 1 0     20\n"
-  "0 2 1     0\n"
-  "1 1 2     3\n"
-  "1 2 3     8\n"
-  "1 3 4     8\n"
-  "2 5 5     5\n"
-  "3 2 6     5\n"
-  "3 5 7     5\n"
-  "3 6 8     5\n"
-  "4 3 9     3\n"
-  "5 7 10    3\n"
-  "5 6 11    10\n"
-  "5 8 12    10\n"
-  "6 8 13    8\n"
-  "8 9 14    20\n"
-  "8 1 15    5\n"
-  "9 5 16    5\n"
-  "@attributes\n"
-  "source 1\n"
-  "target 8\n";
-
-void checkPreflowCompile()
-{
-  typedef int VType;
-  typedef concepts::Digraph Digraph;
-
-  typedef Digraph::Node Node;
-  typedef Digraph::Arc Arc;
-  typedef concepts::ReadMap<Arc,VType> CapMap;
-  typedef concepts::ReadWriteMap<Arc,VType> FlowMap;
-  typedef concepts::WriteMap<Node,bool> CutMap;
-
-  typedef Elevator<Digraph, Digraph::Node> Elev;
-  typedef LinkedElevator<Digraph, Digraph::Node> LinkedElev;
-
-  Digraph g;
-  Node n;
-  Arc e;
-  CapMap cap;
-  FlowMap flow;
-  CutMap cut;
-  VType v;
-  bool b;
-
-  typedef Preflow<Digraph, CapMap>
-            ::SetFlowMap<FlowMap>
-            ::SetElevator<Elev>
-            ::SetStandardElevator<LinkedElev>
-            ::Create PreflowType;
-  PreflowType preflow_test(g, cap, n, n);
-  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)
-    .flowMap(flow)
-    .source(n)
-    .target(n);
-
-  preflow_test.init();
-  preflow_test.init(cap);
-  preflow_test.startFirstPhase();
-  preflow_test.startSecondPhase();
-  preflow_test.run();
-  preflow_test.runMinCut();
-
-  v = const_preflow_test.flowValue();
-  v = const_preflow_test.flow(e);
-  const FlowMap& fm = const_preflow_test.flowMap();
-  b = const_preflow_test.minCut(n);
-  const_preflow_test.minCutMap(cut);
-
-  ignore_unused_variable_warning(fm);
-}
-
-int cutValue (const SmartDigraph& g,
-              const SmartDigraph::NodeMap<bool>& cut,
-              const SmartDigraph::ArcMap<int>& cap) {
-
-  int c=0;
-  for(SmartDigraph::ArcIt e(g); e!=INVALID; ++e) {
-    if (cut[g.source(e)] && !cut[g.target(e)]) c+=cap[e];
-  }
-  return c;
-}
-
-bool checkFlow(const SmartDigraph& g,
-               const SmartDigraph::ArcMap<int>& flow,
-               const SmartDigraph::ArcMap<int>& cap,
-               SmartDigraph::Node s, SmartDigraph::Node t) {
-
-  for (SmartDigraph::ArcIt e(g); e != INVALID; ++e) {
-    if (flow[e] < 0 || flow[e] > cap[e]) return false;
-  }
-
-  for (SmartDigraph::NodeIt n(g); n != INVALID; ++n) {
-    if (n == s || n == t) continue;
-    int sum = 0;
-    for (SmartDigraph::OutArcIt e(g, n); e != INVALID; ++e) {
-      sum += flow[e];
-    }
-    for (SmartDigraph::InArcIt e(g, n); e != INVALID; ++e) {
-      sum -= flow[e];
-    }
-    if (sum != 0) return false;
-  }
-  return true;
-}
-
-int main() {
-
-  typedef SmartDigraph Digraph;
-
-  typedef Digraph::Node Node;
-  typedef Digraph::NodeIt NodeIt;
-  typedef Digraph::ArcIt ArcIt;
-  typedef Digraph::ArcMap<int> CapMap;
-  typedef Digraph::ArcMap<int> FlowMap;
-  typedef Digraph::NodeMap<bool> CutMap;
-
-  typedef Preflow<Digraph, CapMap> PType;
-
-  Digraph g;
-  Node s, t;
-  CapMap cap(g);
-  std::istringstream input(test_lgf);
-  DigraphReader<Digraph>(g,input).
-    arcMap("capacity", cap).
-    node("source",s).
-    node("target",t).
-    run();
-
-  PType preflow_test(g, cap, s, t);
-  preflow_test.run();
-
-  check(checkFlow(g, preflow_test.flowMap(), cap, s, t),
-        "The flow is not feasible.");
-
-  CutMap min_cut(g);
-  preflow_test.minCutMap(min_cut);
-  int min_cut_value=cutValue(g,min_cut,cap);
-
-  check(preflow_test.flowValue() == min_cut_value,
-        "The max flow value is not equal to the three min cut values.");
-
-  FlowMap flow(g);
-  for(ArcIt e(g); e!=INVALID; ++e) flow[e] = preflow_test.flowMap()[e];
-
-  int flow_value=preflow_test.flowValue();
-
-  for(ArcIt e(g); e!=INVALID; ++e) cap[e]=2*cap[e];
-  preflow_test.init(flow);
-  preflow_test.startFirstPhase();
-
-  CutMap min_cut1(g);
-  preflow_test.minCutMap(min_cut1);
-  min_cut_value=cutValue(g,min_cut1,cap);
-
-  check(preflow_test.flowValue() == min_cut_value &&
-        min_cut_value == 2*flow_value,
-        "The max flow value or the min cut value is wrong.");
-
-  preflow_test.startSecondPhase();
-
-  check(checkFlow(g, preflow_test.flowMap(), cap, s, t),
-        "The flow is not feasible.");
-
-  CutMap min_cut2(g);
-  preflow_test.minCutMap(min_cut2);
-  min_cut_value=cutValue(g,min_cut2,cap);
-
-  check(preflow_test.flowValue() == min_cut_value &&
-        min_cut_value == 2*flow_value,
-        "The max flow value or the three min cut values were not doubled");
-
-
-  preflow_test.flowMap(flow);
-
-  NodeIt tmp1(g,s);
-  ++tmp1;
-  if ( tmp1 != INVALID ) s=tmp1;
-
-  NodeIt tmp2(g,t);
-  ++tmp2;
-  if ( tmp2 != INVALID ) t=tmp2;
-
-  preflow_test.source(s);
-  preflow_test.target(t);
-
-  preflow_test.run();
-
-  CutMap min_cut3(g);
-  preflow_test.minCutMap(min_cut3);
-  min_cut_value=cutValue(g,min_cut3,cap);
-
-
-  check(preflow_test.flowValue() == min_cut_value,
-        "The max flow value or the three min cut values are incorrect.");
-
-  return 0;
-}
Index: st/radix_sort_test.cc
===================================================================
--- test/radix_sort_test.cc	(revision 467)
+++ 	(revision )
@@ -1,147 +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 <lemon/time_measure.h>
-#include <lemon/smart_graph.h>
-#include <lemon/maps.h>
-#include <lemon/radix_sort.h>
-#include <lemon/math.h>
-
-#include "test_tools.h"
-
-#include <vector>
-#include <algorithm>
-
-using namespace lemon;
-
-static const int n = 10000;
-
-struct Negate {
-  typedef int argument_type;
-  typedef int result_type;
-  int operator()(int a) { return - a; }
-};
-
-int negate(int a) { return - a; }
-
-
-void generateIntSequence(int n, std::vector<int>& data) {
-  int prime = 9973;
-  int root = 136, value = 1;
-  for (int i = 0; i < n; ++i) {
-    data.push_back(value - prime / 2);
-    value = (value * root) % prime;
-  }
-}
-
-void generateCharSequence(int n, std::vector<unsigned char>& data) {
-  int prime = 251;
-  int root = 3, value = root;
-  for (int i = 0; i < n; ++i) {
-    data.push_back(static_cast<unsigned char>(value));
-    value = (value * root) % prime;
-  }
-}
-
-void checkRadixSort() {
-  {
-    std::vector<int> data1;
-    generateIntSequence(n, data1);
-
-    std::vector<int> data2(data1);
-    std::sort(data1.begin(), data1.end());
-
-    radixSort(data2.begin(), data2.end());
-    for (int i = 0; i < n; ++i) {
-      check(data1[i] == data2[i], "Test failed");
-    }
-
-    radixSort(data2.begin(), data2.end(), Negate());
-    for (int i = 0; i < n; ++i) {
-      check(data1[i] == data2[n - 1 - i], "Test failed");
-    }
-
-    radixSort(data2.begin(), data2.end(), negate);
-    for (int i = 0; i < n; ++i) {
-      check(data1[i] == data2[n - 1 - i], "Test failed");
-    }
-
-  }
-
-  {
-    std::vector<unsigned char> data1(n);
-    generateCharSequence(n, data1);
-
-    std::vector<unsigned char> data2(data1);
-    std::sort(data1.begin(), data1.end());
-
-    radixSort(data2.begin(), data2.end());
-    for (int i = 0; i < n; ++i) {
-      check(data1[i] == data2[i], "Test failed");
-    }
-
-  }
-}
-
-
-void checkStableRadixSort() {
-  {
-    std::vector<int> data1;
-    generateIntSequence(n, data1);
-
-    std::vector<int> data2(data1);
-    std::sort(data1.begin(), data1.end());
-
-    stableRadixSort(data2.begin(), data2.end());
-    for (int i = 0; i < n; ++i) {
-      check(data1[i] == data2[i], "Test failed");
-    }
-
-    stableRadixSort(data2.begin(), data2.end(), Negate());
-    for (int i = 0; i < n; ++i) {
-      check(data1[i] == data2[n - 1 - i], "Test failed");
-    }
-
-    stableRadixSort(data2.begin(), data2.end(), negate);
-    for (int i = 0; i < n; ++i) {
-      check(data1[i] == data2[n - 1 - i], "Test failed");
-    }
-  }
-
-  {
-    std::vector<unsigned char> data1(n);
-    generateCharSequence(n, data1);
-
-    std::vector<unsigned char> data2(data1);
-    std::sort(data1.begin(), data1.end());
-
-    radixSort(data2.begin(), data2.end());
-    for (int i = 0; i < n; ++i) {
-      check(data1[i] == data2[i], "Test failed");
-    }
-
-  }
-}
-
-int main() {
-
-  checkRadixSort();
-  checkStableRadixSort();
-
-  return 0;
-}
Index: test/random_test.cc
===================================================================
--- test/random_test.cc	(revision 463)
+++ test/random_test.cc	(revision 209)
@@ -3,5 +3,5 @@
  * This file is a part of LEMON, a generic C++ optimization library.
  *
- * Copyright (C) 2003-2009
+ * Copyright (C) 2003-2008
  * Egervary Jeno Kombinatorikus Optimalizalasi Kutatocsoport
  * (Egervary Research Group on Combinatorial Optimization, EGRES).
Index: st/suurballe_test.cc
===================================================================
--- test/suurballe_test.cc	(revision 956)
+++ 	(revision )
@@ -1,265 +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 <lemon/list_graph.h>
-#include <lemon/lgf_reader.h>
-#include <lemon/path.h>
-#include <lemon/suurballe.h>
-#include <lemon/concepts/digraph.h>
-#include <lemon/concepts/heap.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"
-  "8\n"
-  "9\n"
-  "10\n"
-  "11\n"
-  "12\n"
-  "@arcs\n"
-  "      length\n"
-  " 1  2  70\n"
-  " 1  3 150\n"
-  " 1  4  80\n"
-  " 2  8  80\n"
-  " 3  5 140\n"
-  " 4  6  60\n"
-  " 4  7  80\n"
-  " 4  8 110\n"
-  " 5  7  60\n"
-  " 5 11 120\n"
-  " 6  3   0\n"
-  " 6  9 140\n"
-  " 6 10  90\n"
-  " 7  1  30\n"
-  " 8 12  60\n"
-  " 9 12  50\n"
-  "10 12  70\n"
-  "10  2 100\n"
-  "10  7  60\n"
-  "11 10  20\n"
-  "12 11  30\n"
-  "@attributes\n"
-  "source  1\n"
-  "target 12\n"
-  "@end\n";
-
-// Check the interface of Suurballe
-void checkSuurballeCompile()
-{
-  typedef int VType;
-  typedef concepts::Digraph Digraph;
-
-  typedef Digraph::Node Node;
-  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;
-
-  Digraph g;
-  Node n;
-  Arc e;
-  LengthMap len;
-  SuurballeType::FlowMap flow(g);
-  SuurballeType::PotentialMap pi(g);
-
-  SuurballeType suurb_test(g, len);
-  const SuurballeType& const_suurb_test = suurb_test;
-
-  suurb_test
-    .flowMap(flow)
-    .potentialMap(pi);
-
-  int k;
-  k = suurb_test.run(n, n);
-  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;
-  c = const_suurb_test.totalLength();
-  f = const_suurb_test.flow(e);
-  const SuurballeType::FlowMap& fm =
-    const_suurb_test.flowMap();
-  c = const_suurb_test.potential(n);
-  const SuurballeType::PotentialMap& pm =
-    const_suurb_test.potentialMap();
-  k = const_suurb_test.pathNum();
-  Path<Digraph> p = const_suurb_test.path(k);
-
-  ignore_unused_variable_warning(fm);
-  ignore_unused_variable_warning(pm);
-}
-
-// Check the feasibility of the flow
-template <typename Digraph, typename FlowMap>
-bool checkFlow( const Digraph& gr, const FlowMap& flow,
-                typename Digraph::Node s, typename Digraph::Node t,
-                int value )
-{
-  TEMPLATE_DIGRAPH_TYPEDEFS(Digraph);
-  for (ArcIt e(gr); e != INVALID; ++e)
-    if (!(flow[e] == 0 || flow[e] == 1)) return false;
-
-  for (NodeIt n(gr); n != INVALID; ++n) {
-    int sum = 0;
-    for (OutArcIt e(gr, n); e != INVALID; ++e)
-      sum += flow[e];
-    for (InArcIt e(gr, n); e != INVALID; ++e)
-      sum -= flow[e];
-    if (n == s && sum != value) return false;
-    if (n == t && sum != -value) return false;
-    if (n != s && n != t && sum != 0) return false;
-  }
-
-  return true;
-}
-
-// Check the optimalitiy of the flow
-template < typename Digraph, typename CostMap,
-           typename FlowMap, typename PotentialMap >
-bool checkOptimality( const Digraph& gr, const CostMap& cost,
-                      const FlowMap& flow, const PotentialMap& pi )
-{
-  // Check the "Complementary Slackness" optimality condition
-  TEMPLATE_DIGRAPH_TYPEDEFS(Digraph);
-  bool opt = true;
-  for (ArcIt e(gr); e != INVALID; ++e) {
-    typename CostMap::Value red_cost =
-      cost[e] + pi[gr.source(e)] - pi[gr.target(e)];
-    opt = (flow[e] == 0 && red_cost >= 0) ||
-          (flow[e] == 1 && red_cost <= 0);
-    if (!opt) break;
-  }
-  return opt;
-}
-
-// Check a path
-template <typename Digraph, typename Path>
-bool checkPath( const Digraph& gr, const Path& path,
-                typename Digraph::Node s, typename Digraph::Node t)
-{
-  TEMPLATE_DIGRAPH_TYPEDEFS(Digraph);
-  Node n = s;
-  for (int i = 0; i < path.length(); ++i) {
-    if (gr.source(path.nth(i)) != n) return false;
-    n = gr.target(path.nth(i));
-  }
-  return n == t;
-}
-
-
-int main()
-{
-  DIGRAPH_TYPEDEFS(ListDigraph);
-
-  // Read the test digraph
-  ListDigraph digraph;
-  ListDigraph::ArcMap<int> length(digraph);
-  Node s, t;
-
-  std::istringstream input(test_lgf);
-  DigraphReader<ListDigraph>(digraph, input).
-    arcMap("length", length).
-    node("source", s).
-    node("target", t).
-    run();
-
-  // Check run()
-  {
-    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),
-          "The flow is not feasible");
-    check(suurballe.totalLength() == 510, "The flow is not optimal");
-    check(checkOptimality(digraph, length, suurballe.flowMap(),
-                          suurballe.potentialMap()),
-          "Wrong potentials");
-    for (int i = 0; i < suurballe.pathNum(); ++i)
-      check(checkPath(digraph, suurballe.path(i), s, t), "Wrong path");
-
-    // Find 3 paths
-    check(suurballe.run(s, t, 3) == 3, "Wrong number of paths");
-    check(checkFlow(digraph, suurballe.flowMap(), s, t, 3),
-          "The flow is not feasible");
-    check(suurballe.totalLength() == 1040, "The flow is not optimal");
-    check(checkOptimality(digraph, length, suurballe.flowMap(),
-                          suurballe.potentialMap()),
-          "Wrong potentials");
-    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)
-    check(suurballe.run(s, t, 5) == 3, "Wrong number of paths");
-    check(checkFlow(digraph, suurballe.flowMap(), s, t, 3),
-          "The flow is not feasible");
-    check(suurballe.totalLength() == 1040, "The flow is not optimal");
-    check(checkOptimality(digraph, length, suurballe.flowMap(),
-                          suurballe.potentialMap()),
-          "Wrong potentials");
-    for (int i = 0; i < suurballe.pathNum(); ++i)
-      check(checkPath(digraph, suurballe.path(i), s, t), "Wrong path");
-  }
-
-  // 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 956)
+++ test/test_tools.h	(revision 209)
@@ -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).
@@ -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: test/test_tools_fail.cc
===================================================================
--- test/test_tools_fail.cc	(revision 463)
+++ test/test_tools_fail.cc	(revision 209)
@@ -3,5 +3,5 @@
  * This file is a part of LEMON, a generic C++ optimization library.
  *
- * Copyright (C) 2003-2009
+ * Copyright (C) 2003-2008
  * Egervary Jeno Kombinatorikus Optimalizalasi Kutatocsoport
  * (Egervary Research Group on Combinatorial Optimization, EGRES).
Index: test/test_tools_pass.cc
===================================================================
--- test/test_tools_pass.cc	(revision 463)
+++ test/test_tools_pass.cc	(revision 209)
@@ -3,5 +3,5 @@
  * This file is a part of LEMON, a generic C++ optimization library.
  *
- * Copyright (C) 2003-2009
+ * Copyright (C) 2003-2008
  * Egervary Jeno Kombinatorikus Optimalizalasi Kutatocsoport
  * (Egervary Research Group on Combinatorial Optimization, EGRES).
Index: test/time_measure_test.cc
===================================================================
--- test/time_measure_test.cc	(revision 605)
+++ test/time_measure_test.cc	(revision 209)
@@ -3,5 +3,5 @@
  * This file is a part of LEMON, a generic C++ optimization library.
  *
- * Copyright (C) 2003-2009
+ * Copyright (C) 2003-2008
  * Egervary Jeno Kombinatorikus Optimalizalasi Kutatocsoport
  * (Egervary Research Group on Combinatorial Optimization, EGRES).
@@ -40,14 +40,16 @@
   Timer T;
   unsigned int n;
-  for(n=0;T.realTime()<0.1;n++) ;
+  for(n=0;T.realTime()<1.0;n++) ;
   std::cout << T << " (" << n << " time queries)\n";
-
+  T.restart();
+  while(T.realTime()<2.0) ;
+  std::cout << T << '\n';
   TimeStamp full;
   TimeStamp t;
-  t=runningTimeTest(f,0.1,&n,&full);
+  t=runningTimeTest(f,1,&n,&full);
   std::cout << t << " (" << n << " tests)\n";
   std::cout << "Total: " << full << "\n";
 
-  t=runningTimeTest(g,0.1,&n,&full);
+  t=runningTimeTest(g,1,&n,&full);
   std::cout << t << " (" << n << " tests)\n";
   std::cout << "Total: " << full << "\n";
Index: test/unionfind_test.cc
===================================================================
--- test/unionfind_test.cc	(revision 463)
+++ test/unionfind_test.cc	(revision 209)
@@ -3,5 +3,5 @@
  * This file is a part of LEMON, a generic C++ optimization library.
  *
- * Copyright (C) 2003-2009
+ * Copyright (C) 2003-2008
  * Egervary Jeno Kombinatorikus Optimalizalasi Kutatocsoport
  * (Egervary Research Group on Combinatorial Optimization, EGRES).
Index: ols/CMakeLists.txt
===================================================================
--- tools/CMakeLists.txt	(revision 726)
+++ 	(revision )
@@ -1,31 +1,0 @@
-INCLUDE_DIRECTORIES(
-  ${PROJECT_SOURCE_DIR}
-  ${PROJECT_BINARY_DIR}
-)
-
-LINK_DIRECTORIES(
-  ${PROJECT_BINARY_DIR}/lemon
-)
-
-ADD_EXECUTABLE(lgf-gen lgf-gen.cc)
-TARGET_LINK_LIBRARIES(lgf-gen lemon)
-
-ADD_EXECUTABLE(dimacs-to-lgf dimacs-to-lgf.cc)
-TARGET_LINK_LIBRARIES(dimacs-to-lgf lemon)
-
-ADD_EXECUTABLE(dimacs-solver dimacs-solver.cc)
-TARGET_LINK_LIBRARIES(dimacs-solver lemon)
-
-INSTALL(
-  TARGETS lgf-gen dimacs-to-lgf dimacs-solver
-  RUNTIME DESTINATION bin
-  COMPONENT bin
-)
-
-IF(NOT WIN32)
-  INSTALL(
-    PROGRAMS ${CMAKE_CURRENT_SOURCE_DIR}/lemon-0.x-to-1.x.sh
-    DESTINATION bin
-    COMPONENT bin
-  )
-ENDIF()
Index: tools/Makefile.am
===================================================================
--- tools/Makefile.am	(revision 721)
+++ tools/Makefile.am	(revision 310)
@@ -1,17 +1,6 @@
-EXTRA_DIST += \
-	tools/CMakeLists.txt
-
 if WANT_TOOLS
 
-bin_PROGRAMS += \
-	tools/dimacs-solver \
-	tools/dimacs-to-lgf \
-	tools/lgf-gen
-
+bin_PROGRAMS +=
 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: ols/dimacs-solver.cc
===================================================================
--- tools/dimacs-solver.cc	(revision 956)
+++ 	(revision )
@@ -1,280 +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.
- *
- */
-
-///\ingroup tools
-///\file
-///\brief DIMACS problem solver.
-///
-/// This program solves various problems given in DIMACS format.
-///
-/// See
-/// \code
-///   dimacs-solver --help
-/// \endcode
-/// for more info on usage.
-
-#include <iostream>
-#include <fstream>
-#include <cstring>
-
-#include <lemon/smart_graph.h>
-#include <lemon/dimacs.h>
-#include <lemon/lgf_writer.h>
-#include <lemon/time_measure.h>
-
-#include <lemon/arg_parser.h>
-#include <lemon/error.h>
-
-#include <lemon/dijkstra.h>
-#include <lemon/preflow.h>
-#include <lemon/matching.h>
-#include <lemon/network_simplex.h>
-
-using namespace lemon;
-typedef SmartDigraph Digraph;
-DIGRAPH_TYPEDEFS(Digraph);
-typedef SmartGraph Graph;
-
-template<class Value>
-void solve_sp(ArgParser &ap, std::istream &is, std::ostream &,
-              DimacsDescriptor &desc)
-{
-  bool report = !ap.given("q");
-  Digraph g;
-  Node s;
-  Digraph::ArcMap<Value> len(g);
-  Timer t;
-  t.restart();
-  readDimacsSp(is, g, len, s, desc);
-  if(report) std::cerr << "Read the file: " << t << '\n';
-  t.restart();
-  Dijkstra<Digraph, Digraph::ArcMap<Value> > dij(g,len);
-  if(report) std::cerr << "Setup Dijkstra class: " << t << '\n';
-  t.restart();
-  dij.run(s);
-  if(report) std::cerr << "Run Dijkstra: " << t << '\n';
-}
-
-template<class Value>
-void solve_max(ArgParser &ap, std::istream &is, std::ostream &,
-               Value infty, DimacsDescriptor &desc)
-{
-  bool report = !ap.given("q");
-  Digraph g;
-  Node s,t;
-  Digraph::ArcMap<Value> cap(g);
-  Timer ti;
-  ti.restart();
-  readDimacsMax(is, g, cap, s, t, infty, desc);
-  if(report) std::cerr << "Read the file: " << ti << '\n';
-  ti.restart();
-  Preflow<Digraph, Digraph::ArcMap<Value> > pre(g,cap,s,t);
-  if(report) std::cerr << "Setup Preflow class: " << ti << '\n';
-  ti.restart();
-  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>
-void solve_min(ArgParser &ap, std::istream &is, std::ostream &,
-               Value infty, DimacsDescriptor &desc)
-{
-  bool report = !ap.given("q");
-  Digraph g;
-  Digraph::ArcMap<Value> lower(g), cap(g), cost(g);
-  Digraph::NodeMap<Value> sup(g);
-  Timer ti;
-
-  ti.restart();
-  readDimacsMin(is, g, lower, cap, cost, sup, infty, desc);
-  ti.stop();
-  Value sum_sup = 0;
-  for (Digraph::NodeIt n(g); n != INVALID; ++n) {
-    sum_sup += sup[n];
-  }
-  if (report) {
-    std::cerr << "Sum of supply values: " << sum_sup << "\n";
-    if (sum_sup <= 0)
-      std::cerr << "GEQ supply contraints are used for NetworkSimplex\n\n";
-    else
-      std::cerr << "LEQ supply contraints are used for NetworkSimplex\n\n";
-  }
-  if (report) std::cerr << "Read the file: " << ti << '\n';
-
-  ti.restart();
-  NetworkSimplex<Digraph, Value> ns(g);
-  ns.lowerMap(lower).upperMap(cap).costMap(cost).supplyMap(sup);
-  if (sum_sup > 0) ns.supplyType(ns.LEQ);
-  if (report) std::cerr << "Setup NetworkSimplex class: " << ti << '\n';
-  ti.restart();
-  bool res = ns.run();
-  if (report) {
-    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';
-  }
-}
-
-void solve_mat(ArgParser &ap, std::istream &is, std::ostream &,
-              DimacsDescriptor &desc)
-{
-  bool report = !ap.given("q");
-  Graph g;
-  Timer ti;
-  ti.restart();
-  readDimacsMat(is, g, desc);
-  if(report) std::cerr << "Read the file: " << ti << '\n';
-  ti.restart();
-  MaxMatching<Graph> mat(g);
-  if(report) std::cerr << "Setup MaxMatching class: " << ti << '\n';
-  ti.restart();
-  mat.run();
-  if(report) std::cerr << "Run MaxMatching: " << ti << '\n';
-  if(report) std::cerr << "\nCardinality of max matching: "
-                       << mat.matchingSize() << '\n';
-}
-
-
-template<class Value, class LargeValue>
-void solve(ArgParser &ap, std::istream &is, std::ostream &os,
-           DimacsDescriptor &desc)
-{
-  std::stringstream iss(static_cast<std::string>(ap["infcap"]));
-  Value infty;
-  iss >> infty;
-  if(iss.fail())
-    {
-      std::cerr << "Cannot interpret '"
-                << static_cast<std::string>(ap["infcap"]) << "' as infinite"
-                << std::endl;
-      exit(1);
-    }
-
-  switch(desc.type)
-    {
-    case DimacsDescriptor::MIN:
-      solve_min<Value, LargeValue>(ap,is,os,infty,desc);
-      break;
-    case DimacsDescriptor::MAX:
-      solve_max<Value>(ap,is,os,infty,desc);
-      break;
-    case DimacsDescriptor::SP:
-      solve_sp<Value>(ap,is,os,desc);
-      break;
-    case DimacsDescriptor::MAT:
-      solve_mat(ap,is,os,desc);
-      break;
-    default:
-      break;
-    }
-}
-
-int main(int argc, const char *argv[]) {
-  typedef SmartDigraph Digraph;
-
-  typedef Digraph::Arc Arc;
-
-  std::string inputName;
-  std::string outputName;
-
-  ArgParser ap(argc, argv);
-  ap.other("[INFILE [OUTFILE]]",
-           "If either the INFILE or OUTFILE file is missing the standard\n"
-           "     input/output will be used instead.")
-    .boolOption("q", "Do not print any report")
-    .boolOption("int","Use 'int' for capacities, costs etc. (default)")
-    .optionGroup("datatype","int")
-#ifdef LEMON_HAVE_LONG_LONG
-    .boolOption("long","Use 'long long' for capacities, costs etc.")
-    .optionGroup("datatype","long")
-#endif
-    .boolOption("double","Use 'double' for capacities, costs etc.")
-    .optionGroup("datatype","double")
-    .boolOption("ldouble","Use 'long double' for capacities, costs etc.")
-    .optionGroup("datatype","ldouble")
-    .onlyOneGroup("datatype")
-    .stringOption("infcap","Value used for 'very high' capacities","0")
-    .run();
-
-  std::ifstream input;
-  std::ofstream output;
-
-  switch(ap.files().size())
-    {
-    case 2:
-      output.open(ap.files()[1].c_str());
-      if (!output) {
-        throw IoError("Cannot open the file for writing", ap.files()[1]);
-      }
-    case 1:
-      input.open(ap.files()[0].c_str());
-      if (!input) {
-        throw IoError("File cannot be found", ap.files()[0]);
-      }
-    case 0:
-      break;
-    default:
-      std::cerr << ap.commandName() << ": too many arguments\n";
-      return 1;
-    }
-  std::istream& is = (ap.files().size()<1 ? std::cin : input);
-  std::ostream& os = (ap.files().size()<2 ? std::cout : output);
-
-  DimacsDescriptor desc = dimacsType(is);
-
-  if(!ap.given("q"))
-    {
-      std::cout << "Problem type: ";
-      switch(desc.type)
-        {
-        case DimacsDescriptor::MIN:
-          std::cout << "min";
-          break;
-        case DimacsDescriptor::MAX:
-          std::cout << "max";
-          break;
-        case DimacsDescriptor::SP:
-          std::cout << "sp";
-        case DimacsDescriptor::MAT:
-          std::cout << "mat";
-          break;
-        default:
-          exit(1);
-          break;
-        }
-      std::cout << "\nNum of nodes: " << desc.nodeNum;
-      std::cout << "\nNum of arcs:  " << desc.edgeNum;
-      std::cout << "\n\n";
-    }
-
-  if(ap.given("double"))
-    solve<double, double>(ap,is,os,desc);
-  else if(ap.given("ldouble"))
-    solve<long double, 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);
-#endif
-
-  return 0;
-}
Index: ols/dimacs-to-lgf.cc
===================================================================
--- tools/dimacs-to-lgf.cc	(revision 631)
+++ 	(revision )
@@ -1,148 +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.
- *
- */
-
-///\ingroup tools
-///\file
-///\brief DIMACS to LGF converter.
-///
-/// This program converts various DIMACS formats to the LEMON Digraph Format
-/// (LGF).
-///
-/// See
-/// \code
-///   dimacs-to-lgf --help
-/// \endcode
-/// for more info on the usage.
-
-#include <iostream>
-#include <fstream>
-#include <cstring>
-
-#include <lemon/smart_graph.h>
-#include <lemon/dimacs.h>
-#include <lemon/lgf_writer.h>
-
-#include <lemon/arg_parser.h>
-#include <lemon/error.h>
-
-using namespace std;
-using namespace lemon;
-
-
-int main(int argc, const char *argv[]) {
-  typedef SmartDigraph Digraph;
-
-  typedef Digraph::Arc Arc;
-  typedef Digraph::Node Node;
-  typedef Digraph::ArcIt ArcIt;
-  typedef Digraph::NodeIt NodeIt;
-  typedef Digraph::ArcMap<double> DoubleArcMap;
-  typedef Digraph::NodeMap<double> DoubleNodeMap;
-
-  std::string inputName;
-  std::string outputName;
-
-  ArgParser ap(argc, argv);
-  ap.other("[INFILE [OUTFILE]]",
-           "If either the INFILE or OUTFILE file is missing the standard\n"
-           "     input/output will be used instead.")
-    .run();
-
-  ifstream input;
-  ofstream output;
-
-  switch(ap.files().size())
-    {
-    case 2:
-      output.open(ap.files()[1].c_str());
-      if (!output) {
-        throw IoError("Cannot open the file for writing", ap.files()[1]);
-      }
-    case 1:
-      input.open(ap.files()[0].c_str());
-      if (!input) {
-        throw IoError("File cannot be found", ap.files()[0]);
-      }
-    case 0:
-      break;
-    default:
-      cerr << ap.commandName() << ": too many arguments\n";
-      return 1;
-  }
-  istream& is = (ap.files().size()<1 ? cin : input);
-  ostream& os = (ap.files().size()<2 ? cout : output);
-
-  DimacsDescriptor desc = dimacsType(is);
-  switch(desc.type)
-    {
-    case DimacsDescriptor::MIN:
-      {
-        Digraph digraph;
-        DoubleArcMap lower(digraph), capacity(digraph), cost(digraph);
-        DoubleNodeMap supply(digraph);
-        readDimacsMin(is, digraph, lower, capacity, cost, supply, 0, desc);
-        DigraphWriter<Digraph>(digraph, os).
-          nodeMap("supply", supply).
-          arcMap("lower", lower).
-          arcMap("capacity", capacity).
-          arcMap("cost", cost).
-          attribute("problem","min").
-          run();
-      }
-      break;
-    case DimacsDescriptor::MAX:
-      {
-        Digraph digraph;
-        Node s, t;
-        DoubleArcMap capacity(digraph);
-        readDimacsMax(is, digraph, capacity, s, t, 0, desc);
-        DigraphWriter<Digraph>(digraph, os).
-          arcMap("capacity", capacity).
-          node("source", s).
-          node("target", t).
-          attribute("problem","max").
-          run();
-      }
-      break;
-    case DimacsDescriptor::SP:
-      {
-        Digraph digraph;
-        Node s;
-        DoubleArcMap capacity(digraph);
-        readDimacsSp(is, digraph, capacity, s, desc);
-        DigraphWriter<Digraph>(digraph, os).
-          arcMap("capacity", capacity).
-          node("source", s).
-          attribute("problem","sp").
-          run();
-      }
-      break;
-    case DimacsDescriptor::MAT:
-      {
-        Digraph digraph;
-        readDimacsMat(is, digraph,desc);
-        DigraphWriter<Digraph>(digraph, os).
-          attribute("problem","mat").
-          run();
-      }
-      break;
-    default:
-      break;
-    }
-  return 0;
-}
Index: tools/lemon-0.x-to-1.x.sh
===================================================================
--- tools/lemon-0.x-to-1.x.sh	(revision 738)
+++ tools/lemon-0.x-to-1.x.sh	(revision 310)
@@ -4,131 +4,124 @@
 
 if [ $# -eq 0 -o x$1 = "x-h" -o x$1 = "x-help" -o x$1 = "x--help" ]; then
-    echo "Usage:"
-    echo "  $0 source-file(s)"
-    exit
+	echo "Usage:"
+	echo "  $0 source-file"
+	exit
 fi
 
-for i in $@
-do
-    echo Update $i...
-    TMP=`mktemp`
-    sed -e "s/\<undirected graph\>/_gr_aph_label_/g"\
-        -e "s/\<undirected graphs\>/_gr_aph_label_s/g"\
-        -e "s/\<undirected edge\>/_ed_ge_label_/g"\
-        -e "s/\<undirected edges\>/_ed_ge_label_s/g"\
-        -e "s/\<directed graph\>/_digr_aph_label_/g"\
-        -e "s/\<directed graphs\>/_digr_aph_label_s/g"\
-        -e "s/\<directed edge\>/_ar_c_label_/g"\
-        -e "s/\<directed edges\>/_ar_c_label_s/g"\
-        -e "s/UGraph/_Gr_aph_label_/g"\
-        -e "s/u[Gg]raph/_gr_aph_label_/g"\
-        -e "s/Graph\>/_Digr_aph_label_/g"\
-        -e "s/\<graph\>/_digr_aph_label_/g"\
-        -e "s/Graphs\>/_Digr_aph_label_s/g"\
-        -e "s/\<graphs\>/_digr_aph_label_s/g"\
-        -e "s/\([Gg]\)raph\([a-z]\)/_\1r_aph_label_\2/g"\
-        -e "s/\([a-z_]\)graph/\1_gr_aph_label_/g"\
-        -e "s/Graph/_Digr_aph_label_/g"\
-        -e "s/graph/_digr_aph_label_/g"\
-        -e "s/UEdge/_Ed_ge_label_/g"\
-        -e "s/u[Ee]dge/_ed_ge_label_/g"\
-        -e "s/IncEdgeIt/_In_cEd_geIt_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/\([Ee]\)dge\([a-z]\)/_\1d_ge_label_\2/g"\
-        -e "s/\([a-z]\)edge/\1_ed_ge_label_/g"\
-        -e "s/Edge/_Ar_c_label_/g"\
-        -e "s/edge/_ar_c_label_/g"\
-        -e "s/A[Nn]ode/_Re_d_label_/g"\
-        -e "s/B[Nn]ode/_Blu_e_label_/g"\
-        -e "s/A-[Nn]ode/_Re_d_label_/g"\
-        -e "s/B-[Nn]ode/_Blu_e_label_/g"\
-        -e "s/a[Nn]ode/_re_d_label_/g"\
-        -e "s/b[Nn]ode/_blu_e_label_/g"\
-        -e "s/\<UGRAPH_TYPEDEFS\([ \t]*([ \t]*\)typename[ \t]/TEMPLATE__GR_APH_TY_PEDE_FS_label_\1/g"\
-        -e "s/\<GRAPH_TYPEDEFS\([ \t]*([ \t]*\)typename[ \t]/TEMPLATE__DIGR_APH_TY_PEDE_FS_label_\1/g"\
-        -e "s/\<UGRAPH_TYPEDEFS\>/_GR_APH_TY_PEDE_FS_label_/g"\
-        -e "s/\<GRAPH_TYPEDEFS\>/_DIGR_APH_TY_PEDE_FS_label_/g"\
-        -e "s/_Digr_aph_label_/Digraph/g"\
-        -e "s/_digr_aph_label_/digraph/g"\
-        -e "s/_Gr_aph_label_/Graph/g"\
-        -e "s/_gr_aph_label_/graph/g"\
-        -e "s/_Ar_c_label_/Arc/g"\
-        -e "s/_ar_c_label_/arc/g"\
-        -e "s/_Ed_ge_label_/Edge/g"\
-        -e "s/_ed_ge_label_/edge/g"\
-        -e "s/_In_cEd_geIt_label_/IncEdgeIt/g"\
-        -e "s/_Re_d_label_/Red/g"\
-        -e "s/_Blu_e_label_/Blue/g"\
-        -e "s/_re_d_label_/red/g"\
-        -e "s/_blu_e_label_/blue/g"\
-        -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"\
-        -e "s/\<DefPredMap\>/SetPredMap/g"\
-        -e "s/\<DefDistMap\>/SetDistMap/g"\
-        -e "s/\<DefReachedMap\>/SetReachedMap/g"\
-        -e "s/\<DefProcessedMap\>/SetProcessedMap/g"\
-        -e "s/\<DefHeap\>/SetHeap/g"\
-        -e "s/\<DefStandardHeap\>/SetStandradHeap/g"\
-        -e "s/\<DefOperationTraits\>/SetOperationTraits/g"\
-        -e "s/\<DefProcessedMapToBeDefaultMap\>/SetStandardProcessedMap/g"\
-        -e "s/\<copyGraph\>/graphCopy/g"\
-        -e "s/\<copyDigraph\>/digraphCopy/g"\
-        -e "s/\<HyperCubeDigraph\>/HypercubeGraph/g"\
-        -e "s/\<IntegerMap\>/RangeMap/g"\
-        -e "s/\<integerMap\>/rangeMap/g"\
-        -e "s/\<\([sS]\)tdMap\>/\1parseMap/g"\
-        -e "s/\<\([Ff]\)unctorMap\>/\1unctorToMap/g"\
-        -e "s/\<\([Mm]\)apFunctor\>/\1apToFunctor/g"\
-        -e "s/\<\([Ff]\)orkWriteMap\>/\1orkMap/g"\
-        -e "s/\<StoreBoolMap\>/LoggerBoolMap/g"\
-        -e "s/\<storeBoolMap\>/loggerBoolMap/g"\
-        -e "s/\<InvertableMap\>/CrossRefMap/g"\
-        -e "s/\<invertableMap\>/crossRefMap/g"\
-        -e "s/\<DescriptorMap\>/RangeIdMap/g"\
-        -e "s/\<descriptorMap\>/rangeIdMap/g"\
-        -e "s/\<BoundingBox\>/Box/g"\
-        -e "s/\<readNauty\>/readNautyGraph/g"\
-        -e "s/\<RevDigraphAdaptor\>/ReverseDigraph/g"\
-        -e "s/\<revDigraphAdaptor\>/reverseDigraph/g"\
-        -e "s/\<SubDigraphAdaptor\>/SubDigraph/g"\
-        -e "s/\<subDigraphAdaptor\>/subDigraph/g"\
-        -e "s/\<SubGraphAdaptor\>/SubGraph/g"\
-        -e "s/\<subGraphAdaptor\>/subGraph/g"\
-        -e "s/\<NodeSubDigraphAdaptor\>/FilterNodes/g"\
-        -e "s/\<nodeSubDigraphAdaptor\>/filterNodes/g"\
-        -e "s/\<ArcSubDigraphAdaptor\>/FilterArcs/g"\
-        -e "s/\<arcSubDigraphAdaptor\>/filterArcs/g"\
-        -e "s/\<UndirDigraphAdaptor\>/Undirector/g"\
-        -e "s/\<undirDigraphAdaptor\>/undirector/g"\
-        -e "s/\<ResDigraphAdaptor\>/ResidualDigraph/g"\
-        -e "s/\<resDigraphAdaptor\>/residualDigraph/g"\
-        -e "s/\<SplitDigraphAdaptor\>/SplitNodes/g"\
-        -e "s/\<splitDigraphAdaptor\>/splitNodes/g"\
-        -e "s/\<SubGraphAdaptor\>/SubGraph/g"\
-        -e "s/\<subGraphAdaptor\>/subGraph/g"\
-        -e "s/\<NodeSubGraphAdaptor\>/FilterNodes/g"\
-        -e "s/\<nodeSubGraphAdaptor\>/filterNodes/g"\
-        -e "s/\<ArcSubGraphAdaptor\>/FilterEdges/g"\
-        -e "s/\<arcSubGraphAdaptor\>/filterEdges/g"\
-        -e "s/\<DirGraphAdaptor\>/Orienter/g"\
-        -e "s/\<dirGraphAdaptor\>/orienter/g"\
-        -e "s/\<LpCplex\>/CplexLp/g"\
-        -e "s/\<MipCplex\>/CplexMip/g"\
-        -e "s/\<LpGlpk\>/GlpkLp/g"\
-        -e "s/\<MipGlpk\>/GlpkMip/g"\
-        -e "s/\<LpSoplex\>/SoplexLp/g"\
-    <$i > $TMP
-    mv $TMP $i
-done
+TMP=`mktemp`
+
+sed	-e "s/undirected graph/_gr_aph_label_/g"\
+	-e "s/undirected edge/_ed_ge_label_/g"\
+	-e "s/graph_/_gr_aph_label__/g"\
+	-e "s/_graph/__gr_aph_label_/g"\
+	-e "s/UGraph/_Gr_aph_label_/g"\
+	-e "s/uGraph/_gr_aph_label_/g"\
+	-e "s/ugraph/_gr_aph_label_/g"\
+	-e "s/Graph/_Digr_aph_label_/g"\
+	-e "s/graph/_digr_aph_label_/g"\
+	-e "s/UEdge/_Ed_ge_label_/g"\
+	-e "s/uEdge/_ed_ge_label_/g"\
+	-e "s/uedge/_ed_ge_label_/g"\
+	-e "s/IncEdgeIt/_In_cEd_geIt_label_/g"\
+	-e "s/Edge/_Ar_c_label_/g"\
+	-e "s/edge/_ar_c_label_/g"\
+	-e "s/ANode/_Re_d_label_/g"\
+	-e "s/BNode/_Blu_e_label_/g"\
+	-e "s/A-Node/_Re_d_label_/g"\
+	-e "s/B-Node/_Blu_e_label_/g"\
+	-e "s/anode/_re_d_label_/g"\
+	-e "s/bnode/_blu_e_label_/g"\
+	-e "s/aNode/_re_d_label_/g"\
+	-e "s/bNode/_blu_e_label_/g"\
+	-e "s/_Digr_aph_label_/Digraph/g"\
+	-e "s/_digr_aph_label_/digraph/g"\
+	-e "s/_Gr_aph_label_/Graph/g"\
+	-e "s/_gr_aph_label_/graph/g"\
+	-e "s/_Ar_c_label_/Arc/g"\
+	-e "s/_ar_c_label_/arc/g"\
+	-e "s/_Ed_ge_label_/Edge/g"\
+	-e "s/_ed_ge_label_/edge/g"\
+	-e "s/_In_cEd_geIt_label_/IncEdgeIt/g"\
+	-e "s/_Re_d_label_/Red/g"\
+	-e "s/_Blu_e_label_/Blue/g"\
+	-e "s/_re_d_label_/red/g"\
+	-e "s/_blu_e_label_/blue/g"\
+	-e "s/\(\W\)DefPredMap\(\W\)/\1SetPredMap\2/g"\
+	-e "s/\(\W\)DefPredMap$/\1SetPredMap/g"\
+	-e "s/^DefPredMap\(\W\)/SetPredMap\1/g"\
+	-e "s/^DefPredMap$/SetPredMap/g"\
+	-e "s/\(\W\)DefDistMap\(\W\)/\1SetDistMap\2/g"\
+	-e "s/\(\W\)DefDistMap$/\1SetDistMap/g"\
+	-e "s/^DefDistMap\(\W\)/SetDistMap\1/g"\
+	-e "s/^DefDistMap$/SetDistMap/g"\
+	-e "s/\(\W\)DefReachedMap\(\W\)/\1SetReachedMap\2/g"\
+	-e "s/\(\W\)DefReachedMap$/\1SetReachedMap/g"\
+	-e "s/^DefReachedMap\(\W\)/SetReachedMap\1/g"\
+	-e "s/^DefReachedMap$/SetReachedMap/g"\
+	-e "s/\(\W\)DefProcessedMap\(\W\)/\1SetProcessedMap\2/g"\
+	-e "s/\(\W\)DefProcessedMap$/\1SetProcessedMap/g"\
+	-e "s/^DefProcessedMap\(\W\)/SetProcessedMap\1/g"\
+	-e "s/^DefProcessedMap$/SetProcessedMap/g"\
+	-e "s/\(\W\)DefHeap\(\W\)/\1SetHeap\2/g"\
+	-e "s/\(\W\)DefHeap$/\1SetHeap/g"\
+	-e "s/^DefHeap\(\W\)/SetHeap\1/g"\
+	-e "s/^DefHeap$/SetHeap/g"\
+	-e "s/\(\W\)DefStandardHeap\(\W\)/\1SetStandradHeap\2/g"\
+	-e "s/\(\W\)DefStandardHeap$/\1SetStandradHeap/g"\
+	-e "s/^DefStandardHeap\(\W\)/SetStandradHeap\1/g"\
+	-e "s/^DefStandardHeap$/SetStandradHeap/g"\
+	-e "s/\(\W\)DefOperationTraits\(\W\)/\1SetOperationTraits\2/g"\
+	-e "s/\(\W\)DefOperationTraits$/\1SetOperationTraits/g"\
+	-e "s/^DefOperationTraits\(\W\)/SetOperationTraits\1/g"\
+	-e "s/^DefOperationTraits$/SetOperationTraits/g"\
+	-e "s/\(\W\)DefProcessedMapToBeDefaultMap\(\W\)/\1SetStandardProcessedMap\2/g"\
+	-e "s/\(\W\)DefProcessedMapToBeDefaultMap$/\1SetStandardProcessedMap/g"\
+	-e "s/^DefProcessedMapToBeDefaultMap\(\W\)/SetStandardProcessedMap\1/g"\
+	-e "s/^DefProcessedMapToBeDefaultMap$/SetStandardProcessedMap/g"\
+	-e "s/\(\W\)IntegerMap\(\W\)/\1RangeMap\2/g"\
+	-e "s/\(\W\)IntegerMap$/\1RangeMap/g"\
+	-e "s/^IntegerMap\(\W\)/RangeMap\1/g"\
+	-e "s/^IntegerMap$/RangeMap/g"\
+	-e "s/\(\W\)integerMap\(\W\)/\1rangeMap\2/g"\
+	-e "s/\(\W\)integerMap$/\1rangeMap/g"\
+	-e "s/^integerMap\(\W\)/rangeMap\1/g"\
+	-e "s/^integerMap$/rangeMap/g"\
+	-e "s/\(\W\)copyGraph\(\W\)/\1graphCopy\2/g"\
+	-e "s/\(\W\)copyGraph$/\1graphCopy/g"\
+	-e "s/^copyGraph\(\W\)/graphCopy\1/g"\
+	-e "s/^copyGraph$/graphCopy/g"\
+	-e "s/\(\W\)copyDigraph\(\W\)/\1digraphCopy\2/g"\
+	-e "s/\(\W\)copyDigraph$/\1digraphCopy/g"\
+	-e "s/^copyDigraph\(\W\)/digraphCopy\1/g"\
+	-e "s/^copyDigraph$/digraphCopy/g"\
+	-e "s/\(\W\)\([sS]\)tdMap\(\W\)/\1\2parseMap\3/g"\
+	-e "s/\(\W\)\([sS]\)tdMap$/\1\2parseMap/g"\
+	-e "s/^\([sS]\)tdMap\(\W\)/\1parseMap\2/g"\
+	-e "s/^\([sS]\)tdMap$/\1parseMap/g"\
+	-e "s/\(\W\)\([Ff]\)unctorMap\(\W\)/\1\2unctorToMap\3/g"\
+	-e "s/\(\W\)\([Ff]\)unctorMap$/\1\2unctorToMap/g"\
+	-e "s/^\([Ff]\)unctorMap\(\W\)/\1unctorToMap\2/g"\
+	-e "s/^\([Ff]\)unctorMap$/\1unctorToMap/g"\
+	-e "s/\(\W\)\([Mm]\)apFunctor\(\W\)/\1\2apToFunctor\3/g"\
+	-e "s/\(\W\)\([Mm]\)apFunctor$/\1\2apToFunctor/g"\
+	-e "s/^\([Mm]\)apFunctor\(\W\)/\1apToFunctor\2/g"\
+	-e "s/^\([Mm]\)apFunctor$/\1apToFunctor/g"\
+	-e "s/\(\W\)\([Ff]\)orkWriteMap\(\W\)/\1\2orkMap\3/g"\
+	-e "s/\(\W\)\([Ff]\)orkWriteMap$/\1\2orkMap/g"\
+	-e "s/^\([Ff]\)orkWriteMap\(\W\)/\1orkMap\2/g"\
+	-e "s/^\([Ff]\)orkWriteMap$/\1orkMap/g"\
+	-e "s/\(\W\)StoreBoolMap\(\W\)/\1LoggerBoolMap\2/g"\
+	-e "s/\(\W\)StoreBoolMap$/\1LoggerBoolMap/g"\
+	-e "s/^StoreBoolMap\(\W\)/LoggerBoolMap\1/g"\
+	-e "s/^StoreBoolMap$/LoggerBoolMap/g"\
+	-e "s/\(\W\)storeBoolMap\(\W\)/\1loggerBoolMap\2/g"\
+	-e "s/\(\W\)storeBoolMap$/\1loggerBoolMap/g"\
+	-e "s/^storeBoolMap\(\W\)/loggerBoolMap\1/g"\
+	-e "s/^storeBoolMap$/loggerBoolMap/g"\
+	-e "s/\(\W\)BoundingBox\(\W\)/\1Box\2/g"\
+	-e "s/\(\W\)BoundingBox$/\1Box/g"\
+	-e "s/^BoundingBox\(\W\)/Box\1/g"\
+	-e "s/^BoundingBox$/Box/g"\
+<$1 > $TMP
+
+mv $TMP $1
Index: ols/lgf-gen.cc
===================================================================
--- tools/lgf-gen.cc	(revision 701)
+++ 	(revision )
@@ -1,834 +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.
- *
- */
-
-/// \ingroup tools
-/// \file
-/// \brief Special plane graph generator.
-///
-/// Graph generator application for various types of plane graphs.
-///
-/// See
-/// \code
-///   lgf-gen --help
-/// \endcode
-/// for more information on the usage.
-
-#include <algorithm>
-#include <set>
-#include <ctime>
-#include <lemon/list_graph.h>
-#include <lemon/random.h>
-#include <lemon/dim2.h>
-#include <lemon/bfs.h>
-#include <lemon/counter.h>
-#include <lemon/suurballe.h>
-#include <lemon/graph_to_eps.h>
-#include <lemon/lgf_writer.h>
-#include <lemon/arg_parser.h>
-#include <lemon/euler.h>
-#include <lemon/math.h>
-#include <lemon/kruskal.h>
-#include <lemon/time_measure.h>
-
-using namespace lemon;
-
-typedef dim2::Point<double> Point;
-
-GRAPH_TYPEDEFS(ListGraph);
-
-bool progress=true;
-
-int N;
-// int girth;
-
-ListGraph g;
-
-std::vector<Node> nodes;
-ListGraph::NodeMap<Point> coords(g);
-
-
-double totalLen(){
-  double tlen=0;
-  for(EdgeIt e(g);e!=INVALID;++e)
-    tlen+=std::sqrt((coords[g.v(e)]-coords[g.u(e)]).normSquare());
-  return tlen;
-}
-
-int tsp_impr_num=0;
-
-const double EPSILON=1e-8;
-bool tsp_improve(Node u, Node v)
-{
-  double luv=std::sqrt((coords[v]-coords[u]).normSquare());
-  Node u2=u;
-  Node v2=v;
-  do {
-    Node n;
-    for(IncEdgeIt e(g,v2);(n=g.runningNode(e))==u2;++e) { }
-    u2=v2;
-    v2=n;
-    if(luv+std::sqrt((coords[v2]-coords[u2]).normSquare())-EPSILON>
-       std::sqrt((coords[u]-coords[u2]).normSquare())+
-       std::sqrt((coords[v]-coords[v2]).normSquare()))
-      {
-         g.erase(findEdge(g,u,v));
-         g.erase(findEdge(g,u2,v2));
-        g.addEdge(u2,u);
-        g.addEdge(v,v2);
-        tsp_impr_num++;
-        return true;
-      }
-  } while(v2!=u);
-  return false;
-}
-
-bool tsp_improve(Node u)
-{
-  for(IncEdgeIt e(g,u);e!=INVALID;++e)
-    if(tsp_improve(u,g.runningNode(e))) return true;
-  return false;
-}
-
-void tsp_improve()
-{
-  bool b;
-  do {
-    b=false;
-    for(NodeIt n(g);n!=INVALID;++n)
-      if(tsp_improve(n)) b=true;
-  } while(b);
-}
-
-void tsp()
-{
-  for(int i=0;i<N;i++) g.addEdge(nodes[i],nodes[(i+1)%N]);
-  tsp_improve();
-}
-
-class Line
-{
-public:
-  Point a;
-  Point b;
-  Line(Point _a,Point _b) :a(_a),b(_b) {}
-  Line(Node _a,Node _b) : a(coords[_a]),b(coords[_b]) {}
-  Line(const Arc &e) : a(coords[g.source(e)]),b(coords[g.target(e)]) {}
-  Line(const Edge &e) : a(coords[g.u(e)]),b(coords[g.v(e)]) {}
-};
-
-inline std::ostream& operator<<(std::ostream &os, const Line &l)
-{
-  os << l.a << "->" << l.b;
-  return os;
-}
-
-bool cross(Line a, Line b)
-{
-  Point ao=rot90(a.b-a.a);
-  Point bo=rot90(b.b-b.a);
-  return (ao*(b.a-a.a))*(ao*(b.b-a.a))<0 &&
-    (bo*(a.a-b.a))*(bo*(a.b-b.a))<0;
-}
-
-struct Parc
-{
-  Node a;
-  Node b;
-  double len;
-};
-
-bool pedgeLess(Parc a,Parc b)
-{
-  return a.len<b.len;
-}
-
-std::vector<Edge> arcs;
-
-namespace _delaunay_bits {
-
-  struct Part {
-    int prev, curr, next;
-
-    Part(int p, int c, int n) : prev(p), curr(c), next(n) {}
-  };
-
-  inline std::ostream& operator<<(std::ostream& os, const Part& part) {
-    os << '(' << part.prev << ',' << part.curr << ',' << part.next << ')';
-    return os;
-  }
-
-  inline double circle_point(const Point& p, const Point& q, const Point& r) {
-    double a = p.x * (q.y - r.y) + q.x * (r.y - p.y) + r.x * (p.y - q.y);
-    if (a == 0) return std::numeric_limits<double>::quiet_NaN();
-
-    double d = (p.x * p.x + p.y * p.y) * (q.y - r.y) +
-      (q.x * q.x + q.y * q.y) * (r.y - p.y) +
-      (r.x * r.x + r.y * r.y) * (p.y - q.y);
-
-    double e = (p.x * p.x + p.y * p.y) * (q.x - r.x) +
-      (q.x * q.x + q.y * q.y) * (r.x - p.x) +
-      (r.x * r.x + r.y * r.y) * (p.x - q.x);
-
-    double f = (p.x * p.x + p.y * p.y) * (q.x * r.y - r.x * q.y) +
-      (q.x * q.x + q.y * q.y) * (r.x * p.y - p.x * r.y) +
-      (r.x * r.x + r.y * r.y) * (p.x * q.y - q.x * p.y);
-
-    return d / (2 * a) + std::sqrt((d * d + e * e) / (4 * a * a) + f / a);
-  }
-
-  inline bool circle_form(const Point& p, const Point& q, const Point& r) {
-    return rot90(q - p) * (r - q) < 0.0;
-  }
-
-  inline double intersection(const Point& p, const Point& q, double sx) {
-    const double epsilon = 1e-8;
-
-    if (p.x == q.x) return (p.y + q.y) / 2.0;
-
-    if (sx < p.x + epsilon) return p.y;
-    if (sx < q.x + epsilon) return q.y;
-
-    double a = q.x - p.x;
-    double b = (q.x - sx) * p.y - (p.x - sx) * q.y;
-    double d = (q.x - sx) * (p.x - sx) * (p - q).normSquare();
-    return (b - std::sqrt(d)) / a;
-  }
-
-  struct YLess {
-
-
-    YLess(const std::vector<Point>& points, double& sweep)
-      : _points(points), _sweep(sweep) {}
-
-    bool operator()(const Part& l, const Part& r) const {
-      const double epsilon = 1e-8;
-
-      //      std::cerr << l << " vs " << r << std::endl;
-      double lbx = l.prev != -1 ?
-        intersection(_points[l.prev], _points[l.curr], _sweep) :
-        - std::numeric_limits<double>::infinity();
-      double rbx = r.prev != -1 ?
-        intersection(_points[r.prev], _points[r.curr], _sweep) :
-        - std::numeric_limits<double>::infinity();
-      double lex = l.next != -1 ?
-        intersection(_points[l.curr], _points[l.next], _sweep) :
-        std::numeric_limits<double>::infinity();
-      double rex = r.next != -1 ?
-        intersection(_points[r.curr], _points[r.next], _sweep) :
-        std::numeric_limits<double>::infinity();
-
-      if (lbx > lex) std::swap(lbx, lex);
-      if (rbx > rex) std::swap(rbx, rex);
-
-      if (lex < epsilon + rex && lbx + epsilon < rex) return true;
-      if (rex < epsilon + lex && rbx + epsilon < lex) return false;
-      return lex < rex;
-    }
-
-    const std::vector<Point>& _points;
-    double& _sweep;
-  };
-
-  struct BeachIt;
-
-  typedef std::multimap<double, BeachIt> SpikeHeap;
-
-  typedef std::multimap<Part, SpikeHeap::iterator, YLess> Beach;
-
-  struct BeachIt {
-    Beach::iterator it;
-
-    BeachIt(Beach::iterator iter) : it(iter) {}
-  };
-
-}
-
-inline void delaunay() {
-  Counter cnt("Number of arcs added: ");
-
-  using namespace _delaunay_bits;
-
-  typedef _delaunay_bits::Part Part;
-  typedef std::vector<std::pair<double, int> > SiteHeap;
-
-
-  std::vector<Point> points;
-  std::vector<Node> nodes;
-
-  for (NodeIt it(g); it != INVALID; ++it) {
-    nodes.push_back(it);
-    points.push_back(coords[it]);
-  }
-
-  SiteHeap siteheap(points.size());
-
-  double sweep;
-
-
-  for (int i = 0; i < int(siteheap.size()); ++i) {
-    siteheap[i] = std::make_pair(points[i].x, i);
-  }
-
-  std::sort(siteheap.begin(), siteheap.end());
-  sweep = siteheap.front().first;
-
-  YLess yless(points, sweep);
-  Beach beach(yless);
-
-  SpikeHeap spikeheap;
-
-  std::set<std::pair<int, int> > arcs;
-
-  int siteindex = 0;
-  {
-    SiteHeap front;
-
-    while (siteindex < int(siteheap.size()) &&
-           siteheap[0].first == siteheap[siteindex].first) {
-      front.push_back(std::make_pair(points[siteheap[siteindex].second].y,
-                                     siteheap[siteindex].second));
-      ++siteindex;
-    }
-
-    std::sort(front.begin(), front.end());
-
-    for (int i = 0; i < int(front.size()); ++i) {
-      int prev = (i == 0 ? -1 : front[i - 1].second);
-      int curr = front[i].second;
-      int next = (i + 1 == int(front.size()) ? -1 : front[i + 1].second);
-
-      beach.insert(std::make_pair(Part(prev, curr, next),
-                                  spikeheap.end()));
-    }
-  }
-
-  while (siteindex < int(points.size()) || !spikeheap.empty()) {
-
-    SpikeHeap::iterator spit = spikeheap.begin();
-
-    if (siteindex < int(points.size()) &&
-        (spit == spikeheap.end() || siteheap[siteindex].first < spit->first)) {
-      int site = siteheap[siteindex].second;
-      sweep = siteheap[siteindex].first;
-
-      Beach::iterator bit = beach.upper_bound(Part(site, site, site));
-
-      if (bit->second != spikeheap.end()) {
-        spikeheap.erase(bit->second);
-      }
-
-      int prev = bit->first.prev;
-      int curr = bit->first.curr;
-      int next = bit->first.next;
-
-      beach.erase(bit);
-
-      SpikeHeap::iterator pit = spikeheap.end();
-      if (prev != -1 &&
-          circle_form(points[prev], points[curr], points[site])) {
-        double x = circle_point(points[prev], points[curr], points[site]);
-        pit = spikeheap.insert(std::make_pair(x, BeachIt(beach.end())));
-        pit->second.it =
-          beach.insert(std::make_pair(Part(prev, curr, site), pit));
-      } else {
-        beach.insert(std::make_pair(Part(prev, curr, site), pit));
-      }
-
-      beach.insert(std::make_pair(Part(curr, site, curr), spikeheap.end()));
-
-      SpikeHeap::iterator nit = spikeheap.end();
-      if (next != -1 &&
-          circle_form(points[site], points[curr],points[next])) {
-        double x = circle_point(points[site], points[curr], points[next]);
-        nit = spikeheap.insert(std::make_pair(x, BeachIt(beach.end())));
-        nit->second.it =
-          beach.insert(std::make_pair(Part(site, curr, next), nit));
-      } else {
-        beach.insert(std::make_pair(Part(site, curr, next), nit));
-      }
-
-      ++siteindex;
-    } else {
-      sweep = spit->first;
-
-      Beach::iterator bit = spit->second.it;
-
-      int prev = bit->first.prev;
-      int curr = bit->first.curr;
-      int next = bit->first.next;
-
-      {
-        std::pair<int, int> arc;
-
-        arc = prev < curr ?
-          std::make_pair(prev, curr) : std::make_pair(curr, prev);
-
-        if (arcs.find(arc) == arcs.end()) {
-          arcs.insert(arc);
-          g.addEdge(nodes[prev], nodes[curr]);
-          ++cnt;
-        }
-
-        arc = curr < next ?
-          std::make_pair(curr, next) : std::make_pair(next, curr);
-
-        if (arcs.find(arc) == arcs.end()) {
-          arcs.insert(arc);
-          g.addEdge(nodes[curr], nodes[next]);
-          ++cnt;
-        }
-      }
-
-      Beach::iterator pbit = bit; --pbit;
-      int ppv = pbit->first.prev;
-      Beach::iterator nbit = bit; ++nbit;
-      int nnt = nbit->first.next;
-
-      if (bit->second != spikeheap.end()) spikeheap.erase(bit->second);
-      if (pbit->second != spikeheap.end()) spikeheap.erase(pbit->second);
-      if (nbit->second != spikeheap.end()) spikeheap.erase(nbit->second);
-
-      beach.erase(nbit);
-      beach.erase(bit);
-      beach.erase(pbit);
-
-      SpikeHeap::iterator pit = spikeheap.end();
-      if (ppv != -1 && ppv != next &&
-          circle_form(points[ppv], points[prev], points[next])) {
-        double x = circle_point(points[ppv], points[prev], points[next]);
-        if (x < sweep) x = sweep;
-        pit = spikeheap.insert(std::make_pair(x, BeachIt(beach.end())));
-        pit->second.it =
-          beach.insert(std::make_pair(Part(ppv, prev, next), pit));
-      } else {
-        beach.insert(std::make_pair(Part(ppv, prev, next), pit));
-      }
-
-      SpikeHeap::iterator nit = spikeheap.end();
-      if (nnt != -1 && prev != nnt &&
-          circle_form(points[prev], points[next], points[nnt])) {
-        double x = circle_point(points[prev], points[next], points[nnt]);
-        if (x < sweep) x = sweep;
-        nit = spikeheap.insert(std::make_pair(x, BeachIt(beach.end())));
-        nit->second.it =
-          beach.insert(std::make_pair(Part(prev, next, nnt), nit));
-      } else {
-        beach.insert(std::make_pair(Part(prev, next, nnt), nit));
-      }
-
-    }
-  }
-
-  for (Beach::iterator it = beach.begin(); it != beach.end(); ++it) {
-    int curr = it->first.curr;
-    int next = it->first.next;
-
-    if (next == -1) continue;
-
-    std::pair<int, int> arc;
-
-    arc = curr < next ?
-      std::make_pair(curr, next) : std::make_pair(next, curr);
-
-    if (arcs.find(arc) == arcs.end()) {
-      arcs.insert(arc);
-      g.addEdge(nodes[curr], nodes[next]);
-      ++cnt;
-    }
-  }
-}
-
-void sparse(int d)
-{
-  Counter cnt("Number of arcs removed: ");
-  Bfs<ListGraph> bfs(g);
-  for(std::vector<Edge>::reverse_iterator ei=arcs.rbegin();
-      ei!=arcs.rend();++ei)
-    {
-      Node a=g.u(*ei);
-      Node b=g.v(*ei);
-      g.erase(*ei);
-      bfs.run(a,b);
-      if(bfs.predArc(b)==INVALID || bfs.dist(b)>d)
-        g.addEdge(a,b);
-      else cnt++;
-    }
-}
-
-void sparse2(int d)
-{
-  Counter cnt("Number of arcs removed: ");
-  for(std::vector<Edge>::reverse_iterator ei=arcs.rbegin();
-      ei!=arcs.rend();++ei)
-    {
-      Node a=g.u(*ei);
-      Node b=g.v(*ei);
-      g.erase(*ei);
-      ConstMap<Arc,int> cegy(1);
-      Suurballe<ListGraph,ConstMap<Arc,int> > sur(g,cegy);
-      int k=sur.run(a,b,2);
-      if(k<2 || sur.totalLength()>d)
-        g.addEdge(a,b);
-      else cnt++;
-//       else std::cout << "Remove arc " << g.id(a) << "-" << g.id(b) << '\n';
-    }
-}
-
-void sparseTriangle(int d)
-{
-  Counter cnt("Number of arcs added: ");
-  std::vector<Parc> pedges;
-  for(NodeIt n(g);n!=INVALID;++n)
-    for(NodeIt m=++(NodeIt(n));m!=INVALID;++m)
-      {
-        Parc p;
-        p.a=n;
-        p.b=m;
-        p.len=(coords[m]-coords[n]).normSquare();
-        pedges.push_back(p);
-      }
-  std::sort(pedges.begin(),pedges.end(),pedgeLess);
-  for(std::vector<Parc>::iterator pi=pedges.begin();pi!=pedges.end();++pi)
-    {
-      Line li(pi->a,pi->b);
-      EdgeIt e(g);
-      for(;e!=INVALID && !cross(e,li);++e) ;
-      Edge ne;
-      if(e==INVALID) {
-        ConstMap<Arc,int> cegy(1);
-        Suurballe<ListGraph,ConstMap<Arc,int> > sur(g,cegy);
-        int k=sur.run(pi->a,pi->b,2);
-        if(k<2 || sur.totalLength()>d)
-          {
-            ne=g.addEdge(pi->a,pi->b);
-            arcs.push_back(ne);
-            cnt++;
-          }
-      }
-    }
-}
-
-template <typename Graph, typename CoordMap>
-class LengthSquareMap {
-public:
-  typedef typename Graph::Edge Key;
-  typedef typename CoordMap::Value::Value Value;
-
-  LengthSquareMap(const Graph& graph, const CoordMap& coords)
-    : _graph(graph), _coords(coords) {}
-
-  Value operator[](const Key& key) const {
-    return (_coords[_graph.v(key)] -
-            _coords[_graph.u(key)]).normSquare();
-  }
-
-private:
-
-  const Graph& _graph;
-  const CoordMap& _coords;
-};
-
-void minTree() {
-  std::vector<Parc> pedges;
-  Timer T;
-  std::cout << T.realTime() << "s: Creating delaunay triangulation...\n";
-  delaunay();
-  std::cout << T.realTime() << "s: Calculating spanning tree...\n";
-  LengthSquareMap<ListGraph, ListGraph::NodeMap<Point> > ls(g, coords);
-  ListGraph::EdgeMap<bool> tree(g);
-  kruskal(g, ls, tree);
-  std::cout << T.realTime() << "s: Removing non tree arcs...\n";
-  std::vector<Edge> remove;
-  for (EdgeIt e(g); e != INVALID; ++e) {
-    if (!tree[e]) remove.push_back(e);
-  }
-  for(int i = 0; i < int(remove.size()); ++i) {
-    g.erase(remove[i]);
-  }
-  std::cout << T.realTime() << "s: Done\n";
-}
-
-void tsp2()
-{
-  std::cout << "Find a tree..." << std::endl;
-
-  minTree();
-
-  std::cout << "Total arc length (tree) : " << totalLen() << std::endl;
-
-  std::cout << "Make it Euler..." << std::endl;
-
-  {
-    std::vector<Node> leafs;
-    for(NodeIt n(g);n!=INVALID;++n)
-      if(countIncEdges(g,n)%2==1) leafs.push_back(n);
-
-//    for(unsigned int i=0;i<leafs.size();i+=2)
-//       g.addArc(leafs[i],leafs[i+1]);
-
-    std::vector<Parc> pedges;
-    for(unsigned int i=0;i<leafs.size()-1;i++)
-      for(unsigned int j=i+1;j<leafs.size();j++)
-        {
-          Node n=leafs[i];
-          Node m=leafs[j];
-          Parc p;
-          p.a=n;
-          p.b=m;
-          p.len=(coords[m]-coords[n]).normSquare();
-          pedges.push_back(p);
-        }
-    std::sort(pedges.begin(),pedges.end(),pedgeLess);
-    for(unsigned int i=0;i<pedges.size();i++)
-      if(countIncEdges(g,pedges[i].a)%2 &&
-         countIncEdges(g,pedges[i].b)%2)
-        g.addEdge(pedges[i].a,pedges[i].b);
-  }
-
-  for(NodeIt n(g);n!=INVALID;++n)
-    if(countIncEdges(g,n)%2 || countIncEdges(g,n)==0 )
-      std::cout << "GEBASZ!!!" << std::endl;
-
-  for(EdgeIt e(g);e!=INVALID;++e)
-    if(g.u(e)==g.v(e))
-      std::cout << "LOOP GEBASZ!!!" << std::endl;
-
-  std::cout << "Number of arcs : " << countEdges(g) << std::endl;
-
-  std::cout << "Total arc length (euler) : " << totalLen() << std::endl;
-
-  ListGraph::EdgeMap<Arc> enext(g);
-  {
-    EulerIt<ListGraph> e(g);
-    Arc eo=e;
-    Arc ef=e;
-//     std::cout << "Tour arc: " << g.id(Edge(e)) << std::endl;
-    for(++e;e!=INVALID;++e)
-      {
-//         std::cout << "Tour arc: " << g.id(Edge(e)) << std::endl;
-        enext[eo]=e;
-        eo=e;
-      }
-    enext[eo]=ef;
-  }
-
-  std::cout << "Creating a tour from that..." << std::endl;
-
-  int nnum = countNodes(g);
-  int ednum = countEdges(g);
-
-  for(Arc p=enext[EdgeIt(g)];ednum>nnum;p=enext[p])
-    {
-//       std::cout << "Checking arc " << g.id(p) << std::endl;
-      Arc e=enext[p];
-      Arc f=enext[e];
-      Node n2=g.source(f);
-      Node n1=g.oppositeNode(n2,e);
-      Node n3=g.oppositeNode(n2,f);
-      if(countIncEdges(g,n2)>2)
-        {
-//           std::cout << "Remove an Arc" << std::endl;
-          Arc ff=enext[f];
-          g.erase(e);
-          g.erase(f);
-          if(n1!=n3)
-            {
-              Arc ne=g.direct(g.addEdge(n1,n3),n1);
-              enext[p]=ne;
-              enext[ne]=ff;
-              ednum--;
-            }
-          else {
-            enext[p]=ff;
-            ednum-=2;
-          }
-        }
-    }
-
-  std::cout << "Total arc length (tour) : " << totalLen() << std::endl;
-
-  std::cout << "2-opt the tour..." << std::endl;
-
-  tsp_improve();
-
-  std::cout << "Total arc length (2-opt tour) : " << totalLen() << std::endl;
-}
-
-
-int main(int argc,const char **argv)
-{
-  ArgParser ap(argc,argv);
-
-//   bool eps;
-  bool disc_d, square_d, gauss_d;
-//   bool tsp_a,two_a,tree_a;
-  int num_of_cities=1;
-  double area=1;
-  N=100;
-//   girth=10;
-  std::string ndist("disc");
-  ap.refOption("n", "Number of nodes (default is 100)", N)
-    .intOption("g", "Girth parameter (default is 10)", 10)
-    .refOption("cities", "Number of cities (default is 1)", num_of_cities)
-    .refOption("area", "Full relative area of the cities (default is 1)", area)
-    .refOption("disc", "Nodes are evenly distributed on a unit disc (default)",
-               disc_d)
-    .optionGroup("dist", "disc")
-    .refOption("square", "Nodes are evenly distributed on a unit square",
-               square_d)
-    .optionGroup("dist", "square")
-    .refOption("gauss", "Nodes are located according to a two-dim Gauss "
-               "distribution", gauss_d)
-    .optionGroup("dist", "gauss")
-    .onlyOneGroup("dist")
-    .boolOption("eps", "Also generate .eps output (<prefix>.eps)")
-    .boolOption("nonodes", "Draw only the edges in the generated .eps output")
-    .boolOption("dir", "Directed graph is generated (each edge is replaced by "
-                "two directed arcs)")
-    .boolOption("2con", "Create a two connected planar graph")
-    .optionGroup("alg","2con")
-    .boolOption("tree", "Create a min. cost spanning tree")
-    .optionGroup("alg","tree")
-    .boolOption("tsp", "Create a TSP tour")
-    .optionGroup("alg","tsp")
-    .boolOption("tsp2", "Create a TSP tour (tree based)")
-    .optionGroup("alg","tsp2")
-    .boolOption("dela", "Delaunay triangulation graph")
-    .optionGroup("alg","dela")
-    .onlyOneGroup("alg")
-    .boolOption("rand", "Use time seed for random number generator")
-    .optionGroup("rand", "rand")
-    .intOption("seed", "Random seed", -1)
-    .optionGroup("rand", "seed")
-    .onlyOneGroup("rand")
-    .other("[prefix]","Prefix of the output files. Default is 'lgf-gen-out'")
-    .run();
-
-  if (ap["rand"]) {
-    int seed = int(time(0));
-    std::cout << "Random number seed: " << seed << std::endl;
-    rnd = Random(seed);
-  }
-  if (ap.given("seed")) {
-    int seed = ap["seed"];
-    std::cout << "Random number seed: " << seed << std::endl;
-    rnd = Random(seed);
-  }
-
-  std::string prefix;
-  switch(ap.files().size())
-    {
-    case 0:
-      prefix="lgf-gen-out";
-      break;
-    case 1:
-      prefix=ap.files()[0];
-      break;
-    default:
-      std::cerr << "\nAt most one prefix can be given\n\n";
-      exit(1);
-    }
-
-  double sum_sizes=0;
-  std::vector<double> sizes;
-  std::vector<double> cum_sizes;
-  for(int s=0;s<num_of_cities;s++)
-    {
-      //         sum_sizes+=rnd.exponential();
-      double d=rnd();
-      sum_sizes+=d;
-      sizes.push_back(d);
-      cum_sizes.push_back(sum_sizes);
-    }
-  int i=0;
-  for(int s=0;s<num_of_cities;s++)
-    {
-      Point center=(num_of_cities==1?Point(0,0):rnd.disc());
-      if(gauss_d)
-        for(;i<N*(cum_sizes[s]/sum_sizes);i++) {
-          Node n=g.addNode();
-          nodes.push_back(n);
-          coords[n]=center+rnd.gauss2()*area*
-            std::sqrt(sizes[s]/sum_sizes);
-        }
-      else if(square_d)
-        for(;i<N*(cum_sizes[s]/sum_sizes);i++) {
-          Node n=g.addNode();
-          nodes.push_back(n);
-          coords[n]=center+Point(rnd()*2-1,rnd()*2-1)*area*
-            std::sqrt(sizes[s]/sum_sizes);
-        }
-      else if(disc_d || true)
-        for(;i<N*(cum_sizes[s]/sum_sizes);i++) {
-          Node n=g.addNode();
-          nodes.push_back(n);
-          coords[n]=center+rnd.disc()*area*
-            std::sqrt(sizes[s]/sum_sizes);
-        }
-    }
-
-//   for (ListGraph::NodeIt n(g); n != INVALID; ++n) {
-//     std::cerr << coords[n] << std::endl;
-//   }
-
-  if(ap["tsp"]) {
-    tsp();
-    std::cout << "#2-opt improvements: " << tsp_impr_num << std::endl;
-  }
-  if(ap["tsp2"]) {
-    tsp2();
-    std::cout << "#2-opt improvements: " << tsp_impr_num << std::endl;
-  }
-  else if(ap["2con"]) {
-    std::cout << "Make triangles\n";
-    //   triangle();
-    sparseTriangle(ap["g"]);
-    std::cout << "Make it sparser\n";
-    sparse2(ap["g"]);
-  }
-  else if(ap["tree"]) {
-    minTree();
-  }
-  else if(ap["dela"]) {
-    delaunay();
-  }
-
-
-  std::cout << "Number of nodes    : " << countNodes(g) << std::endl;
-  std::cout << "Number of arcs    : " << countEdges(g) << std::endl;
-  double tlen=0;
-  for(EdgeIt e(g);e!=INVALID;++e)
-    tlen+=std::sqrt((coords[g.v(e)]-coords[g.u(e)]).normSquare());
-  std::cout << "Total arc length  : " << tlen << std::endl;
-
-  if(ap["eps"])
-    graphToEps(g,prefix+".eps").scaleToA4().
-      scale(600).nodeScale(.005).arcWidthScale(.001).preScale(false).
-      coords(coords).hideNodes(ap.given("nonodes")).run();
-
-  if(ap["dir"])
-    DigraphWriter<ListGraph>(g,prefix+".lgf").
-      nodeMap("coordinates_x",scaleMap(xMap(coords),600)).
-      nodeMap("coordinates_y",scaleMap(yMap(coords),600)).
-      run();
-  else GraphWriter<ListGraph>(g,prefix+".lgf").
-         nodeMap("coordinates_x",scaleMap(xMap(coords),600)).
-         nodeMap("coordinates_y",scaleMap(yMap(coords),600)).
-         run();
-}
-
