Diff [43647f48e971174a38200c0df622a8036f5d12e8:a7d841273c689d1a1ede4568d06af6c4b05ef6ff] for / – LEMON

.hgignore

r610	r944
23	23	lemon/stamp-h2
24	24	doc/Doxyfile
	25	doc/references.dox
25	26	cmake/version.cmake
26	27	.dirstamp

AUTHORS

-                      r320
+                      r1148
 The authors of the 1.x series are
+The main developers of release series 1.x are
  * Balazs Dezso <deba@inf.elte.hu>
 …
  * Akos Ladanyi <ladanyi@tmit.bme.hu>
 For more details on the actual contribution, please visit the history
 of the main LEMON source repository: http://lemon.cs.elte.hu/hg/lemon
+For more complete list of contributors, please visit the history of
+the LEMON source code repository: http://lemon.cs.elte.hu/hg/lemon
 Moreover, this version is heavily based on the 0.x series of
 LEMON. Here is the list of people who contributed to those versions.
+Moreover, this version is heavily based on version 0.x of LEMON. Here
+is the list of people who contributed to those versions.
  * Mihaly Barasz <klao@cs.elte.hu>
 …
 Again, please visit the history of the old LEMON repository for more
 details: http://lemon.cs.elte.hu/svn/lemon/trunk
+details: http://lemon.cs.elte.hu/hg/lemon-0.x

CMakeLists.txt

-                      r791
+                      r1344
+CMAKE_MINIMUM_REQUIRED(VERSION 2.6)
+CMAKE_MINIMUM_REQUIRED(VERSION 2.8)
+IF(POLICY CMP0048)
+  CMAKE_POLICY(SET CMP0048 OLD)
+ENDIF(POLICY CMP0048)
+IF(POLICY CMP0026)
+  #This is for copying the dll's needed by glpk (in lp_test and mip_test)
+  CMAKE_POLICY(SET CMP0026 OLD)
+ENDIF(POLICY CMP0026)
 SET(PROJECT_NAME "LEMON")
 PROJECT(${PROJECT_NAME})
+INCLUDE(FindPythonInterp)
+INCLUDE(FindWget)
 IF(EXISTS ${PROJECT_SOURCE_DIR}/cmake/version.cmake)
 …
 ELSE()
   EXECUTE_PROCESS(
+    COMMAND hg id -i
+    COMMAND
+    hg log -r. --template "{latesttag}"
     WORKING_DIRECTORY ${PROJECT_SOURCE_DIR}
     OUTPUT_VARIABLE HG_REVISION
+    OUTPUT_VARIABLE HG_REVISION_TAG
     ERROR_QUIET
     OUTPUT_STRIP_TRAILING_WHITESPACE
+  )
+  IF(HG_REVISION STREQUAL "")
+    SET(HG_REVISION "hg-tip")
+  EXECUTE_PROCESS(
+    COMMAND
+    hg log -r. --template "{latesttagdistance}"
+    WORKING_DIRECTORY ${PROJECT_SOURCE_DIR}
+    OUTPUT_VARIABLE HG_REVISION_DIST
+    ERROR_QUIET
+    OUTPUT_STRIP_TRAILING_WHITESPACE
+  )
+  EXECUTE_PROCESS(
+    COMMAND
+    hg log -r. --template "{node|short}"
+    WORKING_DIRECTORY ${PROJECT_SOURCE_DIR}
+    OUTPUT_VARIABLE HG_REVISION_ID
+    ERROR_QUIET
+    OUTPUT_STRIP_TRAILING_WHITESPACE
+  )
+  IF(HG_REVISION_TAG STREQUAL "")
+    SET(HG_REVISION_ID "hg-tip")
+  ELSE()
+    IF(HG_REVISION_TAG STREQUAL "null")
+      SET(HG_REVISION_TAG "trunk")
+    ELSEIF(HG_REVISION_TAG MATCHES "^r")
+      STRING(SUBSTRING ${HG_REVISION_TAG} 1 -1 HG_REVISION_TAG)
+    ENDIF()
+    IF(HG_REVISION_DIST STREQUAL "0")
+      SET(HG_REVISION ${HG_REVISION_TAG})
+    ELSE()
+      SET(HG_REVISION
+        "${HG_REVISION_TAG}+${HG_REVISION_DIST}-${HG_REVISION_ID}")
+    ENDIF()
   ENDIF()
   SET(LEMON_VERSION ${HG_REVISION} CACHE STRING "LEMON version string.")
 ENDIF()
 …
 FIND_PACKAGE(Doxygen)
 FIND_PACKAGE(Ghostscript)
+FIND_PACKAGE(GLPK 4.33)
+FIND_PACKAGE(CPLEX)
+FIND_PACKAGE(COIN)
+IF(WIN32)
+  SET(LEMON_WIN32 TRUE)
+ENDIF(WIN32)
+SET(LEMON_ENABLE_GLPK YES CACHE STRING "Enable GLPK solver backend.")
+SET(LEMON_ENABLE_ILOG YES CACHE STRING "Enable ILOG (CPLEX) solver backend.")
+SET(LEMON_ENABLE_COIN YES CACHE STRING "Enable COIN solver backend.")
+SET(LEMON_ENABLE_SOPLEX YES CACHE STRING "Enable SoPlex solver backend.")
+IF(LEMON_ENABLE_GLPK)
+  FIND_PACKAGE(GLPK 4.33)
+ENDIF(LEMON_ENABLE_GLPK)
+IF(LEMON_ENABLE_ILOG)
+  FIND_PACKAGE(ILOG)
+ENDIF(LEMON_ENABLE_ILOG)
+IF(LEMON_ENABLE_COIN)
+  FIND_PACKAGE(COIN)
+ENDIF(LEMON_ENABLE_COIN)
+IF(LEMON_ENABLE_SOPLEX)
+  FIND_PACKAGE(SOPLEX)
+ENDIF(LEMON_ENABLE_SOPLEX)
+IF(GLPK_FOUND)
+  SET(LEMON_HAVE_LP TRUE)
+  SET(LEMON_HAVE_MIP TRUE)
+  SET(LEMON_HAVE_GLPK TRUE)
+ENDIF(GLPK_FOUND)
+IF(ILOG_FOUND)
+  SET(LEMON_HAVE_LP TRUE)
+  SET(LEMON_HAVE_MIP TRUE)
+  SET(LEMON_HAVE_CPLEX TRUE)
+ENDIF(ILOG_FOUND)
+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)
+IF(SOPLEX_FOUND)
+  SET(LEMON_HAVE_LP TRUE)
+  SET(LEMON_HAVE_SOPLEX TRUE)
+ENDIF(SOPLEX_FOUND)
+IF(ILOG_FOUND)
+  SET(DEFAULT_LP "CPLEX")
+  SET(DEFAULT_MIP "CPLEX")
+ELSEIF(COIN_FOUND)
+  SET(DEFAULT_LP "CLP")
+  SET(DEFAULT_MIP "CBC")
+ELSEIF(GLPK_FOUND)
+  SET(DEFAULT_LP "GLPK")
+  SET(DEFAULT_MIP "GLPK")
+ELSEIF(SOPLEX_FOUND)
+  SET(DEFAULT_LP "SOPLEX")
+ENDIF()
+IF(NOT LEMON_DEFAULT_LP OR
+    (NOT ILOG_FOUND AND (LEMON_DEFAULT_LP STREQUAL "CPLEX")) OR
+    (NOT COIN_FOUND AND (LEMON_DEFAULT_LP STREQUAL "CLP")) OR
+    (NOT GLPK_FOUND AND (LEMON_DEFAULT_LP STREQUAL "GLPK")) OR
+    (NOT SOPLEX_FOUND AND (LEMON_DEFAULT_LP STREQUAL "SOPLEX")))
+  SET(LEMON_DEFAULT_LP ${DEFAULT_LP} CACHE STRING
+    "Default LP solver backend (GLPK, CPLEX, CLP or SOPLEX)" FORCE)
+ELSE()
+  SET(LEMON_DEFAULT_LP ${DEFAULT_LP} CACHE STRING
+    "Default LP solver backend (GLPK, CPLEX, CLP or SOPLEX)")
+ENDIF()
+IF(NOT LEMON_DEFAULT_MIP OR
+    (NOT ILOG_FOUND AND (LEMON_DEFAULT_MIP STREQUAL "CPLEX")) OR
+    (NOT COIN_FOUND AND (LEMON_DEFAULT_MIP STREQUAL "CBC")) OR
+    (NOT GLPK_FOUND AND (LEMON_DEFAULT_MIP STREQUAL "GLPK")))
+  SET(LEMON_DEFAULT_MIP ${DEFAULT_MIP} CACHE STRING
+    "Default MIP solver backend (GLPK, CPLEX or CBC)" FORCE)
+ELSE()
+  SET(LEMON_DEFAULT_MIP ${DEFAULT_MIP} CACHE STRING
+    "Default MIP solver backend (GLPK, CPLEX or CBC)")
+ENDIF()
+IF(DEFINED ENV{LEMON_CXX_WARNING})
+  SET(CXX_WARNING $ENV{LEMON_CXX_WARNING})
+ELSE()
+  IF(CMAKE_COMPILER_IS_GNUCXX)
+    SET(CXX_WARNING "-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 -fno-strict-aliasing -Wold-style-cast -Wno-unknown-pragmas")
+    SET(CMAKE_CXX_FLAGS_DEBUG CACHE STRING "-ggdb")
+    SET(CMAKE_C_FLAGS_DEBUG CACHE STRING "-ggdb")
+  ELSEIF(MSVC)
+    # This part is unnecessary 'casue the same is set by the lemon/core.h.
+    # Still kept as an example.
+    # SET(CXX_WARNING "/wd4250 /wd4267 /wd4355 /wd4503 /wd4800 /wd4996")
+    # Suppressed warnings:
+    # C4250: 'class1' : inherits 'class2::member' via dominance
+    # C4267: conversion from 'size_t' to 'type', possible loss of data
+    # 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
+  ELSE()
+    SET(CXX_WARNING "-Wall")
+  ENDIF()
+ENDIF()
+SET(LEMON_CXX_WARNING_FLAGS ${CXX_WARNING} CACHE STRING "LEMON warning flags.")
+SET(CMAKE_CXX_FLAGS "${CMAKE_CXX_FLAGS} ${LEMON_CXX_WARNING_FLAGS}")
+IF(MSVC)
+  SET(CMAKE_CXX_FLAGS "/bigobj ${CMAKE_CXX_FLAGS}")
+  SET( CMAKE_CXX_FLAGS_MAINTAINER "/WX ${CMAKE_CXX_FLAGS_DEBUG}" CACHE STRING
+    "Flags used by the C++ compiler during maintainer builds."
+    )
+  SET( CMAKE_C_FLAGS_MAINTAINER "/WX ${CMAKE_CXX_FLAGS_DEBUG}" CACHE STRING
+    "Flags used by the C compiler during maintainer builds."
+    )
+  SET( CMAKE_EXE_LINKER_FLAGS_MAINTAINER
+    "${CMAKE_EXE_LINKER_FLAGS_DEBUG}" CACHE STRING
+    "Flags used for linking binaries during maintainer builds."
+    )
+  SET( CMAKE_SHARED_LINKER_FLAGS_MAINTAINER
+    "${CMAKE_SHARED_LINKER_FLAGS_DEBUG}" CACHE STRING
+    "Flags used by the shared libraries linker during maintainer builds."
+    )
+ELSE()
+  SET( CMAKE_CXX_FLAGS_MAINTAINER "-Werror -ggdb -O0" CACHE STRING
+    "Flags used by the C++ compiler during maintainer builds."
+    )
+  SET( CMAKE_C_FLAGS_MAINTAINER "-Werror -O0" CACHE STRING
+    "Flags used by the C compiler during maintainer builds."
+    )
+  SET( CMAKE_EXE_LINKER_FLAGS_MAINTAINER
+    "${CMAKE_EXE_LINKER_FLAGS_DEBUG}" CACHE STRING
+    "Flags used for linking binaries during maintainer builds."
+    )
+  SET( CMAKE_SHARED_LINKER_FLAGS_MAINTAINER
+    "${CMAKE_SHARED_LINKER_FLAGS_DEBUG}" CACHE STRING
+    "Flags used by the shared libraries linker during maintainer builds."
+    )
+ENDIF()
+MARK_AS_ADVANCED(
+    CMAKE_CXX_FLAGS_MAINTAINER
+    CMAKE_C_FLAGS_MAINTAINER
+    CMAKE_EXE_LINKER_FLAGS_MAINTAINER
+    CMAKE_SHARED_LINKER_FLAGS_MAINTAINER )
+IF(CMAKE_CONFIGURATION_TYPES)
+  LIST(APPEND CMAKE_CONFIGURATION_TYPES Maintainer)
+  LIST(REMOVE_DUPLICATES CMAKE_CONFIGURATION_TYPES)
+  SET(CMAKE_CONFIGURATION_TYPES "${CMAKE_CONFIGURATION_TYPES}" CACHE STRING
+      "Add the configurations that we need"
+      FORCE)
+ endif()
+IF(NOT CMAKE_BUILD_TYPE)
+  SET(CMAKE_BUILD_TYPE "Release")
+ENDIF()
+SET( CMAKE_BUILD_TYPE "${CMAKE_BUILD_TYPE}" CACHE STRING
+    "Choose the type of build, options are: None(CMAKE_CXX_FLAGS or CMAKE_C_FLAGS used) Debug Release RelWithDebInfo MinSizeRel Maintainer."
+    FORCE )
 INCLUDE(CheckTypeSize)
 …
 SET(LEMON_HAVE_LONG_LONG ${HAVE_LONG_LONG})
+INCLUDE(FindPythonInterp)
+INCLUDE(FindThreads)
+IF(NOT LEMON_THREADING)
+  IF(CMAKE_USE_PTHREADS_INIT)
+    SET(LEMON_THREADING "Pthread")
+  ELSEIF(CMAKE_USE_WIN32_THREADS_INIT)
+    SET(LEMON_THREADING "Win32")
+  ELSE()
+    SET(LEMON_THREADING "None")
+  ENDIF()
+ENDIF()
+SET( LEMON_THREADING "${LEMON_THREADING}" CACHE STRING
+  "Choose the threading library, options are: Pthread Win32 None."
+  FORCE )
+IF(LEMON_THREADING STREQUAL "Pthread")
+  SET(LEMON_USE_PTHREAD TRUE)
+ELSEIF(LEMON_THREADING STREQUAL "Win32")
+  SET(LEMON_USE_WIN32_THREADS TRUE)
+ENDIF()
 ENABLE_TESTING()
+IF(${CMAKE_BUILD_TYPE} STREQUAL "Maintainer")
+  ADD_CUSTOM_TARGET(check ALL COMMAND ${CMAKE_CTEST_COMMAND})
+ELSE()
+  ADD_CUSTOM_TARGET(check COMMAND ${CMAKE_CTEST_COMMAND})
+ENDIF()
 ADD_SUBDIRECTORY(lemon)
 IF(${CMAKE_SOURCE_DIR} STREQUAL ${PROJECT_SOURCE_DIR})
+  ADD_SUBDIRECTORY(contrib)
   ADD_SUBDIRECTORY(demo)
   ADD_SUBDIRECTORY(tools)
 …
 ENDIF()
+IF(${CMAKE_SOURCE_DIR} STREQUAL ${PROJECT_SOURCE_DIR} AND WIN32)
+CONFIGURE_FILE(
+  ${PROJECT_SOURCE_DIR}/cmake/version.cmake.in
+  ${PROJECT_BINARY_DIR}/cmake/version.cmake
+  @ONLY
+)
+SET(ARCHIVE_BASE_NAME ${CMAKE_PROJECT_NAME})
+STRING(TOLOWER ${ARCHIVE_BASE_NAME} ARCHIVE_BASE_NAME)
+SET(ARCHIVE_NAME ${ARCHIVE_BASE_NAME}-${PROJECT_VERSION})
+ADD_CUSTOM_TARGET(dist
+  COMMAND cmake -E remove_directory ${ARCHIVE_NAME}
+  COMMAND hg archive ${ARCHIVE_NAME}
+  COMMAND cmake -E copy cmake/version.cmake ${ARCHIVE_NAME}/cmake/version.cmake
+  COMMAND tar -czf ${ARCHIVE_BASE_NAME}-nodoc-${PROJECT_VERSION}.tar.gz ${ARCHIVE_NAME}
+  COMMAND zip -r ${ARCHIVE_BASE_NAME}-nodoc-${PROJECT_VERSION}.zip ${ARCHIVE_NAME}
+  COMMAND cmake -E copy_directory doc/html ${ARCHIVE_NAME}/doc/html
+  COMMAND tar -czf ${ARCHIVE_NAME}.tar.gz ${ARCHIVE_NAME}
+  COMMAND zip -r ${ARCHIVE_NAME}.zip ${ARCHIVE_NAME}
+  COMMAND cmake -E copy_directory doc/html ${ARCHIVE_BASE_NAME}-doc-${PROJECT_VERSION}
+  COMMAND tar -czf ${ARCHIVE_BASE_NAME}-doc-${PROJECT_VERSION}.tar.gz ${ARCHIVE_BASE_NAME}-doc-${PROJECT_VERSION}
+  COMMAND zip -r ${ARCHIVE_BASE_NAME}-doc-${PROJECT_VERSION}.zip ${ARCHIVE_BASE_NAME}-doc-${PROJECT_VERSION}
+  COMMAND cmake -E remove_directory ${ARCHIVE_NAME}
+  COMMAND cmake -E remove_directory ${ARCHIVE_BASE_NAME}-doc-${PROJECT_VERSION}
+  DEPENDS html
+  WORKING_DIRECTORY ${PROJECT_BINARY_DIR})
+# CPACK config (Basically for NSIS)
+IF(${CMAKE_SOURCE_DIR} STREQUAL ${PROJECT_SOURCE_DIR})
   SET(CPACK_PACKAGE_NAME ${PROJECT_NAME})
   SET(CPACK_PACKAGE_VENDOR "EGRES")

INSTALL

-                      r615
+                      r1233
 =========================
+Since you are reading this I assume you already obtained one of the release
+tarballs and successfully extracted it. The latest version of LEMON is
+available at our web page (http://lemon.cs.elte.hu/).
+This file contains instructions for building and installing LEMON from
+source on Linux. The process on Windows is similar.
+LEMON provides two different build environments, one is based on "autotool",
+while the other is based on "cmake". This file contains instructions only for
+the former one, which is the recommended build environment on Linux, Mac OSX
+and other unices or if you use Cygwin on Windows. For cmake installation
+instructions visit http://lemon.cs.elte.hu.
+Note that it is not necessary to install LEMON in order to use
+it. Instead, you can easily integrate it with your own code
+directly. For instructions, see
+https://lemon.cs.elte.hu/trac/lemon/wiki/HowToCompile
 In order to install LEMON from the extracted source tarball you have to
 issue the following commands:
 . `cd lemon-x.y.z'
+. Step into the root of the source directory.
+      This command changes to the directory which was created when you
+      extracted the sources. The x.y.z part is a version number.
+      $ cd lemon-x.y.z
 . `./configure'
+. Create a build subdirectory and step into it.
       This command runs the configure shell script, which does some checks and
       creates the makefiles.
+      $ mkdir build
+      $ cd build
 . `make'
+. Perform system checks and create the makefiles.
+      This command compiles the non-template part of LEMON into libemon.a
+      file. It also compiles the programs in the tools subdirectory by
+      default.
+      $ cmake ..
 . `make check'
+. Build LEMON.
+      This step is optional, but recommended. It runs the test programs that
+      we developed for LEMON to check whether the library works properly on
+      your platform.
+      $ make
+. `make install'
+      This command compiles the non-template part of LEMON into
+      libemon.a file. It also compiles the programs in the 'tools' and
+      'demo' subdirectories.
+. [Optional] Compile and run the self-tests.
+      $ make check
+. [Optional] Generate the user documentation.
+      $ make html
+      The release tarballs already include the documentation.
+      Note that for this step you need to have the following tools
+      installed: Python, Doxygen, Graphviz, Ghostscript, LaTeX.
+. [Optional] Install LEMON
+      $ make install
       This command installs LEMON under /usr/local (you will need root
+      privileges to be able to do that). If you want to install it to some
+      other location, then pass the --prefix=DIRECTORY flag to configure in
+      step 2. For example: `./configure --prefix=/home/username/lemon'.
+. `make install-html'
+      This command installs the documentation under share/doc/lemon/docs. The
+      generated documentation is included in the tarball. If you want to
+      generate it yourself, then run `make html'. Note that for this you need
+      to have the following programs installed: Doxygen, Graphviz, Ghostscript,
+      Latex.
+      privileges to be able to do that). If you want to install it to
+      some other location, then pass the
+      -DCMAKE_INSTALL_PREFIX=DIRECTORY flag to cmake in Step 3.
+      For example:
+      $ cmake -DCMAKE_INSTALL_PREFIX=/home/username/lemon'
 Configure Options and Variables
 ===============================
+In step 2 you can customize the actions of configure by setting variables
+and passing options to it. This can be done like this:
+`./configure [OPTION]... [VARIABLE=VALUE]...'
+In Step 3, you can customize the build process by passing options to CMAKE.
+Below you will find some useful variables and options (see `./configure --help'
+for more):
+$ cmake [OPTIONS] ..
+CXX='comp'
+You find a list of the most useful options below.
+  Change the C++ compiler to 'comp'.
+CXXFLAGS='flags'
+  Pass the 'flags' to the compiler. For example CXXFLAGS='-O3 -march=pentium-m'
+  turns on generation of aggressively optimized Pentium-M specific code.
+--prefix=PREFIX
+-DCMAKE_INSTALL_PREFIX=PREFIX
   Set the installation prefix to PREFIX. By default it is /usr/local.
 --enable-tools
+-DCMAKE_BUILD_TYPE=[Release|Debug|Maintainer|...]
    Build the programs in the tools subdirectory (default).
+  This sets the compiler options. The choices are the following
+--disable-tools
+  'Release': A strong optimization is turned on (-O3 with gcc). This
+    is the default setting and we strongly recommend using this for
+    the final compilation.
+   Do not build the programs in the tools subdirectory.
+  'Debug': Optimization is turned off and debug info is added (-O0
+    -ggdb with gcc). If is recommended during the development.
+--with-glpk[=PREFIX]
+  'Maintainer': The same as 'Debug' but the compiler warnings are
+    converted to errors (-Werror with gcc). In addition, 'make' will
+    also automatically compile and execute the test codes. It is the
+    best way of ensuring that LEMON codebase is clean and safe.
+   Enable GLPK support (default). You should specify the prefix too if
+   you installed GLPK to some non-standard location (e.g. your home
+   directory). If it is not found, GLPK support will be disabled.
+  'RelWithDebInfo': Optimized build with debug info.
+--with-glpk-includedir=DIR
+  'MinSizeRel': Size optimized build (-Os with gcc)
+   The directory where the GLPK header files are located. This is only
+   useful when the GLPK headers and libraries are not under the same
+   prefix (which is unlikely).
+-DTEST_WITH_VALGRIND=YES
+--with-glpk-libdir=DIR
+  Using this, the test codes will be executed using valgrind. It is a
+  very effective way of identifying indexing problems and memory leaks.
+   The directory where the GLPK libraries are located. This is only
+   useful when the GLPK headers and libraries are not under the same
+   prefix (which is unlikely).
+-DCMAKE_CXX_COMPILER=path-to-compiler
+--without-glpk
+  Change the compiler to be used.
+   Disable GLPK support.
+-DBUILD_SHARED_LIBS=TRUE
+--with-cplex[=PREFIX]
+  Build shared library instead of static one. Think twice if you
+  really want to use this option.
+   Enable CPLEX support (default). You should specify the prefix too
+   if you installed CPLEX to some non-standard location
+   (e.g. /opt/ilog/cplex75). If it is not found, CPLEX support will be
+   disabled.
+-DLEMON_DOC_SOURCE_BROWSER=YES
+--with-cplex-includedir=DIR
+  Include the browsable cross referenced LEMON source code into the
+  doc. It makes the doc quite bloated, but may be useful for
+  developing LEMON itself.
+   The directory where the CPLEX header files are located. This is
+   only useful when the CPLEX headers and libraries are not under the
+   same prefix (e.g.  /usr/local/cplex/cplex75/include).
+-DLEMON_DOC_USE_MATHJAX=YES
+--with-cplex-libdir=DIR
+  Use MathJax (http://mathjax.org) for rendering the math formulae in
+  the doc.  It of much higher quality compared to the default LaTeX
+  generated static images and it allows copy&paste of the formulae to
+  LaTeX, Open Office, MS Word etc. documents.
+   The directory where the CPLEX libraries are located. This is only
+   useful when the CPLEX headers and libraries are not under the same
+   prefix (e.g.
+   /usr/local/cplex/cplex75/lib/i86_linux2_glibc2.2_gcc3.0/static_pic_mt).
+  On the other hand, it needs either Internet access or a locally
+  installed version of MathJax to properly render the doc.
+--without-cplex
+-DLEMON_DOC_MATHJAX_RELPATH=DIRECTORY
+  The location of the MathJax library. It defaults to
+  http://www.mathjax.org/mathjax, which necessitates Internet access
+  for proper rendering. The easiest way to make it usable offline is
+  to set this parameter to 'mathjax' and copy all files of the MathJax
+  library into the 'doc/html/mathjax' subdirectory of the build
+  location.
    Disable CPLEX support.
+  See http://docs.mathjax.org/en/latest/installation.html for more details.
+--with-soplex[=PREFIX]
+-DLEMON_ENABLE_GLPK=NO
+-DLEMON_ENABLE_COIN=NO
+-DLEMON_ENABLE_ILOG=NO
+   Enable SoPlex support (default). You should specify the prefix too if
+   you installed SoPlex to some non-standard location (e.g. your home
+   directory). If it is not found, SoPlex support will be disabled.
+  Enable optional third party libraries. They are all enabled by default.
 --with-soplex-includedir=DIR
+-DLEMON_DEFAULT_LP=GLPK
    The directory where the SoPlex header files are located. This is only
    useful when the SoPlex headers and libraries are not under the same
    prefix (which is unlikely).
+  Sets the default LP solver backend. The supported values are
+  CPLEX, CLP and GLPK. By default, it is set to the first one which
+  is enabled and succesfully discovered.
 --with-soplex-libdir=DIR
+-DLEMON_DEFAULT_MIP=GLPK
    The directory where the SoPlex libraries are located. This is only
    useful when the SoPlex headers and libraries are not under the same
    prefix (which is unlikely).
+  Sets the default MIP solver backend. The supported values are
+  CPLEX, CBC and GLPK. By default, it is set to the first one which
+  is enabled and succesfully discovered.
+--without-soplex
+-DGLPK_ROOT_DIR=DIRECTORY
+-DCOIN_ROOT_DIR=DIRECTORY
+-DILOG_ROOT_DIR=DIRECTORY
    Disable SoPlex support.
+  Root directory prefixes of optional third party libraries.
+--with-coin[=PREFIX]
+Makefile Variables
+==================
+   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.
+make VERBOSE=1
+--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.
+   This results in a more verbose output by showing the full
+   compiler and linker commands.

LICENSE

r600	r1148
2	2	copyright/license.
3	3
4		Copyright (C) 2003-2009 Egervary Jeno Kombinatorikus Optimalizalasi
	4	Copyright (C) 2003-2012 Egervary Jeno Kombinatorikus Optimalizalasi
5	5	Kutatocsoport (Egervary Combinatorial Optimization Research Group,
6	6	EGRES).

NEWS

-                      r712
+                      r1320
+-07-07 Version 1.3.1 released
+        Bugfix release.
+        #484: Require CMAKE 2.8
+        #471, #472, #480: Various clang compatibility fixes
+        #481, #482: Fix shared lib build and versioning
+        #476: Fix invalid map query in NearestNeighborTsp
+        #478: Bugfix in debug checking and lower bound handling
+              in min cost flow algorithms
+        #479, #465: Bugfix in default LP/MIP backend settings
+        #476: Bugfix in tsp_test
+        #487: Add missing include header and std:: namespace spec.
+        #474: Fix division by zero error in NetworkSimplex
+-08-10 Version 1.3 released
+        This is major feature release
+        * New data structures
+          #69 : Bipartite graph concepts and implementations
+        * New algorithms
+          #177: Port Edmonds-Karp algorithm
+          #380, #405: Heuristic algorithm for the max clique problem
+          #386: Heuristic algorithms for symmetric TSP
+          ----: Nagamochi-Ibaraki algorithm [5087694945e4]
+          #397, #56: Max. cardinality search
+        * Other new features
+          #223: Thread safe graph and graph map implementations
+          #442: Different TimeStamp print formats
+          #457: File export functionality to LpBase
+          #362: Bidirectional iterator support for radixSort()
+        * Implementation improvements
+          ----: Network Simplex
+                #391: Better update process, pivot rule and arc mixing
+                #435: Improved Altering List pivot rule
+          #417: Various fine tunings in CostScaling
+          #438: Optional iteration limit in HowardMmc
+          #436: Ensure strongly polynomial running time for CycleCanceling
+                while keeping the same performance
+          ----: Make the CBC interface be compatible with latest CBC releases
+                [ee581a0ecfbf]
+        * CMAKE has become the default build environment (#434)
+          ----: Autotool support has been dropped
+          ----: Improved LP/MIP configuration
+                #465: Enable/disable options for LP/MIP backends
+                #446: Better CPLEX discovery
+                #460: Add cmake config to find SoPlex
+          ----: Allow CPACK configuration on all platforms
+          #390: Add 'Maintainer' CMAKE build type
+          #388: Add 'check' target.
+          #401: Add contrib dir
+          #389: Better version string setting in CMAKE
+          #433: Support shared library build
+          #416: Support testing with valgrind
+        * Doc improvements
+          #395: SOURCE_BROWSER Doxygen switch is configurable from CMAKE
+                update-external-tags CMAKE target
+          #455: Optionally use MathJax for rendering the math formulae
+          #402, #437, #459, #456, #463: Various doc improvements
+        * Bugfixes (compared to release 1.2):
+          #432: Add missing doc/template.h and doc/references.bib to release
+                tarball
+          ----: Intel C++ compatibility fixes
+          #441: Fix buggy reinitialization in _solver_bits::VarIndex::clear()
+          #444: Bugfix in path copy constructors and assignment operators
+          #447: Bugfix in AllArcLookUp<>
+          #448: Bugfix in adaptor_test.cc
+          #449: Fix clang compilation warnings and errors
+          #440: Fix a bug + remove redundant typedefs in dimacs-solver
+          #453: Avoid GCC 4.7 compiler warnings
+          #445: Fix missing initialization in CplexEnv::CplexEnv()
+          #428: Add missing lemon/lemon.pc.cmake to the release tarball
+          #393: Create and install lemon.pc
+          #429: Fix VS warnings
+          #430: Fix LpBase::Constr two-side limit bug
+          #392: Bug fix in Dfs::start(s,t)
+          #414: Fix wrong initialization in Preflow
+          #418: Better Win CodeBlock/MinGW support
+          #419: Build environment improvements
+                - Build of mip_test and lp_test precede the running of the tests
+                - Also search for coin libs under ${COIN_ROOT_DIR}/lib/coin
+                - Do not look for COIN_VOL libraries
+          #382: Allow lgf file without Arc maps
+          #417: Bug fix in CostScaling
+          #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
+          #461: Bugfix in assert.h
+          #470: Fix compilation issues related to various gcc versions
+          #446: Fix #define indicating CPLEX availability
+          #294: Add explicit namespace to
+                ignore_unused_variable_warning() usages
+          #420: Bugfix in IterableValueMap
+          #439: Bugfix in biNodeConnected()
+-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)
 -05-13 Version 1.1 released
 …
           ----: Add missing unistd.h include to time_measure.h
           #204: Compilation bug fixed in graph_to_eps.h with VS2005
           #214,#215: windows.h should never be included by lemon headers
+          #214,#215: windows.h should never be included by LEMON headers
           #230: Build systems check the availability of 'long long' type
           #229: Default implementation of Tolerance<> is used for integer types
 …
 -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.
         * The major name changes compared to the 0.x series (see the
+        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
           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)

README

-                      r705
+                      r921
    Copying, distribution and modification conditions and terms.
+NEWS
+   News and version history.
 INSTALL
 …
    Some example programs to make you easier to get familiar with LEMON.
+scripts/
+   Scripts that make it easier to develop LEMON.
 test/

cmake/FindCOIN.cmake

-                      r681
+                      r1232
 FIND_LIBRARY(COIN_CBC_LIBRARY
   NAMES Cbc libCbc
+  HINTS ${COIN_ROOT_DIR}/lib/coin
   HINTS ${COIN_ROOT_DIR}/lib
+)
 FIND_LIBRARY(COIN_CBC_SOLVER_LIBRARY
   NAMES CbcSolver libCbcSolver
+  HINTS ${COIN_ROOT_DIR}/lib/coin
   HINTS ${COIN_ROOT_DIR}/lib
+)
 FIND_LIBRARY(COIN_CGL_LIBRARY
   NAMES Cgl libCgl
+  HINTS ${COIN_ROOT_DIR}/lib/coin
   HINTS ${COIN_ROOT_DIR}/lib
+)
 FIND_LIBRARY(COIN_CLP_LIBRARY
   NAMES Clp libClp
+  HINTS ${COIN_ROOT_DIR}/lib/coin
   HINTS ${COIN_ROOT_DIR}/lib
+)
 FIND_LIBRARY(COIN_COIN_UTILS_LIBRARY
   NAMES CoinUtils libCoinUtils
+  HINTS ${COIN_ROOT_DIR}/lib/coin
   HINTS ${COIN_ROOT_DIR}/lib
+)
 FIND_LIBRARY(COIN_OSI_LIBRARY
   NAMES Osi libOsi
+  HINTS ${COIN_ROOT_DIR}/lib/coin
   HINTS ${COIN_ROOT_DIR}/lib
+)
 FIND_LIBRARY(COIN_OSI_CBC_LIBRARY
   NAMES OsiCbc libOsiCbc
+  HINTS ${COIN_ROOT_DIR}/lib/coin
   HINTS ${COIN_ROOT_DIR}/lib
+)
 FIND_LIBRARY(COIN_OSI_CLP_LIBRARY
   NAMES OsiClp libOsiClp
+  HINTS ${COIN_ROOT_DIR}/lib/coin
   HINTS ${COIN_ROOT_DIR}/lib
+)
 FIND_LIBRARY(COIN_OSI_VOL_LIBRARY
   NAMES OsiVol libOsiVol
+  HINTS ${COIN_ROOT_DIR}/lib/coin
   HINTS ${COIN_ROOT_DIR}/lib
+)
 FIND_LIBRARY(COIN_VOL_LIBRARY
   NAMES Vol libVol
+  HINTS ${COIN_ROOT_DIR}/lib/coin
+  HINTS ${COIN_ROOT_DIR}/lib
+)
+FIND_LIBRARY(COIN_ZLIB_LIBRARY
+  NAMES z libz
+  HINTS ${COIN_ROOT_DIR}/lib/coin
+  HINTS ${COIN_ROOT_DIR}/lib
+)
+FIND_LIBRARY(COIN_BZ2_LIBRARY
+  NAMES bz2 libbz2
+  HINTS ${COIN_ROOT_DIR}/lib/coin
   HINTS ${COIN_ROOT_DIR}/lib
+)
 …
   COIN_OSI_CBC_LIBRARY
   COIN_OSI_CLP_LIBRARY
   COIN_OSI_VOL_LIBRARY
   COIN_VOL_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})
+  SET(COIN_CLP_LIBRARIES "${COIN_CLP_LIBRARY};${COIN_COIN_UTILS_LIBRARY};${COIN_ZLIB_LIBRARY};${COIN_BZ2_LIBRARY}")
+  IF(COIN_ZLIB_LIBRARY)
+    SET(COIN_CLP_LIBRARIES "${COIN_CLP_LIBRARIES};${COIN_ZLIB_LIBRARY}")
+  ENDIF(COIN_ZLIB_LIBRARY)
+   IF(COIN_BZ2_LIBRARY)
+    SET(COIN_CLP_LIBRARIES "${COIN_CLP_LIBRARIES};${COIN_BZ2_LIBRARY}")
+  ENDIF(COIN_BZ2_LIBRARY)
+  SET(COIN_CBC_LIBRARIES "${COIN_CBC_LIBRARY};${COIN_CBC_SOLVER_LIBRARY};${COIN_CGL_LIBRARY};${COIN_OSI_LIBRARY};${COIN_OSI_CBC_LIBRARY};${COIN_OSI_CLP_LIBRARY};${COIN_ZLIB_LIBRARY};${COIN_BZ2_LIBRARY};${COIN_CLP_LIBRARIES}")
+  SET(COIN_LIBRARIES ${COIN_CBC_LIBRARIES})
 ENDIF(COIN_FOUND)
 …
   COIN_OSI_VOL_LIBRARY
   COIN_VOL_LIBRARY
+  COIN_ZLIB_LIBRARY
+  COIN_BZ2_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)

cmake/FindGLPK.cmake

-                      r685
+                      r1232
 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)

cmake/version.cmake.in

r725	r1135
1		SET(LEMON_VERSION "@~~PACKAGE~~_VERSION@" CACHE STRING "LEMON version string.")
	1	SET(LEMON_VERSION "@LEMON_VERSION@" CACHE STRING "LEMON version string.")

demo/arg_parser_demo.cc

-                      r463
+                      r956
  * This file is a part of LEMON, a generic C++ optimization library.
+ *
  * Copyright (C) 2003-2009
+ * Copyright (C) 2003-2010
  * Egervary Jeno Kombinatorikus Optimalizalasi Kutatocsoport
  * (Egervary Research Group on Combinatorial Optimization, EGRES).
 …
     .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)
+  ap.parse();
+  // The try {} construct is necessary only if the ap.trowOnProblems()
+  // setting is in use.
+  try {
+    ap.parse();
+  } catch (ArgParserException &) { return 1; }
   // Check each option if it has been given and print its value

doc/CMakeLists.txt

-                      r791
+                      r1251
 SET(abs_top_srcdir ${PROJECT_SOURCE_DIR})
 SET(abs_top_builddir ${PROJECT_BINARY_DIR})
+SET(LEMON_DOC_SOURCE_BROWSER "NO" CACHE STRING "Include source into the doc (YES/NO).")
+SET(LEMON_DOC_USE_MATHJAX "NO" CACHE STRING "Use MathJax to display math formulae (YES/NO).")
+SET(LEMON_DOC_MATHJAX_RELPATH "http://www.mathjax.org/mathjax" CACHE STRING "MathJax library location.")
+SET(LEMON_DOC_LIBSTDC++_URL
+  "http://gcc.gnu.org/onlinedocs/gcc-4.7.3/libstdc++/api"
+  CACHE STRING "GCC libstdc++ doxygen doc url.")
 CONFIGURE_FILE(
 …
+)
+CONFIGURE_FILE(
+  ${PROJECT_SOURCE_DIR}/doc/mainpage.dox.in
+  ${PROJECT_BINARY_DIR}/doc/mainpage.dox
+  @ONLY
+)
+# Copy doc from source (if exists)
+IF(EXISTS ${CMAKE_CURRENT_SOURCE_DIR}/html AND
+    NOT EXISTS ${CMAKE_CURRENT_BINARY_DIR}/html/index.html)
+  MESSAGE(STATUS "Copy doc from source tree")
+  EXECUTE_PROCESS(
+    COMMAND cmake -E copy_directory ${CMAKE_CURRENT_SOURCE_DIR}/html ${CMAKE_CURRENT_BINARY_DIR}/html
+    )
+ENDIF()
 IF(DOXYGEN_EXECUTABLE AND PYTHONINTERP_FOUND AND GHOSTSCRIPT_EXECUTABLE)
   FILE(MAKE_DIRECTORY ${CMAKE_CURRENT_BINARY_DIR}/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/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/strongly_connected_components.png ${CMAKE_CURRENT_SOURCE_DIR}/images/strongly_connected_components.eps
+    COMMAND ${GHOSTSCRIPT_EXECUTABLE} ${GHOSTSCRIPT_OPTIONS} -r20 -sOutputFile=gen-images/grid_graph.png ${CMAKE_CURRENT_SOURCE_DIR}/images/grid_graph.eps
+    COMMAND ${GHOSTSCRIPT_EXECUTABLE} ${GHOSTSCRIPT_OPTIONS} -r32 -sOutputFile=gen-images/adaptors2.png ${CMAKE_CURRENT_SOURCE_DIR}/images/adaptors2.eps
+    COMMAND ${GHOSTSCRIPT_EXECUTABLE} ${GHOSTSCRIPT_OPTIONS} -r32 -sOutputFile=gen-images/connected_components.png ${CMAKE_CURRENT_SOURCE_DIR}/images/connected_components.eps
+    COMMAND ${GHOSTSCRIPT_EXECUTABLE} ${GHOSTSCRIPT_OPTIONS} -r32 -sOutputFile=gen-images/strongly_connected_components.png ${CMAKE_CURRENT_SOURCE_DIR}/images/strongly_connected_components.eps
+    COMMAND ${GHOSTSCRIPT_EXECUTABLE} ${GHOSTSCRIPT_OPTIONS} -r32 -sOutputFile=gen-images/node_biconnected_components.png ${CMAKE_CURRENT_SOURCE_DIR}/images/node_biconnected_components.eps
+    COMMAND ${GHOSTSCRIPT_EXECUTABLE} ${GHOSTSCRIPT_OPTIONS} -r32 -sOutputFile=gen-images/edge_biconnected_components.png ${CMAKE_CURRENT_SOURCE_DIR}/images/edge_biconnected_components.eps
+    COMMAND ${GHOSTSCRIPT_EXECUTABLE} ${GHOSTSCRIPT_OPTIONS} -r32 -sOutputFile=gen-images/bipartite_partitions.png ${CMAKE_CURRENT_SOURCE_DIR}/images/bipartite_partitions.eps
+    COMMAND ${GHOSTSCRIPT_EXECUTABLE} ${GHOSTSCRIPT_OPTIONS} -r24 -sOutputFile=gen-images/matching.png ${CMAKE_CURRENT_SOURCE_DIR}/images/matching.eps
+    COMMAND ${GHOSTSCRIPT_EXECUTABLE} ${GHOSTSCRIPT_OPTIONS} -r24 -sOutputFile=gen-images/bipartite_matching.png ${CMAKE_CURRENT_SOURCE_DIR}/images/bipartite_matching.eps
+    COMMAND ${GHOSTSCRIPT_EXECUTABLE} ${GHOSTSCRIPT_OPTIONS} -r40 -sOutputFile=gen-images/planar.png ${CMAKE_CURRENT_SOURCE_DIR}/images/planar.eps
+    COMMAND ${GHOSTSCRIPT_EXECUTABLE} ${GHOSTSCRIPT_OPTIONS} -r24 -sOutputFile=gen-images/tsp.png ${CMAKE_CURRENT_SOURCE_DIR}/images/tsp.eps
+    COMMAND ${GHOSTSCRIPT_EXECUTABLE} ${GHOSTSCRIPT_OPTIONS} -r8 -sOutputFile=gen-images/nodeshape_0.png ${CMAKE_CURRENT_SOURCE_DIR}/images/nodeshape_0.eps
+    COMMAND ${GHOSTSCRIPT_EXECUTABLE} ${GHOSTSCRIPT_OPTIONS} -r8 -sOutputFile=gen-images/nodeshape_1.png ${CMAKE_CURRENT_SOURCE_DIR}/images/nodeshape_1.eps
+    COMMAND ${GHOSTSCRIPT_EXECUTABLE} ${GHOSTSCRIPT_OPTIONS} -r8 -sOutputFile=gen-images/nodeshape_2.png ${CMAKE_CURRENT_SOURCE_DIR}/images/nodeshape_2.eps
+    COMMAND ${GHOSTSCRIPT_EXECUTABLE} ${GHOSTSCRIPT_OPTIONS} -r8 -sOutputFile=gen-images/nodeshape_3.png ${CMAKE_CURRENT_SOURCE_DIR}/images/nodeshape_3.eps
+    COMMAND ${GHOSTSCRIPT_EXECUTABLE} ${GHOSTSCRIPT_OPTIONS} -r8 -sOutputFile=gen-images/nodeshape_4.png ${CMAKE_CURRENT_SOURCE_DIR}/images/nodeshape_4.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}
 …
 ENDIF()
+IF(WGET_FOUND)
+ADD_CUSTOM_TARGET(update-external-tags
+  COMMAND ${WGET_EXECUTABLE} -N ${LEMON_DOC_LIBSTDC++_URL}/libstdc++.tag
+  WORKING_DIRECTORY ${CMAKE_CURRENT_BINARY_DIR}
+  )
+ENDIF()

doc/Doxyfile.in

-                      r803
+                      r1251
 # Doxyfile 1.5.9
+# Doxyfile 1.7.3
 #---------------------------------------------------------------------------
 …
 #---------------------------------------------------------------------------
 DOXYFILE_ENCODING      = UTF-8
+PROJECT_NAME           = @PACKAGE_NAME@
+PROJECT_NUMBER         = @PACKAGE_VERSION@
+PROJECT_NAME           =
+PROJECT_NUMBER         =
+PROJECT_BRIEF          =
+PROJECT_LOGO           =
 OUTPUT_DIRECTORY       =
 CREATE_SUBDIRS         = NO
 …
 OPTIMIZE_FOR_FORTRAN   = NO
 OPTIMIZE_OUTPUT_VHDL   = NO
+EXTENSION_MAPPING      =
 BUILTIN_STL_SUPPORT    = YES
 CPP_CLI_SUPPORT        = NO
 …
 HIDE_SCOPE_NAMES       = YES
 SHOW_INCLUDE_FILES     = YES
+FORCE_LOCAL_INCLUDES   = NO
 INLINE_INFO            = YES
 SORT_MEMBER_DOCS       = NO
 SORT_BRIEF_DOCS        = NO
+SORT_MEMBERS_CTORS_1ST = NO
 SORT_GROUP_NAMES       = NO
 SORT_BY_SCOPE_NAME     = NO
+STRICT_PROTO_MATCHING  = NO
 GENERATE_TODOLIST      = YES
 GENERATE_TESTLIST      = YES
 …
 SHOW_NAMESPACES        = YES
 FILE_VERSION_FILTER    =
+LAYOUT_FILE            = DoxygenLayout.xml
+LAYOUT_FILE            = "@abs_top_srcdir@/doc/DoxygenLayout.xml"
+CITE_BIB_FILES         = "@abs_top_srcdir@/doc/references.bib"
 #---------------------------------------------------------------------------
 # configuration options related to warning and progress messages
 …
                          "@abs_top_srcdir@/lemon/concepts" \
                          "@abs_top_srcdir@/demo" \
+                         "@abs_top_srcdir@/contrib" \
                          "@abs_top_srcdir@/tools" \
                          "@abs_top_srcdir@/test/test_tools.h" \
                          "@abs_top_builddir@/doc/references.dox"
+                         "@abs_top_builddir@/doc/mainpage.dox"
 INPUT_ENCODING         = UTF-8
 FILE_PATTERNS          = *.h \
 …
 FILTER_PATTERNS        =
 FILTER_SOURCE_FILES    = NO
+FILTER_SOURCE_PATTERNS =
 #---------------------------------------------------------------------------
 # configuration options related to source browsing
 #---------------------------------------------------------------------------
 SOURCE_BROWSER         = NO
+SOURCE_BROWSER         = @LEMON_DOC_SOURCE_BROWSER@
 INLINE_SOURCES         = NO
 STRIP_CODE_COMMENTS    = YES
 …
 HTML_FOOTER            =
 HTML_STYLESHEET        =
+HTML_COLORSTYLE_HUE    = 220
+HTML_COLORSTYLE_SAT    = 100
+HTML_COLORSTYLE_GAMMA  = 80
+HTML_TIMESTAMP         = YES
 HTML_ALIGN_MEMBERS     = YES
 HTML_DYNAMIC_SECTIONS  = NO
+HTML_DYNAMIC_SECTIONS  = YES
 GENERATE_DOCSET        = NO
 DOCSET_FEEDNAME        = "Doxygen generated docs"
 DOCSET_BUNDLE_ID       = org.doxygen.Project
+DOCSET_PUBLISHER_ID    = org.doxygen.Publisher
+DOCSET_PUBLISHER_NAME  = Publisher
 GENERATE_HTMLHELP      = NO
 CHM_FILE               =
 …
 QHP_NAMESPACE          = org.doxygen.Project
 QHP_VIRTUAL_FOLDER     = doc
+QHP_CUST_FILTER_NAME   =
+QHP_CUST_FILTER_ATTRS  =
+QHP_SECT_FILTER_ATTRS  =
 QHG_LOCATION           =
+GENERATE_ECLIPSEHELP   = NO
+ECLIPSE_DOC_ID         = org.doxygen.Project
 DISABLE_INDEX          = NO
 ENUM_VALUES_PER_LINE   = 4
 GENERATE_TREEVIEW      = NO
+USE_INLINE_TREES       = NO
 TREEVIEW_WIDTH         = 250
+EXT_LINKS_IN_WINDOW    = NO
 FORMULA_FONTSIZE       = 10
+FORMULA_TRANSPARENT    = YES
+USE_MATHJAX            = @LEMON_DOC_USE_MATHJAX@
+MATHJAX_RELPATH        = @LEMON_DOC_MATHJAX_RELPATH@
+SEARCHENGINE           = YES
+SERVER_BASED_SEARCH    = NO
 #---------------------------------------------------------------------------
 # configuration options related to the LaTeX output
 …
 LATEX_BATCHMODE        = NO
 LATEX_HIDE_INDICES     = NO
+LATEX_SOURCE_CODE      = NO
 #---------------------------------------------------------------------------
 # configuration options related to the RTF output
 …
 SKIP_FUNCTION_MACROS   = YES
 #---------------------------------------------------------------------------
 # Options related to the search engine
 #---------------------------------------------------------------------------
 TAGFILES               = "@abs_top_srcdir@/doc/libstdc++.tag = http://gcc.gnu.org/onlinedocs/libstdc++/latest-doxygen/  "
+# Configuration::additions related to external references
+#---------------------------------------------------------------------------
+TAGFILES               = "@abs_top_builddir@/doc/libstdc++.tag = @LEMON_DOC_LIBSTDC++_URL@"
 GENERATE_TAGFILE       = html/lemon.tag
 ALLEXTERNALS           = NO
 …
 HIDE_UNDOC_RELATIONS   = YES
 HAVE_DOT               = YES
+DOT_NUM_THREADS        = 0
 DOT_FONTNAME           = FreeSans
 DOT_FONTSIZE           = 10
 …
 DOT_PATH               =
 DOTFILE_DIRS           =
+MSCFILE_DIRS           =
 DOT_GRAPH_MAX_NODES    = 50
 MAX_DOT_GRAPH_DEPTH    = 0
 …
 GENERATE_LEGEND        = YES
 DOT_CLEANUP            = YES
-#---------------------------------------------------------------------------
-# Configuration::additions related to the search engine
-#---------------------------------------------------------------------------
-SEARCHENGINE           = NO

doc/DoxygenLayout.xml

-                      r316
+                      r1251
   <navindex>
     <tab type="mainpage" visible="yes" title=""/>
     <tab type="modules" visible="yes" title=""/>
+    <tab type="modules" visible="yes" title="" intro=""/>
     <tab type="classes" visible="yes" title="">
       <tab type="classes" visible="yes" title=""/>
       <tab type="classindex" visible="$ALPHABETICAL_INDEX" title=""/>
       <tab type="hierarchy" visible="yes" title=""/>
       <tab type="classmembers" visible="yes" title=""/>
+      <tab type="classes" visible="yes" title="" intro=""/>
+      <tab type="classindex" visible="$ALPHABETICAL_INDEX" title=""/>
+      <tab type="hierarchy" visible="yes" title="" intro=""/>
+      <tab type="classmembers" visible="yes" title="" intro=""/>
     </tab>
     <tab type="namespaces" visible="yes" title="">
       <tab type="namespaces" visible="yes" title=""/>
       <tab type="namespacemembers" visible="yes" title=""/>
+      <tab type="namespaces" visible="yes" title="" intro=""/>
+      <tab type="namespacemembers" visible="yes" title="" intro=""/>
     </tab>
     <tab type="files" visible="yes" title="">
       <tab type="files" visible="yes" title=""/>
       <tab type="globals" visible="yes" title=""/>
+      <tab type="files" visible="yes" title="" intro=""/>
+      <tab type="globals" visible="yes" title="" intro=""/>
     </tab>
+    <tab type="dirs" visible="yes" title=""/>
+    <tab type="examples" visible="yes" title=""/>
+    <tab type="pages" visible="yes" title=""/>
+    <tab type="examples" visible="yes" title="" intro=""/>
+    <tab type="pages" visible="yes" title="" intro=""/>
   </navindex>

doc/coding_style.dox

-                      r463
+                      r1270
  * This file is a part of LEMON, a generic C++ optimization library.
+ *
  * Copyright (C) 2003-2009
+ * Copyright (C) 2003-2013
  * Egervary Jeno Kombinatorikus Optimalizalasi Kutatocsoport
  * (Egervary Research Group on Combinatorial Optimization, EGRES).
 …
 \subsection pri-loc-var Private member variables
 Private member variables should start with underscore
+Private member variables should start with underscore.
 \code
 _start_with_underscores
+_start_with_underscore
 \endcode

doc/dirs.dox

-                      r463
+                      r1270
  * This file is a part of LEMON, a generic C++ optimization library.
+ *
  * Copyright (C) 2003-2009
+ * Copyright (C) 2003-2013
  * Egervary Jeno Kombinatorikus Optimalizalasi Kutatocsoport
  * (Egervary Research Group on Combinatorial Optimization, EGRES).
 …
 documentation.
 */
+/**
+\dir contrib
+\brief Directory for user contributed source codes.
+You can place your own C++ code using LEMON into this directory, which
+will compile to an executable along with LEMON when you build the
+library. This is probably the easiest way of compiling short to medium
+codes, for this does require neither a LEMON installed system-wide nor
+adding several paths to the compiler.
+Please have a look at <tt>contrib/CMakeLists.txt</tt> for
+instruction on how to add your own files into the build process.  */
 /**

doc/groups.dox

-                      r879
+                      r1280
  * This file is a part of LEMON, a generic C++ optimization library.
+ *
  * Copyright (C) 2003-2009
+ * Copyright (C) 2003-2013
  * Egervary Jeno Kombinatorikus Optimalizalasi Kutatocsoport
  * (Egervary Research Group on Combinatorial Optimization, EGRES).
 …
 detailed documentation of particular adaptors.
+Since the adaptor classes conform to the \ref graph_concepts "graph concepts",
+an adaptor can even be applied to another one.
+The following image illustrates a situation when a \ref SubDigraph adaptor
+is applied on a digraph and \ref Undirector is applied on the subgraph.
+\image html adaptors2.png
+\image latex adaptors2.eps "Using graph adaptors" width=\textwidth
 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
 …
 /**
-@defgroup matrices Matrices
-@ingroup datas
-\brief Two dimensional data storages implemented in LEMON.
-This group contains two dimensional data storages implemented in LEMON.
-*/
-/**
 @defgroup auxdat Auxiliary Data Structures
 @ingroup datas
 …
 /**
-@defgroup matrices Matrices
-@ingroup auxdat
-\brief Two dimensional data storages implemented in LEMON.
-This group contains two dimensional data storages implemented in LEMON.
-*/
-/**
 @defgroup algs Algorithms
 \brief This group contains the several algorithms
 …
 This group contains the common graph search algorithms, namely
 \e breadth-first \e search (BFS) and \e depth-first \e search (DFS)
 \ref clrs01algorithms.
+\cite clrs01algorithms.
 */
 …
 This group contains the algorithms for finding shortest paths in digraphs
 \ref clrs01algorithms.
+\cite clrs01algorithms.
  - \ref Dijkstra algorithm for finding shortest paths from a source node
 …
    but the digraph should not contain directed cycles with negative total
    length.
- - \ref FloydWarshall "Floyd-Warshall" and \ref Johnson "Johnson" algorithms
-   for solving the \e all-pairs \e shortest \e paths \e problem 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.
 …
 This group contains the algorithms for finding minimum cost spanning
 trees and arborescences \ref clrs01algorithms.
+trees and arborescences \cite clrs01algorithms.
 */
 …
 This group contains the algorithms for finding maximum flows and
 feasible circulations \ref clrs01algorithms, \ref amo93networkflows.
+feasible circulations \cite clrs01algorithms, \cite amo93networkflows.
 The \e maximum \e flow \e problem is to find a flow of maximum value between
 …
 \f[ 0 \leq f(uv) \leq cap(uv) \quad \forall uv\in A \f]
+LEMON contains several algorithms for solving maximum flow problems:
+- \ref EdmondsKarp Edmonds-Karp algorithm
+  \ref edmondskarp72theoretical.
+- \ref Preflow Goldberg-Tarjan's preflow push-relabel algorithm
+  \ref goldberg88newapproach.
+- \ref DinitzSleatorTarjan Dinitz's blocking flow algorithm with dynamic trees
+  \ref dinic70algorithm, \ref sleator83dynamic.
+- \ref GoldbergTarjan !Preflow push-relabel algorithm with dynamic trees
+  \ref goldberg88newapproach, \ref sleator83dynamic.
+In most cases the \ref Preflow algorithm provides the
+fastest method for computing a maximum flow. All implementations
+also provide functions to query the minimum cut, which is the dual
+problem of maximum flow.
+\ref Circulation is a preflow push-relabel algorithm implemented directly
+\ref Preflow is an efficient implementation of Goldberg-Tarjan's
+preflow push-relabel algorithm \cite 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.
 …
 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
+circulations \cite 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.
+   pivot strategies \cite dantzig63linearprog, \cite kellyoneill91netsimplex.
  - \ref CostScaling Cost Scaling algorithm based on push/augment and
    relabel operations \ref goldberg90approximation, \ref goldberg97efficient,
    \ref bunnagel98efficient.
+   relabel operations \cite goldberg90approximation, \cite goldberg97efficient,
+   \cite bunnagel98efficient.
  - \ref CapacityScaling Capacity Scaling algorithm based on the successive
    shortest path method \ref edmondskarp72theoretical.
+   shortest path method \cite 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.
+   strongly polynomial \cite klein67primal, \cite goldberg89cyclecanceling.
+In general, \ref NetworkSimplex and \ref CostScaling are the most efficient
+implementations.
+\ref NetworkSimplex is usually the fastest on relatively small graphs (up to
+several thousands of nodes) and on dense graphs, while \ref CostScaling is
+typically more efficient on large graphs (e.g. hundreds of thousands of
+nodes or above), especially if they are sparse.
+However, other algorithms could be faster in special cases.
 For example, if the total supply and/or capacities are rather small,
+CapacityScaling is usually the fastest algorithm (without effective scaling).
+\ref CapacityScaling is usually the fastest algorithm
+(without effective scaling).
+These classes are intended to be used with integer-valued input data
+(capacities, supply values, and costs), except for \ref CapacityScaling,
+which is capable of handling real-valued arc costs (other numerical
+data are required to be integer).
+For more details about these implementations and for a comprehensive
+experimental study, see the paper \cite KiralyKovacs12MCF.
+It also compares these codes to other publicly available
+minimum cost flow solvers.
 */
 …
 This group contains the algorithms for finding minimum mean cycles
 \ref clrs01algorithms, \ref amo93networkflows.
+\cite amo93networkflows, \cite karp78characterization.
 The \e minimum \e mean \e cycle \e problem is to find a directed cycle
 …
 LEMON contains three algorithms for solving the minimum mean cycle problem:
+- \ref Karp "Karp"'s original algorithm \ref amo93networkflows,
+  \ref dasdan98minmeancycle.
+- \ref HartmannOrlin "Hartmann-Orlin"'s algorithm, which is an improved
+  version of Karp's algorithm \ref dasdan98minmeancycle.
+- \ref Howard "Howard"'s policy iteration algorithm
+  \ref dasdan98minmeancycle.
+In practice, the Howard algorithm proved to be by far the most efficient
+one, though the best known theoretical bound on its running time is
+exponential.
+Both Karp and HartmannOrlin 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.
+- \ref KarpMmc Karp's original algorithm \cite karp78characterization.
+- \ref HartmannOrlinMmc Hartmann-Orlin's algorithm, which is an improved
+  version of Karp's algorithm \cite hartmann93finding.
+- \ref HowardMmc Howard's policy iteration algorithm
+  \cite dasdan98minmeancycle, \cite dasdan04experimental.
+In practice, the \ref HowardMmc "Howard" algorithm turned out to be by far the
+most efficient one, though the best known theoretical bound on its running
+time is exponential.
+Both \ref KarpMmc "Karp" and \ref HartmannOrlinMmc "Hartmann-Orlin" algorithms
+run in time O(nm) and use space O(n<sup>2</sup>+m).
 */
 …
 The matching algorithms implemented in LEMON:
-- \ref MaxBipartiteMatching Hopcroft-Karp augmenting path algorithm
-  for calculating maximum cardinality matching in bipartite graphs.
-- \ref PrBipartiteMatching Push-relabel algorithm
-  for calculating maximum cardinality matching in bipartite graphs.
-- \ref MaxWeightedBipartiteMatching
-  Successive shortest path algorithm for calculating maximum weighted
-  matching and maximum weighted bipartite matching in bipartite graphs.
-- \ref MinCostMaxBipartiteMatching
-  Successive shortest path algorithm for calculating minimum cost maximum
-  matching in bipartite graphs.
 - \ref MaxMatching Edmond's blossom shrinking algorithm for calculating
   maximum cardinality matching in general graphs.
 …
   Edmond's blossom shrinking algorithm for calculating maximum weighted
   perfect matching in general graphs.
+\image html bipartite_matching.png
+\image latex bipartite_matching.eps "Bipartite Matching" width=\textwidth
+- \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 planar Planarity Embedding and Drawing
+@defgroup planar Planar Embedding and Drawing
 @ingroup algs
 \brief Algorithms for planarity checking, embedding and drawing
 …
 /**
+@defgroup approx Approximation Algorithms
+@defgroup tsp Traveling Salesman Problem
+@ingroup algs
+\brief Algorithms for the symmetric traveling salesman problem
+This group contains basic heuristic algorithms for the the symmetric
+\e traveling \e salesman \e problem (TSP).
+Given an \ref FullGraph "undirected full graph" with a cost map on its edges,
+the problem is to find a shortest possible tour that visits each node exactly
+once (i.e. the minimum cost Hamiltonian cycle).
+These TSP algorithms are intended to be used with a \e metric \e cost
+\e function, i.e. the edge costs should satisfy the triangle inequality.
+Otherwise the algorithms could yield worse results.
+LEMON provides five well-known heuristics for solving symmetric TSP:
+ - \ref NearestNeighborTsp Neareast neighbor algorithm
+ - \ref GreedyTsp Greedy algorithm
+ - \ref InsertionTsp Insertion heuristic (with four selection methods)
+ - \ref ChristofidesTsp Christofides algorithm
+ - \ref Opt2Tsp 2-opt algorithm
+\ref NearestNeighborTsp, \ref GreedyTsp, and \ref InsertionTsp are the fastest
+solution methods. Furthermore, \ref InsertionTsp is usually quite effective.
+\ref ChristofidesTsp is somewhat slower, but it has the best guaranteed
+approximation factor: 3/2.
+\ref Opt2Tsp usually provides the best results in practice, but
+it is the slowest method. It can also be used to improve given tours,
+for example, the results of other algorithms.
+\image html tsp.png
+\image latex tsp.eps "Traveling salesman problem" width=\textwidth
+*/
+/**
+@defgroup approx_algs Approximation Algorithms
 @ingroup algs
 \brief Approximation algorithms.
 …
 This group contains the approximation and heuristic algorithms
 implemented in LEMON.
+<b>Maximum Clique Problem</b>
+  - \ref GrossoLocatelliPullanMc An efficient heuristic algorithm of
+    Grosso, Locatelli, and Pullan.
 */
 …
 high-level interface.
+The currently supported solvers are \ref glpk, \ref clp, \ref cbc,
+\ref cplex, \ref soplex.
+*/
+/**
+@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 contains some metaheuristic optimization tools.
+The currently supported solvers are \cite glpk, \cite clp, \cite cbc,
+\cite cplex, \cite soplex.
 */
 …
 This group contains general \c EPS drawing methods and special
 graph exporting tools.
+\image html graph_to_eps.png
 */

doc/images/bipartite_partitions.eps

-                      r634
+                      r1213
 %!PS-Adobe-2.0 EPSF-2.0
 %%Creator: LEMON, graphToEps()
 %%CreationDate: Tue Nov 15 16:51:43 2005
+%%CreationDate: Fri Mar  8 00:18:43 2013
 %%BoundingBox: 0 0 842 596
 %%EndComments
 …
 %Edges:
 gsave
 .857 -446.322 296.569 -487.43 79.2808 -528.539 0 0 0 2 lb
 .857 -446.322 575.52 -315.655 637.183 -184.989 0 0 0 2 lb
 .468 566.711 494.771 434.577 596.074 302.442 0 0 0 2 lb
 .468 566.711 155.625 579.925 -82.2171 593.138 0 0 0 2 lb
 .468 566.711 251.056 450.726 108.644 334.741 0 0 0 2 lb
 .153 52.8539 732.613 177.648 596.074 302.442 0 0 0 2 lb
 .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
 .2808 -528.539 -66.0671 -490.366 -211.415 -452.194 0 0 0 2 lb
 .183 -184.989 421.363 -253.993 205.543 -322.996 0 0 0 2 lb
 .543 -322.996 162.966 -226.097 120.389 -129.198 0 0 0 2 lb
 .34 88.0898 259.865 -20.5541 120.389 -129.198 0 0 0 2 lb
 .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
 .389 -129.198 -76.8055 -130.099 -274 -131 0 0 0 2 lb
+.857 -446.322 296.569 -487.43 79.2808 -528.539 0 0 0 7.00153 lb
+.857 -446.322 575.52 -315.656 637.183 -184.989 0 0 0 7.00153 lb
+.468 566.711 494.771 434.577 596.074 302.442 0 0 0 7.00153 lb
+.468 566.711 155.625 579.925 -82.2171 593.138 0 0 0 7.00153 lb
+.468 566.711 251.056 450.726 108.644 334.741 0 0 0 7.00153 lb
+.153 52.8539 732.613 177.648 596.074 302.442 0 0 0 7.00153 lb
+.153 52.8539 753.168 -66.0676 637.183 -184.989 0 0 0 7.00153 lb
+-82.2171 593.138 -91.0261 346.487 -99.8351 99.8351 0 0 0 7.00153 lb
+-663.61 546.157 -753.168 394.936 -842.726 243.715 0 0 0 7.00153 lb
+-663.61 546.157 -574.052 437.513 -484.494 328.869 0 0 0 7.00153 lb
+-1077.63 161.498 -960.178 202.606 -842.726 243.715 0 0 0 7.00153 lb
+-1077.63 161.498 -968.987 66.0674 -860.344 -29.3633 0 0 0 7.00153 lb
+-1177.47 -234.906 -1029.18 -381.722 -880.898 -528.539 0 0 0 7.00153 lb
+-1177.47 -234.906 -1018.91 -132.135 -860.344 -29.3633 0 0 0 7.00153 lb
+-880.898 -528.539 -744.359 -387.595 -607.82 -246.651 0 0 0 7.00153 lb
+-499.175 -499.175 -355.295 -475.685 -211.415 -452.194 0 0 0 7.00153 lb
+-499.175 -499.175 -553.498 -372.913 -607.82 -246.651 0 0 0 7.00153 lb
+-499.175 -499.175 -386.587 -315.087 -274 -131 0 0 0 7.00153 lb
+.2808 -528.539 -66.0671 -490.366 -211.415 -452.194 0 0 0 7.00153 lb
+.183 -184.989 421.363 -253.993 205.543 -322.996 0 0 0 7.00153 lb
+.543 -322.996 162.966 -226.097 120.389 -129.198 0 0 0 7.00153 lb
+.34 88.0898 259.865 -20.5541 120.389 -129.198 0 0 0 7.00153 lb
+.34 88.0898 253.992 211.415 108.644 334.741 0 0 0 7.00153 lb
+-842.726 243.715 -471.281 171.775 -99.8351 99.8351 0 0 0 7.00153 lb
+-842.726 243.715 -558.363 56.3575 -274 -131 0 0 0 7.00153 lb
+-860.344 -29.3633 -734.082 -138.007 -607.82 -246.651 0 0 0 7.00153 lb
+-211.415 -452.194 -45.513 -290.696 120.389 -129.198 0 0 0 7.00153 lb
+-99.8351 99.8351 4.40445 217.288 108.644 334.741 0 0 0 7.00153 lb
+-99.8351 99.8351 -292.165 214.352 -484.494 328.869 0 0 0 7.00153 lb
+.389 -129.198 -76.8055 -130.099 -274 -131 0 0 0 7.00153 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
 .644 334.741 20 0 0 1 nc
 .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
 .34 88.0898 20 1 0 0 nc
 .543 -322.996 20 1 0 0 nc
 .183 -184.989 20 0 0 1 nc
 .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
 .074 302.442 20 0 0 1 nc
 .153 52.8539 20 1 0 0 nc
 .468 566.711 20 1 0 0 nc
 .857 -446.322 20 1 0 0 nc
+-274 -131 23.3384 1 0 0 nc
+-607.82 -246.651 23.3384 1 0 0 nc
+-484.494 328.869 23.3384 0 0 1 nc
+.644 334.741 23.3384 0 0 1 nc
+.389 -129.198 23.3384 0 0 1 nc
+-99.8351 99.8351 23.3384 1 0 0 nc
+-211.415 -452.194 23.3384 1 0 0 nc
+-860.344 -29.3633 23.3384 0 0 1 nc
+-842.726 243.715 23.3384 0 0 1 nc
+.34 88.0898 23.3384 1 0 0 nc
+.543 -322.996 23.3384 1 0 0 nc
+.183 -184.989 23.3384 0 0 1 nc
+.2808 -528.539 23.3384 0 0 1 nc
+-499.175 -499.175 23.3384 0 0 1 nc
+-880.898 -528.539 23.3384 0 0 1 nc
+-1177.47 -234.906 23.3384 1 0 0 nc
+-1077.63 161.498 23.3384 1 0 0 nc
+-663.61 546.157 23.3384 1 0 0 nc
+-82.2171 593.138 23.3384 0 0 1 nc
+.074 302.442 23.3384 0 0 1 nc
+.153 52.8539 23.3384 1 0 0 nc
+.468 566.711 23.3384 1 0 0 nc
+.857 -446.322 23.3384 1 0 0 nc
 grestore
 grestore

doc/images/connected_components.eps

-                      r634
+                      r1213
 %!PS-Adobe-2.0 EPSF-2.0
 %%Creator: LEMON, graphToEps()
 %%CreationDate: Fri Nov  4 13:47:12 2005
+%%CreationDate: Fri Mar  8 00:18:43 2013
 %%BoundingBox: 0 0 842 596
 %%EndComments
 …
 %Edges:
 gsave
 .035 177.301 622.149 225.748 670.264 274.195 0 0 0 2 lb
 .579 115.483 682.421 194.839 670.264 274.195 0 0 0 2 lb
 .402 10.3938 246.402 -6.60595 212.403 -23.6057 0 0 0 2 lb
 .402 10.3938 283.493 -18.9695 286.584 -48.3327 0 0 0 2 lb
 .403 -23.6057 249.493 -35.9692 286.584 -48.3327 0 0 0 2 lb
 .584 -48.3327 326.765 -79.2414 366.947 -110.15 0 0 0 2 lb
 .584 -48.3327 278.857 -111.695 271.13 -175.058 0 0 0 2 lb
 .037 -88.514 417.946 -142.604 397.855 -196.694 0 0 0 2 lb
 .037 -88.514 402.492 -99.332 366.947 -110.15 0 0 0 2 lb
 .855 -196.694 382.401 -153.422 366.947 -110.15 0 0 0 2 lb
 .947 -110.15 319.038 -142.604 271.13 -175.058 0 0 0 2 lb
 .13 -175.058 274.221 -213.694 277.311 -252.33 0 0 0 2 lb
 .13 -175.058 238.675 -190.512 206.221 -205.967 0 0 0 2 lb
 .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
 .312 201.403 946.592 42.798 986.873 -115.807 0 0 0 2 lb
 .312 201.403 834.562 91.8901 762.812 -17.6227 0 0 0 2 lb
 .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
 .945 521.129 208.955 541.269 -5.03507 561.41 0 0 0 2 lb
 .945 521.129 376.371 417.911 329.797 314.692 0 0 0 2 lb
 .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
 .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
 .812 -17.6227 644.488 7.5526 526.164 32.7279 0 0 0 2 lb
 .812 -17.6227 746.448 -162.381 730.084 -307.139 0 0 0 2 lb
 .164 32.7279 470.779 -128.394 415.393 -289.516 0 0 0 2 lb
 .084 -307.139 572.738 -298.327 415.393 -289.516 0 0 0 2 lb
 .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
 .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
 .264 274.195 629.188 409.347 588.113 544.499 0 0 0 2 lb
 .264 274.195 797.466 341.771 924.667 409.347 0 0 0 2 lb
 .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
+.035 177.301 622.149 225.748 670.264 274.195 0 0 0 6.25356 lb
+.579 115.483 682.421 194.839 670.264 274.195 0 0 0 6.25356 lb
+.402 10.3938 246.402 -6.60595 212.403 -23.6057 0 0 0 6.25356 lb
+.402 10.3938 283.493 -18.9695 286.584 -48.3327 0 0 0 6.25356 lb
+.403 -23.6057 249.493 -35.9692 286.584 -48.3327 0 0 0 6.25356 lb
+.584 -48.3327 326.765 -79.2414 366.947 -110.15 0 0 0 6.25356 lb
+.584 -48.3327 278.857 -111.695 271.13 -175.058 0 0 0 6.25356 lb
+.037 -88.514 417.946 -142.604 397.855 -196.694 0 0 0 6.25356 lb
+.037 -88.514 402.492 -99.332 366.947 -110.15 0 0 0 6.25356 lb
+.855 -196.694 382.401 -153.422 366.947 -110.15 0 0 0 6.25356 lb
+.947 -110.15 319.038 -142.604 271.13 -175.058 0 0 0 6.25356 lb
+.13 -175.058 274.221 -213.694 277.311 -252.33 0 0 0 6.25356 lb
+.13 -175.058 238.675 -190.512 206.221 -205.967 0 0 0 6.25356 lb
+.311 -252.33 241.766 -229.149 206.221 -205.967 0 0 0 6.25356 lb
+-840.856 -246.718 -804.351 -66.7145 -767.847 113.289 0 0 0 6.25356 lb
+-579.033 445.603 -673.44 279.446 -767.847 113.289 0 0 0 6.25356 lb
+-579.033 445.603 -524.906 302.104 -470.779 158.605 0 0 0 6.25356 lb
+-767.847 113.289 -619.313 135.947 -470.779 158.605 0 0 0 6.25356 lb
+.312 201.403 946.592 42.798 986.873 -115.807 0 0 0 6.25356 lb
+.312 201.403 834.562 91.8901 762.812 -17.6227 0 0 0 6.25356 lb
+.873 -115.807 874.842 -66.7148 762.812 -17.6227 0 0 0 6.25356 lb
+-470.779 158.605 -390.218 50.3508 -309.657 -57.9033 0 0 0 6.25356 lb
+.945 521.129 208.955 541.269 -5.03507 561.41 0 0 0 6.25356 lb
+.945 521.129 376.371 417.911 329.797 314.692 0 0 0 6.25356 lb
+.945 521.129 474.554 276.928 526.164 32.7279 0 0 0 6.25356 lb
+-5.03507 561.41 -36.5042 440.568 -67.9734 319.727 0 0 0 6.25356 lb
+.797 314.692 130.912 317.209 -67.9734 319.727 0 0 0 6.25356 lb
+-67.9734 319.727 229.095 176.227 526.164 32.7279 0 0 0 6.25356 lb
+.812 -17.6227 644.488 7.5526 526.164 32.7279 0 0 0 6.25356 lb
+.812 -17.6227 746.448 -162.381 730.084 -307.139 0 0 0 6.25356 lb
+.164 32.7279 470.779 -128.394 415.393 -289.516 0 0 0 6.25356 lb
+.084 -307.139 572.738 -298.327 415.393 -289.516 0 0 0 6.25356 lb
+.393 -289.516 173.71 -318.468 -67.9734 -347.42 0 0 0 6.25356 lb
+-67.9734 -347.42 -188.815 -202.662 -309.657 -57.9033 0 0 0 6.25356 lb
+-67.9734 -347.42 -195.758 -390.692 -323.543 -433.964 0 0 0 6.25356 lb
+-309.657 -57.9033 -424.775 -160.272 -539.894 -262.64 0 0 0 6.25356 lb
+-323.543 -433.964 -431.719 -348.302 -539.894 -262.64 0 0 0 6.25356 lb
+-26.6953 -19.9585 44.8558 -96.8093 116.407 -173.66 0 0 0 6.25356 lb
+-26.6953 -19.9585 87.2563 9.19185 201.208 38.3422 0 0 0 6.25356 lb
+-26.6953 -19.9585 -144.622 43.6422 -262.548 107.243 0 0 0 6.25356 lb
+-26.6953 -19.9585 -20.0703 56.8923 -13.4452 133.743 0 0 0 6.25356 lb
+.407 -173.66 158.808 -67.6589 201.208 38.3422 0 0 0 6.25356 lb
+-262.548 107.243 -137.997 120.493 -13.4452 133.743 0 0 0 6.25356 lb
+-262.548 107.243 -221.472 176.144 -180.397 245.045 0 0 0 6.25356 lb
+-13.4452 133.743 -96.9211 189.394 -180.397 245.045 0 0 0 6.25356 lb
+-180.397 245.045 -113.509 338.465 -132.697 451.748 0 0 0 6.25356 lb
+-180.397 245.045 -199.585 358.328 -132.697 451.748 0 0 0 6.25356 lb
+-416.25 345.746 -274.474 398.747 -132.697 451.748 0 0 0 6.25356 lb
+-416.25 345.746 -393.725 457.048 -371.2 568.349 0 0 0 6.25356 lb
+-132.697 451.748 -251.948 510.048 -371.2 568.349 0 0 0 6.25356 lb
+.264 274.195 629.188 409.347 588.113 544.499 0 0 0 6.25356 lb
+.264 274.195 797.466 341.771 924.667 409.347 0 0 0 6.25356 lb
+.113 544.499 756.39 476.923 924.667 409.347 0 0 0 6.25356 lb
+-689.204 -237.261 -587.735 -114.393 -567.302 43.6423 0 0 0 6.25356 lb
+-689.204 -237.261 -668.771 -79.2259 -567.302 43.6423 0 0 0 6.25356 lb
 grestore
 %Nodes:
 gsave
 -567.302 43.6423 20 0 0 0 nc
 -689.204 -237.261 20 0 0 0 nc
 .667 409.347 20 1 0 0 nc
 .113 544.499 20 1 0 0 nc
 .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
 .208 38.3422 20 0 1 0 nc
 .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
 .393 -289.516 20 0 0 1 nc
 .084 -307.139 20 0 0 1 nc
 .164 32.7279 20 0 0 1 nc
 .812 -17.6227 20 0 0 1 nc
 -67.9734 319.727 20 0 0 1 nc
 .797 314.692 20 0 0 1 nc
 -5.03507 561.41 20 0 0 1 nc
 .945 521.129 20 0 0 1 nc
 -470.779 158.605 20 0 0 1 nc
 .873 -115.807 20 0 0 1 nc
 .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
 .221 -205.967 20 1 1 0 nc
 .311 -252.33 20 1 1 0 nc
 .13 -175.058 20 1 1 0 nc
 .947 -110.15 20 1 1 0 nc
 .855 -196.694 20 1 1 0 nc
 .037 -88.514 20 1 1 0 nc
 .584 -48.3327 20 1 1 0 nc
 .403 -23.6057 20 1 1 0 nc
 .402 10.3938 20 1 1 0 nc
 .579 115.483 20 1 0 0 nc
 .035 177.301 20 1 0 0 nc
+-567.302 43.6423 20.8452 0 0 0 nc
+-689.204 -237.261 20.8452 0 0 0 nc
+.667 409.347 20.8452 1 0 0 nc
+.113 544.499 20.8452 1 0 0 nc
+.264 274.195 20.8452 1 0 0 nc
+-371.2 568.349 20.8452 0 1 0 nc
+-132.697 451.748 20.8452 0 1 0 nc
+-416.25 345.746 20.8452 0 1 0 nc
+-180.397 245.045 20.8452 0 1 0 nc
+-13.4452 133.743 20.8452 0 1 0 nc
+-262.548 107.243 20.8452 0 1 0 nc
+.208 38.3422 20.8452 0 1 0 nc
+.407 -173.66 20.8452 0 1 0 nc
+-26.6953 -19.9585 20.8452 0 1 0 nc
+-539.894 -262.64 20.8452 0 0 1 nc
+-323.543 -433.964 20.8452 0 0 1 nc
+-309.657 -57.9033 20.8452 0 0 1 nc
+-67.9734 -347.42 20.8452 0 0 1 nc
+.393 -289.516 20.8452 0 0 1 nc
+.084 -307.139 20.8452 0 0 1 nc
+.164 32.7279 20.8452 0 0 1 nc
+.812 -17.6227 20.8452 0 0 1 nc
+-67.9734 319.727 20.8452 0 0 1 nc
+.797 314.692 20.8452 0 0 1 nc
+-5.03507 561.41 20.8452 0 0 1 nc
+.945 521.129 20.8452 0 0 1 nc
+-470.779 158.605 20.8452 0 0 1 nc
+.873 -115.807 20.8452 0 0 1 nc
+.312 201.403 20.8452 0 0 1 nc
+-767.847 113.289 20.8452 0 0 1 nc
+-579.033 445.603 20.8452 0 0 1 nc
+-840.856 -246.718 20.8452 0 0 1 nc
+.221 -205.967 20.8452 1 1 0 nc
+.311 -252.33 20.8452 1 1 0 nc
+.13 -175.058 20.8452 1 1 0 nc
+.947 -110.15 20.8452 1 1 0 nc
+.855 -196.694 20.8452 1 1 0 nc
+.037 -88.514 20.8452 1 1 0 nc
+.584 -48.3327 20.8452 1 1 0 nc
+.403 -23.6057 20.8452 1 1 0 nc
+.402 10.3938 20.8452 1 1 0 nc
+.579 115.483 20.8452 1 0 0 nc
+.035 177.301 20.8452 1 0 0 nc
 grestore
 grestore

doc/images/edge_biconnected_components.eps

-                      r634
+                      r1213
 %!PS-Adobe-2.0 EPSF-2.0
 %%Creator: LEMON, graphToEps()
 %%CreationDate: Fri Nov  4 13:47:12 2005
+%%CreationDate: Fri Mar  8 00:18:43 2013
 %%BoundingBox: 0 0 842 596
 %%EndComments
 …
 %Edges:
 gsave
 .035 177.301 622.149 225.748 670.264 274.195 1 0 0 2 lb
 .579 115.483 682.421 194.839 670.264 274.195 1 0 0 2 lb
 .402 10.3938 246.402 -6.60595 212.403 -23.6057 0 0 1 2 lb
 .402 10.3938 283.493 -18.9695 286.584 -48.3327 0 0 1 2 lb
 .403 -23.6057 249.493 -35.9692 286.584 -48.3327 0 0 1 2 lb
 .584 -48.3327 326.765 -79.2414 366.947 -110.15 0 0 1 2 lb
 .584 -48.3327 278.857 -111.695 271.13 -175.058 0 0 1 2 lb
 .037 -88.514 417.946 -142.604 397.855 -196.694 0 0 1 2 lb
 .037 -88.514 402.492 -99.332 366.947 -110.15 0 0 1 2 lb
 .855 -196.694 382.401 -153.422 366.947 -110.15 0 0 1 2 lb
 .947 -110.15 319.038 -142.604 271.13 -175.058 0 0 1 2 lb
 .13 -175.058 274.221 -213.694 277.311 -252.33 0 0 1 2 lb
 .13 -175.058 238.675 -190.512 206.221 -205.967 0 0 1 2 lb
 .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
 .312 201.403 946.592 42.798 986.873 -115.807 0 0 1 2 lb
 .312 201.403 834.562 91.8901 762.812 -17.6227 0 0 1 2 lb
 .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
 .945 521.129 208.955 541.269 -5.03507 561.41 0 0 1 2 lb
 .945 521.129 376.371 417.911 329.797 314.692 0 0 1 2 lb
 .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
 .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
 .812 -17.6227 644.488 7.5526 526.164 32.7279 0 0 1 2 lb
 .812 -17.6227 746.448 -162.381 730.084 -307.139 0 0 1 2 lb
 .164 32.7279 470.779 -128.394 415.393 -289.516 0 0 1 2 lb
 .084 -307.139 572.738 -298.327 415.393 -289.516 0 0 1 2 lb
 .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
 .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
 .264 274.195 629.188 409.347 588.113 544.499 0 0 1 2 lb
 .264 274.195 797.466 341.771 924.667 409.347 0 0 1 2 lb
 .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
+.035 177.301 622.149 225.748 670.264 274.195 1 0 0 6.25356 lb
+.579 115.483 682.421 194.839 670.264 274.195 1 0 0 6.25356 lb
+.402 10.3938 246.402 -6.60595 212.403 -23.6057 0 0 1 6.25356 lb
+.402 10.3938 283.493 -18.9695 286.584 -48.3327 0 0 1 6.25356 lb
+.403 -23.6057 249.493 -35.9692 286.584 -48.3327 0 0 1 6.25356 lb
+.584 -48.3327 326.765 -79.2414 366.947 -110.15 0 0 1 6.25356 lb
+.584 -48.3327 278.857 -111.695 271.13 -175.058 0 0 1 6.25356 lb
+.037 -88.514 417.946 -142.604 397.855 -196.694 0 0 1 6.25356 lb
+.037 -88.514 402.492 -99.332 366.947 -110.15 0 0 1 6.25356 lb
+.855 -196.694 382.401 -153.422 366.947 -110.15 0 0 1 6.25356 lb
+.947 -110.15 319.038 -142.604 271.13 -175.058 0 0 1 6.25356 lb
+.13 -175.058 274.221 -213.694 277.311 -252.33 0 0 1 6.25356 lb
+.13 -175.058 238.675 -190.512 206.221 -205.967 0 0 1 6.25356 lb
+.311 -252.33 241.766 -229.149 206.221 -205.967 0 0 1 6.25356 lb
+-840.856 -246.718 -804.351 -66.7145 -767.847 113.289 1 0 0 6.25356 lb
+-579.033 445.603 -673.44 279.446 -767.847 113.289 0 0 1 6.25356 lb
+-579.033 445.603 -524.906 302.104 -470.779 158.605 0 0 1 6.25356 lb
+-767.847 113.289 -619.313 135.947 -470.779 158.605 0 0 1 6.25356 lb
+.312 201.403 946.592 42.798 986.873 -115.807 0 0 1 6.25356 lb
+.312 201.403 834.562 91.8901 762.812 -17.6227 0 0 1 6.25356 lb
+.873 -115.807 874.842 -66.7148 762.812 -17.6227 0 0 1 6.25356 lb
+-470.779 158.605 -390.218 50.3508 -309.657 -57.9033 1 0 0 6.25356 lb
+.945 521.129 208.955 541.269 -5.03507 561.41 0 0 1 6.25356 lb
+.945 521.129 376.371 417.911 329.797 314.692 0 0 1 6.25356 lb
+.945 521.129 474.554 276.928 526.164 32.7279 0 0 1 6.25356 lb
+-5.03507 561.41 -36.5042 440.568 -67.9734 319.727 0 0 1 6.25356 lb
+.797 314.692 130.912 317.209 -67.9734 319.727 0 0 1 6.25356 lb
+-67.9734 319.727 229.095 176.227 526.164 32.7279 0 0 1 6.25356 lb
+.812 -17.6227 644.488 7.5526 526.164 32.7279 0 0 1 6.25356 lb
+.812 -17.6227 746.448 -162.381 730.084 -307.139 0 0 1 6.25356 lb
+.164 32.7279 470.779 -128.394 415.393 -289.516 0 0 1 6.25356 lb
+.084 -307.139 572.738 -298.327 415.393 -289.516 0 0 1 6.25356 lb
+.393 -289.516 173.71 -318.468 -67.9734 -347.42 1 0 0 6.25356 lb
+-67.9734 -347.42 -188.815 -202.662 -309.657 -57.9033 0 0 1 6.25356 lb
+-67.9734 -347.42 -195.758 -390.692 -323.543 -433.964 0 0 1 6.25356 lb
+-309.657 -57.9033 -424.775 -160.272 -539.894 -262.64 0 0 1 6.25356 lb
+-323.543 -433.964 -431.719 -348.302 -539.894 -262.64 0 0 1 6.25356 lb
+-26.6953 -19.9585 44.8558 -96.8093 116.407 -173.66 0 0 1 6.25356 lb
+-26.6953 -19.9585 87.2563 9.19185 201.208 38.3422 0 0 1 6.25356 lb
+-26.6953 -19.9585 -144.622 43.6422 -262.548 107.243 0 0 1 6.25356 lb
+-26.6953 -19.9585 -20.0703 56.8923 -13.4452 133.743 0 0 1 6.25356 lb
+.407 -173.66 158.808 -67.6589 201.208 38.3422 0 0 1 6.25356 lb
+-262.548 107.243 -137.997 120.493 -13.4452 133.743 0 0 1 6.25356 lb
+-262.548 107.243 -221.472 176.144 -180.397 245.045 0 0 1 6.25356 lb
+-13.4452 133.743 -96.9211 189.394 -180.397 245.045 0 0 1 6.25356 lb
+-180.397 245.045 -113.509 338.465 -132.697 451.748 0 0 1 6.25356 lb
+-180.397 245.045 -199.585 358.328 -132.697 451.748 0 0 1 6.25356 lb
+-416.25 345.746 -274.474 398.747 -132.697 451.748 0 0 1 6.25356 lb
+-416.25 345.746 -393.725 457.048 -371.2 568.349 0 0 1 6.25356 lb
+-132.697 451.748 -251.948 510.048 -371.2 568.349 0 0 1 6.25356 lb
+.264 274.195 629.188 409.347 588.113 544.499 0 0 1 6.25356 lb
+.264 274.195 797.466 341.771 924.667 409.347 0 0 1 6.25356 lb
+.113 544.499 756.39 476.923 924.667 409.347 0 0 1 6.25356 lb
+-689.204 -237.261 -587.735 -114.393 -567.302 43.6423 0 0 1 6.25356 lb
+-689.204 -237.261 -668.771 -79.2259 -567.302 43.6423 0 0 1 6.25356 lb
 grestore
 %Nodes:
 gsave
 -567.302 43.6423 20 0 0 0 nc
 -689.204 -237.261 20 0 0 0 nc
 .667 409.347 20 0 0 1 nc
 .113 544.499 20 0 0 1 nc
 .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
 .208 38.3422 20 1 1 0 nc
 .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
 .393 -289.516 20 0.5 0 0 nc
 .084 -307.139 20 0.5 0 0 nc
 .164 32.7279 20 0.5 0 0 nc
 .812 -17.6227 20 0.5 0 0 nc
 -67.9734 319.727 20 0.5 0 0 nc
 .797 314.692 20 0.5 0 0 nc
 -5.03507 561.41 20 0.5 0 0 nc
 .945 521.129 20 0.5 0 0 nc
 -470.779 158.605 20 0 1 1 nc
 .873 -115.807 20 0.5 0 0 nc
 .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
 .221 -205.967 20 0 0 0.5 nc
 .311 -252.33 20 0 0 0.5 nc
 .13 -175.058 20 0 0 0.5 nc
 .947 -110.15 20 0 0 0.5 nc
 .855 -196.694 20 0 0 0.5 nc
 .037 -88.514 20 0 0 0.5 nc
 .584 -48.3327 20 0 0 0.5 nc
 .403 -23.6057 20 0 0 0.5 nc
 .402 10.3938 20 0 0 0.5 nc
 .579 115.483 20 1 0 0 nc
 .035 177.301 20 0 1 0 nc
+-567.302 43.6423 20.8452 0 0 0 nc
+-689.204 -237.261 20.8452 0 0 0 nc
+.667 409.347 20.8452 0 0 1 nc
+.113 544.499 20.8452 0 0 1 nc
+.264 274.195 20.8452 0 0 1 nc
+-371.2 568.349 20.8452 1 1 0 nc
+-132.697 451.748 20.8452 1 1 0 nc
+-416.25 345.746 20.8452 1 1 0 nc
+-180.397 245.045 20.8452 1 1 0 nc
+-13.4452 133.743 20.8452 1 1 0 nc
+-262.548 107.243 20.8452 1 1 0 nc
+.208 38.3422 20.8452 1 1 0 nc
+.407 -173.66 20.8452 1 1 0 nc
+-26.6953 -19.9585 20.8452 1 1 0 nc
+-539.894 -262.64 20.8452 0 0.5 0 nc
+-323.543 -433.964 20.8452 0 0.5 0 nc
+-309.657 -57.9033 20.8452 0 0.5 0 nc
+-67.9734 -347.42 20.8452 0 0.5 0 nc
+.393 -289.516 20.8452 0.5 0 0 nc
+.084 -307.139 20.8452 0.5 0 0 nc
+.164 32.7279 20.8452 0.5 0 0 nc
+.812 -17.6227 20.8452 0.5 0 0 nc
+-67.9734 319.727 20.8452 0.5 0 0 nc
+.797 314.692 20.8452 0.5 0 0 nc
+-5.03507 561.41 20.8452 0.5 0 0 nc
+.945 521.129 20.8452 0.5 0 0 nc
+-470.779 158.605 20.8452 0 1 1 nc
+.873 -115.807 20.8452 0.5 0 0 nc
+.312 201.403 20.8452 0.5 0 0 nc
+-767.847 113.289 20.8452 0 1 1 nc
+-579.033 445.603 20.8452 0 1 1 nc
+-840.856 -246.718 20.8452 1 0 1 nc
+.221 -205.967 20.8452 0 0 0.5 nc
+.311 -252.33 20.8452 0 0 0.5 nc
+.13 -175.058 20.8452 0 0 0.5 nc
+.947 -110.15 20.8452 0 0 0.5 nc
+.855 -196.694 20.8452 0 0 0.5 nc
+.037 -88.514 20.8452 0 0 0.5 nc
+.584 -48.3327 20.8452 0 0 0.5 nc
+.403 -23.6057 20.8452 0 0 0.5 nc
+.402 10.3938 20.8452 0 0 0.5 nc
+.579 115.483 20.8452 1 0 0 nc
+.035 177.301 20.8452 0 1 0 nc
 grestore
 grestore

doc/images/node_biconnected_components.eps

-                      r634
+                      r1213
 %!PS-Adobe-2.0 EPSF-2.0
 %%Creator: LEMON, graphToEps()
 %%CreationDate: Fri Nov  4 13:47:12 2005
+%%CreationDate: Fri Mar  8 00:18:43 2013
 %%BoundingBox: 0 0 842 596
 %%EndComments
 …
 %Edges:
 gsave
 .035 177.301 622.149 225.748 670.264 274.195 0 1 0 5 lb
 .579 115.483 682.421 194.839 670.264 274.195 1 0 0 5 lb
 .402 10.3938 246.402 -6.60595 212.403 -23.6057 1 1 0.5 5 lb
 .402 10.3938 283.493 -18.9695 286.584 -48.3327 1 1 0.5 5 lb
 .403 -23.6057 249.493 -35.9692 286.584 -48.3327 1 1 0.5 5 lb
 .584 -48.3327 326.765 -79.2414 366.947 -110.15 1 0.5 1 5 lb
 .584 -48.3327 278.857 -111.695 271.13 -175.058 1 0.5 1 5 lb
 .037 -88.514 417.946 -142.604 397.855 -196.694 0.5 0.5 1 5 lb
 .037 -88.514 402.492 -99.332 366.947 -110.15 0.5 0.5 1 5 lb
 .855 -196.694 382.401 -153.422 366.947 -110.15 0.5 0.5 1 5 lb
 .947 -110.15 319.038 -142.604 271.13 -175.058 1 0.5 1 5 lb
 .13 -175.058 274.221 -213.694 277.311 -252.33 0.5 1 1 5 lb
 .13 -175.058 238.675 -190.512 206.221 -205.967 0.5 1 1 5 lb
 .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
 .312 201.403 946.592 42.798 986.873 -115.807 0 0.5 0.5 5 lb
 .312 201.403 834.562 91.8901 762.812 -17.6227 0 0.5 0.5 5 lb
 .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
 .945 521.129 208.955 541.269 -5.03507 561.41 0.5 0 0.5 5 lb
 .945 521.129 376.371 417.911 329.797 314.692 0.5 0 0.5 5 lb
 .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
 .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
 .812 -17.6227 644.488 7.5526 526.164 32.7279 0.5 0.5 0.5 5 lb
 .812 -17.6227 746.448 -162.381 730.084 -307.139 0.5 0.5 0.5 5 lb
 .164 32.7279 470.779 -128.394 415.393 -289.516 0.5 0.5 0.5 5 lb
 .084 -307.139 572.738 -298.327 415.393 -289.516 0.5 0.5 0.5 5 lb
 .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
 .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
 .264 274.195 629.188 409.347 588.113 544.499 0 0 1 5 lb
 .264 274.195 797.466 341.771 924.667 409.347 0 0 1 5 lb
 .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
+.035 177.301 622.149 225.748 670.264 274.195 0 1 0 6.25356 lb
+.579 115.483 682.421 194.839 670.264 274.195 1 0 0 6.25356 lb
+.402 10.3938 246.402 -6.60595 212.403 -23.6057 1 1 0.5 6.25356 lb
+.402 10.3938 283.493 -18.9695 286.584 -48.3327 1 1 0.5 6.25356 lb
+.403 -23.6057 249.493 -35.9692 286.584 -48.3327 1 1 0.5 6.25356 lb
+.584 -48.3327 326.765 -79.2414 366.947 -110.15 1 0.5 1 6.25356 lb
+.584 -48.3327 278.857 -111.695 271.13 -175.058 1 0.5 1 6.25356 lb
+.037 -88.514 417.946 -142.604 397.855 -196.694 0.5 0.5 1 6.25356 lb
+.037 -88.514 402.492 -99.332 366.947 -110.15 0.5 0.5 1 6.25356 lb
+.855 -196.694 382.401 -153.422 366.947 -110.15 0.5 0.5 1 6.25356 lb
+.947 -110.15 319.038 -142.604 271.13 -175.058 1 0.5 1 6.25356 lb
+.13 -175.058 274.221 -213.694 277.311 -252.33 0.5 1 1 6.25356 lb
+.13 -175.058 238.675 -190.512 206.221 -205.967 0.5 1 1 6.25356 lb
+.311 -252.33 241.766 -229.149 206.221 -205.967 0.5 1 1 6.25356 lb
+-840.856 -246.718 -804.351 -66.7145 -767.847 113.289 0 0.5 0 6.25356 lb
+-579.033 445.603 -673.44 279.446 -767.847 113.289 0 0 0.5 6.25356 lb
+-579.033 445.603 -524.906 302.104 -470.779 158.605 0 0 0.5 6.25356 lb
+-767.847 113.289 -619.313 135.947 -470.779 158.605 0 0 0.5 6.25356 lb
+.312 201.403 946.592 42.798 986.873 -115.807 0 0.5 0.5 6.25356 lb
+.312 201.403 834.562 91.8901 762.812 -17.6227 0 0.5 0.5 6.25356 lb
+.873 -115.807 874.842 -66.7148 762.812 -17.6227 0 0.5 0.5 6.25356 lb
+-470.779 158.605 -390.218 50.3508 -309.657 -57.9033 0.5 0.5 0 6.25356 lb
+.945 521.129 208.955 541.269 -5.03507 561.41 0.5 0 0.5 6.25356 lb
+.945 521.129 376.371 417.911 329.797 314.692 0.5 0 0.5 6.25356 lb
+.945 521.129 474.554 276.928 526.164 32.7279 0.5 0 0.5 6.25356 lb
+-5.03507 561.41 -36.5042 440.568 -67.9734 319.727 0.5 0 0.5 6.25356 lb
+.797 314.692 130.912 317.209 -67.9734 319.727 0.5 0 0.5 6.25356 lb
+-67.9734 319.727 229.095 176.227 526.164 32.7279 0.5 0 0.5 6.25356 lb
+.812 -17.6227 644.488 7.5526 526.164 32.7279 0.5 0.5 0.5 6.25356 lb
+.812 -17.6227 746.448 -162.381 730.084 -307.139 0.5 0.5 0.5 6.25356 lb
+.164 32.7279 470.779 -128.394 415.393 -289.516 0.5 0.5 0.5 6.25356 lb
+.084 -307.139 572.738 -298.327 415.393 -289.516 0.5 0.5 0.5 6.25356 lb
+.393 -289.516 173.71 -318.468 -67.9734 -347.42 1 0.5 0.5 6.25356 lb
+-67.9734 -347.42 -188.815 -202.662 -309.657 -57.9033 0.5 1 0.5 6.25356 lb
+-67.9734 -347.42 -195.758 -390.692 -323.543 -433.964 0.5 1 0.5 6.25356 lb
+-309.657 -57.9033 -424.775 -160.272 -539.894 -262.64 0.5 1 0.5 6.25356 lb
+-323.543 -433.964 -431.719 -348.302 -539.894 -262.64 0.5 1 0.5 6.25356 lb
+-26.6953 -19.9585 44.8558 -96.8093 116.407 -173.66 1 1 0 6.25356 lb
+-26.6953 -19.9585 87.2563 9.19185 201.208 38.3422 1 1 0 6.25356 lb
+-26.6953 -19.9585 -144.622 43.6422 -262.548 107.243 1 0 1 6.25356 lb
+-26.6953 -19.9585 -20.0703 56.8923 -13.4452 133.743 1 0 1 6.25356 lb
+.407 -173.66 158.808 -67.6589 201.208 38.3422 1 1 0 6.25356 lb
+-262.548 107.243 -137.997 120.493 -13.4452 133.743 1 0 1 6.25356 lb
+-262.548 107.243 -221.472 176.144 -180.397 245.045 1 0 1 6.25356 lb
+-13.4452 133.743 -96.9211 189.394 -180.397 245.045 1 0 1 6.25356 lb
+-180.397 245.045 -113.509 338.465 -132.697 451.748 0 1 1 6.25356 lb
+-180.397 245.045 -199.585 358.328 -132.697 451.748 0 1 1 6.25356 lb
+-416.25 345.746 -274.474 398.747 -132.697 451.748 0.5 0 0 6.25356 lb
+-416.25 345.746 -393.725 457.048 -371.2 568.349 0.5 0 0 6.25356 lb
+-132.697 451.748 -251.948 510.048 -371.2 568.349 0.5 0 0 6.25356 lb
+.264 274.195 629.188 409.347 588.113 544.499 0 0 1 6.25356 lb
+.264 274.195 797.466 341.771 924.667 409.347 0 0 1 6.25356 lb
+.113 544.499 756.39 476.923 924.667 409.347 0 0 1 6.25356 lb
+-689.204 -237.261 -587.735 -114.393 -567.302 43.6423 0 0 0 6.25356 lb
+-689.204 -237.261 -668.771 -79.2259 -567.302 43.6423 0 0 0 6.25356 lb
 grestore
 %Nodes:
 gsave
 -567.302 43.6423 20 0 0 1 nc
 -689.204 -237.261 20 0 0 1 nc
 .667 409.347 20 0 0 1 nc
 .113 544.499 20 0 0 1 nc
 .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
 .208 38.3422 20 0 0 1 nc
 .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
 .393 -289.516 20 1 0 0 nc
 .084 -307.139 20 0 0 1 nc
 .164 32.7279 20 1 0 0 nc
 .812 -17.6227 20 1 0 0 nc
 -67.9734 319.727 20 0 0 1 nc
 .797 314.692 20 0 0 1 nc
 -5.03507 561.41 20 0 0 1 nc
 .945 521.129 20 0 0 1 nc
 -470.779 158.605 20 1 0 0 nc
 .873 -115.807 20 0 0 1 nc
 .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
 .221 -205.967 20 0 0 1 nc
 .311 -252.33 20 0 0 1 nc
 .13 -175.058 20 1 0 0 nc
 .947 -110.15 20 1 0 0 nc
 .855 -196.694 20 0 0 1 nc
 .037 -88.514 20 0 0 1 nc
 .584 -48.3327 20 1 0 0 nc
 .403 -23.6057 20 0 0 1 nc
 .402 10.3938 20 0 0 1 nc
 .579 115.483 20 0 0 1 nc
 .035 177.301 20 0 0 1 nc
+-567.302 43.6423 20.8452 0 0 1 nc
+-689.204 -237.261 20.8452 0 0 1 nc
+.667 409.347 20.8452 0 0 1 nc
+.113 544.499 20.8452 0 0 1 nc
+.264 274.195 20.8452 1 0 0 nc
+-371.2 568.349 20.8452 0 0 1 nc
+-132.697 451.748 20.8452 1 0 0 nc
+-416.25 345.746 20.8452 0 0 1 nc
+-180.397 245.045 20.8452 1 0 0 nc
+-13.4452 133.743 20.8452 0 0 1 nc
+-262.548 107.243 20.8452 0 0 1 nc
+.208 38.3422 20.8452 0 0 1 nc
+.407 -173.66 20.8452 0 0 1 nc
+-26.6953 -19.9585 20.8452 1 0 0 nc
+-539.894 -262.64 20.8452 0 0 1 nc
+-323.543 -433.964 20.8452 0 0 1 nc
+-309.657 -57.9033 20.8452 1 0 0 nc
+-67.9734 -347.42 20.8452 1 0 0 nc
+.393 -289.516 20.8452 1 0 0 nc
+.084 -307.139 20.8452 0 0 1 nc
+.164 32.7279 20.8452 1 0 0 nc
+.812 -17.6227 20.8452 1 0 0 nc
+-67.9734 319.727 20.8452 0 0 1 nc
+.797 314.692 20.8452 0 0 1 nc
+-5.03507 561.41 20.8452 0 0 1 nc
+.945 521.129 20.8452 0 0 1 nc
+-470.779 158.605 20.8452 1 0 0 nc
+.873 -115.807 20.8452 0 0 1 nc
+.312 201.403 20.8452 0 0 1 nc
+-767.847 113.289 20.8452 1 0 0 nc
+-579.033 445.603 20.8452 0 0 1 nc
+-840.856 -246.718 20.8452 0 0 1 nc
+.221 -205.967 20.8452 0 0 1 nc
+.311 -252.33 20.8452 0 0 1 nc
+.13 -175.058 20.8452 1 0 0 nc
+.947 -110.15 20.8452 1 0 0 nc
+.855 -196.694 20.8452 0 0 1 nc
+.037 -88.514 20.8452 0 0 1 nc
+.584 -48.3327 20.8452 1 0 0 nc
+.403 -23.6057 20.8452 0 0 1 nc
+.402 10.3938 20.8452 0 0 1 nc
+.579 115.483 20.8452 0 0 1 nc
+.035 177.301 20.8452 0 0 1 nc
 grestore
 grestore

doc/images/strongly_connected_components.eps

-                      r634
+                      r1213
 %!PS-Adobe-2.0 EPSF-2.0
 %%Creator: LEMON, graphToEps()
 %%CreationDate: Fri Nov  4 13:47:12 2005
+%%CreationDate: Fri Mar  8 00:22:15 2013
 %%BoundingBox: 0 0 842 596
 %%EndComments
 …
 %Edges:
 gsave
 setlinewidth 0 0 1 setrgbcolor newpath
+.56973 setlinewidth 0 0 1 setrgbcolor newpath
 .178 27.2723 moveto
 .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
 setlinewidth 0 0 1 setrgbcolor newpath
+.849 -31.0725 190.033 -46.2697 176.306 -82.1369 curveto stroke
+newpath 163.235 -116.291 moveto 165.206 -77.8889 lineto 187.405 -86.3849 lineto closepath fill
+.56973 setlinewidth 0 0 1 setrgbcolor newpath
 .8044 15.5841 moveto
 .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
 setlinewidth 1 0 0 setrgbcolor newpath
+.705 19.9594 126.016 21.0591 166.493 23.7879 curveto stroke
+newpath 202.98 26.2477 moveto 167.292 11.9299 lineto 165.694 35.6458 lineto closepath fill
+.56973 setlinewidth 1 0 0 setrgbcolor newpath
 .178 27.2723 moveto
 .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
 setlinewidth 0 0 1 setrgbcolor newpath
+.264 -80.3935 289.87 -95.0808 338.092 -177.379 curveto stroke
+newpath 356.579 -208.932 moveto 327.837 -183.388 lineto 348.346 -171.371 lineto closepath fill
+.56973 setlinewidth 0 0 1 setrgbcolor newpath
 .79 -130.517 moveto
 .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
 setlinewidth 1 0 0 setrgbcolor newpath
+.446 -74.4692 104.358 -61.4239 76.4943 -25.394 curveto stroke
+newpath 54.1228 3.53455 moveto 85.8959 -18.1234 lineto 67.0928 -32.6646 lineto closepath fill
+.56973 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
 setlinewidth 0 0 1 setrgbcolor newpath
+-39.4801 -139.85 -31.344 -124.846 20.1113 -29.9539 curveto stroke
+newpath 37.5434 2.19358 moveto 30.559 -35.6192 lineto 9.66361 -24.2886 lineto closepath fill
+.56973 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
 setlinewidth 0 0 1 setrgbcolor newpath
+-550.335 -27.1603 -566.8 -24.1113 -625.027 -13.3286 curveto stroke
+newpath -660.985 -6.66971 moveto -622.863 -1.64245 lineto -627.191 -25.0148 lineto closepath fill
+.56973 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
 setlinewidth 1 0 0 setrgbcolor newpath
+-535.911 -114.447 -524.692 -103.027 -501.88 -79.8085 curveto stroke
+newpath -476.251 -53.7222 moveto -493.402 -88.1377 lineto -510.358 -71.4793 lineto closepath fill
+.56973 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
 setlinewidth 0 0 1 setrgbcolor newpath
+-481.623 60.8277 -479.143 44.8049 -473.499 8.33636 curveto stroke
+newpath -467.906 -27.8032 moveto -485.244 6.51862 lineto -461.754 10.1541 lineto closepath fill
+.56973 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
 setlinewidth 0 0 1 setrgbcolor newpath
+-637.405 -60.9909 -628.201 -74.6206 -603.658 -110.963 curveto stroke
+newpath -583.191 -141.27 moveto -613.507 -117.615 lineto -593.808 -104.312 lineto closepath fill
+.56973 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
 setlinewidth 0 0 1 setrgbcolor newpath
+-439.75 208.465 -431.238 223.057 -394.278 286.417 curveto stroke
+newpath -375.851 318.006 moveto -384.012 280.429 lineto -404.543 292.406 lineto closepath fill
+.56973 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
 setlinewidth 0 0 1 setrgbcolor newpath
+-358.311 117.318 -375.109 117.756 -439.117 119.426 curveto stroke
+newpath -475.674 120.38 moveto -438.807 131.307 lineto -439.426 107.545 lineto closepath fill
+.56973 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
 setlinewidth 1 0 0 setrgbcolor newpath
+-326.156 241.466 -318.997 226.186 -288.855 161.843 curveto stroke
+newpath -273.341 128.727 moveto -299.617 156.801 lineto -278.092 166.885 lineto closepath fill
+.56973 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
 setlinewidth 0 0 1 setrgbcolor newpath
+-226.764 227.755 -221.069 243.774 -190.728 329.107 curveto stroke
+newpath -178.477 363.564 moveto -179.53 325.126 lineto -201.926 333.089 lineto closepath fill
+.56973 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
 setlinewidth 0 0 1 setrgbcolor newpath
+-198.044 -308.079 -183.61 -300.766 -151.402 -284.448 curveto stroke
+newpath -118.781 -267.92 moveto -146.031 -295.049 lineto -156.774 -273.846 lineto closepath fill
+.56973 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
 setlinewidth 1 0 0 setrgbcolor newpath
+-332.039 -219.059 -322.392 -232.919 -280.889 -292.543 curveto stroke
+newpath -259.996 -322.557 moveto -290.643 -299.333 lineto -271.134 -285.753 lineto closepath fill
+.56973 setlinewidth 1 0 0 setrgbcolor newpath
 .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
 setlinewidth 0 0 1 setrgbcolor newpath
+-70.5724 261.706 -81.8227 274.423 -139.051 339.116 curveto stroke
+newpath -163.281 366.507 moveto -130.149 346.991 lineto -147.953 331.242 lineto closepath fill
+.56973 setlinewidth 0 0 1 setrgbcolor newpath
 .478 311.683 moveto
 .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
 setlinewidth 0 0 1 setrgbcolor newpath
+.641 256.819 90.7821 246.103 45.6398 208.485 curveto stroke
+newpath 17.546 185.074 moveto 38.0313 217.615 lineto 53.2483 199.355 lineto closepath fill
+.56973 setlinewidth 0 0 1 setrgbcolor newpath
 .851 111.037 moveto
 .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
 setlinewidth 0 0 1 setrgbcolor newpath
+.224 196.246 258.132 209.083 203.347 272.486 curveto stroke
+newpath 179.437 300.157 moveto 212.34 280.257 lineto 194.354 264.716 lineto closepath fill
+.56973 setlinewidth 0 0 1 setrgbcolor newpath
 .84406 175.322 moveto
 .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
 setlinewidth 0 0 1 setrgbcolor newpath
+.419 146.79 172.221 143.585 291.966 120.743 curveto stroke
+newpath 327.888 113.891 moveto 289.739 109.069 lineto 294.193 132.418 lineto closepath fill
+.56973 setlinewidth 0 0 1 setrgbcolor newpath
 .851 111.037 moveto
 .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
 setlinewidth 0 0 1 setrgbcolor newpath
+.978 6.99574 505.015 -2.86383 627.727 -89.0547 curveto stroke
+newpath 657.653 -110.074 moveto 620.896 -98.7802 lineto 634.558 -79.3291 lineto closepath fill
+.56973 setlinewidth 0 0 1 setrgbcolor newpath
 .28 -222.074 moveto
 .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
 setlinewidth 0 0 1 setrgbcolor newpath
+.807 -74.8128 353.709 -57.7536 346.177 59.3416 curveto stroke
+newpath 343.829 95.836 moveto 358.037 60.1045 lineto 334.316 58.5786 lineto closepath fill
+.56973 setlinewidth 0 0 1 setrgbcolor newpath
 .118 -118.829 moveto
 .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
 setlinewidth 1 0 0 setrgbcolor newpath
+.595 -164.241 519.412 -169.704 413.361 -205.505 curveto stroke
+newpath 378.712 -217.202 moveto 409.559 -194.245 lineto 417.162 -216.766 lineto closepath fill
+.56973 setlinewidth 1 0 0 setrgbcolor newpath
 -105.193 -261.035 moveto
 .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
 setlinewidth 0 0 1 setrgbcolor newpath
+.939 -243.099 128.069 -241.677 312.655 -226.358 curveto stroke
+newpath 349.1 -223.334 moveto 313.638 -238.202 lineto 311.672 -214.514 lineto closepath fill
+.56973 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
 setlinewidth 0 0 1 setrgbcolor newpath
+-156.746 -168.566 -164.987 -153.784 -202.693 -86.1539 curveto stroke
+newpath -220.5 -54.2129 moveto -192.312 -80.3665 lineto -213.073 -91.9413 lineto closepath fill
+.56973 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
+-290.327 -77.7521 -304.558 -86.1532 -344.995 -110.026 curveto stroke
+newpath -376.487 -128.617 moveto -351.037 -99.7914 lineto -338.953 -120.26 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
 .28 -222.074 20 1 1 0 nc
 .118 -118.829 20 1 1 0 nc
 .851 111.037 20 1 1 0 nc
 .84406 175.322 20 1 1 0 nc
 .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
 .8044 15.5841 20 0 0 1 nc
 .79 -130.517 20 0 0 1 nc
 .178 27.2723 20 0 0 1 nc
+-389.604 -136.361 15.2324 0 1 0 nc
+-227.918 -40.9084 15.2324 0 1 0 nc
+-105.193 -261.035 15.2324 0 1 0 nc
+.28 -222.074 15.2324 1 1 0 nc
+.118 -118.829 15.2324 1 1 0 nc
+.851 111.037 15.2324 1 1 0 nc
+.84406 175.322 15.2324 1 1 0 nc
+.478 311.683 15.2324 1 1 0 nc
+-173.374 377.916 15.2324 1 0 1 nc
+-251.294 -335.059 15.2324 0 1 0 nc
+-266.879 114.933 15.2324 0 0 0 nc
+-368.176 331.163 15.2324 0 0 0 nc
+-490.901 120.777 15.2324 0 0 0 nc
+-574.666 -153.893 15.2324 1 0 0 nc
+-675.963 -3.89604 15.2324 1 0 0 nc
+-465.576 -42.8564 15.2324 1 0 0 nc
+.8044 15.5841 15.2324 0 0 1 nc
+.79 -130.517 15.2324 0 0 1 nc
+.178 27.2723 15.2324 0 0 1 nc
 grestore
 grestore

doc/lgf.dox

-                      r463
+                      r1270
  * This file is a part of LEMON, a generic C++ optimization library.
+ *
  * Copyright (C) 2003-2009
+ * Copyright (C) 2003-2013
  * Egervary Jeno Kombinatorikus Optimalizalasi Kutatocsoport
  * (Egervary Research Group on Combinatorial Optimization, EGRES).
 …
 \endcode
+The \e LGF files can also contain bipartite graphs, in this case a
+\c \@red_nodes and a \c \@blue_nodes sections describe the node set of the
+graph. If a map is in both of these sections, then it can be used as a
+regular node map.
+\code
+ @red_nodes
+ label  only_red_map   name
+      "cherry"       "John"
+      "Santa Claus"  "Jack"
+      "blood"        "Jason"
+ @blue_nodes
+ label  name
+      "Elisabeth"
+      "Eve"
+\endcode
 The \c \@arcs section is very similar to the \c \@nodes section,
 it again starts with a header line describing the names of the maps,
 …
 \endcode
+If there is no map in the \c \@arcs section at all, then it must be
+indicated by a sole '-' sign in the first line.
+\code
+ @arcs
+         -
+   2
+   3
+   3
+\endcode
 The \c \@edges is just a synonym of \c \@arcs. The \@arcs section can
 also store the edge set of an undirected graph. In such case there is
 a conventional method for store arc maps in the file, if two columns
 has the same caption with \c '+' and \c '-' prefix, then these columns
+have the same caption with \c '+' and \c '-' prefix, then these columns
 can be regarded as the values of an arc map.

doc/min_cost_flow.dox

-                      r835
+                      r1270
  * This file is a part of LEMON, a generic C++ optimization library.
+ *
  * Copyright (C) 2003-2009
+ * Copyright (C) 2003-2013
  * Egervary Jeno Kombinatorikus Optimalizalasi Kutatocsoport
  * (Egervary Research Group on Combinatorial Optimization, EGRES).
 …
 minimum total cost from a set of supply nodes to a set of demand nodes
 in a network with capacity constraints (lower and upper bounds)
 and arc costs \ref amo93networkflows.
+and arc costs \cite amo93networkflows.
 Formally, let \f$G=(V,A)\f$ be a digraph, \f$lower: A\rightarrow\mathbf{R}\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[ 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
+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
 …
 \f[ lower(uv) \leq f(uv) \leq upper(uv) \quad \forall uv\in A \f]
 It means that the total demand must be less or equal to the
+It means that the total demand must be less or equal to the
 total supply (i.e. \f$\sum_{u\in V} sup(u)\f$ must be zero or
 positive) and all the demands have to be satisfied, but there

doc/references.bib

-                      r802
+                      r1219
   title =        {{LEMON} -- {L}ibrary for {E}fficient {M}odeling and
                   {O}ptimization in {N}etworks},
+  howpublished = {\url{http://lemon.cs.elte.hu/}},
+  year =         2009
+  howpublished = {\url{http://lemon.cs.elte.hu/}}
+}
 …
                   {O}perations {R}esearch},
   url =          {http://www.coin-or.org/}
+}
+%%%%% Papers related to LEMON %%%%%
+@article{DezsoJuttnerKovacs11Lemon,
+  author =       {B. Dezs{\H o} and A. J\"uttner and P. Kov\'acs},
+  title =        {{LEMON} -- an open source {C++} graph template library},
+  journal =      {Electronic Notes in Theoretical Computer Science},
+  volume =       {264},
+  pages =        {23--45},
+  year =         {2011},
+  note =         {Proc. 2nd Workshop on Generative Technologies}
+}
+@article{KiralyKovacs12MCF,
+  author =       {Z. Kir\'aly and P. Kov\'acs},
+  title =        {Efficient implementations of minimum-cost flow algorithms},
+  journal =      {Acta Universitatis Sapientiae, Informatica},
+  year =         {2012},
+  volume =       {4},
+  pages =        {67--118}
+}
 …
   volume =       23,
   pages =        {309-311}
+}
+@article{hartmann93finding,
+  author =       {Mark Hartmann and James B. Orlin},
+  title =        {Finding minimum cost to time ratio cycles with small
+                  integral transit times},
+  journal =      {Networks},
+  year =         1993,
+  volume =       23,
+  pages =        {567-574}
+}
 …
+}
+@article{dasdan04experimental,
+  author =       {Ali Dasdan},
+  title =        {Experimental analysis of the fastest optimum cycle
+                  ratio and mean algorithms},
+  journal =      {ACM Trans. Des. Autom. Electron. Syst.},
+  year =         2004,
+  volume =       9,
+  issue =        4,
+  pages =        {385-418}
+}
 %%%%% Minimum cost flow algorithms %%%%%
 …
   address =      {Dublin, Ireland},
   year =         1991,
+  month =        sep,
+}
+  month =        sep
+}
+%%%%% Other algorithms %%%%%
+@article{grosso08maxclique,
+  author =       {Andrea Grosso and Marco Locatelli and Wayne Pullan},
+  title =        {Simple ingredients leading to very efficient
+                  heuristics for the maximum clique problem},
+  journal =      {Journal of Heuristics},
+  year =         2008,
+  volume =       14,
+  number =       6,
+  pages =        {587--612}
+}

lemon/CMakeLists.txt

-                      r726
+                      r1315
 CONFIGURE_FILE(
   ${CMAKE_CURRENT_SOURCE_DIR}/config.h.cmake
+  ${CMAKE_CURRENT_SOURCE_DIR}/config.h.in
   ${CMAKE_CURRENT_BINARY_DIR}/config.h
+)
+CONFIGURE_FILE(
+  ${CMAKE_CURRENT_SOURCE_DIR}/lemon.pc.in
+  ${CMAKE_CURRENT_BINARY_DIR}/lemon.pc
+  @ONLY
+)
 …
 IF(LEMON_HAVE_CPLEX)
   SET(LEMON_SOURCES ${LEMON_SOURCES} cplex.cc)
   INCLUDE_DIRECTORIES(${CPLEX_INCLUDE_DIRS})
+  INCLUDE_DIRECTORIES(${ILOG_INCLUDE_DIRS})
 ENDIF()
 …
 ENDIF()
+IF(LEMON_HAVE_SOPLEX)
+  SET(LEMON_SOURCES ${LEMON_SOURCES} soplex.cc)
+  INCLUDE_DIRECTORIES(${SOPLEX_INCLUDE_DIRS})
+ENDIF()
 ADD_LIBRARY(lemon ${LEMON_SOURCES})
+TARGET_LINK_LIBRARIES(lemon
+  ${GLPK_LIBRARIES} ${COIN_LIBRARIES} ${ILOG_LIBRARIES} ${SOPLEX_LIBRARIES}
+  )
 IF(UNIX)
   SET_TARGET_PROPERTIES(lemon PROPERTIES OUTPUT_NAME emon)
+  SET_TARGET_PROPERTIES(lemon PROPERTIES OUTPUT_NAME emon VERSION ${LEMON_VERSION} SOVERSION ${LEMON_VERSION})
 ENDIF()
 …
   TARGETS lemon
   ARCHIVE DESTINATION lib
+  LIBRARY DESTINATION lib
   COMPONENT library
+)
 …
   COMPONENT headers
+)
+INSTALL(
+  FILES ${CMAKE_CURRENT_BINARY_DIR}/lemon.pc
+  DESTINATION lib/pkgconfig
+)

lemon/adaptors.h

-                      r834
+                      r1270
  * This file is a part of LEMON, a generic C++ optimization library.
+ *
  * Copyright (C) 2003-2009
+ * Copyright (C) 2003-2013
  * Egervary Jeno Kombinatorikus Optimalizalasi Kutatocsoport
  * (Egervary Research Group on Combinatorial Optimization, EGRES).
 …
       Parent::initialize(digraph);
       _node_filter = &node_filter;
       _arc_filter = &arc_filter;
+      _arc_filter = &arc_filter;
+    }
 …
     template <typename V>
     class NodeMap
       : public SubMapExtender<SubDigraphBase<DGR, NF, AF, ch>,
               LEMON_SCOPE_FIX(DigraphAdaptorBase<DGR>, NodeMap<V>)> {
+    class NodeMap
+      : public SubMapExtender<SubDigraphBase<DGR, NF, AF, ch>,
+              LEMON_SCOPE_FIX(DigraphAdaptorBase<DGR>, NodeMap<V>)> {
       typedef SubMapExtender<SubDigraphBase<DGR, NF, AF, ch>,
         LEMON_SCOPE_FIX(DigraphAdaptorBase<DGR>, NodeMap<V>)> Parent;
+        LEMON_SCOPE_FIX(DigraphAdaptorBase<DGR>, NodeMap<V>)> Parent;
     public:
 …
     template <typename V>
     class ArcMap
+    class ArcMap
       : public SubMapExtender<SubDigraphBase<DGR, NF, AF, ch>,
               LEMON_SCOPE_FIX(DigraphAdaptorBase<DGR>, ArcMap<V>)> {
+              LEMON_SCOPE_FIX(DigraphAdaptorBase<DGR>, ArcMap<V>)> {
       typedef SubMapExtender<SubDigraphBase<DGR, NF, AF, ch>,
         LEMON_SCOPE_FIX(DigraphAdaptorBase<DGR>, ArcMap<V>)> Parent;
 …
       Parent::initialize(digraph);
       _node_filter = &node_filter;
       _arc_filter = &arc_filter;
+      _arc_filter = &arc_filter;
+    }
 …
     template <typename V>
     class NodeMap
+    class NodeMap
       : public SubMapExtender<SubDigraphBase<DGR, NF, AF, false>,
           LEMON_SCOPE_FIX(DigraphAdaptorBase<DGR>, NodeMap<V>)> {
       typedef SubMapExtender<SubDigraphBase<DGR, NF, AF, false>,
+      typedef SubMapExtender<SubDigraphBase<DGR, NF, AF, false>,
         LEMON_SCOPE_FIX(DigraphAdaptorBase<DGR>, NodeMap<V>)> Parent;
 …
     template <typename V>
     class ArcMap
+    class ArcMap
       : public SubMapExtender<SubDigraphBase<DGR, NF, AF, false>,
           LEMON_SCOPE_FIX(DigraphAdaptorBase<DGR>, ArcMap<V>)> {
 …
     template <typename V>
     class NodeMap
+    class NodeMap
       : public SubMapExtender<SubGraphBase<GR, NF, EF, ch>,
           LEMON_SCOPE_FIX(GraphAdaptorBase<GR>, NodeMap<V>)> {
       typedef SubMapExtender<SubGraphBase<GR, NF, EF, ch>,
+      typedef SubMapExtender<SubGraphBase<GR, NF, EF, ch>,
         LEMON_SCOPE_FIX(GraphAdaptorBase<GR>, NodeMap<V>)> Parent;
 …
     template <typename V>
     class ArcMap
+    class ArcMap
       : public SubMapExtender<SubGraphBase<GR, NF, EF, ch>,
           LEMON_SCOPE_FIX(GraphAdaptorBase<GR>, ArcMap<V>)> {
       typedef SubMapExtender<SubGraphBase<GR, NF, EF, ch>,
+      typedef SubMapExtender<SubGraphBase<GR, NF, EF, ch>,
         LEMON_SCOPE_FIX(GraphAdaptorBase<GR>, ArcMap<V>)> Parent;
 …
     template <typename V>
     class EdgeMap
+    class EdgeMap
       : public SubMapExtender<SubGraphBase<GR, NF, EF, ch>,
         LEMON_SCOPE_FIX(GraphAdaptorBase<GR>, EdgeMap<V>)> {
       typedef SubMapExtender<SubGraphBase<GR, NF, EF, ch>,
+      typedef SubMapExtender<SubGraphBase<GR, NF, EF, ch>,
         LEMON_SCOPE_FIX(GraphAdaptorBase<GR>, EdgeMap<V>)> Parent;
 …
     NF* _node_filter;
     EF* _edge_filter;
     SubGraphBase()
           : Parent(), _node_filter(0), _edge_filter(0) { }
+    SubGraphBase()
+          : Parent(), _node_filter(0), _edge_filter(0) { }
     void initialize(GR& graph, NF& node_filter, EF& edge_filter) {
 …
     template <typename V>
     class NodeMap
+    class NodeMap
       : public SubMapExtender<SubGraphBase<GR, NF, EF, false>,
           LEMON_SCOPE_FIX(GraphAdaptorBase<GR>, NodeMap<V>)> {
       typedef SubMapExtender<SubGraphBase<GR, NF, EF, false>,
+      typedef SubMapExtender<SubGraphBase<GR, NF, EF, false>,
         LEMON_SCOPE_FIX(GraphAdaptorBase<GR>, NodeMap<V>)> Parent;
 …
     template <typename V>
     class ArcMap
+    class ArcMap
       : public SubMapExtender<SubGraphBase<GR, NF, EF, false>,
           LEMON_SCOPE_FIX(GraphAdaptorBase<GR>, ArcMap<V>)> {
       typedef SubMapExtender<SubGraphBase<GR, NF, EF, false>,
+      typedef SubMapExtender<SubGraphBase<GR, NF, EF, false>,
         LEMON_SCOPE_FIX(GraphAdaptorBase<GR>, ArcMap<V>)> Parent;
 …
     template <typename V>
     class EdgeMap
+    class EdgeMap
       : public SubMapExtender<SubGraphBase<GR, NF, EF, false>,
         LEMON_SCOPE_FIX(GraphAdaptorBase<GR>, EdgeMap<V>)> {
       typedef SubMapExtender<SubGraphBase<GR, NF, EF, false>,
         LEMON_SCOPE_FIX(GraphAdaptorBase<GR>, EdgeMap<V>)> Parent;
+      typedef SubMapExtender<SubGraphBase<GR, NF, EF, false>,
+        LEMON_SCOPE_FIX(GraphAdaptorBase<GR>, EdgeMap<V>)> Parent;
     public:
 …
     /// and edge filter maps.
     SubGraph(GR& graph, NF& node_filter, EF& edge_filter) {
       initialize(graph, node_filter, edge_filter);
+      this->initialize(graph, node_filter, edge_filter);
+    }
 …
 #endif
     typedef DigraphAdaptorExtender<
       SubDigraphBase<GR, NF, ConstMap<typename GR::Arc, Const<bool, true> >,
+      SubDigraphBase<GR, NF, ConstMap<typename GR::Arc, Const<bool, true> >,
                      true> > Parent;
 …
     /// Creates a subgraph for the given digraph or graph with the
     /// given node filter map.
     FilterNodes(GR& graph, NF& node_filter)
+    FilterNodes(GR& graph, NF& node_filter)
       : Parent(), const_true_map()
+    {
 …
                     typename enable_if<UndirectedTagIndicator<GR> >::type> :
     public GraphAdaptorExtender<
       SubGraphBase<GR, NF, ConstMap<typename GR::Edge, Const<bool, true> >,
+      SubGraphBase<GR, NF, ConstMap<typename GR::Edge, Const<bool, true> >,
                    true> > {
     typedef GraphAdaptorExtender<
       SubGraphBase<GR, NF, ConstMap<typename GR::Edge, Const<bool, true> >,
+      SubGraphBase<GR, NF, ConstMap<typename GR::Edge, Const<bool, true> >,
                    true> > Parent;
 …
 #endif
     typedef DigraphAdaptorExtender<
       SubDigraphBase<DGR, ConstMap<typename DGR::Node, Const<bool, true> >,
+      SubDigraphBase<DGR, ConstMap<typename DGR::Node, Const<bool, true> >,
                      AF, false> > Parent;
 …
   class FilterEdges :
     public GraphAdaptorExtender<
       SubGraphBase<GR, ConstMap<typename GR::Node, Const<bool, true> >,
+      SubGraphBase<GR, ConstMap<typename GR::Node, Const<bool, true> >,
                    EF, false> > {
 #endif
     typedef GraphAdaptorExtender<
       SubGraphBase<GR, ConstMap<typename GR::Node, Const<bool, true > >,
+      SubGraphBase<GR, ConstMap<typename GR::Node, Const<bool, true > >,
                    EF, false> > Parent;
 …
     /// Creates a subgraph for the given graph with the given edge
     /// filter map.
     FilterEdges(GR& graph, EF& edge_filter)
+    FilterEdges(GR& graph, EF& edge_filter)
       : Parent(), const_true_map() {
       Parent::initialize(graph, const_true_map, edge_filter);
 …
       bool _forward;
       Arc(const Edge& edge, bool forward)
+      Arc(const Edge& edge, bool forward)
         : _edge(edge), _forward(forward) {}
 …
       ArcMapBase(const UndirectorBase<DGR>& adaptor, const V& value)
         : _forward(*adaptor._digraph, value),
+        : _forward(*adaptor._digraph, value),
           _backward(*adaptor._digraph, value) {}
 …
     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()); }
 …
     /// Creates an undirected graph from the given digraph.
     Undirector(DGR& digraph) {
       initialize(digraph);
+      this->initialize(digraph);
+    }
 …
            typename FM = CM,
            typename TL = Tolerance<typename CM::Value> >
   class ResidualDigraph
+  class ResidualDigraph
     : public SubDigraph<
         Undirector<const DGR>,
 …
     ResidualDigraph(const DGR& digraph, const CM& capacity,
                     FM& flow, const TL& tolerance = Tolerance())
       : Parent(), _capacity(&capacity), _flow(&flow),
+      : Parent(), _capacity(&capacity), _flow(&flow),
         _graph(digraph), _node_filter(),
         _forward_filter(capacity, flow, tolerance),
 …
       /// Constructor
       ResidualCapacity(const ResidualDigraph<DGR, CM, FM, TL>& adaptor)
+      ResidualCapacity(const ResidualDigraph<DGR, CM, FM, TL>& adaptor)
         : _adaptor(&adaptor) {}
 …
     /// to get a node map of the split digraph.
     /// Its value type is inherited from the first node map type (\c IN).
     /// \tparam IN The type of the node map for the in-nodes.
+    /// \tparam IN The type of the node map for the in-nodes.
     /// \tparam OUT The type of the node map for the out-nodes.
     template <typename IN, typename OUT>

lemon/arg_parser.cc

-                      r463
+                      r956
  * This file is a part of LEMON, a generic C++ optimization library.
+ *
  * Copyright (C) 2003-2009
+ * Copyright (C) 2003-2010
  * Egervary Jeno Kombinatorikus Optimalizalasi Kutatocsoport
  * (Egervary Research Group on Combinatorial Optimization, EGRES).
 …
 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();
     exit(1);
+    (static_cast<ArgParser*>(p))->_terminate(ArgParserException::HELP);
+  }
   ArgParser::ArgParser(int argc, const char * const *argv)
+    :_argc(argc), _argv(argv), _command_name(argv[0]) {
+    :_argc(argc), _argv(argv), _command_name(argv[0]),
+    _exit_on_problems(true) {
     funcOption("-help","Print a short help message",_showHelp,this);
     synonym("help","-help");
 …
         i!=_others_help.end();++i) showHelp(i);
     for(Opts::const_iterator i=_opts.begin();i!=_opts.end();++i) showHelp(i);
     exit(1);
+    _terminate(ArgParserException::HELP);
+  }
 …
     std::cerr << "\nType '" << _command_name <<
       " --help' to obtain a short summary on the usage.\n\n";
     exit(1);
+    _terminate(ArgParserException::UNKNOWN_OPT);
+  }
 …
       std::cerr << "\nType '" << _command_name <<
         " --help' to obtain a short summary on the usage.\n\n";
       exit(1);
+      _terminate(ArgParserException::INVALID_OPT);
+    }
+  }

lemon/arg_parser.h

-                      r463
+                      r1327
  * This file is a part of LEMON, a generic C++ optimization library.
+ *
  * Copyright (C) 2003-2009
+ * Copyright (C) 2003-2010
  * Egervary Jeno Kombinatorikus Optimalizalasi Kutatocsoport
  * (Egervary Research Group on Combinatorial Optimization, EGRES).
 …
 #include <sstream>
 #include <algorithm>
+#include <lemon/core.h>
 #include <lemon/assert.h>
 …
 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
 …
                     const std::string &help,
                     void (*func)(void *),void *data);
+    bool _exit_on_problems;
+    void _terminate(ArgParserException::Reason reason) const;
   public:
 …
     const std::vector<std::string> &files() const { return _file_args; }
+    ///Throw instead of exit in case of problems
+    void throwOnProblems()
+    {
+      _exit_on_problems=false;
+    }
   };
+}

lemon/assert.h

-                      r463
+                      r1270
  * This file is a part of LEMON, a generic C++ optimization library.
+ *
  * Copyright (C) 2003-2009
+ * Copyright (C) 2003-2013
  * Egervary Jeno Kombinatorikus Optimalizalasi Kutatocsoport
  * (Egervary Research Group on Combinatorial Optimization, EGRES).
 …
                              ::lemon::_assert_bits::cstringify(msg),    \
                              #exp), 0)))
 #    if LEMON_ENABLE_DEBUG
+#    if defined LEMON_ENABLE_DEBUG
 #      define LEMON_DEBUG(exp, msg)                                     \
          (static_cast<void> (!!(exp) ? 0 : (                            \

lemon/base.cc

-                      r554
+                      r1270
  * This file is a part of LEMON, a generic C++ optimization library.
+ *
  * Copyright (C) 2003-2009
+ * Copyright (C) 2003-2013
  * Egervary Jeno Kombinatorikus Optimalizalasi Kutatocsoport
  * (Egervary Research Group on Combinatorial Optimization, EGRES).
 …
 #include<lemon/tolerance.h>
 #include<lemon/core.h>
+#include<lemon/time_measure.h>
 namespace lemon {
 …
 #endif
+  TimeStamp::Format TimeStamp::_format = TimeStamp::NORMAL;
 } //namespace lemon

lemon/bellman_ford.h

-                      r870
+                      r1270
 /* -*- C++ -*-
+/* -*- mode: C++; indent-tabs-mode: nil; -*-
+ *
  * This file is a part of LEMON, a generic C++ optimization library
+ * This file is a part of LEMON, a generic C++ optimization library.
+ *
  * Copyright (C) 2003-2008
+ * Copyright (C) 2003-2013
  * Egervary Jeno Kombinatorikus Optimalizalasi Kutatocsoport
  * (Egervary Research Group on Combinatorial Optimization, EGRES).
 …
   /// \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.
 …
   /// value is used as extremal infinity value.
   template <
     typename V,
+    typename V,
     bool has_inf = std::numeric_limits<V>::has_infinity>
   struct BellmanFordDefaultOperationTraits {
 …
+    }
   };
   /// \brief Default traits class of BellmanFord class.
   ///
 …
   template<typename GR, typename LEN>
   struct BellmanFordDefaultTraits {
     /// The type of the digraph the algorithm runs on.
+    /// The type of the digraph the algorithm runs on.
     typedef GR Digraph;
 …
     /// \see BellmanFordDefaultOperationTraits
     typedef BellmanFordDefaultOperationTraits<Value> OperationTraits;
     /// \brief The type of the map that stores the last arcs of the
+    /// \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.
 …
     /// \brief Instantiates a \c PredMap.
     ///
     /// This function instantiates a \ref PredMap.
+    ///
+    /// This function instantiates a \ref PredMap.
     /// \param g is the digraph to which we would like to define the
     /// \ref PredMap.
 …
     /// \brief Instantiates a \c DistMap.
     ///
     /// This function instantiates a \ref DistMap.
     /// \param g is the digraph to which we would like to define the
+    /// 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) {
 …
   };
   /// \brief %BellmanFord algorithm class.
   ///
   /// \ingroup shortest_path
   /// This class provides an efficient implementation of the Bellman-Ford
+  /// This class provides an efficient implementation of the Bellman-Ford
   /// algorithm. The maximum time complexity of the algorithm is
   /// <tt>O(ne)</tt>.
+  /// <tt>O(nm)</tt>.
   ///
   /// The Bellman-Ford algorithm solves the single-source shortest path
 …
   ///
   /// The arc lengths are passed to the algorithm using a
   /// \ref concepts::ReadMap "ReadMap", so it is easy to change it to any
+  /// \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.
 …
   /// 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>
 …
     ///The type of the underlying digraph.
     typedef typename TR::Digraph Digraph;
     /// \brief The type of the arc lengths.
     typedef typename TR::LengthMap::Value Value;
 …
     /// The type of the paths.
     typedef PredMapPath<Digraph, PredMap> Path;
     ///\brief The \ref BellmanFordDefaultOperationTraits
+    ///\brief The \ref lemon::BellmanFordDefaultOperationTraits
     /// "operation traits class" of the algorithm.
     typedef typename TR::OperationTraits OperationTraits;
+    ///The \ref BellmanFordDefaultTraits "traits class" of the algorithm.
+    ///\brief The \ref lemon::BellmanFordDefaultTraits "traits class"
+    ///of the algorithm.
     typedef TR Traits;
 …
     void create_maps() {
       if(!_pred) {
         _local_pred = true;
         _pred = Traits::createPredMap(*_gr);
+        _local_pred = true;
+        _pred = Traits::createPredMap(*_gr);
+      }
       if(!_dist) {
         _local_dist = true;
         _dist = Traits::createDistMap(*_gr);
+        _local_dist = true;
+        _dist = Traits::createDistMap(*_gr);
+      }
       if(!_mask) {
 …
+      }
+    }
   public :
     typedef BellmanFord Create;
 …
     /// It must conform to the \ref concepts::WriteMap "WriteMap" concept.
     template <class T>
     struct SetPredMap
+    struct SetPredMap
       : public BellmanFord< Digraph, LengthMap, SetPredMapTraits<T> > {
       typedef BellmanFord< Digraph, LengthMap, SetPredMapTraits<T> > Create;
     };
     template <class T>
     struct SetDistMapTraits : public Traits {
 …
     /// It must conform to the \ref concepts::WriteMap "WriteMap" concept.
     template <class T>
     struct SetDistMap
+    struct SetDistMap
       : public BellmanFord< Digraph, LengthMap, SetDistMapTraits<T> > {
       typedef BellmanFord< Digraph, LengthMap, SetDistMapTraits<T> > Create;
 …
       typedef T OperationTraits;
     };
     /// \brief \ref named-templ-param "Named parameter" for setting
+    /// \brief \ref named-templ-param "Named parameter" for setting
     /// \c OperationTraits type.
     ///
 …
       Create;
     };
     ///@}
   protected:
     BellmanFord() {}
   public:
+  public:
     /// \brief Constructor.
     ///
 …
       _pred(0), _local_pred(false),
       _dist(0), _local_dist(false), _mask(0) {}
     ///Destructor.
     ~BellmanFord() {
 …
     BellmanFord &predMap(PredMap &map) {
       if(_local_pred) {
         delete _pred;
         _local_pred=false;
+        delete _pred;
+        _local_pred=false;
+      }
       _pred = &map;
 …
     BellmanFord &distMap(DistMap &map) {
       if(_local_dist) {
         delete _dist;
         _local_dist=false;
+        delete _dist;
+        _local_dist=false;
+      }
       _dist = &map;
 …
     /// \brief Initializes the internal data structures.
     ///
+    ///
     /// Initializes the internal data structures. The optional parameter
     /// is the initial distance of each node.
 …
       create_maps();
       for (NodeIt it(*_gr); it != INVALID; ++it) {
         _pred->set(it, INVALID);
         _dist->set(it, value);
+        _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);
+        }
+        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);
+        }
+      }
+    }
+        for (NodeIt it(*_gr); it != INVALID; ++it) {
+          _mask->set(it, false);
+        }
+      }
+    }
     /// \brief Adds a new source node.
     ///
 …
       _dist->set(source, dst);
       if (!(*_mask)[source]) {
         _process.push_back(source);
         _mask->set(source, true);
+        _process.push_back(source);
+        _mask->set(source, true);
+      }
+    }
 …
     bool processNextRound() {
       for (int i = 0; i < int(_process.size()); ++i) {
         _mask->set(_process[i], false);
+        _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]];
+        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);
+            }
+          }
+        }
+        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);
 …
     bool processNextWeakRound() {
       for (int i = 0; i < int(_process.size()); ++i) {
         _mask->set(_process[i], false);
+        _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);
+            }
+          }
+        }
+        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);
 …
       int num = countNodes(*_gr) - 1;
       for (int i = 0; i < num; ++i) {
         if (processNextWeakRound()) break;
+        if (processNextWeakRound()) break;
+      }
+    }
 …
     /// if the digraph contains cycles with negative total length.
     ///
     /// The algorithm computes
+    /// 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.
+    /// added with addSource() before using this function.
     bool checkedStart() {
       int num = countNodes(*_gr);
       for (int i = 0; i < num; ++i) {
         if (processNextWeakRound()) return true;
+        if (processNextWeakRound()) return true;
+      }
       return _process.empty();
 …
     ///
     /// \pre init() must be called and at least one root node should be
     /// added with addSource() before using this function.
+    /// added with addSource() before using this function.
     void limitedStart(int num) {
       for (int i = 0; i < num; ++i) {
         if (processNextRound()) break;
+      }
+    }
+        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.
 …
       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
 …
       limitedStart(num);
+    }
     ///@}
 …
       ///
       /// Constructor for getting the active nodes of the given BellmanFord
       /// instance.
+      /// instance.
       ActiveIt(const BellmanFord& algorithm) : _algorithm(&algorithm)
+      {
 …
       ///
       /// Conversion to \c Node.
       operator Node() const {
+      operator Node() const {
         return _index >= 0 ? _algorithm->_process[_index] : INVALID;
+      }
 …
       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);
+      }
+        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).
     ///
 …
       return Path(*_gr, *_pred, t);
+    }
     /// \brief The distance of the given node from the root(s).
     ///
 …
     /// \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]);
+    }
+    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.
 …
     /// using this function.
     const DistMap &distMap() const { return *_dist;}
     /// \brief Returns a const reference to the node map that stores the
     /// predecessor arcs.
 …
     /// using this function.
     const PredMap &predMap() const { return *_pred; }
     /// \brief Checks if a node is reached from the root(s).
     ///
 …
     /// \brief Gives back a negative cycle.
     ///
+    ///
     /// This function gives back a directed cycle with negative total
     /// length if the algorithm has already found one.
 …
       return cycle;
+    }
     ///@}
   };
   /// \brief Default traits class of bellmanFord() function.
   ///
 …
   template <typename GR, typename LEN>
   struct BellmanFordWizardDefaultTraits {
     /// The type of the digraph the algorithm runs on.
+    /// The type of the digraph the algorithm runs on.
     typedef GR Digraph;
 …
     /// \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.
 …
     /// \brief Instantiates a \c PredMap.
     ///
+    ///
     /// This function instantiates a \ref PredMap.
     /// \param g is the digraph to which we would like to define the
 …
     /// \brief Instantiates a \c DistMap.
     ///
     /// This function instantiates a \ref DistMap.
+    /// This function instantiates a \ref DistMap.
     /// \param g is the digraph to which we would like to define the
     /// \ref DistMap.
 …
     typedef lemon::Path<Digraph> Path;
   };
   /// \brief Default traits class used by BellmanFordWizard.
   ///
 …
   /// \tparam LEN The type of the length map.
   template <typename GR, typename LEN>
   class BellmanFordWizardBase
+  class BellmanFordWizardBase
     : public BellmanFordWizardDefaultTraits<GR, LEN> {
 …
     public:
     /// Constructor.
     /// This constructor does not require parameters, it initiates
     /// all of the attributes to default values \c 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))),
+    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 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 typename Digraph::Arc Arc;
     typedef typename Digraph::OutArcIt ArcIt;
     typedef typename TR::LengthMap LengthMap;
     typedef typename LengthMap::Value Value;
 …
     /// \param gr The digraph the algorithm runs on.
     /// \param len The length map.
     BellmanFordWizard(const Digraph& gr, const LengthMap& len)
+    BellmanFordWizard(const Digraph& gr, const LengthMap& len)
       : TR(gr, len) {}
 …
     /// \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),
+      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));
 …
       SetPredMapBase(const TR &b) : TR(b) {}
     };
     /// \brief \ref named-templ-param "Named parameter" for setting
     /// the predecessor map.
 …
       return BellmanFordWizard<SetPredMapBase<T> >(*this);
+    }
     template<class T>
     struct SetDistMapBase : public Base {
 …
       SetDistMapBase(const TR &b) : TR(b) {}
     };
     /// \brief \ref named-templ-param "Named parameter" for setting
     /// the distance map.
 …
       return *this;
+    }
   };
   /// \brief Function type interface for the \ref BellmanFord "Bellman-Ford"
   /// algorithm.
 …
   /// algorithm.
   ///
   /// This function also has several \ref named-templ-func-param
   /// "named parameters", they are declared as the members of class
+  /// 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.
 …
   BellmanFordWizard<BellmanFordWizardBase<GR,LEN> >
   bellmanFord(const GR& digraph,
               const LEN& length)
+              const LEN& length)
+  {
     return BellmanFordWizard<BellmanFordWizardBase<GR,LEN> >(digraph, length);

lemon/bfs.h

-                      r835
+                      r1270
  * This file is a part of LEMON, a generic C++ optimization library.
+ *
  * Copyright (C) 2003-2009
+ * Copyright (C) 2003-2013
  * Egervary Jeno Kombinatorikus Optimalizalasi Kutatocsoport
  * (Egervary Research Group on Combinatorial Optimization, EGRES).
 …
     ///The type of the map that indicates which nodes are reached.
+    ///It must conform to the \ref concepts::ReadWriteMap "ReadWriteMap" concept.
+    ///It must conform to
+    ///the \ref concepts::ReadWriteMap "ReadWriteMap" concept.
     typedef typename Digraph::template NodeMap<bool> ReachedMap;
     ///Instantiates a \c ReachedMap.
 …
   ///\tparam GR The type of the digraph the algorithm runs on.
   ///The default type is \ref ListDigraph.
+  ///\tparam TR The traits class that defines various types used by the
+  ///algorithm. By default, it is \ref BfsDefaultTraits
+  ///"BfsDefaultTraits<GR>".
+  ///In most cases, this parameter should not be set directly,
+  ///consider to use the named template parameters instead.
 #ifdef DOXYGEN
   template <typename GR,
 …
     typedef PredMapPath<Digraph, PredMap> Path;
     ///The \ref BfsDefaultTraits "traits class" of the algorithm.
+    ///The \ref lemon::BfsDefaultTraits "traits class" of the algorithm.
     typedef TR Traits;
 …
     ///\ref named-templ-param "Named parameter" for setting
     ///\c ReachedMap type.
+    ///It must conform to the \ref concepts::ReadWriteMap "ReadWriteMap" concept.
+    ///It must conform to
+    ///the \ref concepts::ReadWriteMap "ReadWriteMap" concept.
     template <class T>
     struct SetReachedMap : public Bfs< Digraph, SetReachedMapTraits<T> > {
 …
     ///The type of the map that indicates which nodes are reached.
+    ///It must conform to the \ref concepts::ReadWriteMap "ReadWriteMap" concept.
+    ///It must conform to
+    ///the \ref concepts::ReadWriteMap "ReadWriteMap" concept.
     typedef typename Digraph::template NodeMap<bool> ReachedMap;
     ///Instantiates a ReachedMap.
 …
   /// 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
 …
+      }
       _Visitor& visitor;
+      Constraints() {}
     };
   };
 …
     ///
     /// The type of the map that indicates which nodes are reached.
+    /// It must conform to the \ref concepts::ReadWriteMap "ReadWriteMap" concept.
+    /// It must conform to
+    ///the \ref concepts::ReadWriteMap "ReadWriteMap" concept.
     typedef typename Digraph::template NodeMap<bool> ReachedMap;
 …
   /// does not observe the BFS events. If you want to observe the BFS
   /// events, you should implement your own visitor class.
   /// \tparam TR Traits class to set various data types used by the
   /// algorithm. The default traits class is
   /// \ref BfsVisitDefaultTraits "BfsVisitDefaultTraits<GR>".
   /// See \ref BfsVisitDefaultTraits for the documentation of
   /// a BFS visit traits class.
+  /// \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.
 #ifdef DOXYGEN
   template <typename GR, typename VS, typename TR>

lemon/bin_heap.h

r758	r1270
3	3	* This file is a part of LEMON, a generic C++ optimization library.
4	4	*
5		* Copyright (C) 2003-2009
	5	* Copyright (C) 2003-2013
6	6	* Egervary Jeno Kombinatorikus Optimalizalasi Kutatocsoport
7	7	* (Egervary Research Group on Combinatorial Optimization, EGRES).

lemon/bits/alteration_notifier.h

-                      r463
+                      r1270
  * This file is a part of LEMON, a generic C++ optimization library.
+ *
  * Copyright (C) 2003-2009
+ * Copyright (C) 2003-2013
  * Egervary Jeno Kombinatorikus Optimalizalasi Kutatocsoport
  * (Egervary Research Group on Combinatorial Optimization, EGRES).
 …
 #include <lemon/core.h>
+#include <lemon/bits/lock.h>
 //\ingroup graphbits
 …
     typedef std::list<ObserverBase*> Observers;
     Observers _observers;
+    lemon::bits::Lock _lock;
   public:
 …
     void attach(ObserverBase& observer) {
+      _lock.lock();
       observer._index = _observers.insert(_observers.begin(), &observer);
       observer._notifier = this;
+      _lock.unlock();
+    }
     void detach(ObserverBase& observer) {
+      _lock.lock();
       _observers.erase(observer._index);
       observer._index = _observers.end();
       observer._notifier = 0;
+      _lock.unlock();
+    }

lemon/bits/array_map.h

-                      r664
+                      r1270
  * This file is a part of LEMON, a generic C++ optimization library.
+ *
  * Copyright (C) 2003-2009
+ * Copyright (C) 2003-2013
  * Egervary Jeno Kombinatorikus Optimalizalasi Kutatocsoport
  * (Egervary Research Group on Combinatorial Optimization, EGRES).
 …
   private:
     // The MapBase of the Map which imlements the core regisitry function.
     typedef typename Notifier::ObserverBase Parent;

lemon/bits/bezier.h

-                      r463
+                      r1270
  * This file is a part of LEMON, a generic C++ optimization library.
+ *
  * Copyright (C) 2003-2009
+ * Copyright (C) 2003-2013
  * Egervary Jeno Kombinatorikus Optimalizalasi Kutatocsoport
  * (Egervary Research Group on Combinatorial Optimization, EGRES).
 …
     const Point d=(a+b)/2;
     const Point e=(b+c)/2;
     const Point f=(d+e)/2;
+    // const Point f=(d+e)/2;
     R f1=_f(Bezier3(p1,a,d,e),_d);
     R f2=_f(Bezier3(e,d,c,p4),_d);

lemon/bits/default_map.h

-                      r674
+                      r1270
  * This file is a part of LEMON, a generic C++ optimization library.
+ *
  * Copyright (C) 2003-2009
+ * Copyright (C) 2003-2013
  * Egervary Jeno Kombinatorikus Optimalizalasi Kutatocsoport
  * (Egervary Research Group on Combinatorial Optimization, EGRES).
 …
   public:
     typedef DefaultMap<_Graph, _Item, _Value> Map;
     typedef typename Parent::GraphType GraphType;
     typedef typename Parent::Value Value;

lemon/bits/edge_set_extender.h

-                      r732
+                      r1270
 /* -*- C++ -*-
+/* -*- mode: C++; indent-tabs-mode: nil; -*-
+ *
  * This file is a part of LEMON, a generic C++ optimization library
+ * This file is a part of LEMON, a generic C++ optimization library.
+ *
  * Copyright (C) 2003-2008
+ * Copyright (C) 2003-2013
  * Egervary Jeno Kombinatorikus Optimalizalasi Kutatocsoport
  * (Egervary Research Group on Combinatorial Optimization, EGRES).
 …
     Node oppositeNode(const Node &n, const Arc &e) const {
       if (n == Parent::source(e))
         return Parent::target(e);
+        return Parent::target(e);
       else if(n==Parent::target(e))
         return Parent::source(e);
+        return Parent::source(e);
       else
         return INVALID;
+        return INVALID;
+    }
 …
     // Iterable extensions
     class NodeIt : public Node {
+    class NodeIt : public Node {
       const Digraph* digraph;
     public:
 …
       explicit NodeIt(const Digraph& _graph) : digraph(&_graph) {
         _graph.first(static_cast<Node&>(*this));
+      }
       NodeIt(const Digraph& _graph, const Node& node)
         : Node(node), digraph(&_graph) {}
       NodeIt& operator++() {
         digraph->next(*this);
+        return *this;
+      }
     };
     class ArcIt : public Arc {
+        _graph.first(static_cast<Node&>(*this));
+      }
+      NodeIt(const Digraph& _graph, const Node& node)
+        : Node(node), digraph(&_graph) {}
+      NodeIt& operator++() {
+        digraph->next(*this);
+        return *this;
+      }
+    };
+    class ArcIt : public Arc {
       const Digraph* digraph;
     public:
 …
       explicit ArcIt(const Digraph& _graph) : digraph(&_graph) {
         _graph.first(static_cast<Arc&>(*this));
+      }
       ArcIt(const Digraph& _graph, const Arc& e) :
         Arc(e), digraph(&_graph) { }
       ArcIt& operator++() {
         digraph->next(*this);
+        return *this;
+      }
     };
     class OutArcIt : public Arc {
+        _graph.first(static_cast<Arc&>(*this));
+      }
+      ArcIt(const Digraph& _graph, const Arc& e) :
+        Arc(e), digraph(&_graph) { }
+      ArcIt& operator++() {
+        digraph->next(*this);
+        return *this;
+      }
+    };
+    class OutArcIt : public Arc {
       const Digraph* digraph;
     public:
 …
       OutArcIt(Invalid i) : Arc(i) { }
       OutArcIt(const Digraph& _graph, const Node& node)
         : digraph(&_graph) {
         _graph.firstOut(*this, node);
+      }
       OutArcIt(const Digraph& _graph, const Arc& arc)
         : Arc(arc), digraph(&_graph) {}
       OutArcIt& operator++() {
         digraph->nextOut(*this);
+        return *this;
+      }
     };
     class InArcIt : public Arc {
+      OutArcIt(const Digraph& _graph, const Node& node)
+        : digraph(&_graph) {
+        _graph.firstOut(*this, node);
+      }
+      OutArcIt(const Digraph& _graph, const Arc& arc)
+        : Arc(arc), digraph(&_graph) {}
+      OutArcIt& operator++() {
+        digraph->nextOut(*this);
+        return *this;
+      }
+    };
+    class InArcIt : public Arc {
       const Digraph* digraph;
     public:
 …
       InArcIt(Invalid i) : Arc(i) { }
       InArcIt(const Digraph& _graph, const Node& node)
         : digraph(&_graph) {
         _graph.firstIn(*this, node);
+      }
       InArcIt(const Digraph& _graph, const Arc& arc) :
         Arc(arc), digraph(&_graph) {}
       InArcIt& operator++() {
         digraph->nextIn(*this);
+        return *this;
+      InArcIt(const Digraph& _graph, const Node& node)
+        : digraph(&_graph) {
+        _graph.firstIn(*this, node);
+      }
+      InArcIt(const Digraph& _graph, const Arc& arc) :
+        Arc(arc), digraph(&_graph) {}
+      InArcIt& operator++() {
+        digraph->nextIn(*this);
+        return *this;
+      }
 …
     // Mappable extension
     template <typename _Value>
     class ArcMap
+    class ArcMap
       : public MapExtender<DefaultMap<Digraph, Arc, _Value> > {
       typedef MapExtender<DefaultMap<Digraph, Arc, _Value> > Parent;
     public:
       explicit ArcMap(const Digraph& _g)
         : Parent(_g) {}
       ArcMap(const Digraph& _g, const _Value& _v)
         : Parent(_g, _v) {}
+      explicit ArcMap(const Digraph& _g)
+        : Parent(_g) {}
+      ArcMap(const Digraph& _g, const _Value& _v)
+        : Parent(_g, _v) {}
       ArcMap& operator=(const ArcMap& cmap) {
         return operator=<ArcMap>(cmap);
+        return operator=<ArcMap>(cmap);
+      }
 …
       ArcMap& operator=(const CMap& cmap) {
         Parent::operator=(cmap);
         return *this;
+        return *this;
+      }
 …
       return arc;
+    }
     void clear() {
       notifier(Arc()).clear();
 …
     typedef EdgeSetExtender Graph;
+    typedef True UndirectedTag;
     typedef typename Parent::Node Node;
     typedef typename Parent::Arc Arc;
 …
     Node oppositeNode(const Node &n, const Edge &e) const {
       if( n == Parent::u(e))
         return Parent::v(e);
+        return Parent::v(e);
       else if( n == Parent::v(e))
         return Parent::u(e);
+        return Parent::u(e);
       else
         return INVALID;
+        return INVALID;
+    }
 …
     using Parent::notifier;
     ArcNotifier& notifier(Arc) const {
       return arc_notifier;
 …
     class NodeIt : public Node {
+    class NodeIt : public Node {
       const Graph* graph;
     public:
 …
       explicit NodeIt(const Graph& _graph) : graph(&_graph) {
         _graph.first(static_cast<Node&>(*this));
+      }
       NodeIt(const Graph& _graph, const Node& node)
         : Node(node), graph(&_graph) {}
       NodeIt& operator++() {
         graph->next(*this);
+        return *this;
+      }
     };
     class ArcIt : public Arc {
+        _graph.first(static_cast<Node&>(*this));
+      }
+      NodeIt(const Graph& _graph, const Node& node)
+        : Node(node), graph(&_graph) {}
+      NodeIt& operator++() {
+        graph->next(*this);
+        return *this;
+      }
+    };
+    class ArcIt : public Arc {
       const Graph* graph;
     public:
 …
       explicit ArcIt(const Graph& _graph) : graph(&_graph) {
         _graph.first(static_cast<Arc&>(*this));
+      }
       ArcIt(const Graph& _graph, const Arc& e) :
         Arc(e), graph(&_graph) { }
       ArcIt& operator++() {
         graph->next(*this);
+        return *this;
+      }
     };
     class OutArcIt : public Arc {
+        _graph.first(static_cast<Arc&>(*this));
+      }
+      ArcIt(const Graph& _graph, const Arc& e) :
+        Arc(e), graph(&_graph) { }
+      ArcIt& operator++() {
+        graph->next(*this);
+        return *this;
+      }
+    };
+    class OutArcIt : public Arc {
       const Graph* graph;
     public:
 …
       OutArcIt(Invalid i) : Arc(i) { }
       OutArcIt(const Graph& _graph, const Node& node)
         : graph(&_graph) {
         _graph.firstOut(*this, node);
+      }
       OutArcIt(const Graph& _graph, const Arc& arc)
         : Arc(arc), graph(&_graph) {}
       OutArcIt& operator++() {
         graph->nextOut(*this);
+        return *this;
+      }
     };
     class InArcIt : public Arc {
+      OutArcIt(const Graph& _graph, const Node& node)
+        : graph(&_graph) {
+        _graph.firstOut(*this, node);
+      }
+      OutArcIt(const Graph& _graph, const Arc& arc)
+        : Arc(arc), graph(&_graph) {}
+      OutArcIt& operator++() {
+        graph->nextOut(*this);
+        return *this;
+      }
+    };
+    class InArcIt : public Arc {
       const Graph* graph;
     public:
 …
       InArcIt(Invalid i) : Arc(i) { }
       InArcIt(const Graph& _graph, const Node& node)
         : graph(&_graph) {
         _graph.firstIn(*this, node);
+      }
       InArcIt(const Graph& _graph, const Arc& arc) :
         Arc(arc), graph(&_graph) {}
       InArcIt& operator++() {
         graph->nextIn(*this);
+        return *this;
+      }
     };
     class EdgeIt : public Parent::Edge {
+      InArcIt(const Graph& _graph, const Node& node)
+        : graph(&_graph) {
+        _graph.firstIn(*this, node);
+      }
+      InArcIt(const Graph& _graph, const Arc& arc) :
+        Arc(arc), graph(&_graph) {}
+      InArcIt& operator++() {
+        graph->nextIn(*this);
+        return *this;
+      }
+    };
+    class EdgeIt : public Parent::Edge {
       const Graph* graph;
     public:
 …
       explicit EdgeIt(const Graph& _graph) : graph(&_graph) {
         _graph.first(static_cast<Edge&>(*this));
+      }
       EdgeIt(const Graph& _graph, const Edge& e) :
         Edge(e), graph(&_graph) { }
       EdgeIt& operator++() {
         graph->next(*this);
+        return *this;
+        _graph.first(static_cast<Edge&>(*this));
+      }
+      EdgeIt(const Graph& _graph, const Edge& e) :
+        Edge(e), graph(&_graph) { }
+      EdgeIt& operator++() {
+        graph->next(*this);
+        return *this;
+      }
 …
       IncEdgeIt(const Graph& _graph, const Node &n) : graph(&_graph) {
         _graph.firstInc(*this, direction, n);
+        _graph.firstInc(*this, direction, n);
+      }
       IncEdgeIt(const Graph& _graph, const Edge &ue, const Node &n)
         : graph(&_graph), Edge(ue) {
         direction = (_graph.source(ue) == n);
+        : graph(&_graph), Edge(ue) {
+        direction = (_graph.source(ue) == n);
+      }
       IncEdgeIt& operator++() {
         graph->nextInc(*this, direction);
+        return *this;
+        graph->nextInc(*this, direction);
+        return *this;
+      }
     };
 …
     // Returns the base node of the iterator
     Node baseNode(const IncEdgeIt &e) const {
       return e.direction ? u(e) : v(e);
+      return e.direction ? this->u(e) : this->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);
+      return e.direction ? this->v(e) : this->u(e);
+    }
     template <typename _Value>
     class ArcMap
+    class ArcMap
       : public MapExtender<DefaultMap<Graph, Arc, _Value> > {
       typedef MapExtender<DefaultMap<Graph, Arc, _Value> > Parent;
     public:
       explicit ArcMap(const Graph& _g)
         : Parent(_g) {}
       ArcMap(const Graph& _g, const _Value& _v)
         : Parent(_g, _v) {}
+      explicit ArcMap(const Graph& _g)
+        : Parent(_g) {}
+      ArcMap(const Graph& _g, const _Value& _v)
+        : Parent(_g, _v) {}
       ArcMap& operator=(const ArcMap& cmap) {
         return operator=<ArcMap>(cmap);
+        return operator=<ArcMap>(cmap);
+      }
 …
       ArcMap& operator=(const CMap& cmap) {
         Parent::operator=(cmap);
         return *this;
+        return *this;
+      }
 …
     template <typename _Value>
     class EdgeMap
+    class EdgeMap
       : public MapExtender<DefaultMap<Graph, Edge, _Value> > {
       typedef MapExtender<DefaultMap<Graph, Edge, _Value> > Parent;
     public:
       explicit EdgeMap(const Graph& _g)
         : Parent(_g) {}
       EdgeMap(const Graph& _g, const _Value& _v)
         : Parent(_g, _v) {}
+      explicit EdgeMap(const Graph& _g)
+        : Parent(_g) {}
+      EdgeMap(const Graph& _g, const _Value& _v)
+        : Parent(_g, _v) {}
       EdgeMap& operator=(const EdgeMap& cmap) {
         return operator=<EdgeMap>(cmap);
+        return operator=<EdgeMap>(cmap);
+      }
 …
       EdgeMap& operator=(const CMap& cmap) {
         Parent::operator=(cmap);
         return *this;
+        return *this;
+      }
 …
       return edge;
+    }
     void clear() {
       notifier(Arc()).clear();
 …
       arc_notifier.clear();
+    }
   };

lemon/bits/graph_adaptor_extender.h

-                      r664
+                      r1270
  * This file is a part of LEMON, a generic C++ optimization library.
+ *
  * Copyright (C) 2003-2009
+ * Copyright (C) 2003-2013
  * Egervary Jeno Kombinatorikus Optimalizalasi Kutatocsoport
  * (Egervary Research Group on Combinatorial Optimization, EGRES).
 …
     typedef GraphAdaptorExtender Adaptor;
+    typedef True UndirectedTag;
     typedef typename Parent::Node Node;
     typedef typename Parent::Arc Arc;

lemon/bits/graph_extender.h

-                      r825
+                      r1270
  * This file is a part of LEMON, a generic C++ optimization library.
+ *
  * Copyright (C) 2003-2009
+ * Copyright (C) 2003-2013
  * Egervary Jeno Kombinatorikus Optimalizalasi Kutatocsoport
  * (Egervary Research Group on Combinatorial Optimization, EGRES).
 …
     // Returns the base node of the iterator
     Node baseNode(const IncEdgeIt &edge) const {
       return edge._direction ? u(edge) : v(edge);
+      return edge._direction ? this->u(edge) : this->v(edge);
+    }
     // Running node of the iterator
 …
     // Returns the running node of the iterator
     Node runningNode(const IncEdgeIt &edge) const {
       return edge._direction ? v(edge) : u(edge);
+      return edge._direction ? this->v(edge) : this->u(edge);
+    }
 …
   };
+  // \ingroup _graphbits
+  //
+  // \brief Extender for the BpGraphs
+  template <typename Base>
+  class BpGraphExtender : public Base {
+    typedef Base Parent;
+  public:
+    typedef BpGraphExtender BpGraph;
+    typedef True UndirectedTag;
+    typedef typename Parent::Node Node;
+    typedef typename Parent::RedNode RedNode;
+    typedef typename Parent::BlueNode BlueNode;
+    typedef typename Parent::Arc Arc;
+    typedef typename Parent::Edge Edge;
+    // BpGraph extension
+    using Parent::first;
+    using Parent::next;
+    using Parent::id;
+    int maxId(Node) const {
+      return Parent::maxNodeId();
+    }
+    int maxId(RedNode) const {
+      return Parent::maxRedId();
+    }
+    int maxId(BlueNode) const {
+      return Parent::maxBlueId();
+    }
+    int maxId(Arc) const {
+      return Parent::maxArcId();
+    }
+    int maxId(Edge) const {
+      return Parent::maxEdgeId();
+    }
+    static Node fromId(int id, Node) {
+      return Parent::nodeFromId(id);
+    }
+    static Arc fromId(int id, Arc) {
+      return Parent::arcFromId(id);
+    }
+    static Edge fromId(int id, Edge) {
+      return Parent::edgeFromId(id);
+    }
+    Node u(Edge e) const { return this->redNode(e); }
+    Node v(Edge e) const { return this->blueNode(e); }
+    Node oppositeNode(const Node &n, const Edge &e) const {
+      if( n == u(e))
+        return v(e);
+      else if( n == v(e))
+        return u(e);
+      else
+        return INVALID;
+    }
+    Arc oppositeArc(const Arc &arc) const {
+      return Parent::direct(arc, !Parent::direction(arc));
+    }
+    using Parent::direct;
+    Arc direct(const Edge &edge, const Node &node) const {
+      return Parent::direct(edge, Parent::redNode(edge) == node);
+    }
+    RedNode asRedNode(const Node& node) const {
+      if (node == INVALID || Parent::blue(node)) {
+        return INVALID;
+      } else {
+        return Parent::asRedNodeUnsafe(node);
+      }
+    }
+    BlueNode asBlueNode(const Node& node) const {
+      if (node == INVALID || Parent::red(node)) {
+        return INVALID;
+      } else {
+        return Parent::asBlueNodeUnsafe(node);
+      }
+    }
+    // Alterable extension
+    typedef AlterationNotifier<BpGraphExtender, Node> NodeNotifier;
+    typedef AlterationNotifier<BpGraphExtender, RedNode> RedNodeNotifier;
+    typedef AlterationNotifier<BpGraphExtender, BlueNode> BlueNodeNotifier;
+    typedef AlterationNotifier<BpGraphExtender, Arc> ArcNotifier;
+    typedef AlterationNotifier<BpGraphExtender, Edge> EdgeNotifier;
+  protected:
+    mutable NodeNotifier node_notifier;
+    mutable RedNodeNotifier red_node_notifier;
+    mutable BlueNodeNotifier blue_node_notifier;
+    mutable ArcNotifier arc_notifier;
+    mutable EdgeNotifier edge_notifier;
+  public:
+    NodeNotifier& notifier(Node) const {
+      return node_notifier;
+    }
+    RedNodeNotifier& notifier(RedNode) const {
+      return red_node_notifier;
+    }
+    BlueNodeNotifier& notifier(BlueNode) const {
+      return blue_node_notifier;
+    }
+    ArcNotifier& notifier(Arc) const {
+      return arc_notifier;
+    }
+    EdgeNotifier& notifier(Edge) const {
+      return edge_notifier;
+    }
+    class NodeIt : public Node {
+      const BpGraph* _graph;
+    public:
+      NodeIt() {}
+      NodeIt(Invalid i) : Node(i) { }
+      explicit NodeIt(const BpGraph& graph) : _graph(&graph) {
+        _graph->first(static_cast<Node&>(*this));
+      }
+      NodeIt(const BpGraph& graph, const Node& node)
+        : Node(node), _graph(&graph) {}
+      NodeIt& operator++() {
+        _graph->next(*this);
+        return *this;
+      }
+    };
+    class RedNodeIt : public RedNode {
+      const BpGraph* _graph;
+    public:
+      RedNodeIt() {}
+      RedNodeIt(Invalid i) : RedNode(i) { }
+      explicit RedNodeIt(const BpGraph& graph) : _graph(&graph) {
+        _graph->first(static_cast<RedNode&>(*this));
+      }
+      RedNodeIt(const BpGraph& graph, const RedNode& node)
+        : RedNode(node), _graph(&graph) {}
+      RedNodeIt& operator++() {
+        _graph->next(static_cast<RedNode&>(*this));
+        return *this;
+      }
+    };
+    class BlueNodeIt : public BlueNode {
+      const BpGraph* _graph;
+    public:
+      BlueNodeIt() {}
+      BlueNodeIt(Invalid i) : BlueNode(i) { }
+      explicit BlueNodeIt(const BpGraph& graph) : _graph(&graph) {
+        _graph->first(static_cast<BlueNode&>(*this));
+      }
+      BlueNodeIt(const BpGraph& graph, const BlueNode& node)
+        : BlueNode(node), _graph(&graph) {}
+      BlueNodeIt& operator++() {
+        _graph->next(static_cast<BlueNode&>(*this));
+        return *this;
+      }
+    };
+    class ArcIt : public Arc {
+      const BpGraph* _graph;
+    public:
+      ArcIt() { }
+      ArcIt(Invalid i) : Arc(i) { }
+      explicit ArcIt(const BpGraph& graph) : _graph(&graph) {
+        _graph->first(static_cast<Arc&>(*this));
+      }
+      ArcIt(const BpGraph& graph, const Arc& arc) :
+        Arc(arc), _graph(&graph) { }
+      ArcIt& operator++() {
+        _graph->next(*this);
+        return *this;
+      }
+    };
+    class OutArcIt : public Arc {
+      const BpGraph* _graph;
+    public:
+      OutArcIt() { }
+      OutArcIt(Invalid i) : Arc(i) { }
+      OutArcIt(const BpGraph& graph, const Node& node)
+        : _graph(&graph) {
+        _graph->firstOut(*this, node);
+      }
+      OutArcIt(const BpGraph& graph, const Arc& arc)
+        : Arc(arc), _graph(&graph) {}
+      OutArcIt& operator++() {
+        _graph->nextOut(*this);
+        return *this;
+      }
+    };
+    class InArcIt : public Arc {
+      const BpGraph* _graph;
+    public:
+      InArcIt() { }
+      InArcIt(Invalid i) : Arc(i) { }
+      InArcIt(const BpGraph& graph, const Node& node)
+        : _graph(&graph) {
+        _graph->firstIn(*this, node);
+      }
+      InArcIt(const BpGraph& graph, const Arc& arc) :
+        Arc(arc), _graph(&graph) {}
+      InArcIt& operator++() {
+        _graph->nextIn(*this);
+        return *this;
+      }
+    };
+    class EdgeIt : public Parent::Edge {
+      const BpGraph* _graph;
+    public:
+      EdgeIt() { }
+      EdgeIt(Invalid i) : Edge(i) { }
+      explicit EdgeIt(const BpGraph& graph) : _graph(&graph) {
+        _graph->first(static_cast<Edge&>(*this));
+      }
+      EdgeIt(const BpGraph& graph, const Edge& edge) :
+        Edge(edge), _graph(&graph) { }
+      EdgeIt& operator++() {
+        _graph->next(*this);
+        return *this;
+      }
+    };
+    class IncEdgeIt : public Parent::Edge {
+      friend class BpGraphExtender;
+      const BpGraph* _graph;
+      bool _direction;
+    public:
+      IncEdgeIt() { }
+      IncEdgeIt(Invalid i) : Edge(i), _direction(false) { }
+      IncEdgeIt(const BpGraph& graph, const Node &node) : _graph(&graph) {
+        _graph->firstInc(*this, _direction, node);
+      }
+      IncEdgeIt(const BpGraph& graph, const Edge &edge, const Node &node)
+        : _graph(&graph), Edge(edge) {
+        _direction = (_graph->source(edge) == node);
+      }
+      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 &arc) const {
+      return Parent::source(static_cast<const Arc&>(arc));
+    }
+    // \brief Running node of the iterator
+    //
+    // Returns the running node (ie. the target in this case) of the
+    // iterator
+    Node runningNode(const OutArcIt &arc) const {
+      return Parent::target(static_cast<const Arc&>(arc));
+    }
+    // \brief Base node of the iterator
+    //
+    // Returns the base node (ie. the target in this case) of the iterator
+    Node baseNode(const InArcIt &arc) const {
+      return Parent::target(static_cast<const Arc&>(arc));
+    }
+    // \brief Running node of the iterator
+    //
+    // Returns the running node (ie. the source in this case) of the
+    // iterator
+    Node runningNode(const InArcIt &arc) const {
+      return Parent::source(static_cast<const Arc&>(arc));
+    }
+    // Base node of the iterator
+    //
+    // Returns the base node of the iterator
+    Node baseNode(const IncEdgeIt &edge) const {
+      return edge._direction ? this->u(edge) : this->v(edge);
+    }
+    // Running node of the iterator
+    //
+    // Returns the running node of the iterator
+    Node runningNode(const IncEdgeIt &edge) const {
+      return edge._direction ? this->v(edge) : this->u(edge);
+    }
+    // Mappable extension
+    template <typename _Value>
+    class NodeMap
+      : public MapExtender<DefaultMap<BpGraph, Node, _Value> > {
+      typedef MapExtender<DefaultMap<BpGraph, Node, _Value> > Parent;
+    public:
+      explicit NodeMap(const BpGraph& bpgraph)
+        : Parent(bpgraph) {}
+      NodeMap(const BpGraph& bpgraph, const _Value& value)
+        : Parent(bpgraph, 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 _Value>
+    class RedNodeMap
+      : public MapExtender<DefaultMap<BpGraph, RedNode, _Value> > {
+      typedef MapExtender<DefaultMap<BpGraph, RedNode, _Value> > Parent;
+    public:
+      explicit RedNodeMap(const BpGraph& bpgraph)
+        : Parent(bpgraph) {}
+      RedNodeMap(const BpGraph& bpgraph, const _Value& value)
+        : Parent(bpgraph, value) {}
+    private:
+      RedNodeMap& operator=(const RedNodeMap& cmap) {
+        return operator=<RedNodeMap>(cmap);
+      }
+      template <typename CMap>
+      RedNodeMap& operator=(const CMap& cmap) {
+        Parent::operator=(cmap);
+        return *this;
+      }
+    };
+    template <typename _Value>
+    class BlueNodeMap
+      : public MapExtender<DefaultMap<BpGraph, BlueNode, _Value> > {
+      typedef MapExtender<DefaultMap<BpGraph, BlueNode, _Value> > Parent;
+    public:
+      explicit BlueNodeMap(const BpGraph& bpgraph)
+        : Parent(bpgraph) {}
+      BlueNodeMap(const BpGraph& bpgraph, const _Value& value)
+        : Parent(bpgraph, value) {}
+    private:
+      BlueNodeMap& operator=(const BlueNodeMap& cmap) {
+        return operator=<BlueNodeMap>(cmap);
+      }
+      template <typename CMap>
+      BlueNodeMap& operator=(const CMap& cmap) {
+        Parent::operator=(cmap);
+        return *this;
+      }
+    };
+    template <typename _Value>
+    class ArcMap
+      : public MapExtender<DefaultMap<BpGraph, Arc, _Value> > {
+      typedef MapExtender<DefaultMap<BpGraph, Arc, _Value> > Parent;
+    public:
+      explicit ArcMap(const BpGraph& graph)
+        : Parent(graph) {}
+      ArcMap(const BpGraph& graph, const _Value& value)
+        : Parent(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 _Value>
+    class EdgeMap
+      : public MapExtender<DefaultMap<BpGraph, Edge, _Value> > {
+      typedef MapExtender<DefaultMap<BpGraph, Edge, _Value> > Parent;
+    public:
+      explicit EdgeMap(const BpGraph& graph)
+        : Parent(graph) {}
+      EdgeMap(const BpGraph& graph, const _Value& value)
+        : Parent(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;
+      }
+    };
+    // Alteration extension
+    RedNode addRedNode() {
+      RedNode node = Parent::addRedNode();
+      notifier(RedNode()).add(node);
+      notifier(Node()).add(node);
+      return node;
+    }
+    BlueNode addBlueNode() {
+      BlueNode node = Parent::addBlueNode();
+      notifier(BlueNode()).add(node);
+      notifier(Node()).add(node);
+      return node;
+    }
+    Edge addEdge(const RedNode& from, const BlueNode& to) {
+      Edge edge = Parent::addEdge(from, to);
+      notifier(Edge()).add(edge);
+      std::vector<Arc> av;
+      av.push_back(Parent::direct(edge, true));
+      av.push_back(Parent::direct(edge, false));
+      notifier(Arc()).add(av);
+      return edge;
+    }
+    void clear() {
+      notifier(Arc()).clear();
+      notifier(Edge()).clear();
+      notifier(Node()).clear();
+      notifier(BlueNode()).clear();
+      notifier(RedNode()).clear();
+      Parent::clear();
+    }
+    template <typename BpGraph, typename NodeRefMap, typename EdgeRefMap>
+    void build(const BpGraph& graph, NodeRefMap& nodeRef,
+               EdgeRefMap& edgeRef) {
+      Parent::build(graph, nodeRef, edgeRef);
+      notifier(RedNode()).build();
+      notifier(BlueNode()).build();
+      notifier(Node()).build();
+      notifier(Edge()).build();
+      notifier(Arc()).build();
+    }
+    void erase(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);
+      }
+      if (Parent::red(node)) {
+        notifier(RedNode()).erase(this->asRedNodeUnsafe(node));
+      } else {
+        notifier(BlueNode()).erase(this->asBlueNodeUnsafe(node));
+      }
+      notifier(Node()).erase(node);
+      Parent::erase(node);
+    }
+    void erase(const Edge& edge) {
+      std::vector<Arc> av;
+      av.push_back(Parent::direct(edge, true));
+      av.push_back(Parent::direct(edge, false));
+      notifier(Arc()).erase(av);
+      notifier(Edge()).erase(edge);
+      Parent::erase(edge);
+    }
+    BpGraphExtender() {
+      red_node_notifier.setContainer(*this);
+      blue_node_notifier.setContainer(*this);
+      node_notifier.setContainer(*this);
+      arc_notifier.setContainer(*this);
+      edge_notifier.setContainer(*this);
+    }
+    ~BpGraphExtender() {
+      edge_notifier.clear();
+      arc_notifier.clear();
+      node_notifier.clear();
+      blue_node_notifier.clear();
+      red_node_notifier.clear();
+    }
+  };
+}

lemon/bits/map_extender.h

r867	r1270
3	3	* This file is a part of LEMON, a generic C++ optimization library.
4	4	*
5		* Copyright (C) 2003-2009
	5	* Copyright (C) 2003-2013
6	6	* Egervary Jeno Kombinatorikus Optimalizalasi Kutatocsoport
7	7	* (Egervary Research Group on Combinatorial Optimization, EGRES).

lemon/bits/path_dump.h

-                      r576
+                      r1270
  * This file is a part of LEMON, a generic C++ optimization library.
+ *
  * Copyright (C) 2003-2009
+ * Copyright (C) 2003-2013
  * Egervary Jeno Kombinatorikus Optimalizalasi Kutatocsoport
  * (Egervary Research Group on Combinatorial Optimization, EGRES).
 …
     bool empty() const {
       return predMap[target] != INVALID;
+      return predMap[target] == INVALID;
+    }
 …
     bool empty() const {
       return source != target;
+      return predMatrixMap(source, target) == INVALID;
+    }

lemon/bits/solver_bits.h

-                      r566
+                      r1270
  * This file is a part of LEMON, a generic C++ optimization library.
+ *
  * Copyright (C) 2003-2008
+ * Copyright (C) 2003-2013
  * Egervary Jeno Kombinatorikus Optimalizalasi Kutatocsoport
  * (Egervary Research Group on Combinatorial Optimization, EGRES).
 …
       void clear() {
         first_item = -1;
+        last_item = -1;
         first_free_item = -1;
         items.clear();

lemon/bits/traits.h

-                      r663
+                      r1270
  * This file is a part of LEMON, a generic C++ optimization library.
+ *
  * Copyright (C) 2003-2009
+ * Copyright (C) 2003-2013
  * Egervary Jeno Kombinatorikus Optimalizalasi Kutatocsoport
  * (Egervary Research Group on Combinatorial Optimization, EGRES).
 …
         : Parent(_digraph, _value) {}
     };
+  };
+  template <typename GR, typename Enable = void>
+  struct RedNodeNotifierIndicator {
+    typedef InvalidType Type;
+  };
+  template <typename GR>
+  struct RedNodeNotifierIndicator<
+    GR,
+    typename enable_if<typename GR::RedNodeNotifier::Notifier, void>::type
+  > {
+    typedef typename GR::RedNodeNotifier Type;
+  };
+  template <typename GR>
+  class ItemSetTraits<GR, typename GR::RedNode> {
+  public:
+    typedef GR BpGraph;
+    typedef GR Graph;
+    typedef GR Digraph;
+    typedef typename GR::RedNode Item;
+    typedef typename GR::RedNodeIt ItemIt;
+    typedef typename RedNodeNotifierIndicator<GR>::Type ItemNotifier;
+    template <typename V>
+    class Map : public GR::template RedNodeMap<V> {
+      typedef typename GR::template RedNodeMap<V> Parent;
+    public:
+      typedef typename GR::template RedNodeMap<V> Type;
+      typedef typename Parent::Value Value;
+      Map(const GR& _bpgraph) : Parent(_bpgraph) {}
+      Map(const GR& _bpgraph, const Value& _value)
+        : Parent(_bpgraph, _value) {}
+     };
+  };
+  template <typename GR, typename Enable = void>
+  struct BlueNodeNotifierIndicator {
+    typedef InvalidType Type;
+  };
+  template <typename GR>
+  struct BlueNodeNotifierIndicator<
+    GR,
+    typename enable_if<typename GR::BlueNodeNotifier::Notifier, void>::type
+  > {
+    typedef typename GR::BlueNodeNotifier Type;
+  };
+  template <typename GR>
+  class ItemSetTraits<GR, typename GR::BlueNode> {
+  public:
+    typedef GR BpGraph;
+    typedef GR Graph;
+    typedef GR Digraph;
+    typedef typename GR::BlueNode Item;
+    typedef typename GR::BlueNodeIt ItemIt;
+    typedef typename BlueNodeNotifierIndicator<GR>::Type ItemNotifier;
+    template <typename V>
+    class Map : public GR::template BlueNodeMap<V> {
+      typedef typename GR::template BlueNodeMap<V> Parent;
+    public:
+      typedef typename GR::template BlueNodeMap<V> Type;
+      typedef typename Parent::Value Value;
+      Map(const GR& _bpgraph) : Parent(_bpgraph) {}
+      Map(const GR& _bpgraph, const Value& _value)
+        : Parent(_bpgraph, _value) {}
+     };
   };

lemon/bits/windows.cc

-                      r513
+                      r1341
  * This file is a part of LEMON, a generic C++ optimization library.
+ *
  * Copyright (C) 2003-2009
+ * Copyright (C) 2003-2013
  * Egervary Jeno Kombinatorikus Optimalizalasi Kutatocsoport
  * (Egervary Research Group on Combinatorial Optimization, EGRES).
 …
 #include<lemon/bits/windows.h>
+#ifdef WIN32
+#if defined(LEMON_WIN32) && defined(__GNUC__)
+#pragma GCC diagnostic ignored "-Wold-style-cast"
+#endif
+#ifdef LEMON_WIN32
 #ifndef WIN32_LEAN_AND_MEAN
 #define WIN32_LEAN_AND_MEAN
 …
 #include <unistd.h>
 #include <ctime>
+#ifndef LEMON_WIN32
 #include <sys/times.h>
+#endif
 #include <sys/time.h>
 #endif
 …
                          double &cutime, double &cstime)
+    {
 #ifdef WIN32
+#ifdef LEMON_WIN32
       static const double ch = 4294967296.0e-7;
       static const double cl = 1.0e-7;
 …
+    {
       std::ostringstream os;
 #ifdef WIN32
+#ifdef LEMON_WIN32
       SYSTEMTIME time;
       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,
 …
     int getWinRndSeed()
+    {
 #ifdef WIN32
+#ifdef LEMON_WIN32
       FILETIME time;
       GetSystemTimeAsFileTime(&time);
 …
 #endif
+    }
+    WinLock::WinLock() {
+#ifdef LEMON_WIN32
+      CRITICAL_SECTION *lock = new CRITICAL_SECTION;
+      InitializeCriticalSection(lock);
+      _repr = lock;
+#else
+      _repr = 0; //Just to avoid 'unused variable' warning with clang
+#endif
+    }
+    WinLock::~WinLock() {
+#ifdef LEMON_WIN32
+      CRITICAL_SECTION *lock = static_cast<CRITICAL_SECTION*>(_repr);
+      DeleteCriticalSection(lock);
+      delete lock;
+#endif
+    }
+    void WinLock::lock() {
+#ifdef LEMON_WIN32
+      CRITICAL_SECTION *lock = static_cast<CRITICAL_SECTION*>(_repr);
+      EnterCriticalSection(lock);
+#endif
+    }
+    void WinLock::unlock() {
+#ifdef LEMON_WIN32
+      CRITICAL_SECTION *lock = static_cast<CRITICAL_SECTION*>(_repr);
+      LeaveCriticalSection(lock);
+#endif
+    }
+  }
+}

lemon/bits/windows.h

-                      r576
+                      r1340
  * This file is a part of LEMON, a generic C++ optimization library.
+ *
  * Copyright (C) 2003-2009
+ * Copyright (C) 2003-2013
  * Egervary Jeno Kombinatorikus Optimalizalasi Kutatocsoport
  * (Egervary Research Group on Combinatorial Optimization, EGRES).
 …
 #define LEMON_BITS_WINDOWS_H
+#include <lemon/config.h>
 #include <string>
 …
     std::string getWinFormattedDate();
     int getWinRndSeed();
+    class WinLock {
+    public:
+      WinLock();
+      ~WinLock();
+      void lock();
+      void unlock();\
+    private:
+      void *_repr;
+    };
+  }
+}

lemon/bucket_heap.h

-                      r758
+                      r956
  * This file is a part of LEMON, a generic C++ optimization library.
+ *
  * Copyright (C) 2003-2009
+ * Copyright (C) 2003-2010
  * Egervary Jeno Kombinatorikus Optimalizalasi Kutatocsoport
  * (Egervary Research Group on Combinatorial Optimization, EGRES).
 …
   ///
   /// Note that this implementation does not conform to the
   /// \ref concepts::Heap "heap concept" due to the lack of some
+  /// \ref concepts::Heap "heap concept" due to the lack of some
   /// functionality.
   ///

lemon/capacity_scaling.h

-                      r1362
+                      r1363
 /* -*- C++ -*-
+/* -*- mode: C++; indent-tabs-mode: nil; -*-
+ *
  * This file is a part of LEMON, a generic C++ optimization library
+ * This file is a part of LEMON, a generic C++ optimization library.
+ *
  * Copyright (C) 2003-2008
+ * Copyright (C) 2003-2013
  * Egervary Jeno Kombinatorikus Optimalizalasi Kutatocsoport
  * (Egervary Research Group on Combinatorial Optimization, EGRES).
 …
   /// \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.
+  /// \ref min_cost_flow "minimum cost flow" \cite amo93networkflows,
+  /// \cite edmondskarp72theoretical. It is an efficient dual
+  /// solution method, which runs in polynomial time
+  /// \f$O(m\log U (n+m)\log n)\f$, where <i>U</i> denotes the maximum
+  /// of node supply and arc capacity values.
+  ///
+  /// This algorithm is typically slower than \ref CostScaling and
+  /// \ref NetworkSimplex, but in special cases, it can be more
+  /// efficient than them.
+  /// (For more information, see \ref min_cost_flow_algs "the module page".)
   ///
   /// Most of the parameters of the problem (except for the digraph)
 …
   /// \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.
+  /// 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.
+  /// 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.
+  /// \warning Both \c V and \c C must be signed number types.
+  /// \warning Capacity bounds and supply values must be integer, but
+  /// arc costs can be arbitrary real numbers.
+  /// \warning This algorithm does not support negative costs for
+  /// arcs having infinite upper bound.
 #ifdef DOXYGEN
   template <typename GR, typename V, typename C, typename TR>
 …
     typedef typename TR::Heap Heap;
+    /// The \ref CapacityScalingDefaultTraits "traits class" of the algorithm
+    /// \brief The \ref lemon::CapacityScalingDefaultTraits "traits class"
+    /// of the algorithm
     typedef TR Traits;
 …
       UNBOUNDED
     };
   private:
 …
     typedef std::vector<int> IntVector;
-    typedef std::vector<char> BoolVector;
     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:
 …
     // Parameters of the problem
     bool _have_lower;
+    bool _has_lower;
     Value _sum_supply;
 …
   public:
     /// \brief Constant for infinite upper bounds (capacities).
     ///
 …
       CostVector &_pi;
       IntVector &_pred;
       IntVector _proc_nodes;
       CostVector _dist;
     public:
 …
     /// @}
+  protected:
+    CapacityScaling() {}
   public:
 …
         "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) {
+      _has_lower = true;
+      for (ArcIt a(_graph); a != INVALID; ++a) {
+        _lower[_arc_idf[a]] = map[a];
+      }
+      return *this;
+    }
+    /// \brief Set the upper bounds (capacities) on the arcs.
+    ///
+    /// This function sets the upper bounds (capacities) on the arcs.
+    /// If it is not used before calling \ref run(), the upper bounds
+    /// will be set to \ref INF on all arcs (i.e. the flow value will be
+    /// unbounded from above).
+    ///
+    /// \param map An arc map storing the upper bounds.
+    /// Its \c Value type must be convertible to the \c Value type
+    /// of the algorithm.
+    ///
+    /// \return <tt>(*this)</tt>
+    template<typename UpperMap>
+    CapacityScaling& upperMap(const UpperMap& map) {
+      for (ArcIt a(_graph); a != INVALID; ++a) {
+        _upper[_arc_idf[a]] = map[a];
+      }
+      return *this;
+    }
+    /// \brief Set the costs of the arcs.
+    ///
+    /// This function sets the costs of the arcs.
+    /// If it is not used before calling \ref run(), the costs
+    /// will be set to \c 1 on all arcs.
+    ///
+    /// \param map An arc map storing the costs.
+    /// Its \c Value type must be convertible to the \c Cost type
+    /// of the algorithm.
+    ///
+    /// \return <tt>(*this)</tt>
+    template<typename CostMap>
+    CapacityScaling& costMap(const CostMap& map) {
+      for (ArcIt a(_graph); a != INVALID; ++a) {
+        _cost[_arc_idf[a]] =  map[a];
+        _cost[_arc_idb[a]] = -map[a];
+      }
+      return *this;
+    }
+    /// \brief Set the supply values of the nodes.
+    ///
+    /// This function sets the supply values of the nodes.
+    /// If neither this function nor \ref stSupply() is used before
+    /// calling \ref run(), the supply of each node will be set to zero.
+    ///
+    /// \param map A node map storing the supply values.
+    /// Its \c Value type must be convertible to the \c Value type
+    /// of the algorithm.
+    ///
+    /// \return <tt>(*this)</tt>
+    template<typename SupplyMap>
+    CapacityScaling& supplyMap(const SupplyMap& map) {
+      for (NodeIt n(_graph); n != INVALID; ++n) {
+        _supply[_node_id[n]] = map[n];
+      }
+      return *this;
+    }
+    /// \brief Set single source and target nodes and a supply value.
+    ///
+    /// This function sets a single source node and a single target node
+    /// and the required flow value.
+    /// If neither this function nor \ref supplyMap() is used before
+    /// calling \ref run(), the supply of each node will be set to zero.
+    ///
+    /// Using this function has the same effect as using \ref supplyMap()
+    /// with a map in which \c k is assigned to \c s, \c -k is
+    /// assigned to \c t and all other nodes have zero supply value.
+    ///
+    /// \param s The source node.
+    /// \param t The target node.
+    /// \param k The required amount of flow from node \c s to node \c t
+    /// (i.e. the supply of \c s and the demand of \c t).
+    ///
+    /// \return <tt>(*this)</tt>
+    CapacityScaling& stSupply(const Node& s, const Node& t, Value k) {
+      for (int i = 0; i != _node_num; ++i) {
+        _supply[i] = 0;
+      }
+      _supply[_node_id[s]] =  k;
+      _supply[_node_id[t]] = -k;
+      return *this;
+    }
+    /// @}
+    /// \name Execution control
+    /// The algorithm can be executed using \ref run().
+    /// @{
+    /// \brief Run the algorithm.
+    ///
+    /// This function runs the algorithm.
+    /// The paramters can be specified using functions \ref lowerMap(),
+    /// \ref upperMap(), \ref costMap(), \ref supplyMap(), \ref stSupply().
+    /// For example,
+    /// \code
+    ///   CapacityScaling<ListDigraph> cs(graph);
+    ///   cs.lowerMap(lower).upperMap(upper).costMap(cost)
+    ///     .supplyMap(sup).run();
+    /// \endcode
+    ///
+    /// This function can be called more than once. All the given parameters
+    /// are kept for the next call, unless \ref resetParams() or \ref reset()
+    /// is used, thus only the modified parameters have to be set again.
+    /// If the underlying digraph was also modified after the construction
+    /// of the class (or the last \ref reset() call), then the \ref reset()
+    /// function must be called.
+    ///
+    /// \param factor The capacity scaling factor. It must be larger than
+    /// one to use scaling. If it is less or equal to one, then scaling
+    /// will be disabled.
+    ///
+    /// \return \c INFEASIBLE if no feasible flow exists,
+    /// \n \c OPTIMAL if the problem has optimal solution
+    /// (i.e. it is feasible and bounded), and the algorithm has found
+    /// optimal flow and node potentials (primal and dual solutions),
+    /// \n \c UNBOUNDED if the digraph contains an arc of negative cost
+    /// and infinite upper bound. It means that the objective function
+    /// is unbounded on that arc, however, note that it could actually be
+    /// bounded over the feasible flows, but this algroithm cannot handle
+    /// these cases.
+    ///
+    /// \see ProblemType
+    /// \see resetParams(), reset()
+    ProblemType run(int factor = 4) {
+      _factor = factor;
+      ProblemType pt = init();
+      if (pt != OPTIMAL) return pt;
+      return start();
+    }
+    /// \brief Reset all the parameters that have been given before.
+    ///
+    /// This function resets all the paramaters that have been given
+    /// before using functions \ref lowerMap(), \ref upperMap(),
+    /// \ref costMap(), \ref supplyMap(), \ref stSupply().
+    ///
+    /// It is useful for multiple \ref run() calls. Basically, all the given
+    /// parameters are kept for the next \ref run() call, unless
+    /// \ref resetParams() or \ref reset() is used.
+    /// If the underlying digraph was also modified after the construction
+    /// of the class or the last \ref reset() call, then the \ref reset()
+    /// function must be used, otherwise \ref resetParams() is sufficient.
+    ///
+    /// For example,
+    /// \code
+    ///   CapacityScaling<ListDigraph> cs(graph);
+    ///
+    ///   // First run
+    ///   cs.lowerMap(lower).upperMap(upper).costMap(cost)
+    ///     .supplyMap(sup).run();
+    ///
+    ///   // Run again with modified cost map (resetParams() is not called,
+    ///   // so only the cost map have to be set again)
+    ///   cost[e] += 100;
+    ///   cs.costMap(cost).run();
+    ///
+    ///   // Run again from scratch using resetParams()
+    ///   // (the lower bounds will be set to zero on all arcs)
+    ///   cs.resetParams();
+    ///   cs.upperMap(capacity).costMap(cost)
+    ///     .supplyMap(sup).run();
+    /// \endcode
+    ///
+    /// \return <tt>(*this)</tt>
+    ///
+    /// \see reset(), run()
+    CapacityScaling& resetParams() {
+      for (int i = 0; i != _node_num; ++i) {
+        _supply[i] = 0;
+      }
+      for (int j = 0; j != _res_arc_num; ++j) {
+        _lower[j] = 0;
+        _upper[j] = INF;
+        _cost[j] = _forward[j] ? 1 : -1;
+      }
+      _has_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);
 …
       _cost.resize(_res_arc_num);
       _supply.resize(_node_num);
       _res_cap.resize(_res_arc_num);
       _pi.resize(_node_num);
 …
         _reverse[bi] = fi;
+      }
       // Reset parameters
+      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 parameters
+    /// that have been given are kept for the next call, unless
+    /// \ref reset() is called, thus only the modified parameters
+    /// have to be set again. See \ref reset() for examples.
+    /// However, the underlying digraph must not be modified after this
+    /// class have been constructed, since it copies and extends the graph.
+    ///
+    /// \param 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
+    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 run() calls. If this function is not
+    /// used, all the parameters given before are kept for the next
+    /// \ref run() call.
+    /// However, the underlying digraph must not be modified after this
+    /// class have been constructed, since it copies and extends the graph.
+    ///
+    /// For example,
+    /// \code
+    ///   CapacityScaling<ListDigraph> cs(graph);
+    ///
+    ///   // First run
+    ///   cs.lowerMap(lower).upperMap(upper).costMap(cost)
+    ///     .supplyMap(sup).run();
+    ///
+    ///   // Run again with modified cost map (reset() 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 reset()
+    ///   // (the lower bounds will be set to zero on all arcs)
+    ///   cs.reset();
+    ///   cs.upperMap(capacity).costMap(cost)
+    ///     .supplyMap(sup).run();
+    /// \endcode
+    ///
+    /// \return <tt>(*this)</tt>
+    CapacityScaling& reset() {
+      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;
+      resetParams();
       return *this;
+    }
 …
     ///
     /// This function returns the total cost of the found flow.
     /// Its complexity is O(e).
+    /// Its complexity is O(m).
     ///
     /// \note The return type of the function can be specified as a
 …
+    }
+    /// \brief Return the flow map (the primal solution).
+    /// \brief Copy the flow values (the primal solution) into the
+    /// given map.
     ///
     /// This function copies the flow value on each arc into the given
 …
+    }
+    /// \brief Return the potential map (the dual solution).
+    /// \brief Copy the potential values (the dual solution) into the
+    /// given map.
     ///
     /// This function copies the potential (dual value) of each node
 …
+      }
       if (_sum_supply > 0) return INFEASIBLE;
+      // Check lower and upper bounds
+      LEMON_DEBUG(checkBoundMaps(),
+          "Upper bounds must be greater or equal to the lower bounds");
       // Initialize vectors
       for (int i = 0; i != _root; ++i) {
 …
       const Value MAX = std::numeric_limits<Value>::max();
       int last_out;
       if (_have_lower) {
+      if (_has_lower) {
         for (int i = 0; i != _root; ++i) {
           last_out = _first_out[i+1];
 …
+        }
+      }
       // Handle GEQ supply type
       if (_sum_supply < 0) {
 …
       if (_factor > 1) {
         // With scaling
         Value max_sup = 0, max_dem = 0;
         for (int i = 0; i != _node_num; ++i) {
+        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;
+        }
         Value max_cap = 0;
         for (int j = 0; j != _res_arc_num; ++j) {
           if (_res_cap[j] > max_cap) max_cap = _res_cap[j];
+          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);
 …
       return OPTIMAL;
+    }
+    // Check if the upper bound is greater than or equal to the lower bound
+    // on each forward arc.
+    bool checkBoundMaps() {
+      for (int j = 0; j != _res_arc_num; ++j) {
+        if (_forward[j] && _upper[j] < _lower[j]) return false;
+      }
+      return true;
+    }
 …
       // Handle non-zero lower bounds
       if (_have_lower) {
+      if (_has_lower) {
         int limit = _first_out[_root];
         for (int j = 0; j != limit; ++j) {
           if (!_forward[j]) _res_cap[j] += _lower[j];
+          if (_forward[j]) _res_cap[_reverse[j]] += _lower[j];
+        }
+      }
 …
         for (int i = 0; i != _node_num; ++i) {
           _pi[i] -= pr;
+        }
+      }
+        }
+      }
       return pt;
+    }

lemon/cbc.cc

-                      r793
+                      r1270
  * This file is a part of LEMON, a generic C++ optimization library.
+ *
  * Copyright (C) 2003-2009
+ * Copyright (C) 2003-2013
  * Egervary Jeno Kombinatorikus Optimalizalasi Kutatocsoport
  * (Egervary Research Group on Combinatorial Optimization, EGRES).
 …
 #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"
 …
       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);
 …
       _cbc_model->addCutGenerator(&flowGen, -1, "FlowCover");
-#ifdef COIN_HAS_CLP
       OsiClpSolverInterface* osiclp =
         dynamic_cast<OsiClpSolverInterface*>(_cbc_model->solver());
 …
         osiclp->setupForRepeatedUse(2, 0);
+      }
-#endif
       CbcRounding heuristic1(*_cbc_model);
 …
     _prob = new CoinModel();
-    rows.clear();
-    cols.clear();
+  }

lemon/cbc.h

-                      r793
+                      r1270
  * This file is a part of LEMON, a generic C++ optimization library.
+ *
  * Copyright (C) 2003-2009
+ * Copyright (C) 2003-2013
  * Egervary Jeno Kombinatorikus Optimalizalasi Kutatocsoport
  * (Egervary Research Group on Combinatorial Optimization, EGRES).
 …
  */
-// -*- C++ -*-
 #ifndef LEMON_CBC_H
 #define LEMON_CBC_H
 …
     int _message_level;
   };

lemon/circulation.h

-                      r833
+                      r1270
  * This file is a part of LEMON, a generic C++ optimization library.
+ *
  * Copyright (C) 2003-2009
+ * Copyright (C) 2003-2013
  * Egervary Jeno Kombinatorikus Optimalizalasi Kutatocsoport
  * (Egervary Research Group on Combinatorial Optimization, EGRES).
 …
     /// \brief The type of supply map.
     ///
     /// The type of the map that stores the signed supply values of the
     /// nodes.
+    /// The type of the map that stores the signed supply values of the
+    /// nodes.
     /// It must conform to the \ref concepts::ReadMap "ReadMap" concept.
     typedef SM SupplyMap;
 …
      \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
 …
      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
 …
      \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
 …
   public:
+    ///The \ref CirculationDefaultTraits "traits class" of the algorithm.
+    /// \brief The \ref lemon::CirculationDefaultTraits "traits class"
+    /// of the algorithm.
     typedef TR Traits;
     ///The type of the digraph the algorithm runs on.
 …
     /// \param graph The digraph the algorithm runs on.
     /// \param lower The lower bounds for the flow values on the arcs.
     /// \param upper The upper bounds (capacities) for the flow values
+    /// \param upper The upper bounds (capacities) for the flow values
     /// on the arcs.
     /// \param supply The signed supply values of the nodes.
 …
       Node act;
-      Node bact=INVALID;
-      Node last_activated=INVALID;
       while((act=_level->highestActive())!=INVALID) {
         int actlevel=(*_level)[act];

lemon/clp.cc

-                      r793
+                      r1270
  * This file is a part of LEMON, a generic C++ optimization library.
+ *
  * Copyright (C) 2003-2008
+ * Copyright (C) 2003-2013
  * Egervary Jeno Kombinatorikus Optimalizalasi Kutatocsoport
  * (Egervary Research Group on Combinatorial Optimization, EGRES).
 …
     delete _prob;
     _prob = new ClpSimplex();
-    rows.clear();
-    cols.clear();
     _col_names_ref.clear();
     _clear_temporals();

lemon/clp.h

-                      r793
+                      r1270
  * This file is a part of LEMON, a generic C++ optimization library.
+ *
  * Copyright (C) 2003-2008
+ * Copyright (C) 2003-2013
  * Egervary Jeno Kombinatorikus Optimalizalasi Kutatocsoport
  * (Egervary Research Group on Combinatorial Optimization, EGRES).
 …
     virtual void _messageLevel(MessageLevel);
   public:

lemon/concept_check.h

-                      r463
+                      r1270
  * This file is a part of LEMON, a generic C++ optimization library.
+ *
  * Copyright (C) 2003-2009
+ * Copyright (C) 2003-2013
  * Egervary Jeno Kombinatorikus Optimalizalasi Kutatocsoport
  * (Egervary Research Group on Combinatorial Optimization, EGRES).
 …
   template <class T> inline void ignore_unused_variable_warning(const T&) { }
+  template <class T1, class T2>
+  inline void ignore_unused_variable_warning(const T1&, const T2&) { }
+  template <class T1, class T2, class T3>
+  inline void ignore_unused_variable_warning(const T1&, const T2&,
+                                             const T3&) { }
+  template <class T1, class T2, class T3, class T4>
+  inline void ignore_unused_variable_warning(const T1&, const T2&,
+                                             const T3&, const T4&) { }
+  template <class T1, class T2, class T3, class T4, class T5>
+  inline void ignore_unused_variable_warning(const T1&, const T2&,
+                                             const T3&, const T4&,
+                                             const T5&) { }
+  template <class T1, class T2, class T3, class T4, class T5, class T6>
+  inline void ignore_unused_variable_warning(const T1&, const T2&,
+                                             const T3&, const T4&,
+                                             const T5&, const T6&) { }
   ///\e
 …
 #if !defined(NDEBUG)
     void (Concept::*x)() = & Concept::constraints;
     ignore_unused_variable_warning(x);
+    ::lemon::ignore_unused_variable_warning(x);
 #endif
+  }
 …
     typedef typename Concept::template Constraints<Type> ConceptCheck;
     void (ConceptCheck::*x)() = & ConceptCheck::constraints;
     ignore_unused_variable_warning(x);
+    ::lemon::ignore_unused_variable_warning(x);
 #endif
+  }

lemon/concepts/digraph.h

-                      r833
+                      r1271
  * This file is a part of LEMON, a generic C++ optimization library.
+ *
  * Copyright (C) 2003-2009
+ * Copyright (C) 2003-2013
  * Egervary Jeno Kombinatorikus Optimalizalasi Kutatocsoport
  * (Egervary Research Group on Combinatorial Optimization, EGRES).
 …
         /// Sets the iterator to the first arc of the given digraph.
         ///
+        explicit ArcIt(const Digraph& g) { ignore_unused_variable_warning(g); }
+        explicit ArcIt(const Digraph& g) {
+          ::lemon::ignore_unused_variable_warning(g);
+        }
         /// Sets the iterator to the given arc.
 …
       /// \brief The base node of the iterator.
       ///
       /// Returns the base node of the given incomming arc iterator
+      /// Returns the base node of the given incoming 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
+      /// Returns the running node of the given incoming arc iterator
       /// (i.e. the source node of the corresponding arc).
       Node runningNode(InArcIt) const { return INVALID; }
 …
       private:
         ///Copy constructor
         NodeMap(const NodeMap& nm) :
+        NodeMap(const NodeMap& nm) :
           ReferenceMap<Node, T, T&, const T&>(nm) { }
         ///Assignment operator

lemon/concepts/graph.h

-                      r833
+                      r1271
  * This file is a part of LEMON, a generic C++ optimization library.
+ *
  * Copyright (C) 2003-2009
+ * Copyright (C) 2003-2013
  * Egervary Jeno Kombinatorikus Optimalizalasi Kutatocsoport
  * (Egervary Research Group on Combinatorial Optimization, EGRES).
 …
     /// run properly, of course.
     /// An actual graph implementation like \ref ListGraph or
     /// \ref SmartGraph may have additional functionality.
+    /// \ref SmartGraph may have additional functionality.
     ///
     /// The undirected graphs also fulfill the concept of \ref Digraph
 …
     class Graph {
     private:
       /// Graphs are \e not copy constructible. Use DigraphCopy instead.
+      /// Graphs are \e not copy constructible. Use GraphCopy instead.
       Graph(const Graph&) {}
       /// \brief Assignment of a graph to another one is \e not allowed.
       /// Use DigraphCopy instead.
+      /// Use GraphCopy instead.
       void operator=(const Graph&) {}
 …
       ///
       /// Undirected graphs should be tagged with \c UndirectedTag.
       ///
+      ///
       /// This tag helps the \c enable_if technics to make compile time
       /// specializations for undirected graphs.
 …
         /// Converison to \c Edge
         /// Converison to \c Edge.
         ///
 …
         /// Sets the iterator to the first arc of the given graph.
         ///
+        explicit ArcIt(const Graph &g) { ignore_unused_variable_warning(g); }
+        explicit ArcIt(const Graph &g) {
+          ::lemon::ignore_unused_variable_warning(g);
+        }
         /// Sets the iterator to the given arc.
 …
         ///
         OutArcIt(const Graph& n, const Node& g) {
           ignore_unused_variable_warning(n);
           ignore_unused_variable_warning(g);
+          ::lemon::ignore_unused_variable_warning(n);
+          ::lemon::ignore_unused_variable_warning(g);
+        }
         /// Sets the iterator to the given arc.
 …
         ///
         InArcIt(const Graph& g, const Node& n) {
           ignore_unused_variable_warning(n);
           ignore_unused_variable_warning(g);
+          ::lemon::ignore_unused_variable_warning(n);
+          ::lemon::ignore_unused_variable_warning(g);
+        }
         /// Sets the iterator to the given arc.
 …
       /// \brief The base node of the iterator.
       ///
       /// Returns the base node of the given incomming arc iterator
+      /// Returns the base node of the given incoming 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
+      /// Returns the running node of the given incoming arc iterator
       /// (i.e. the source node of the corresponding arc).
       Node runningNode(InArcIt) const { return INVALID; }

lemon/concepts/graph_components.h

-                      r833
+                      r1270
  * This file is a part of LEMON, a generic C++ optimization library.
+ *
  * Copyright (C) 2003-2009
+ * Copyright (C) 2003-2013
  * Egervary Jeno Kombinatorikus Optimalizalasi Kutatocsoport
  * (Egervary Research Group on Combinatorial Optimization, EGRES).
 …
     /// \note This class is a template class so that we can use it to
     /// create graph skeleton classes. The reason for this is that \c Node
     /// and \c Arc (or \c Edge) types should \e not derive from the same
+    /// and \c Arc (or \c Edge) types should \e not derive from the same
     /// base class. For \c Node you should instantiate it with character
     /// \c 'n', for \c Arc with \c 'a' and for \c Edge with \c 'e'.
 …
       ///
       /// This operator defines an ordering of the items.
       /// It makes possible to use graph item types as key types in
+      /// It makes possible to use graph item types as key types in
       /// associative containers (e.g. \c std::map).
       ///
 …
           bool b;
+          ::lemon::ignore_unused_variable_warning(b);
           b = (ia == ib) && (ia != ib);
           b = (ia == INVALID) && (ib != INVALID);
 …
         const _GraphItem &ia;
         const _GraphItem &ib;
+        Constraints() {}
       };
     };
 …
     /// This class describes the base interface of directed graph types.
     /// All digraph %concepts have to conform to this class.
     /// It just provides types for nodes and arcs and functions
+    /// It just provides types for nodes and arcs and functions
     /// to get the source and the target nodes of arcs.
     class BaseDigraphComponent {
 …
         const _Digraph& digraph;
+        Constraints() {}
       };
     };
 …
             ue = e;
             bool d = graph.direction(e);
             ignore_unused_variable_warning(d);
+            ::lemon::ignore_unused_variable_warning(d);
+          }
+        }
         const _Graph& graph;
+      Constraints() {}
+      };
+    };
+    /// \brief Base skeleton class for undirected bipartite graphs.
+    ///
+    /// This class describes the base interface of undirected
+    /// bipartite graph types.  All bipartite graph %concepts have to
+    /// conform to this class.  It extends the interface of \ref
+    /// BaseGraphComponent 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.
+    class BaseBpGraphComponent : public BaseGraphComponent {
+    public:
+      typedef BaseBpGraphComponent BpGraph;
+      typedef BaseDigraphComponent::Node Node;
+      typedef BaseDigraphComponent::Arc Arc;
+      /// \brief Class to represent red nodes.
+      ///
+      /// This class represents the red nodes of the graph. The red
+      /// nodes can also be used as normal nodes.
+      class RedNode : public Node {
+        typedef Node Parent;
+      public:
+        /// \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.
+        RedNode() {}
+        /// \brief Copy constructor.
+        ///
+        /// Copy constructor.
+        RedNode(const RedNode &) : Parent() {}
+        /// \brief Constructor for conversion from \c INVALID.
+        ///
+        /// Constructor for conversion from \c INVALID.
+        /// It initializes the item to be invalid.
+        /// \sa Invalid for more details.
+        RedNode(Invalid) {}
+      };
+      /// \brief Class to represent blue nodes.
+      ///
+      /// This class represents the blue nodes of the graph. The blue
+      /// nodes can also be used as normal nodes.
+      class BlueNode : public Node {
+        typedef Node Parent;
+      public:
+        /// \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.
+        BlueNode() {}
+        /// \brief Copy constructor.
+        ///
+        /// Copy constructor.
+        BlueNode(const BlueNode &) : Parent() {}
+        /// \brief Constructor for conversion from \c INVALID.
+        ///
+        /// Constructor for conversion from \c INVALID.
+        /// It initializes the item to be invalid.
+        /// \sa Invalid for more details.
+        BlueNode(Invalid) {}
+        /// \brief Constructor for conversion from a node.
+        ///
+        /// Constructor for conversion from a node. The conversion can
+        /// be invalid, since the Node can be member of the red
+        /// set.
+        BlueNode(const Node&) {}
+      };
+      /// \brief Gives back %true for red nodes.
+      ///
+      /// Gives back %true for red nodes.
+      bool red(const Node&) const { return true; }
+      /// \brief Gives back %true for blue nodes.
+      ///
+      /// Gives back %true for blue nodes.
+      bool blue(const Node&) const { return true; }
+      /// \brief Gives back the red end node of the edge.
+      ///
+      /// Gives back the red end node of the edge.
+      RedNode redNode(const Edge&) const { return RedNode(); }
+      /// \brief Gives back the blue end node of the edge.
+      ///
+      /// Gives back the blue end node of the edge.
+      BlueNode blueNode(const Edge&) const { return BlueNode(); }
+      /// \brief Converts the node to red node object.
+      ///
+      /// This function converts unsafely the node to red node
+      /// object. It should be called only if the node is from the red
+      /// partition or INVALID.
+      RedNode asRedNodeUnsafe(const Node&) const { return RedNode(); }
+      /// \brief Converts the node to blue node object.
+      ///
+      /// This function converts unsafely the node to blue node
+      /// object. It should be called only if the node is from the red
+      /// partition or INVALID.
+      BlueNode asBlueNodeUnsafe(const Node&) const { return BlueNode(); }
+      /// \brief Converts the node to red node object.
+      ///
+      /// This function converts safely the node to red node
+      /// object. If the node is not from the red partition, then it
+      /// returns INVALID.
+      RedNode asRedNode(const Node&) const { return RedNode(); }
+      /// \brief Converts the node to blue node object.
+      ///
+      /// This function converts unsafely the node to blue node
+      /// object. If the node is not from the blue partition, then it
+      /// returns INVALID.
+      BlueNode asBlueNode(const Node&) const { return BlueNode(); }
+      template <typename _BpGraph>
+      struct Constraints {
+        typedef typename _BpGraph::Node Node;
+        typedef typename _BpGraph::RedNode RedNode;
+        typedef typename _BpGraph::BlueNode BlueNode;
+        typedef typename _BpGraph::Arc Arc;
+        typedef typename _BpGraph::Edge Edge;
+        void constraints() {
+          checkConcept<BaseGraphComponent, _BpGraph>();
+          checkConcept<GraphItem<'n'>, RedNode>();
+          checkConcept<GraphItem<'n'>, BlueNode>();
+          {
+            Node n;
+            RedNode rn;
+            BlueNode bn;
+            Node rnan = rn;
+            Node bnan = bn;
+            Edge e;
+            bool b;
+            b = bpgraph.red(rnan);
+            b = bpgraph.blue(bnan);
+            rn = bpgraph.redNode(e);
+            bn = bpgraph.blueNode(e);
+            rn = bpgraph.asRedNodeUnsafe(rnan);
+            bn = bpgraph.asBlueNodeUnsafe(bnan);
+            rn = bpgraph.asRedNode(rnan);
+            bn = bpgraph.asBlueNode(bnan);
+            ::lemon::ignore_unused_variable_warning(b);
+          }
+        }
+        const _BpGraph& bpgraph;
       };
 …
           nid = digraph.maxNodeId();
           ignore_unused_variable_warning(nid);
+          ::lemon::ignore_unused_variable_warning(nid);
           eid = digraph.maxArcId();
           ignore_unused_variable_warning(eid);
+          ::lemon::ignore_unused_variable_warning(eid);
+        }
         const _Digraph& digraph;
+        Constraints() {}
       };
     };
 …
           edge = graph.edgeFromId(ueid);
           ueid = graph.maxEdgeId();
           ignore_unused_variable_warning(ueid);
+          ::lemon::ignore_unused_variable_warning(ueid);
+        }
         const _Graph& graph;
+        Constraints() {}
+      };
+    };
+    /// \brief Skeleton class for \e idable undirected bipartite graphs.
+    ///
+    /// This class describes the interface of \e idable undirected
+    /// bipartite graphs. It extends \ref IDableGraphComponent with
+    /// the core ID functions of undirected bipartite graphs. Beside
+    /// the regular node ids, this class also provides ids within the
+    /// the red and blue sets of the nodes. This concept is part of
+    /// the BpGraph concept.
+    template <typename BAS = BaseBpGraphComponent>
+    class IDableBpGraphComponent : public IDableGraphComponent<BAS> {
+    public:
+      typedef BAS Base;
+      typedef IDableGraphComponent<BAS> Parent;
+      typedef typename Base::Node Node;
+      typedef typename Base::RedNode RedNode;
+      typedef typename Base::BlueNode BlueNode;
+      using Parent::id;
+      /// \brief Return a unique integer id for the given node in the red set.
+      ///
+      /// Return a unique integer id for the given node in the red set.
+      int id(const RedNode&) const { return -1; }
+      /// \brief Return a unique integer id for the given node in the blue set.
+      ///
+      /// Return a unique integer id for the given node in the blue set.
+      int id(const BlueNode&) const { return -1; }
+      /// \brief Return an integer greater or equal to the maximum
+      /// node id in the red set.
+      ///
+      /// Return an integer greater or equal to the maximum
+      /// node id in the red set.
+      int maxRedId() const { return -1; }
+      /// \brief Return an integer greater or equal to the maximum
+      /// node id in the blue set.
+      ///
+      /// Return an integer greater or equal to the maximum
+      /// node id in the blue set.
+      int maxBlueId() const { return -1; }
+      template <typename _BpGraph>
+      struct Constraints {
+        void constraints() {
+          checkConcept<IDableGraphComponent<Base>, _BpGraph>();
+          typename _BpGraph::Node node;
+          typename _BpGraph::RedNode red;
+          typename _BpGraph::BlueNode blue;
+          int rid = bpgraph.id(red);
+          int bid = bpgraph.id(blue);
+          rid = bpgraph.maxRedId();
+          bid = bpgraph.maxBlueId();
+          ::lemon::ignore_unused_variable_warning(rid);
+          ::lemon::ignore_unused_variable_warning(bid);
+        }
+        const _BpGraph& bpgraph;
       };
     };
 …
     /// \brief Concept class for \c NodeIt, \c ArcIt and \c EdgeIt types.
     ///
     /// This class describes the concept of \c NodeIt, \c ArcIt and
+    /// This class describes the concept of \c NodeIt, \c ArcIt and
     /// \c EdgeIt subtypes of digraph and graph types.
     template <typename GR, typename Item>
 …
       /// next item.
       GraphItemIt& operator++() { return *this; }
       /// \brief Equality operator
       ///
 …
           _GraphItemIt it3 = it1;
           _GraphItemIt it4 = INVALID;
+          ::lemon::ignore_unused_variable_warning(it3);
+          ::lemon::ignore_unused_variable_warning(it4);
           it2 = ++it1;
 …
+        }
         const GR& g;
+      };
+    };
+    /// \brief Concept class for \c InArcIt, \c OutArcIt and
+        Constraints() {}
+      };
+    };
+    /// \brief Concept class for \c InArcIt, \c OutArcIt and
     /// \c IncEdgeIt types.
     ///
     /// This class describes the concept of \c InArcIt, \c OutArcIt
+    /// This class describes the concept of \c InArcIt, \c OutArcIt
     /// and \c IncEdgeIt subtypes of digraph and graph types.
     ///
     /// \note Since these iterator classes do not inherit from the same
     /// base class, there is an additional template parameter (selector)
     /// \c sel. For \c InArcIt you should instantiate it with character
+    /// \c sel. For \c InArcIt you should instantiate it with character
     /// \c 'i', for \c OutArcIt with \c 'o' and for \c IncEdgeIt with \c 'e'.
     template <typename GR,
 …
       GraphIncIt(const GraphIncIt& it) : Item(it) {}
       /// \brief Constructor that sets the iterator to the first
+      /// \brief Constructor that sets the iterator to the first
       /// incoming or outgoing arc.
       ///
       /// Constructor that sets the iterator to the first arc
+      /// Constructor that sets the iterator to the first arc
       /// incoming to or outgoing from the given node.
       explicit GraphIncIt(const GR&, const Base&) {}
 …
           _GraphIncIt it3 = it1;
           _GraphIncIt it4 = INVALID;
+          ::lemon::ignore_unused_variable_warning(it3);
+          ::lemon::ignore_unused_variable_warning(it4);
           it2 = ++it1;
 …
         const Base& node;
         const GR& graph;
+        Constraints() {}
       };
     };
 …
       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 Return the first arc incoming to the given node.
+      ///
+      /// This function gives back the first arc incoming to 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
+      /// \brief Return the next arc incoming to the given node.
+      ///
+      /// This function gives back the next arc incoming to the
       /// given node.
       void nextIn(Arc&) const {}
 …
             n = digraph.baseNode(oait);
             n = digraph.runningNode(oait);
             ignore_unused_variable_warning(n);
+            ::lemon::ignore_unused_variable_warning(n);
+          }
+        }
         const _Digraph& digraph;
+        Constraints() {}
       };
     };
 …
       /// \brief Return the first edge incident to the given node.
       ///
       /// This function gives back the first edge incident to the given
+      /// This function gives back the first edge incident to the given
       /// node. The bool parameter gives back the direction for which the
       /// source node of the directed arc representing the edge is the
+      /// source node of the directed arc representing the edge is the
       /// given node.
       void firstInc(Edge&, bool&, const Node&) const {}
 …
       /// given node.
       ///
       /// This function gives back the next edge incident to the given
+      /// This function gives back the next edge incident to the given
       /// node. The bool parameter should be used as \c firstInc() use it.
       void nextInc(Edge&, bool&) const {}
 …
         const _Graph& graph;
+        Constraints() {}
+      };
+    };
+    /// \brief Skeleton class for iterable undirected bipartite graphs.
+    ///
+    /// This class describes the interface of iterable undirected
+    /// bipartite graphs. It extends \ref IterableGraphComponent with
+    /// the core iterable interface of undirected bipartite graphs.
+    /// This concept is part of the BpGraph concept.
+    template <typename BAS = BaseBpGraphComponent>
+    class IterableBpGraphComponent : public IterableGraphComponent<BAS> {
+    public:
+      typedef BAS Base;
+      typedef typename Base::Node Node;
+      typedef typename Base::RedNode RedNode;
+      typedef typename Base::BlueNode BlueNode;
+      typedef typename Base::Arc Arc;
+      typedef typename Base::Edge Edge;
+      typedef IterableBpGraphComponent BpGraph;
+      using IterableGraphComponent<BAS>::first;
+      using IterableGraphComponent<BAS>::next;
+      /// \name Base Iteration
+      ///
+      /// This interface provides functions for iteration on red and blue nodes.
+      ///
+      /// @{
+      /// \brief Return the first red node.
+      ///
+      /// This function gives back the first red node in the iteration order.
+      void first(RedNode&) const {}
+      /// \brief Return the next red node.
+      ///
+      /// This function gives back the next red node in the iteration order.
+      void next(RedNode&) const {}
+      /// \brief Return the first blue node.
+      ///
+      /// This function gives back the first blue node in the iteration order.
+      void first(BlueNode&) const {}
+      /// \brief Return the next blue node.
+      ///
+      /// This function gives back the next blue node in the iteration order.
+      void next(BlueNode&) const {}
+      /// @}
+      /// \name Class Based Iteration
+      ///
+      /// This interface provides iterator classes for red and blue nodes.
+      ///
+      /// @{
+      /// \brief This iterator goes through each red node.
+      ///
+      /// This iterator goes through each red node.
+      typedef GraphItemIt<BpGraph, RedNode> RedNodeIt;
+      /// \brief This iterator goes through each blue node.
+      ///
+      /// This iterator goes through each blue node.
+      typedef GraphItemIt<BpGraph, BlueNode> BlueNodeIt;
+      /// @}
+      template <typename _BpGraph>
+      struct Constraints {
+        void constraints() {
+          checkConcept<IterableGraphComponent<Base>, _BpGraph>();
+          typename _BpGraph::RedNode rn(INVALID);
+          bpgraph.first(rn);
+          bpgraph.next(rn);
+          typename _BpGraph::BlueNode bn(INVALID);
+          bpgraph.first(bn);
+          bpgraph.next(bn);
+          checkConcept<GraphItemIt<_BpGraph, typename _BpGraph::RedNode>,
+            typename _BpGraph::RedNodeIt>();
+          checkConcept<GraphItemIt<_BpGraph, typename _BpGraph::BlueNode>,
+            typename _BpGraph::BlueNodeIt>();
+        }
+        const _BpGraph& bpgraph;
       };
     };
 …
       ArcNotifier;
+      mutable NodeNotifier node_notifier;
+      mutable ArcNotifier arc_notifier;
       /// \brief Return the node alteration notifier.
       ///
       /// This function gives back the node alteration notifier.
       NodeNotifier& notifier(Node) const {
          return NodeNotifier();
+        return node_notifier;
+      }
 …
       /// This function gives back the arc alteration notifier.
       ArcNotifier& notifier(Arc) const {
         return ArcNotifier();
+        return arc_notifier;
+      }
 …
             = digraph.notifier(typename _Digraph::Arc());
           ignore_unused_variable_warning(nn);
           ignore_unused_variable_warning(en);
+          ::lemon::ignore_unused_variable_warning(nn);
+          ::lemon::ignore_unused_variable_warning(en);
+        }
         const _Digraph& digraph;
+        Constraints() {}
       };
     };
 …
       typedef BAS Base;
+      typedef AlterableDigraphComponent<Base> Parent;
       typedef typename Base::Edge Edge;
 …
       EdgeNotifier;
+      mutable EdgeNotifier edge_notifier;
+      using Parent::notifier;
       /// \brief Return the edge alteration notifier.
       ///
       /// This function gives back the edge alteration notifier.
       EdgeNotifier& notifier(Edge) const {
         return EdgeNotifier();
+        return edge_notifier;
+      }
 …
           typename _Graph::EdgeNotifier& uen
             = graph.notifier(typename _Graph::Edge());
           ignore_unused_variable_warning(uen);
+          ::lemon::ignore_unused_variable_warning(uen);
+        }
         const _Graph& graph;
+        Constraints() {}
+      };
+    };
+    /// \brief Skeleton class for alterable undirected bipartite graphs.
+    ///
+    /// This class describes the interface of alterable undirected
+    /// bipartite graphs. It extends \ref AlterableGraphComponent with
+    /// the alteration notifier interface of bipartite graphs. It
+    /// implements an observer-notifier pattern for the red and blue
+    /// nodes. More obsevers can be registered into the notifier and
+    /// whenever an alteration occured in the graph all the observers
+    /// will be notified about it.
+    template <typename BAS = BaseBpGraphComponent>
+    class AlterableBpGraphComponent : public AlterableGraphComponent<BAS> {
+    public:
+      typedef BAS Base;
+      typedef AlterableGraphComponent<Base> Parent;
+      typedef typename Base::RedNode RedNode;
+      typedef typename Base::BlueNode BlueNode;
+      /// Red node alteration notifier class.
+      typedef AlterationNotifier<AlterableBpGraphComponent, RedNode>
+      RedNodeNotifier;
+      /// Blue node alteration notifier class.
+      typedef AlterationNotifier<AlterableBpGraphComponent, BlueNode>
+      BlueNodeNotifier;
+      mutable RedNodeNotifier red_node_notifier;
+      mutable BlueNodeNotifier blue_node_notifier;
+      using Parent::notifier;
+      /// \brief Return the red node alteration notifier.
+      ///
+      /// This function gives back the red node alteration notifier.
+      RedNodeNotifier& notifier(RedNode) const {
+        return red_node_notifier;
+      }
+      /// \brief Return the blue node alteration notifier.
+      ///
+      /// This function gives back the blue node alteration notifier.
+      BlueNodeNotifier& notifier(BlueNode) const {
+        return blue_node_notifier;
+      }
+      template <typename _BpGraph>
+      struct Constraints {
+        void constraints() {
+          checkConcept<AlterableGraphComponent<Base>, _BpGraph>();
+          typename _BpGraph::RedNodeNotifier& rnn
+            = bpgraph.notifier(typename _BpGraph::RedNode());
+          typename _BpGraph::BlueNodeNotifier& bnn
+            = bpgraph.notifier(typename _BpGraph::BlueNode());
+          ::lemon::ignore_unused_variable_warning(rnn);
+          ::lemon::ignore_unused_variable_warning(bnn);
+        }
+        const _BpGraph& bpgraph;
       };
     };
 …
     ///
     /// This class describes the concept of standard graph maps, i.e.
     /// the \c NodeMap, \c ArcMap and \c EdgeMap subtypes of digraph and
+    /// the \c NodeMap, \c ArcMap and \c EdgeMap subtypes of digraph and
     /// graph types, which can be used for associating data to graph items.
     /// The standard graph maps must conform to the ReferenceMap concept.
 …
           _Map m1(g);
           _Map m2(g,t);
           // Copy constructor
           // _Map m3(m);
 …
           // m3 = cmap;
           ignore_unused_variable_warning(m1);
           ignore_unused_variable_warning(m2);
           // ignore_unused_variable_warning(m3);
+          ::lemon::ignore_unused_variable_warning(m1);
+          ::lemon::ignore_unused_variable_warning(m2);
+          // ::lemon::ignore_unused_variable_warning(m3);
+        }
 …
         const GR &g;
         const typename GraphMap::Value &t;
+        Constraints() {}
       };
 …
     ///
     /// This class describes the interface of mappable directed graphs.
     /// It extends \ref BaseDigraphComponent with the standard digraph
+    /// It extends \ref BaseDigraphComponent with the standard digraph
     /// map classes, namely \c NodeMap and \c ArcMap.
     /// This concept is part of the Digraph concept.
 …
         const _Digraph& digraph;
+        Constraints() {}
       };
     };
 …
     ///
     /// This class describes the interface of mappable undirected graphs.
     /// It extends \ref MappableDigraphComponent with the standard graph
+    /// It extends \ref MappableDigraphComponent with the standard graph
     /// map class for edges (\c EdgeMap).
     /// This concept is part of the Graph concept.
 …
         const _Graph& graph;
+        Constraints() {}
+      };
+    };
+    /// \brief Skeleton class for mappable undirected bipartite graphs.
+    ///
+    /// This class describes the interface of mappable undirected
+    /// bipartite graphs.  It extends \ref MappableGraphComponent with
+    /// the standard graph map class for red and blue nodes (\c
+    /// RedNodeMap and BlueNodeMap). This concept is part of the
+    /// BpGraph concept.
+    template <typename BAS = BaseBpGraphComponent>
+    class MappableBpGraphComponent : public MappableGraphComponent<BAS>  {
+    public:
+      typedef BAS Base;
+      typedef typename Base::Node Node;
+      typedef MappableBpGraphComponent BpGraph;
+      /// \brief Standard graph map for the red nodes.
+      ///
+      /// Standard graph map for the red nodes.
+      /// It conforms to the ReferenceMap concept.
+      template <typename V>
+      class RedNodeMap : public GraphMap<MappableBpGraphComponent, Node, V> {
+        typedef GraphMap<MappableBpGraphComponent, Node, V> Parent;
+      public:
+        /// \brief Construct a new map.
+        ///
+        /// Construct a new map for the graph.
+        explicit RedNodeMap(const MappableBpGraphComponent& graph)
+          : Parent(graph) {}
+        /// \brief Construct a new map with default value.
+        ///
+        /// Construct a new map for the graph and initalize the values.
+        RedNodeMap(const MappableBpGraphComponent& graph, const V& value)
+          : Parent(graph, value) {}
+      private:
+        /// \brief Copy constructor.
+        ///
+        /// Copy Constructor.
+        RedNodeMap(const RedNodeMap& nm) : Parent(nm) {}
+        /// \brief Assignment operator.
+        ///
+        /// Assignment operator.
+        template <typename CMap>
+        RedNodeMap& operator=(const CMap&) {
+          checkConcept<ReadMap<Node, V>, CMap>();
+          return *this;
+        }
+      };
+      /// \brief Standard graph map for the blue nodes.
+      ///
+      /// Standard graph map for the blue nodes.
+      /// It conforms to the ReferenceMap concept.
+      template <typename V>
+      class BlueNodeMap : public GraphMap<MappableBpGraphComponent, Node, V> {
+        typedef GraphMap<MappableBpGraphComponent, Node, V> Parent;
+      public:
+        /// \brief Construct a new map.
+        ///
+        /// Construct a new map for the graph.
+        explicit BlueNodeMap(const MappableBpGraphComponent& graph)
+          : Parent(graph) {}
+        /// \brief Construct a new map with default value.
+        ///
+        /// Construct a new map for the graph and initalize the values.
+        BlueNodeMap(const MappableBpGraphComponent& graph, const V& value)
+          : Parent(graph, value) {}
+      private:
+        /// \brief Copy constructor.
+        ///
+        /// Copy Constructor.
+        BlueNodeMap(const BlueNodeMap& nm) : Parent(nm) {}
+        /// \brief Assignment operator.
+        ///
+        /// Assignment operator.
+        template <typename CMap>
+        BlueNodeMap& operator=(const CMap&) {
+          checkConcept<ReadMap<Node, V>, CMap>();
+          return *this;
+        }
+      };
+      template <typename _BpGraph>
+      struct Constraints {
+        struct Dummy {
+          int value;
+          Dummy() : value(0) {}
+          Dummy(int _v) : value(_v) {}
+        };
+        void constraints() {
+          checkConcept<MappableGraphComponent<Base>, _BpGraph>();
+          { // int map test
+            typedef typename _BpGraph::template RedNodeMap<int>
+              IntRedNodeMap;
+            checkConcept<GraphMap<_BpGraph, typename _BpGraph::RedNode, int>,
+              IntRedNodeMap >();
+          } { // bool map test
+            typedef typename _BpGraph::template RedNodeMap<bool>
+              BoolRedNodeMap;
+            checkConcept<GraphMap<_BpGraph, typename _BpGraph::RedNode, bool>,
+              BoolRedNodeMap >();
+          } { // Dummy map test
+            typedef typename _BpGraph::template RedNodeMap<Dummy>
+              DummyRedNodeMap;
+            checkConcept<GraphMap<_BpGraph, typename _BpGraph::RedNode, Dummy>,
+              DummyRedNodeMap >();
+          }
+          { // int map test
+            typedef typename _BpGraph::template BlueNodeMap<int>
+              IntBlueNodeMap;
+            checkConcept<GraphMap<_BpGraph, typename _BpGraph::BlueNode, int>,
+              IntBlueNodeMap >();
+          } { // bool map test
+            typedef typename _BpGraph::template BlueNodeMap<bool>
+              BoolBlueNodeMap;
+            checkConcept<GraphMap<_BpGraph, typename _BpGraph::BlueNode, bool>,
+              BoolBlueNodeMap >();
+          } { // Dummy map test
+            typedef typename _BpGraph::template BlueNodeMap<Dummy>
+              DummyBlueNodeMap;
+            checkConcept<GraphMap<_BpGraph, typename _BpGraph::BlueNode, Dummy>,
+              DummyBlueNodeMap >();
+          }
+        }
+        const _BpGraph& bpgraph;
       };
     };
 …
     ///
     /// This class describes the interface of extendable directed graphs.
     /// It extends \ref BaseDigraphComponent with functions for adding
+    /// It extends \ref BaseDigraphComponent with functions for adding
     /// nodes and arcs to the digraph.
     /// This concept requires \ref AlterableDigraphComponent.
 …
         _Digraph& digraph;
+        Constraints() {}
       };
     };
 …
     ///
     /// This class describes the interface of extendable undirected graphs.
     /// It extends \ref BaseGraphComponent with functions for adding
+    /// It extends \ref BaseGraphComponent with functions for adding
     /// nodes and edges to the graph.
     /// This concept requires \ref AlterableGraphComponent.
 …
         _Graph& graph;
+        Constraints() {}
+      };
+    };
+    /// \brief Skeleton class for extendable undirected bipartite graphs.
+    ///
+    /// This class describes the interface of extendable undirected
+    /// bipartite graphs. It extends \ref BaseGraphComponent with
+    /// functions for adding nodes and edges to the graph. This
+    /// concept requires \ref AlterableBpGraphComponent.
+    template <typename BAS = BaseBpGraphComponent>
+    class ExtendableBpGraphComponent : public BAS {
+    public:
+      typedef BAS Base;
+      typedef typename Base::Node Node;
+      typedef typename Base::RedNode RedNode;
+      typedef typename Base::BlueNode BlueNode;
+      typedef typename Base::Edge Edge;
+      /// \brief Add a new red node to the digraph.
+      ///
+      /// This function adds a red new node to the digraph.
+      RedNode addRedNode() {
+        return INVALID;
+      }
+      /// \brief Add a new blue node to the digraph.
+      ///
+      /// This function adds a blue new node to the digraph.
+      BlueNode addBlueNode() {
+        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. The first node has to be a red node, and the
+      /// second one a blue node.
+      Edge addEdge(const RedNode&, const BlueNode&) {
+        return INVALID;
+      }
+      Edge addEdge(const BlueNode&, const RedNode&) {
+        return INVALID;
+      }
+      template <typename _BpGraph>
+      struct Constraints {
+        void constraints() {
+          checkConcept<Base, _BpGraph>();
+          typename _BpGraph::RedNode red_node;
+          typename _BpGraph::BlueNode blue_node;
+          red_node = bpgraph.addRedNode();
+          blue_node = bpgraph.addBlueNode();
+          typename _BpGraph::Edge edge;
+          edge = bpgraph.addEdge(red_node, blue_node);
+          edge = bpgraph.addEdge(blue_node, red_node);
+        }
+        _BpGraph& bpgraph;
       };
     };
 …
     ///
     /// This class describes the interface of erasable directed graphs.
     /// It extends \ref BaseDigraphComponent with functions for removing
+    /// It extends \ref BaseDigraphComponent with functions for removing
     /// nodes and arcs from the digraph.
     /// This concept requires \ref AlterableDigraphComponent.
 …
       /// \brief Erase a node from the digraph.
       ///
       /// This function erases the given node from the digraph and all arcs
+      /// This function erases the given node from the digraph and all arcs
       /// connected to the node.
       void erase(const Node&) {}
 …
         _Digraph& digraph;
+        Constraints() {}
       };
     };
 …
     ///
     /// This class describes the interface of erasable undirected graphs.
     /// It extends \ref BaseGraphComponent with functions for removing
+    /// It extends \ref BaseGraphComponent with functions for removing
     /// nodes and edges from the graph.
     /// This concept requires \ref AlterableGraphComponent.
 …
         _Graph& graph;
+      };
+    };
+        Constraints() {}
+      };
+    };
+    /// \brief Skeleton class for erasable undirected graphs.
+    ///
+    /// This class describes the interface of erasable undirected
+    /// bipartite graphs. It extends \ref BaseBpGraphComponent with
+    /// functions for removing nodes and edges from the graph. This
+    /// concept requires \ref AlterableBpGraphComponent.
+    template <typename BAS = BaseBpGraphComponent>
+    class ErasableBpGraphComponent : public ErasableGraphComponent<BAS> {};
     /// \brief Skeleton class for clearable directed graphs.
 …
         _Digraph& digraph;
+        Constraints() {}
       };
     };
 …
     /// 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() {}
+      template <typename _Graph>
+      struct Constraints {
+        void constraints() {
+          checkConcept<Base, _Graph>();
+          graph.clear();
+        }
+        _Graph& graph;
+      };
+    };
+    class ClearableGraphComponent : public ClearableDigraphComponent<BAS> {};
+    /// \brief Skeleton class for clearable undirected biparite graphs.
+    ///
+    /// This class describes the interface of clearable undirected
+    /// bipartite graphs. It extends \ref BaseBpGraphComponent with a
+    /// function for clearing the graph.  This concept requires \ref
+    /// AlterableBpGraphComponent.
+    template <typename BAS = BaseBpGraphComponent>
+    class ClearableBpGraphComponent : public ClearableGraphComponent<BAS> {};
+  }

lemon/concepts/heap.h

-                      r883
+                      r1270
  * This file is a part of LEMON, a generic C++ optimization library.
+ *
  * Copyright (C) 2003-2009
+ * Copyright (C) 2003-2013
  * Egervary Jeno Kombinatorikus Optimalizalasi Kutatocsoport
  * (Egervary Research Group on Combinatorial Optimization, EGRES).
 …
 #else
       explicit Heap(ItemIntMap&) {}
 #endif
+#endif
       /// \brief Constructor.
 …
 #else
       explicit Heap(ItemIntMap&, const CMP&) {}
 #endif
+#endif
       /// \brief The number of items stored in the heap.
 …
 #else
       void push(const Item&, const Prio&) {}
 #endif
+#endif
       /// \brief Return the item having minimum priority.
 …
 #else
       void erase(const Item&) {}
 #endif
+#endif
       /// \brief The priority of the given item.
 …
 #else
       Prio operator[](const Item&) const { return Prio(); }
 #endif
+#endif
       /// \brief Set the priority of an item or insert it, if it is
 …
 #else
       void set(const Item&, const Prio&) {}
 #endif
+#endif
       /// \brief Decrease the priority of an item to the given value.
 …
 #else
       void decrease(const Item&, const Prio&) {}
 #endif
+#endif
       /// \brief Increase the priority of an item to the given value.
 …
 #else
       void increase(const Item&, const Prio&) {}
 #endif
+#endif
       /// \brief Return the state of an item.
 …
 #else
       State state(const Item&) const { return PRE_HEAP; }
 #endif
+#endif
       /// \brief Set the state of an item in the heap.
 …
 #else
       void state(const Item&, State) {}
 #endif
+#endif
 …
           item=Item();
           prio=Prio();
           ignore_unused_variable_warning(item);
           ignore_unused_variable_warning(prio);
+          ::lemon::ignore_unused_variable_warning(item);
+          ::lemon::ignore_unused_variable_warning(prio);
           OwnItem own_item;
 …
           own_item=Item();
           own_prio=Prio();
           ignore_unused_variable_warning(own_item);
           ignore_unused_variable_warning(own_prio);
           ignore_unused_variable_warning(own_state);
+          ::lemon::ignore_unused_variable_warning(own_item);
+          ::lemon::ignore_unused_variable_warning(own_prio);
+          ::lemon::ignore_unused_variable_warning(own_state);
           _Heap heap1(map);
           _Heap heap2 = heap1;
           ignore_unused_variable_warning(heap1);
           ignore_unused_variable_warning(heap2);
+          ::lemon::ignore_unused_variable_warning(heap1);
+          ::lemon::ignore_unused_variable_warning(heap2);
           int s = heap.size();
           ignore_unused_variable_warning(s);
+          ::lemon::ignore_unused_variable_warning(s);
           bool e = heap.empty();
           ignore_unused_variable_warning(e);
+          ::lemon::ignore_unused_variable_warning(e);
           prio = heap.prio();
 …
         _Heap& heap;
         ItemIntMap& map;
+        Constraints() {}
       };
     };

lemon/concepts/maps.h

-                      r765
+                      r1270
  * This file is a part of LEMON, a generic C++ optimization library.
+ *
  * Copyright (C) 2003-2009
+ * Copyright (C) 2003-2013
  * Egervary Jeno Kombinatorikus Optimalizalasi Kutatocsoport
  * (Egervary Research Group on Combinatorial Optimization, EGRES).
 …
       /// Returns the value associated with the given key.
       Value operator[](const Key &) const {
         return *static_cast<Value *>(0);
+        return *(static_cast<Value *>(0)+1);
+      }
 …
           own_val = m[own_key];
           ignore_unused_variable_warning(key);
           ignore_unused_variable_warning(val);
           ignore_unused_variable_warning(own_key);
           ignore_unused_variable_warning(own_val);
+          ::lemon::ignore_unused_variable_warning(key);
+          ::lemon::ignore_unused_variable_warning(val);
+          ::lemon::ignore_unused_variable_warning(own_key);
+          ::lemon::ignore_unused_variable_warning(own_val);
+        }
         const Key& key;
         const typename _ReadMap::Key& own_key;
         const _ReadMap& m;
+        Constraints() {}
       };
 …
           m.set(own_key, own_val);
           ignore_unused_variable_warning(key);
           ignore_unused_variable_warning(val);
           ignore_unused_variable_warning(own_key);
           ignore_unused_variable_warning(own_val);
+          ::lemon::ignore_unused_variable_warning(key);
+          ::lemon::ignore_unused_variable_warning(val);
+          ::lemon::ignore_unused_variable_warning(own_key);
+          ::lemon::ignore_unused_variable_warning(own_val);
+        }
         const Key& key;
 …
         const typename _WriteMap::Value& own_val;
         _WriteMap& m;
+        Constraints() {}
       };
     };
 …
       /// Returns the value associated with the given key.
       Value operator[](const Key &) const {
+        return *static_cast<Value *>(0);
+        Value *r = 0;
+        return *r;
+      }
 …
       /// Returns a reference to the value associated with the given key.
       Reference operator[](const Key &) {
+        return *static_cast<Value *>(0);
+        Value *r = 0;
+        return *r;
+      }
       /// Returns a const reference to the value associated with the given key.
       ConstReference operator[](const Key &) const {
+        return *static_cast<Value *>(0);
+        Value *r = 0;
+        return *r;
+      }
 …
         typename _ReferenceMap::ConstReference own_cref;
         _ReferenceMap& m;
+        Constraints() {}
       };
     };

lemon/concepts/path.h

-                      r832
+                      r1270
  * This file is a part of LEMON, a generic C++ optimization library.
+ *
  * Copyright (C) 2003-2009
+ * Copyright (C) 2003-2013
  * Egervary Jeno Kombinatorikus Optimalizalasi Kutatocsoport
  * (Egervary Research Group on Combinatorial Optimization, EGRES).
 …
       template <typename CPath>
       Path& operator=(const CPath& cpath) {
         ignore_unused_variable_warning(cpath);
+        ::lemon::ignore_unused_variable_warning(cpath);
         return *this;
+      }
 …
           e = (i < ii);
           ignore_unused_variable_warning(l);
           ignore_unused_variable_warning(pp);
           ignore_unused_variable_warning(e);
           ignore_unused_variable_warning(id);
           ignore_unused_variable_warning(ii);
           ignore_unused_variable_warning(ed);
+          ::lemon::ignore_unused_variable_warning(l);
+          ::lemon::ignore_unused_variable_warning(pp);
+          ::lemon::ignore_unused_variable_warning(e);
+          ::lemon::ignore_unused_variable_warning(id);
+          ::lemon::ignore_unused_variable_warning(ii);
+          ::lemon::ignore_unused_variable_warning(ed);
+        }
       };
 …
           e = (i != INVALID);
           ignore_unused_variable_warning(l);
           ignore_unused_variable_warning(e);
           ignore_unused_variable_warning(id);
           ignore_unused_variable_warning(ed);
+          ::lemon::ignore_unused_variable_warning(l);
+          ::lemon::ignore_unused_variable_warning(e);
+          ::lemon::ignore_unused_variable_warning(id);
+          ::lemon::ignore_unused_variable_warning(ed);
+        }
         _Path& p;
+        PathDumperConstraints() {}
       };
 …
           e = (i != INVALID);
           ignore_unused_variable_warning(l);
           ignore_unused_variable_warning(e);
           ignore_unused_variable_warning(id);
           ignore_unused_variable_warning(ed);
+          ::lemon::ignore_unused_variable_warning(l);
+          ::lemon::ignore_unused_variable_warning(e);
+          ::lemon::ignore_unused_variable_warning(id);
+          ::lemon::ignore_unused_variable_warning(ed);
+        }
         _Path& p;
+        PathDumperConstraints() {}
       };

lemon/config.h.in

-                      r725
+                      r1340
+/* The version string */
 #undef LEMON_VERSION
+#ifndef LEMON_CONFIG_H
+#define LEMON_CONFIG_H
+/* Define to 1 if you have long long */
 #undef LEMON_HAVE_LONG_LONG
+#define LEMON_VERSION "@PROJECT_VERSION@"
+#cmakedefine LEMON_HAVE_LONG_LONG 1
+/* Define to 1 if you have any LP solver. */
+#undef LEMON_HAVE_LP
+#cmakedefine LEMON_WIN32 1
+/* Define to 1 if you have any MIP solver. */
+#undef LEMON_HAVE_MIP
+#cmakedefine LEMON_HAVE_LP 1
+#cmakedefine LEMON_HAVE_MIP 1
+#cmakedefine LEMON_HAVE_GLPK 1
+#cmakedefine LEMON_HAVE_CPLEX 1
+#cmakedefine LEMON_HAVE_SOPLEX 1
+#cmakedefine LEMON_HAVE_CLP 1
+#cmakedefine LEMON_HAVE_CBC 1
+/* Define to 1 if you have CPLEX. */
+#undef LEMON_HAVE_CPLEX
+#define LEMON_CPLEX_ 1
+#define LEMON_CLP_ 2
+#define LEMON_GLPK_ 3
+#define LEMON_SOPLEX_ 4
+#define LEMON_CBC_ 5
+/* Define to 1 if you have GLPK. */
 #undef LEMON_HAVE_GLPK
+#cmakedefine LEMON_DEFAULT_LP LEMON_@LEMON_DEFAULT_LP@_
+#cmakedefine LEMON_DEFAULT_MIP LEMON_@LEMON_DEFAULT_MIP@_
+/* Define to 1 if you have SOPLEX */
 #undef LEMON_HAVE_SOPLEX
+#cmakedefine LEMON_USE_PTHREAD 1
+#cmakedefine LEMON_USE_WIN32_THREADS 1
+/* Define to 1 if you have CLP */
+#undef LEMON_HAVE_CLP
+/* Define to 1 if you have CBC */
+#undef LEMON_HAVE_CBC
+#endif

lemon/connectivity.h

-                      r695
+                      r1270
  * This file is a part of LEMON, a generic C++ optimization library.
+ *
  * Copyright (C) 2003-2009
+ * Copyright (C) 2003-2013
  * Egervary Jeno Kombinatorikus Optimalizalasi Kutatocsoport
  * (Egervary Research Group on Combinatorial Optimization, EGRES).
 …
   /// \return \c true if the digraph is strongly connected.
   /// \note By definition, the empty digraph is strongly connected.
   ///
+  ///
   /// \see countStronglyConnectedComponents(), stronglyConnectedComponents()
   /// \see connected()
 …
   /// \ingroup graph_properties
   ///
   /// \brief Count the number of strongly connected components of a
+  /// \brief Count the number of strongly connected components of a
   /// directed graph
   ///
 …
   /// \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.
+  /// This function checks whether the given undirected graph is
+  /// bi-node-connected, i.e. a connected graph without articulation
+  /// node.
   ///
   /// \return \c true if the graph bi-node-connected.
+  /// \note By definition, the empty graph is bi-node-connected.
+  ///
+  /// \note By definition,
+  /// \li a graph consisting of zero or one node is bi-node-connected,
+  /// \li a graph consisting of two isolated nodes
+  /// is \e not bi-node-connected and
+  /// \li a graph consisting of two nodes connected by an edge
+  /// is bi-node-connected.
   ///
   /// \see countBiNodeConnectedComponents(), biNodeConnectedComponents()
   template <typename Graph>
   bool biNodeConnected(const Graph& graph) {
+    bool hasNonIsolated = false, hasIsolated = false;
+    for (typename Graph::NodeIt n(graph); n != INVALID; ++n) {
+      if (typename Graph::OutArcIt(graph, n) == INVALID) {
+        if (hasIsolated || hasNonIsolated) {
+          return false;
+        } else {
+          hasIsolated = true;
+        }
+      } else {
+        if (hasIsolated) {
+          return false;
+        } else {
+          hasNonIsolated = true;
+        }
+      }
+    }
     return countBiNodeConnectedComponents(graph) <= 1;
+  }
 …
   /// \ingroup graph_properties
   ///
   /// \brief Count the number of bi-node-connected components of an
+  /// \brief Count the number of bi-node-connected components of an
   /// undirected graph.
   ///
 …
   /// \retval compMap A writable edge map. The values will be set from 0
   /// to the number of the bi-node-connected components minus one. Each
   /// value of the map will be set exactly once, and the values of a
+  /// value of the map will be set exactly once, and the values of a
   /// certain component will be set continuously.
   /// \return The number of bi-node-connected components.
 …
   ///
   /// \param graph The undirected graph.
   /// \retval cutMap A writable node map. The values will be set to
+  /// \retval cutMap A writable node map. The values will be set to
   /// \c true for the nodes that separate two or more components
   /// (exactly once for each cut node), and will not be changed for
 …
   /// \brief Check whether an undirected graph is bi-edge-connected.
   ///
   /// This function checks whether the given undirected graph is
+  /// This function checks whether the given undirected graph is
   /// bi-edge-connected, i.e. any two nodes are connected with at least
   /// two edge-disjoint paths.
 …
   ///
   /// This function finds the bi-edge-connected cut edges in the given
   /// undirected graph.
+  /// undirected graph.
   ///
   /// The bi-edge-connected components are the classes of an equivalence
 …
   /// \param digraph The digraph.
   /// \retval order A readable and writable node map. The values will be
   /// set from 0 to the number of the nodes in the digraph minus one.
+  /// set from 0 to the number of the nodes in the digraph minus one.
   /// Each value of the map will be set exactly once, and the values will
   /// be set descending order.

lemon/core.h

-                      r718
+                      r1341
  * This file is a part of LEMON, a generic C++ optimization library.
+ *
  * Copyright (C) 2003-2009
+ * Copyright (C) 2003-2013
  * Egervary Jeno Kombinatorikus Optimalizalasi Kutatocsoport
  * (Egervary Research Group on Combinatorial Optimization, EGRES).
 …
 #define LEMON_CORE_H
-#include <vector>
-#include <algorithm>
-#include <lemon/config.h>
-#include <lemon/bits/enable_if.h>
-#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
 ///\brief LEMON core utilities.
 …
 ///It is automatically included by all graph types, therefore it usually
 ///do not have to be included directly.
+// Disable the following warnings when compiling with MSVC:
+// C4250: 'class1' : inherits 'class2::member' via dominance
+// C4267: conversion from 'size_t' to 'type', possible loss of data
+// 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 4267 4355 4503 4800 4996 )
+#endif
+#if __GNUC__ > 4 || (__GNUC__ == 4 && __GNUC_MINOR__ >= 8)
+// Needed by the [DI]GRAPH_TYPEDEFS marcos for gcc 4.8
+#pragma GCC diagnostic ignored "-Wunused-local-typedefs"
+#endif
+#include <vector>
+#include <algorithm>
+#include <lemon/config.h>
+#include <lemon/bits/enable_if.h>
+#include <lemon/bits/traits.h>
+#include <lemon/assert.h>
 namespace lemon {
 …
   typedef typename Graph::template EdgeMap<double> DoubleEdgeMap
+  ///Create convenience typedefs for the bipartite graph types and iterators
+  ///This \c \#define creates the same convenient type definitions as
+  ///defined by \ref GRAPH_TYPEDEFS(BpGraph) and ten more, namely it
+  ///creates \c RedNode, \c RedNodeIt, \c BoolRedNodeMap,
+  ///\c IntRedNodeMap, \c DoubleRedNodeMap, \c BlueNode, \c BlueNodeIt,
+  ///\c BoolBlueNodeMap, \c IntBlueNodeMap, \c DoubleBlueNodeMap.
+  ///
+  ///\note If the graph type is a dependent type, ie. the graph type depend
+  ///on a template parameter, then use \c TEMPLATE_BPGRAPH_TYPEDEFS()
+  ///macro.
+#define BPGRAPH_TYPEDEFS(BpGraph)                                       \
+  GRAPH_TYPEDEFS(BpGraph);                                              \
+  typedef BpGraph::RedNode RedNode;                                     \
+  typedef BpGraph::RedNodeIt RedNodeIt;                                 \
+  typedef BpGraph::RedNodeMap<bool> BoolRedNodeMap;                     \
+  typedef BpGraph::RedNodeMap<int> IntRedNodeMap;                       \
+  typedef BpGraph::RedNodeMap<double> DoubleRedNodeMap;                 \
+  typedef BpGraph::BlueNode BlueNode;                                   \
+  typedef BpGraph::BlueNodeIt BlueNodeIt;                               \
+  typedef BpGraph::BlueNodeMap<bool> BoolBlueNodeMap;                   \
+  typedef BpGraph::BlueNodeMap<int> IntBlueNodeMap;                     \
+  typedef BpGraph::BlueNodeMap<double> DoubleBlueNodeMap
+  ///Create convenience typedefs for the bipartite graph types and iterators
+  ///\see BPGRAPH_TYPEDEFS
+  ///
+  ///\note Use this macro, if the graph type is a dependent type,
+  ///ie. the graph type depend on a template parameter.
+#define TEMPLATE_BPGRAPH_TYPEDEFS(BpGraph)                                  \
+  TEMPLATE_GRAPH_TYPEDEFS(BpGraph);                                         \
+  typedef typename BpGraph::RedNode RedNode;                                \
+  typedef typename BpGraph::RedNodeIt RedNodeIt;                            \
+  typedef typename BpGraph::template RedNodeMap<bool> BoolRedNodeMap;       \
+  typedef typename BpGraph::template RedNodeMap<int> IntRedNodeMap;         \
+  typedef typename BpGraph::template RedNodeMap<double> DoubleRedNodeMap;   \
+  typedef typename BpGraph::BlueNode BlueNode;                              \
+  typedef typename BpGraph::BlueNodeIt BlueNodeIt;                          \
+  typedef typename BpGraph::template BlueNodeMap<bool> BoolBlueNodeMap;     \
+  typedef typename BpGraph::template BlueNodeMap<int> IntBlueNodeMap;       \
+  typedef typename BpGraph::template BlueNodeMap<double> DoubleBlueNodeMap
   /// \brief Function to count the items in a graph.
   ///
 …
+  }
+  namespace _graph_utils_bits {
+    template <typename Graph, typename Enable = void>
+    struct CountRedNodesSelector {
+      static int count(const Graph &g) {
+        return countItems<Graph, typename Graph::RedNode>(g);
+      }
+    };
+    template <typename Graph>
+    struct CountRedNodesSelector<
+      Graph, typename
+      enable_if<typename Graph::NodeNumTag, void>::type>
+    {
+      static int count(const Graph &g) {
+        return g.redNum();
+      }
+    };
+  }
+  /// \brief Function to count the red nodes in the graph.
+  ///
+  /// This function counts the red nodes in the graph.
+  /// The complexity of the function is O(n) but for some
+  /// graph structures it is specialized to run in O(1).
+  ///
+  /// If the graph contains a \e redNum() member function and a
+  /// \e NodeNumTag tag then this function calls directly the member
+  /// function to query the cardinality of the node set.
+  template <typename Graph>
+  inline int countRedNodes(const Graph& g) {
+    return _graph_utils_bits::CountRedNodesSelector<Graph>::count(g);
+  }
+  namespace _graph_utils_bits {
+    template <typename Graph, typename Enable = void>
+    struct CountBlueNodesSelector {
+      static int count(const Graph &g) {
+        return countItems<Graph, typename Graph::BlueNode>(g);
+      }
+    };
+    template <typename Graph>
+    struct CountBlueNodesSelector<
+      Graph, typename
+      enable_if<typename Graph::NodeNumTag, void>::type>
+    {
+      static int count(const Graph &g) {
+        return g.blueNum();
+      }
+    };
+  }
+  /// \brief Function to count the blue nodes in the graph.
+  ///
+  /// This function counts the blue nodes in the graph.
+  /// The complexity of the function is O(n) but for some
+  /// graph structures it is specialized to run in O(1).
+  ///
+  /// If the graph contains a \e blueNum() member function and a
+  /// \e NodeNumTag tag then this function calls directly the member
+  /// function to query the cardinality of the node set.
+  template <typename Graph>
+  inline int countBlueNodes(const Graph& g) {
+    return _graph_utils_bits::CountBlueNodesSelector<Graph>::count(g);
+  }
   // Arc counting:
 …
       static void copy(const From& from, Digraph &to,
                        NodeRefMap& nodeRefMap, ArcRefMap& arcRefMap) {
+        to.clear();
         for (typename From::NodeIt it(from); it != INVALID; ++it) {
           nodeRefMap[it] = to.addNode();
 …
       static void copy(const From& from, Graph &to,
                        NodeRefMap& nodeRefMap, EdgeRefMap& edgeRefMap) {
+        to.clear();
         for (typename From::NodeIt it(from); it != INVALID; ++it) {
           nodeRefMap[it] = to.addNode();
 …
       template <typename From, typename NodeRefMap, typename EdgeRefMap>
       static void copy(const From& from, Graph &to,
+                       NodeRefMap& nodeRefMap, EdgeRefMap& edgeRefMap) {
+                       NodeRefMap& nodeRefMap,
+                       EdgeRefMap& edgeRefMap) {
         to.build(from, nodeRefMap, edgeRefMap);
+      }
     };
+    template <typename BpGraph, typename Enable = void>
+    struct BpGraphCopySelector {
+      template <typename From, typename RedNodeRefMap,
+                typename BlueNodeRefMap, typename EdgeRefMap>
+      static void copy(const From& from, BpGraph &to,
+                       RedNodeRefMap& redNodeRefMap,
+                       BlueNodeRefMap& blueNodeRefMap,
+                       EdgeRefMap& edgeRefMap) {
+        to.clear();
+        for (typename From::RedNodeIt it(from); it != INVALID; ++it) {
+          redNodeRefMap[it] = to.addRedNode();
+        }
+        for (typename From::BlueNodeIt it(from); it != INVALID; ++it) {
+          blueNodeRefMap[it] = to.addBlueNode();
+        }
+        for (typename From::EdgeIt it(from); it != INVALID; ++it) {
+          edgeRefMap[it] = to.addEdge(redNodeRefMap[from.redNode(it)],
+                                      blueNodeRefMap[from.blueNode(it)]);
+        }
+      }
+    };
+    template <typename BpGraph>
+    struct BpGraphCopySelector<
+      BpGraph,
+      typename enable_if<typename BpGraph::BuildTag, void>::type>
+    {
+      template <typename From, typename RedNodeRefMap,
+                typename BlueNodeRefMap, typename EdgeRefMap>
+      static void copy(const From& from, BpGraph &to,
+                       RedNodeRefMap& redNodeRefMap,
+                       BlueNodeRefMap& blueNodeRefMap,
+                       EdgeRefMap& edgeRefMap) {
+        to.build(from, redNodeRefMap, blueNodeRefMap, edgeRefMap);
+      }
+    };
+  }
+  /// \brief Check whether a graph is undirected.
+  ///
+  /// This function returns \c true if the given graph is undirected.
+#ifdef DOXYGEN
+  template <typename GR>
+  bool undirected(const GR& g) { return false; }
+#else
+  template <typename GR>
+  typename enable_if<UndirectedTagIndicator<GR>, bool>::type
+  undirected(const GR&) {
+    return true;
+  }
+  template <typename GR>
+  typename disable_if<UndirectedTagIndicator<GR>, bool>::type
+  undirected(const GR&) {
+    return false;
+  }
+#endif
   /// \brief Class to copy a digraph.
 …
   graphCopy(const From& from, To& to) {
     return GraphCopy<From, To>(from, to);
+  }
+  /// \brief Class to copy a bipartite graph.
+  ///
+  /// Class to copy a bipartite graph to another graph (duplicate a
+  /// graph). The simplest way of using it is through the
+  /// \c bpGraphCopy() function.
+  ///
+  /// This class not only make a copy of a bipartite graph, but it can
+  /// create references and cross references between the nodes, edges
+  /// and arcs of the two graphs, and it can copy maps for using with
+  /// the newly created graph.
+  ///
+  /// To make a copy from a graph, first an instance of BpGraphCopy
+  /// should be created, then the data belongs to the graph should
+  /// assigned to copy. In the end, the \c run() member should be
+  /// called.
+  ///
+  /// The next code copies a graph with several data:
+  ///\code
+  ///  BpGraphCopy<OrigBpGraph, NewBpGraph> cg(orig_graph, new_graph);
+  ///  // Create references for the nodes
+  ///  OrigBpGraph::NodeMap<NewBpGraph::Node> nr(orig_graph);
+  ///  cg.nodeRef(nr);
+  ///  // Create cross references (inverse) for the edges
+  ///  NewBpGraph::EdgeMap<OrigBpGraph::Edge> ecr(new_graph);
+  ///  cg.edgeCrossRef(ecr);
+  ///  // Copy a red node map
+  ///  OrigBpGraph::RedNodeMap<double> ormap(orig_graph);
+  ///  NewBpGraph::RedNodeMap<double> nrmap(new_graph);
+  ///  cg.redNodeMap(ormap, nrmap);
+  ///  // Copy a node
+  ///  OrigBpGraph::Node on;
+  ///  NewBpGraph::Node nn;
+  ///  cg.node(on, nn);
+  ///  // Execute copying
+  ///  cg.run();
+  ///\endcode
+  template <typename From, typename To>
+  class BpGraphCopy {
+  private:
+    typedef typename From::Node Node;
+    typedef typename From::RedNode RedNode;
+    typedef typename From::BlueNode BlueNode;
+    typedef typename From::NodeIt NodeIt;
+    typedef typename From::Arc Arc;
+    typedef typename From::ArcIt ArcIt;
+    typedef typename From::Edge Edge;
+    typedef typename From::EdgeIt EdgeIt;
+    typedef typename To::Node TNode;
+    typedef typename To::RedNode TRedNode;
+    typedef typename To::BlueNode TBlueNode;
+    typedef typename To::Arc TArc;
+    typedef typename To::Edge TEdge;
+    typedef typename From::template RedNodeMap<TRedNode> RedNodeRefMap;
+    typedef typename From::template BlueNodeMap<TBlueNode> BlueNodeRefMap;
+    typedef typename From::template EdgeMap<TEdge> EdgeRefMap;
+    struct NodeRefMap {
+      NodeRefMap(const From& from, const RedNodeRefMap& red_node_ref,
+                 const BlueNodeRefMap& blue_node_ref)
+        : _from(from), _red_node_ref(red_node_ref),
+          _blue_node_ref(blue_node_ref) {}
+      typedef typename From::Node Key;
+      typedef typename To::Node Value;
+      Value operator[](const Key& key) const {
+        if (_from.red(key)) {
+          return _red_node_ref[_from.asRedNodeUnsafe(key)];
+        } else {
+          return _blue_node_ref[_from.asBlueNodeUnsafe(key)];
+        }
+      }
+      const From& _from;
+      const RedNodeRefMap& _red_node_ref;
+      const BlueNodeRefMap& _blue_node_ref;
+    };
+    struct ArcRefMap {
+      ArcRefMap(const From& from, const To& to, const EdgeRefMap& edge_ref)
+        : _from(from), _to(to), _edge_ref(edge_ref) {}
+      typedef typename From::Arc Key;
+      typedef typename To::Arc Value;
+      Value operator[](const Key& key) const {
+        return _to.direct(_edge_ref[key], _from.direction(key));
+      }
+      const From& _from;
+      const To& _to;
+      const EdgeRefMap& _edge_ref;
+    };
+  public:
+    /// \brief Constructor of BpGraphCopy.
+    ///
+    /// Constructor of BpGraphCopy for copying the content of the
+    /// \c from graph into the \c to graph.
+    BpGraphCopy(const From& from, To& to)
+      : _from(from), _to(to) {}
+    /// \brief Destructor of BpGraphCopy
+    ///
+    /// Destructor of BpGraphCopy.
+    ~BpGraphCopy() {
+      for (int i = 0; i < int(_node_maps.size()); ++i) {
+        delete _node_maps[i];
+      }
+      for (int i = 0; i < int(_red_maps.size()); ++i) {
+        delete _red_maps[i];
+      }
+      for (int i = 0; i < int(_blue_maps.size()); ++i) {
+        delete _blue_maps[i];
+      }
+      for (int i = 0; i < int(_arc_maps.size()); ++i) {
+        delete _arc_maps[i];
+      }
+      for (int i = 0; i < int(_edge_maps.size()); ++i) {
+        delete _edge_maps[i];
+      }
+    }
+    /// \brief Copy the node references into the given map.
+    ///
+    /// This function copies the node references into the given map.
+    /// The parameter should be a map, whose key type is the Node type of
+    /// the source graph, while the value type is the Node type of the
+    /// destination graph.
+    template <typename NodeRef>
+    BpGraphCopy& nodeRef(NodeRef& map) {
+      _node_maps.push_back(new _core_bits::RefCopy<From, Node,
+                           NodeRefMap, NodeRef>(map));
+      return *this;
+    }
+    /// \brief Copy the node cross references into the given map.
+    ///
+    /// This function copies the node cross references (reverse references)
+    /// into the given map. The parameter should be a map, whose key type
+    /// is the Node type of the destination graph, while the value type is
+    /// the Node type of the source graph.
+    template <typename NodeCrossRef>
+    BpGraphCopy& nodeCrossRef(NodeCrossRef& map) {
+      _node_maps.push_back(new _core_bits::CrossRefCopy<From, Node,
+                           NodeRefMap, NodeCrossRef>(map));
+      return *this;
+    }
+    /// \brief Make a copy of the given node map.
+    ///
+    /// This function makes a copy of the given node map for the newly
+    /// created graph.
+    /// The key type of the new map \c tmap should be the Node type of the
+    /// destination graph, and the key type of the original map \c map
+    /// should be the Node type of the source graph.
+    template <typename FromMap, typename ToMap>
+    BpGraphCopy& nodeMap(const FromMap& map, ToMap& tmap) {
+      _node_maps.push_back(new _core_bits::MapCopy<From, Node,
+                           NodeRefMap, FromMap, ToMap>(map, tmap));
+      return *this;
+    }
+    /// \brief Make a copy of the given node.
+    ///
+    /// This function makes a copy of the given node.
+    BpGraphCopy& node(const Node& node, TNode& tnode) {
+      _node_maps.push_back(new _core_bits::ItemCopy<From, Node,
+                           NodeRefMap, TNode>(node, tnode));
+      return *this;
+    }
+    /// \brief Copy the red node references into the given map.
+    ///
+    /// This function copies the red node references into the given
+    /// map.  The parameter should be a map, whose key type is the
+    /// Node type of the source graph with the red item set, while the
+    /// value type is the Node type of the destination graph.
+    template <typename RedRef>
+    BpGraphCopy& redRef(RedRef& map) {
+      _red_maps.push_back(new _core_bits::RefCopy<From, RedNode,
+                          RedNodeRefMap, RedRef>(map));
+      return *this;
+    }
+    /// \brief Copy the red node cross references into the given map.
+    ///
+    /// This function copies the red node cross references (reverse
+    /// references) into the given map. The parameter should be a map,
+    /// whose key type is the Node type of the destination graph with
+    /// the red item set, while the value type is the Node type of the
+    /// source graph.
+    template <typename RedCrossRef>
+    BpGraphCopy& redCrossRef(RedCrossRef& map) {
+      _red_maps.push_back(new _core_bits::CrossRefCopy<From, RedNode,
+                          RedNodeRefMap, RedCrossRef>(map));
+      return *this;
+    }
+    /// \brief Make a copy of the given red node map.
+    ///
+    /// This function makes a copy of the given red node map for the newly
+    /// created graph.
+    /// The key type of the new map \c tmap should be the Node type of
+    /// the destination graph with the red items, and the key type of
+    /// the original map \c map should be the Node type of the source
+    /// graph.
+    template <typename FromMap, typename ToMap>
+    BpGraphCopy& redNodeMap(const FromMap& map, ToMap& tmap) {
+      _red_maps.push_back(new _core_bits::MapCopy<From, RedNode,
+                          RedNodeRefMap, FromMap, ToMap>(map, tmap));
+      return *this;
+    }
+    /// \brief Make a copy of the given red node.
+    ///
+    /// This function makes a copy of the given red node.
+    BpGraphCopy& redNode(const RedNode& node, TRedNode& tnode) {
+      _red_maps.push_back(new _core_bits::ItemCopy<From, RedNode,
+                          RedNodeRefMap, TRedNode>(node, tnode));
+      return *this;
+    }
+    /// \brief Copy the blue node references into the given map.
+    ///
+    /// This function copies the blue node references into the given
+    /// map.  The parameter should be a map, whose key type is the
+    /// Node type of the source graph with the blue item set, while the
+    /// value type is the Node type of the destination graph.
+    template <typename BlueRef>
+    BpGraphCopy& blueRef(BlueRef& map) {
+      _blue_maps.push_back(new _core_bits::RefCopy<From, BlueNode,
+                           BlueNodeRefMap, BlueRef>(map));
+      return *this;
+    }
+    /// \brief Copy the blue node cross references into the given map.
+    ///
+    /// This function copies the blue node cross references (reverse
+    /// references) into the given map. The parameter should be a map,
+    /// whose key type is the Node type of the destination graph with
+    /// the blue item set, while the value type is the Node type of the
+    /// source graph.
+    template <typename BlueCrossRef>
+    BpGraphCopy& blueCrossRef(BlueCrossRef& map) {
+      _blue_maps.push_back(new _core_bits::CrossRefCopy<From, BlueNode,
+                           BlueNodeRefMap, BlueCrossRef>(map));
+      return *this;
+    }
+    /// \brief Make a copy of the given blue node map.
+    ///
+    /// This function makes a copy of the given blue node map for the newly
+    /// created graph.
+    /// The key type of the new map \c tmap should be the Node type of
+    /// the destination graph with the blue items, and the key type of
+    /// the original map \c map should be the Node type of the source
+    /// graph.
+    template <typename FromMap, typename ToMap>
+    BpGraphCopy& blueNodeMap(const FromMap& map, ToMap& tmap) {
+      _blue_maps.push_back(new _core_bits::MapCopy<From, BlueNode,
+                           BlueNodeRefMap, FromMap, ToMap>(map, tmap));
+      return *this;
+    }
+    /// \brief Make a copy of the given blue node.
+    ///
+    /// This function makes a copy of the given blue node.
+    BpGraphCopy& blueNode(const BlueNode& node, TBlueNode& tnode) {
+      _blue_maps.push_back(new _core_bits::ItemCopy<From, BlueNode,
+                           BlueNodeRefMap, TBlueNode>(node, tnode));
+      return *this;
+    }
+    /// \brief Copy the arc references into the given map.
+    ///
+    /// This function copies the arc references into the given map.
+    /// The parameter should be a map, whose key type is the Arc type of
+    /// the source graph, while the value type is the Arc type of the
+    /// destination graph.
+    template <typename ArcRef>
+    BpGraphCopy& arcRef(ArcRef& map) {
+      _arc_maps.push_back(new _core_bits::RefCopy<From, Arc,
+                          ArcRefMap, ArcRef>(map));
+      return *this;
+    }
+    /// \brief Copy the arc cross references into the given map.
+    ///
+    /// This function copies the arc cross references (reverse references)
+    /// into the given map. The parameter should be a map, whose key type
+    /// is the Arc type of the destination graph, while the value type is
+    /// the Arc type of the source graph.
+    template <typename ArcCrossRef>
+    BpGraphCopy& arcCrossRef(ArcCrossRef& map) {
+      _arc_maps.push_back(new _core_bits::CrossRefCopy<From, Arc,
+                          ArcRefMap, ArcCrossRef>(map));
+      return *this;
+    }
+    /// \brief Make a copy of the given arc map.
+    ///
+    /// This function makes a copy of the given arc map for the newly
+    /// created graph.
+    /// The key type of the new map \c tmap should be the Arc type of the
+    /// destination graph, and the key type of the original map \c map
+    /// should be the Arc type of the source graph.
+    template <typename FromMap, typename ToMap>
+    BpGraphCopy& arcMap(const FromMap& map, ToMap& tmap) {
+      _arc_maps.push_back(new _core_bits::MapCopy<From, Arc,
+                          ArcRefMap, FromMap, ToMap>(map, tmap));
+      return *this;
+    }
+    /// \brief Make a copy of the given arc.
+    ///
+    /// This function makes a copy of the given arc.
+    BpGraphCopy& arc(const Arc& arc, TArc& tarc) {
+      _arc_maps.push_back(new _core_bits::ItemCopy<From, Arc,
+                          ArcRefMap, TArc>(arc, tarc));
+      return *this;
+    }
+    /// \brief Copy the edge references into the given map.
+    ///
+    /// This function copies the edge references into the given map.
+    /// The parameter should be a map, whose key type is the Edge type of
+    /// the source graph, while the value type is the Edge type of the
+    /// destination graph.
+    template <typename EdgeRef>
+    BpGraphCopy& edgeRef(EdgeRef& map) {
+      _edge_maps.push_back(new _core_bits::RefCopy<From, Edge,
+                           EdgeRefMap, EdgeRef>(map));
+      return *this;
+    }
+    /// \brief Copy the edge cross references into the given map.
+    ///
+    /// This function copies the edge cross references (reverse references)
+    /// into the given map. The parameter should be a map, whose key type
+    /// is the Edge type of the destination graph, while the value type is
+    /// the Edge type of the source graph.
+    template <typename EdgeCrossRef>
+    BpGraphCopy& edgeCrossRef(EdgeCrossRef& map) {
+      _edge_maps.push_back(new _core_bits::CrossRefCopy<From,
+                           Edge, EdgeRefMap, EdgeCrossRef>(map));
+      return *this;
+    }
+    /// \brief Make a copy of the given edge map.
+    ///
+    /// This function makes a copy of the given edge map for the newly
+    /// created graph.
+    /// The key type of the new map \c tmap should be the Edge type of the
+    /// destination graph, and the key type of the original map \c map
+    /// should be the Edge type of the source graph.
+    template <typename FromMap, typename ToMap>
+    BpGraphCopy& edgeMap(const FromMap& map, ToMap& tmap) {
+      _edge_maps.push_back(new _core_bits::MapCopy<From, Edge,
+                           EdgeRefMap, FromMap, ToMap>(map, tmap));
+      return *this;
+    }
+    /// \brief Make a copy of the given edge.
+    ///
+    /// This function makes a copy of the given edge.
+    BpGraphCopy& edge(const Edge& edge, TEdge& tedge) {
+      _edge_maps.push_back(new _core_bits::ItemCopy<From, Edge,
+                           EdgeRefMap, TEdge>(edge, tedge));
+      return *this;
+    }
+    /// \brief Execute copying.
+    ///
+    /// This function executes the copying of the graph along with the
+    /// copying of the assigned data.
+    void run() {
+      RedNodeRefMap redNodeRefMap(_from);
+      BlueNodeRefMap blueNodeRefMap(_from);
+      NodeRefMap nodeRefMap(_from, redNodeRefMap, blueNodeRefMap);
+      EdgeRefMap edgeRefMap(_from);
+      ArcRefMap arcRefMap(_from, _to, edgeRefMap);
+      _core_bits::BpGraphCopySelector<To>::
+        copy(_from, _to, redNodeRefMap, blueNodeRefMap, edgeRefMap);
+      for (int i = 0; i < int(_node_maps.size()); ++i) {
+        _node_maps[i]->copy(_from, nodeRefMap);
+      }
+      for (int i = 0; i < int(_red_maps.size()); ++i) {
+        _red_maps[i]->copy(_from, redNodeRefMap);
+      }
+      for (int i = 0; i < int(_blue_maps.size()); ++i) {
+        _blue_maps[i]->copy(_from, blueNodeRefMap);
+      }
+      for (int i = 0; i < int(_edge_maps.size()); ++i) {
+        _edge_maps[i]->copy(_from, edgeRefMap);
+      }
+      for (int i = 0; i < int(_arc_maps.size()); ++i) {
+        _arc_maps[i]->copy(_from, arcRefMap);
+      }
+    }
+  private:
+    const From& _from;
+    To& _to;
+    std::vector<_core_bits::MapCopyBase<From, Node, NodeRefMap>* >
+      _node_maps;
+    std::vector<_core_bits::MapCopyBase<From, RedNode, RedNodeRefMap>* >
+      _red_maps;
+    std::vector<_core_bits::MapCopyBase<From, BlueNode, BlueNodeRefMap>* >
+      _blue_maps;
+    std::vector<_core_bits::MapCopyBase<From, Arc, ArcRefMap>* >
+      _arc_maps;
+    std::vector<_core_bits::MapCopyBase<From, Edge, EdgeRefMap>* >
+      _edge_maps;
+  };
+  /// \brief Copy a graph to another graph.
+  ///
+  /// This function copies a graph to another graph.
+  /// The complete usage of it is detailed in the BpGraphCopy class,
+  /// but a short example shows a basic work:
+  ///\code
+  /// graphCopy(src, trg).nodeRef(nr).edgeCrossRef(ecr).run();
+  ///\endcode
+  ///
+  /// After the copy the \c nr map will contain the mapping from the
+  /// nodes of the \c from graph to the nodes of the \c to graph and
+  /// \c ecr will contain the mapping from the edges of the \c to graph
+  /// to the edges of the \c from graph.
+  ///
+  /// \see BpGraphCopy
+  template <typename From, typename To>
+  BpGraphCopy<From, To>
+  bpGraphCopy(const From& from, To& to) {
+    return BpGraphCopy<From, To>(from, to);
+  }
 …
   protected:
+    class AutoNodeMap : public ItemSetTraits<GR, Node>::template Map<Arc>::Type {
+    class AutoNodeMap : public ItemSetTraits<GR, Node>::template Map<Arc>::Type
+    {
       typedef typename ItemSetTraits<GR, Node>::template Map<Arc>::Type Parent;
 …
     };
   protected:
+  protected:
     const Digraph &_g;
 …
     ///a single node \c n, then \ref refresh(Node) "refresh(n)" is enough.
     ///
+#ifdef DOXYGEN
+    Arc operator()(Node s, Node t, Arc prev=INVALID) const {}
+#else
+    using ArcLookUp<GR>::operator() ;
+    Arc operator()(Node s, Node t, Arc prev) const
+    Arc operator()(Node s, Node t, Arc prev=INVALID) const
+    {
+      return prev==INVALID?(*this)(s,t):_next[prev];
+    }
+      if(prev==INVALID)
+        {
+          Arc f=INVALID;
+          Arc e;
+          for(e=_head[s];
+              e!=INVALID&&_g.target(e)!=t;
+              e = t < _g.target(e)?_left[e]:_right[e]) ;
+          while(e!=INVALID)
+            if(_g.target(e)==t)
+              {
+                f = e;
+                e = _left[e];
+              }
+            else e = _right[e];
+          return f;
+        }
+      else return _next[prev];
+    }
+  };
+  /// @}
+} //namespace lemon
 #endif
-  };
-  /// @}
-} //namespace lemon
-#endif

lemon/cost_scaling.h

-                      r887
+                      r1298
 /* -*- C++ -*-
+/* -*- mode: C++; indent-tabs-mode: nil; -*-
+ *
  * This file is a part of LEMON, a generic C++ optimization library
+ * This file is a part of LEMON, a generic C++ optimization library.
+ *
  * Copyright (C) 2003-2008
+ * Copyright (C) 2003-2013
  * Egervary Jeno Kombinatorikus Optimalizalasi Kutatocsoport
  * (Egervary Research Group on Combinatorial Optimization, EGRES).
 …
   /// \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.
+  /// "minimum cost flow" \cite amo93networkflows,
+  /// \cite goldberg90approximation,
+  /// \cite goldberg97efficient, \cite 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.
+  /// It is a polynomial algorithm, its running time complexity is
+  /// \f$O(n^2m\log(nK))\f$, where <i>K</i> denotes the maximum arc cost.
+  ///
+  /// In general, \ref NetworkSimplex and \ref CostScaling are the fastest
+  /// implementations available in LEMON for solving this problem.
+  /// (For more information, see \ref min_cost_flow_algs "the module page".)
   ///
   /// Most of the parameters of the problem (except for the digraph)
 …
   /// \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.
+  /// 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.
+  /// 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
+  /// \warning Both \c V and \c C must be signed number types.
+  /// \warning All input data (capacities, supply values, and costs) must
   /// be integer.
   /// \warning This algorithm does not support negative costs for such
   /// arcs that have infinite upper bound.
+  /// \warning This algorithm does not support negative costs for
+  /// arcs having infinite upper bound.
   ///
   /// \note %CostScaling provides three different internal methods,
 …
     ///
     /// The large cost type used for internal computations.
+    /// Using the \ref CostScalingDefaultTraits "default traits class",
+    /// it is \c long \c long if the \c Cost type is integer,
+    /// 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
+    /// \brief The \ref lemon::CostScalingDefaultTraits "traits class"
+    /// of the algorithm
     typedef TR Traits;
 …
     /// relabel operation.
     /// By default, the so called \ref PARTIAL_AUGMENT
     /// "Partial Augment-Relabel" method is used, which proved to be
+    /// "Partial Augment-Relabel" method is used, which turned out to be
     /// the most efficient and the most robust on various test inputs.
     /// However, the other methods can be selected using the \ref run()
 …
       /// paths from a node with excess to a node with deficit.
       AUGMENT,
       /// Partial augment operations are used, i.e. flow is moved on
+      /// 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
 …
     typedef std::vector<int> IntVector;
-    typedef std::vector<char> BoolVector;
     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 {
 …
       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)];
 …
         return _v[StaticDigraph::id(key)];
+      }
       void set(const Key& key, const Value& val) {
         _v[StaticDigraph::id(key)] = val;
 …
     };
-    typedef StaticVectorMap<StaticDigraph::Node, LargeCost> LargeCostNodeMap;
     typedef StaticVectorMap<StaticDigraph::Arc, LargeCost> LargeCostArcMap;
 …
     // Parameters of the problem
     bool _have_lower;
+    bool _has_lower;
     Value _sum_supply;
+    int _sup_node_num;
     // Data structures for storing the digraph
 …
     int _alpha;
+    // 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;
+    IntVector _buckets;
+    IntVector _bucket_next;
+    IntVector _bucket_prev;
+    IntVector _rank;
+    int _max_rank;
   public:
     /// \brief Constant for infinite upper bounds (capacities).
     ///
 …
     /// @}
+  protected:
+    CostScaling() {}
   public:
 …
     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() :
 …
         "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) {
+      _has_lower = true;
+      for (ArcIt a(_graph); a != INVALID; ++a) {
+        _lower[_arc_idf[a]] = map[a];
+      }
+      return *this;
+    }
+    /// \brief Set the upper bounds (capacities) on the arcs.
+    ///
+    /// This function sets the upper bounds (capacities) on the arcs.
+    /// If it is not used before calling \ref run(), the upper bounds
+    /// will be set to \ref INF on all arcs (i.e. the flow value will be
+    /// unbounded from above).
+    ///
+    /// \param map An arc map storing the upper bounds.
+    /// Its \c Value type must be convertible to the \c Value type
+    /// of the algorithm.
+    ///
+    /// \return <tt>(*this)</tt>
+    template<typename UpperMap>
+    CostScaling& upperMap(const UpperMap& map) {
+      for (ArcIt a(_graph); a != INVALID; ++a) {
+        _upper[_arc_idf[a]] = map[a];
+      }
+      return *this;
+    }
+    /// \brief Set the costs of the arcs.
+    ///
+    /// This function sets the costs of the arcs.
+    /// If it is not used before calling \ref run(), the costs
+    /// will be set to \c 1 on all arcs.
+    ///
+    /// \param map An arc map storing the costs.
+    /// Its \c Value type must be convertible to the \c Cost type
+    /// of the algorithm.
+    ///
+    /// \return <tt>(*this)</tt>
+    template<typename CostMap>
+    CostScaling& costMap(const CostMap& map) {
+      for (ArcIt a(_graph); a != INVALID; ++a) {
+        _scost[_arc_idf[a]] =  map[a];
+        _scost[_arc_idb[a]] = -map[a];
+      }
+      return *this;
+    }
+    /// \brief Set the supply values of the nodes.
+    ///
+    /// This function sets the supply values of the nodes.
+    /// If neither this function nor \ref stSupply() is used before
+    /// calling \ref run(), the supply of each node will be set to zero.
+    ///
+    /// \param map A node map storing the supply values.
+    /// Its \c Value type must be convertible to the \c Value type
+    /// of the algorithm.
+    ///
+    /// \return <tt>(*this)</tt>
+    template<typename SupplyMap>
+    CostScaling& supplyMap(const SupplyMap& map) {
+      for (NodeIt n(_graph); n != INVALID; ++n) {
+        _supply[_node_id[n]] = map[n];
+      }
+      return *this;
+    }
+    /// \brief Set single source and target nodes and a supply value.
+    ///
+    /// This function sets a single source node and a single target node
+    /// and the required flow value.
+    /// If neither this function nor \ref supplyMap() is used before
+    /// calling \ref run(), the supply of each node will be set to zero.
+    ///
+    /// Using this function has the same effect as using \ref supplyMap()
+    /// with a map in which \c k is assigned to \c s, \c -k is
+    /// assigned to \c t and all other nodes have zero supply value.
+    ///
+    /// \param s The source node.
+    /// \param t The target node.
+    /// \param k The required amount of flow from node \c s to node \c t
+    /// (i.e. the supply of \c s and the demand of \c t).
+    ///
+    /// \return <tt>(*this)</tt>
+    CostScaling& stSupply(const Node& s, const Node& t, Value k) {
+      for (int i = 0; i != _res_node_num; ++i) {
+        _supply[i] = 0;
+      }
+      _supply[_node_id[s]] =  k;
+      _supply[_node_id[t]] = -k;
+      return *this;
+    }
+    /// @}
+    /// \name Execution control
+    /// The algorithm can be executed using \ref run().
+    /// @{
+    /// \brief Run the algorithm.
+    ///
+    /// This function runs the algorithm.
+    /// The paramters can be specified using functions \ref lowerMap(),
+    /// \ref upperMap(), \ref costMap(), \ref supplyMap(), \ref stSupply().
+    /// For example,
+    /// \code
+    ///   CostScaling<ListDigraph> cs(graph);
+    ///   cs.lowerMap(lower).upperMap(upper).costMap(cost)
+    ///     .supplyMap(sup).run();
+    /// \endcode
+    ///
+    /// This function can be called more than once. All the given parameters
+    /// are kept for the next call, unless \ref resetParams() or \ref reset()
+    /// is used, thus only the modified parameters have to be set again.
+    /// If the underlying digraph was also modified after the construction
+    /// of the class (or the last \ref reset() call), then the \ref reset()
+    /// function must be called.
+    ///
+    /// \param method The internal method that will be used in the
+    /// algorithm. For more information, see \ref Method.
+    /// \param factor The cost scaling factor. It must be at least two.
+    ///
+    /// \return \c INFEASIBLE if no feasible flow exists,
+    /// \n \c OPTIMAL if the problem has optimal solution
+    /// (i.e. it is feasible and bounded), and the algorithm has found
+    /// optimal flow and node potentials (primal and dual solutions),
+    /// \n \c UNBOUNDED if the digraph contains an arc of negative cost
+    /// and infinite upper bound. It means that the objective function
+    /// is unbounded on that arc, however, note that it could actually be
+    /// bounded over the feasible flows, but this algroithm cannot handle
+    /// these cases.
+    ///
+    /// \see ProblemType, Method
+    /// \see resetParams(), reset()
+    ProblemType run(Method method = PARTIAL_AUGMENT, int factor = 16) {
+      LEMON_ASSERT(factor >= 2, "The scaling factor must be at least 2");
+      _alpha = factor;
+      ProblemType pt = init();
+      if (pt != OPTIMAL) return pt;
+      start(method);
+      return OPTIMAL;
+    }
+    /// \brief Reset all the parameters that have been given before.
+    ///
+    /// This function resets all the paramaters that have been given
+    /// before using functions \ref lowerMap(), \ref upperMap(),
+    /// \ref costMap(), \ref supplyMap(), \ref stSupply().
+    ///
+    /// It is useful for multiple \ref run() calls. Basically, all the given
+    /// parameters are kept for the next \ref run() call, unless
+    /// \ref resetParams() or \ref reset() is used.
+    /// If the underlying digraph was also modified after the construction
+    /// of the class or the last \ref reset() call, then the \ref reset()
+    /// function must be used, otherwise \ref resetParams() is sufficient.
+    ///
+    /// For example,
+    /// \code
+    ///   CostScaling<ListDigraph> cs(graph);
+    ///
+    ///   // First run
+    ///   cs.lowerMap(lower).upperMap(upper).costMap(cost)
+    ///     .supplyMap(sup).run();
+    ///
+    ///   // Run again with modified cost map (resetParams() is not called,
+    ///   // so only the cost map have to be set again)
+    ///   cost[e] += 100;
+    ///   cs.costMap(cost).run();
+    ///
+    ///   // Run again from scratch using resetParams()
+    ///   // (the lower bounds will be set to zero on all arcs)
+    ///   cs.resetParams();
+    ///   cs.upperMap(capacity).costMap(cost)
+    ///     .supplyMap(sup).run();
+    /// \endcode
+    ///
+    /// \return <tt>(*this)</tt>
+    ///
+    /// \see reset(), run()
+    CostScaling& resetParams() {
+      for (int i = 0; i != _res_node_num; ++i) {
+        _supply[i] = 0;
+      }
+      int limit = _first_out[_root];
+      for (int j = 0; j != limit; ++j) {
+        _lower[j] = 0;
+        _upper[j] = INF;
+        _scost[j] = _forward[j] ? 1 : -1;
+      }
+      for (int j = limit; j != _res_arc_num; ++j) {
+        _lower[j] = 0;
+        _upper[j] = INF;
+        _scost[j] = 0;
+        _scost[_reverse[j]] = 0;
+      }
+      _has_lower = false;
+      return *this;
+    }
+    /// \brief Reset the internal data structures and all the parameters
+    /// that have been given before.
+    ///
+    /// This function resets the internal data structures and all the
+    /// paramaters that have been given before using functions \ref lowerMap(),
+    /// \ref upperMap(), \ref costMap(), \ref supplyMap(), \ref stSupply().
+    ///
+    /// It is useful for multiple \ref run() calls. By default, all the given
+    /// parameters are kept for the next \ref run() call, unless
+    /// \ref resetParams() or \ref reset() is used.
+    /// If the underlying digraph was also modified after the construction
+    /// of the class or the last \ref reset() call, then the \ref reset()
+    /// function must be used, otherwise \ref resetParams() is sufficient.
+    ///
+    /// See \ref resetParams() for examples.
+    ///
+    /// \return <tt>(*this)</tt>
+    ///
+    /// \see resetParams(), run()
+    CostScaling& reset() {
       // Resize vectors
       _node_num = countNodes(_graph);
 …
       _scost.resize(_res_arc_num);
       _supply.resize(_res_node_num);
       _res_cap.resize(_res_arc_num);
       _cost.resize(_res_arc_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
 …
         _reverse[bi] = fi;
+      }
       // Reset parameters
+      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 parameters
+    /// that have been given are kept for the next call, unless
+    /// \ref reset() is called, thus only the modified parameters
+    /// have to be set again. See \ref reset() for examples.
+    /// However, the underlying digraph must not be modified after this
+    /// class have been constructed, since it copies and extends the graph.
+    ///
+    /// \param 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
+    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 run() calls. If this function is not
+    /// used, all the parameters given before are kept for the next
+    /// \ref run() call.
+    /// However, the underlying digraph must not be modified after this
+    /// class have been constructed, since it copies and extends the graph.
+    ///
+    /// For example,
+    /// \code
+    ///   CostScaling<ListDigraph> cs(graph);
+    ///
+    ///   // First run
+    ///   cs.lowerMap(lower).upperMap(upper).costMap(cost)
+    ///     .supplyMap(sup).run();
+    ///
+    ///   // Run again with modified cost map (reset() 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 reset()
+    ///   // (the lower bounds will be set to zero on all arcs)
+    ///   cs.reset();
+    ///   cs.upperMap(capacity).costMap(cost)
+    ///     .supplyMap(sup).run();
+    /// \endcode
+    ///
+    /// \return <tt>(*this)</tt>
+    CostScaling& reset() {
+      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;
+      resetParams();
       return *this;
+    }
 …
     ///
     /// This function returns the total cost of the found flow.
     /// Its complexity is O(e).
+    /// Its complexity is O(m).
     ///
     /// \note The return type of the function can be specified as a
 …
+    }
+    /// \brief Return the flow map (the primal solution).
+    /// \brief Copy the flow values (the primal solution) into the
+    /// given map.
     ///
     /// This function copies the flow value on each arc into the given
 …
+    }
+    /// \brief Return the potential map (the dual solution).
+    /// \brief Copy the potential values (the dual solution) into the
+    /// given map.
     ///
     /// This function copies the potential (dual value) of each node
 …
+      }
       if (_sum_supply > 0) return INFEASIBLE;
+      // Check lower and upper bounds
+      LEMON_DEBUG(checkBoundMaps(),
+          "Upper bounds must be greater or equal to the lower bounds");
       // Initialize vectors
 …
         _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) {
+      if (_has_lower) {
         for (int i = 0; i != _root; ++i) {
           last_out = _first_out[i+1];
 …
         sup[n] = _supply[_node_id[n]];
+      }
       if (_have_lower) {
+      if (_has_lower) {
         for (ArcIt a(_graph); a != INVALID; ++a) {
           int j = _arc_idf[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;
+      }
 …
         for (int a = _first_out[_root]; a != _res_arc_num; ++a) {
           int ra = _reverse[a];
           _res_cap[a] = 1;
+          _res_cap[a] = 0;
           _res_cap[ra] = 0;
           _cost[a] = 0;
 …
+        }
+      }
+      // Initialize data structures for buckets
+      _max_rank = _alpha * _res_node_num;
+      _buckets.resize(_max_rank);
+      _bucket_next.resize(_res_node_num + 1);
+      _bucket_prev.resize(_res_node_num + 1);
+      _rank.resize(_res_node_num + 1);
       return OPTIMAL;
+    }
+    // Check if the upper bound is greater than or equal to the lower bound
+    // on each forward arc.
+    bool checkBoundMaps() {
+      for (int j = 0; j != _res_arc_num; ++j) {
+        if (_forward[j] && _upper[j] < _lower[j]) return false;
+      }
+      return true;
+    }
     // Execute the algorithm and transform the results
     void start(Method method) {
+      // Maximum path length for partial augment
+      const int MAX_PATH_LENGTH = 4;
+      // Execute the algorithm
+      const int MAX_PARTIAL_PATH_LENGTH = 4;
       switch (method) {
         case PUSH:
 …
           break;
         case AUGMENT:
           startAugment();
+          startAugment(_res_node_num - 1);
           break;
         case PARTIAL_AUGMENT:
           startAugment(MAX_PATH_LENGTH);
+          startAugment(MAX_PARTIAL_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();
+      // Compute node potentials (dual solution)
+      for (int i = 0; i != _res_node_num; ++i) {
+        _pi[i] = static_cast<Cost>(_pi[i] / (_res_node_num * _alpha));
+      }
+      bool optimal = true;
+      for (int i = 0; optimal && i != _res_node_num; ++i) {
+        LargeCost pi_i = _pi[i];
+        int last_out = _first_out[i+1];
+        for (int j = _first_out[i]; j != last_out; ++j) {
+          if (_res_cap[j] > 0 && _scost[j] + pi_i - _pi[_target[j]] < 0) {
+            optimal = false;
+            break;
+          }
+        }
+      }
+      if (!optimal) {
+        // Compute node potentials for the original costs with BellmanFord
+        // (if it is necessary)
+        typedef std::pair<int, int> IntPair;
+        StaticDigraph sgr;
+        std::vector<IntPair> arc_vec;
+        std::vector<LargeCost> cost_vec;
+        LargeCostArcMap cost_map(cost_vec);
+        arc_vec.clear();
+        cost_vec.clear();
+        for (int j = 0; j != _res_arc_num; ++j) {
+          if (_res_cap[j] > 0) {
+            int u = _source[j], v = _target[j];
+            arc_vec.push_back(IntPair(u, v));
+            cost_vec.push_back(_scost[j] + _pi[u] - _pi[v]);
+          }
+        }
+        sgr.build(_res_node_num, arc_vec.begin(), arc_vec.end());
+        typename BellmanFord<StaticDigraph, LargeCostArcMap>::Create
+          bf(sgr, cost_map);
+        bf.init(0);
+        bf.start();
+        for (int i = 0; i != _res_node_num; ++i) {
+          _pi[i] += bf.dist(sgr.node(i));
+        }
+      }
+      // Shift potentials to meet the requirements of the GEQ type
+      // optimality conditions
+      LargeCost max_pot = _pi[_root];
+      for (int i = 0; i != _res_node_num; ++i) {
+        if (_pi[i] > max_pot) max_pot = _pi[i];
+      }
+      if (max_pot != 0) {
+        for (int i = 0; i != _res_node_num; ++i) {
+          _pi[i] -= max_pot;
+        }
+      }
       // Handle non-zero lower bounds
       if (_have_lower) {
+      if (_has_lower) {
         int limit = _first_out[_root];
         for (int j = 0; j != limit; ++j) {
+          if (!_forward[j]) _res_cap[j] += _lower[j];
+          if (_forward[j]) _res_cap[_reverse[j]] += _lower[j];
+        }
+      }
+    }
+    // Initialize a cost scaling phase
+    void initPhase() {
+      // Saturate arcs not satisfying the optimality condition
+      for (int u = 0; u != _res_node_num; ++u) {
+        int last_out = _first_out[u+1];
+        LargeCost pi_u = _pi[u];
+        for (int a = _first_out[u]; a != last_out; ++a) {
+          Value delta = _res_cap[a];
+          if (delta > 0) {
+            int v = _target[a];
+            if (_cost[a] + pi_u - _pi[v] < 0) {
+              _excess[u] -= delta;
+              _excess[v] += delta;
+              _res_cap[a] = 0;
+              _res_cap[_reverse[a]] += delta;
+            }
+          }
+        }
+      }
+      // Find active nodes (i.e. nodes with positive excess)
+      for (int u = 0; u != _res_node_num; ++u) {
+        if (_excess[u] > 0) _active_nodes.push_back(u);
+      }
+      // Initialize the next arcs
+      for (int u = 0; u != _res_node_num; ++u) {
+        _next_out[u] = _first_out[u];
+      }
+    }
+    // Price (potential) refinement heuristic
+    bool priceRefinement() {
+      // Stack for stroing the topological order
+      IntVector stack(_res_node_num);
+      int stack_top;
+      // Perform phases
+      while (topologicalSort(stack, stack_top)) {
+        // Compute node ranks in the acyclic admissible network and
+        // store the nodes in buckets
+        for (int i = 0; i != _res_node_num; ++i) {
+          _rank[i] = 0;
+        }
+        const int bucket_end = _root + 1;
+        for (int r = 0; r != _max_rank; ++r) {
+          _buckets[r] = bucket_end;
+        }
+        int top_rank = 0;
+        for ( ; stack_top >= 0; --stack_top) {
+          int u = stack[stack_top], v;
+          int rank_u = _rank[u];
+          LargeCost rc, pi_u = _pi[u];
+          int last_out = _first_out[u+1];
+          for (int a = _first_out[u]; a != last_out; ++a) {
+            if (_res_cap[a] > 0) {
+              v = _target[a];
+              rc = _cost[a] + pi_u - _pi[v];
+              if (rc < 0) {
+                LargeCost nrc = static_cast<LargeCost>((-rc - 0.5) / _epsilon);
+                if (nrc < LargeCost(_max_rank)) {
+                  int new_rank_v = rank_u + static_cast<int>(nrc);
+                  if (new_rank_v > _rank[v]) {
+                    _rank[v] = new_rank_v;
+                  }
+                }
+              }
+            }
+          }
+          if (rank_u > 0) {
+            top_rank = std::max(top_rank, rank_u);
+            int bfirst = _buckets[rank_u];
+            _bucket_next[u] = bfirst;
+            _bucket_prev[bfirst] = u;
+            _buckets[rank_u] = u;
+          }
+        }
+        // Check if the current flow is epsilon-optimal
+        if (top_rank == 0) {
+          return true;
+        }
+        // Process buckets in top-down order
+        for (int rank = top_rank; rank > 0; --rank) {
+          while (_buckets[rank] != bucket_end) {
+            // Remove the first node from the current bucket
+            int u = _buckets[rank];
+            _buckets[rank] = _bucket_next[u];
+            // Search the outgoing arcs of u
+            LargeCost rc, pi_u = _pi[u];
+            int last_out = _first_out[u+1];
+            int v, old_rank_v, new_rank_v;
+            for (int a = _first_out[u]; a != last_out; ++a) {
+              if (_res_cap[a] > 0) {
+                v = _target[a];
+                old_rank_v = _rank[v];
+                if (old_rank_v < rank) {
+                  // Compute the new rank of node v
+                  rc = _cost[a] + pi_u - _pi[v];
+                  if (rc < 0) {
+                    new_rank_v = rank;
+                  } else {
+                    LargeCost nrc = rc / _epsilon;
+                    new_rank_v = 0;
+                    if (nrc < LargeCost(_max_rank)) {
+                      new_rank_v = rank - 1 - static_cast<int>(nrc);
+                    }
+                  }
+                  // Change the rank of node v
+                  if (new_rank_v > old_rank_v) {
+                    _rank[v] = new_rank_v;
+                    // Remove v from its old bucket
+                    if (old_rank_v > 0) {
+                      if (_buckets[old_rank_v] == v) {
+                        _buckets[old_rank_v] = _bucket_next[v];
+                      } else {
+                        int pv = _bucket_prev[v], nv = _bucket_next[v];
+                        _bucket_next[pv] = nv;
+                        _bucket_prev[nv] = pv;
+                      }
+                    }
+                    // Insert v into its new bucket
+                    int nv = _buckets[new_rank_v];
+                    _bucket_next[v] = nv;
+                    _bucket_prev[nv] = v;
+                    _buckets[new_rank_v] = v;
+                  }
+                }
+              }
+            }
+            // Refine potential of node u
+            _pi[u] -= rank * _epsilon;
+          }
+        }
+      }
+      return false;
+    }
+    // Find and cancel cycles in the admissible network and
+    // determine topological order using DFS
+    bool topologicalSort(IntVector &stack, int &stack_top) {
+      const int MAX_CYCLE_CANCEL = 1;
+      BoolVector reached(_res_node_num, false);
+      BoolVector processed(_res_node_num, false);
+      IntVector pred(_res_node_num);
+      for (int i = 0; i != _res_node_num; ++i) {
+        _next_out[i] = _first_out[i];
+      }
+      stack_top = -1;
+      int cycle_cnt = 0;
+      for (int start = 0; start != _res_node_num; ++start) {
+        if (reached[start]) continue;
+        // Start DFS search from this start node
+        pred[start] = -1;
+        int tip = start, v;
+        while (true) {
+          // Check the outgoing arcs of the current tip node
+          reached[tip] = true;
+          LargeCost pi_tip = _pi[tip];
+          int a, last_out = _first_out[tip+1];
+          for (a = _next_out[tip]; a != last_out; ++a) {
+            if (_res_cap[a] > 0) {
+              v = _target[a];
+              if (_cost[a] + pi_tip - _pi[v] < 0) {
+                if (!reached[v]) {
+                  // A new node is reached
+                  reached[v] = true;
+                  pred[v] = tip;
+                  _next_out[tip] = a;
+                  tip = v;
+                  a = _next_out[tip];
+                  last_out = _first_out[tip+1];
+                  break;
+                }
+                else if (!processed[v]) {
+                  // A cycle is found
+                  ++cycle_cnt;
+                  _next_out[tip] = a;
+                  // Find the minimum residual capacity along the cycle
+                  Value d, delta = _res_cap[a];
+                  int u, delta_node = tip;
+                  for (u = tip; u != v; ) {
+                    u = pred[u];
+                    d = _res_cap[_next_out[u]];
+                    if (d <= delta) {
+                      delta = d;
+                      delta_node = u;
+                    }
+                  }
+                  // Augment along the cycle
+                  _res_cap[a] -= delta;
+                  _res_cap[_reverse[a]] += delta;
+                  for (u = tip; u != v; ) {
+                    u = pred[u];
+                    int ca = _next_out[u];
+                    _res_cap[ca] -= delta;
+                    _res_cap[_reverse[ca]] += delta;
+                  }
+                  // Check the maximum number of cycle canceling
+                  if (cycle_cnt >= MAX_CYCLE_CANCEL) {
+                    return false;
+                  }
+                  // Roll back search to delta_node
+                  if (delta_node != tip) {
+                    for (u = tip; u != delta_node; u = pred[u]) {
+                      reached[u] = false;
+                    }
+                    tip = delta_node;
+                    a = _next_out[tip] + 1;
+                    last_out = _first_out[tip+1];
+                    break;
+                  }
+                }
+              }
+            }
+          }
+          // Step back to the previous node
+          if (a == last_out) {
+            processed[tip] = true;
+            stack[++stack_top] = tip;
+            tip = pred[tip];
+            if (tip < 0) {
+              // Finish DFS from the current start node
+              break;
+            }
+            ++_next_out[tip];
+          }
+        }
+      }
+      return (cycle_cnt == 0);
+    }
+    // Global potential update heuristic
+    void globalUpdate() {
+      const int bucket_end = _root + 1;
+      // Initialize buckets
+      for (int r = 0; r != _max_rank; ++r) {
+        _buckets[r] = bucket_end;
+      }
+      Value total_excess = 0;
+      int b0 = bucket_end;
+      for (int i = 0; i != _res_node_num; ++i) {
+        if (_excess[i] < 0) {
+          _rank[i] = 0;
+          _bucket_next[i] = b0;
+          _bucket_prev[b0] = i;
+          b0 = i;
+        } else {
+          total_excess += _excess[i];
+          _rank[i] = _max_rank;
+        }
+      }
+      if (total_excess == 0) return;
+      _buckets[0] = b0;
+      // Search the buckets
+      int r = 0;
+      for ( ; r != _max_rank; ++r) {
+        while (_buckets[r] != bucket_end) {
+          // Remove the first node from the current bucket
+          int u = _buckets[r];
+          _buckets[r] = _bucket_next[u];
+          // Search the incoming arcs of u
+          LargeCost pi_u = _pi[u];
+          int last_out = _first_out[u+1];
+          for (int a = _first_out[u]; a != last_out; ++a) {
+            int ra = _reverse[a];
+            if (_res_cap[ra] > 0) {
+              int v = _source[ra];
+              int old_rank_v = _rank[v];
+              if (r < old_rank_v) {
+                // Compute the new rank of v
+                LargeCost nrc = (_cost[ra] + _pi[v] - pi_u) / _epsilon;
+                int new_rank_v = old_rank_v;
+                if (nrc < LargeCost(_max_rank)) {
+                  new_rank_v = r + 1 + static_cast<int>(nrc);
+                }
+                // Change the rank of v
+                if (new_rank_v < old_rank_v) {
+                  _rank[v] = new_rank_v;
+                  _next_out[v] = _first_out[v];
+                  // Remove v from its old bucket
+                  if (old_rank_v < _max_rank) {
+                    if (_buckets[old_rank_v] == v) {
+                      _buckets[old_rank_v] = _bucket_next[v];
+                    } else {
+                      int pv = _bucket_prev[v], nv = _bucket_next[v];
+                      _bucket_next[pv] = nv;
+                      _bucket_prev[nv] = pv;
+                    }
+                  }
+                  // Insert v into its new bucket
+                  int nv = _buckets[new_rank_v];
+                  _bucket_next[v] = nv;
+                  _bucket_prev[nv] = v;
+                  _buckets[new_rank_v] = v;
+                }
+              }
+            }
+          }
+          // Finish search if there are no more active nodes
+          if (_excess[u] > 0) {
+            total_excess -= _excess[u];
+            if (total_excess <= 0) break;
+          }
+        }
+        if (total_excess <= 0) break;
+      }
+      // Relabel nodes
+      for (int u = 0; u != _res_node_num; ++u) {
+        int k = std::min(_rank[u], r);
+        if (k > 0) {
+          _pi[u] -= _epsilon * k;
+          _next_out[u] = _first_out[u];
+        }
+      }
 …
     /// Execute the algorithm performing augment and relabel operations
     void startAugment(int max_length = std::numeric_limits<int>::max()) {
+    void startAugment(int max_length) {
       // Paramters for heuristics
+      const int BF_HEURISTIC_EPSILON_BOUND = 1000;
+      const int BF_HEURISTIC_BOUND_FACTOR  = 3;
+      const int PRICE_REFINEMENT_LIMIT = 2;
+      const double GLOBAL_UPDATE_FACTOR = 1.0;
+      const int global_update_skip = static_cast<int>(GLOBAL_UPDATE_FACTOR *
+        (_res_node_num + _sup_node_num * _sup_node_num));
+      int next_global_update_limit = global_update_skip;
       // Perform cost scaling phases
+      IntVector pred_arc(_res_node_num);
+      std::vector<int> path_nodes;
+      IntVector path;
+      BoolVector path_arc(_res_arc_num, false);
+      int relabel_cnt = 0;
+      int eps_phase_cnt = 0;
       for ( ; _epsilon >= 1; _epsilon = _epsilon < _alpha && _epsilon > 1 ?
 : _epsilon / _alpha )
+      {
+        // "Early Termination" heuristic: use Bellman-Ford algorithm
+        // to check if the current flow is optimal
+        if (_epsilon <= BF_HEURISTIC_EPSILON_BOUND) {
+          _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());
+          BellmanFord<StaticDigraph, LargeCostArcMap> bf(_sgr, _cost_map);
+          bf.init(0);
+          bool done = false;
+          int K = int(BF_HEURISTIC_BOUND_FACTOR * sqrt(_res_node_num));
+          for (int i = 0; i < K && !done; ++i)
+            done = bf.processNextWeakRound();
+          if (done) break;
+        }
+        // Saturate arcs not satisfying the optimality condition
+        for (int a = 0; a != _res_arc_num; ++a) {
+          if (_res_cap[a] > 0 &&
+              _cost[a] + _pi[_source[a]] - _pi[_target[a]] < 0) {
+            Value delta = _res_cap[a];
+            _excess[_source[a]] -= delta;
+            _excess[_target[a]] += 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];
+        }
+        ++eps_phase_cnt;
+        // Price refinement heuristic
+        if (eps_phase_cnt >= PRICE_REFINEMENT_LIMIT) {
+          if (priceRefinement()) continue;
+        }
+        // Initialize current phase
+        initPhase();
         // Perform partial augment and relabel operations
 …
           if (_active_nodes.size() == 0) break;
           int start = _active_nodes.front();
-          path_nodes.clear();
-          path_nodes.push_back(start);
           // Find an augmenting path from the start node
           int tip = start;
+          while (_excess[tip] >= 0 &&
+                 int(path_nodes.size()) <= max_length) {
+          while (int(path.size()) < max_length && _excess[tip] >= 0) {
             int u;
             LargeCost min_red_cost, rc;
             int last_out = _sum_supply < 0 ?
               _first_out[tip+1] : _first_out[tip+1] - 1;
+            LargeCost rc, min_red_cost = std::numeric_limits<LargeCost>::max();
+            LargeCost pi_tip = _pi[tip];
+            int last_out = _first_out[tip+1];
             for (int a = _next_out[tip]; a != last_out; ++a) {
+              if (_res_cap[a] > 0 &&
+                  _cost[a] + _pi[_source[a]] - _pi[_target[a]] < 0) {
+              if (_res_cap[a] > 0) {
                 u = _target[a];
+                pred_arc[u] = a;
+                _next_out[tip] = a;
+                tip = u;
+                path_nodes.push_back(tip);
+                goto next_step;
+                rc = _cost[a] + pi_tip - _pi[u];
+                if (rc < 0) {
+                  path.push_back(a);
+                  _next_out[tip] = a;
+                  if (path_arc[a]) {
+                    goto augment;   // a cycle is found, stop path search
+                  }
+                  tip = u;
+                  path_arc[a] = true;
+                  goto next_step;
+                }
+                else if (rc < min_red_cost) {
+                  min_red_cost = rc;
+                }
+              }
+            }
             // Relabel tip node
+            min_red_cost = std::numeric_limits<LargeCost>::max() / 2;
+            if (tip != start) {
+              int ra = _reverse[path.back()];
+              min_red_cost =
+                std::min(min_red_cost, _cost[ra] + pi_tip - _pi[_target[ra]]);
+            }
+            last_out = _next_out[tip];
             for (int a = _first_out[tip]; a != last_out; ++a) {
+              rc = _cost[a] + _pi[_source[a]] - _pi[_target[a]];
+              if (_res_cap[a] > 0 && rc < min_red_cost) {
+                min_red_cost = rc;
+              if (_res_cap[a] > 0) {
+                rc = _cost[a] + pi_tip - _pi[_target[a]];
+                if (rc < min_red_cost) {
+                  min_red_cost = rc;
+                }
+              }
+            }
             _pi[tip] -= min_red_cost + _epsilon;
-            // Reset the next arc of tip
             _next_out[tip] = _first_out[tip];
+            ++relabel_cnt;
             // Step back
             if (tip != start) {
+              path_nodes.pop_back();
+              tip = path_nodes.back();
+              int pa = path.back();
+              path_arc[pa] = false;
+              tip = _source[pa];
+              path.pop_back();
+            }
 …
           // Augment along the found path (as much flow as possible)
+        augment:
           Value delta;
+          int u, v = path_nodes.front(), pa;
+          for (int i = 1; i < int(path_nodes.size()); ++i) {
+          int pa, u, v = start;
+          for (int i = 0; i != int(path.size()); ++i) {
+            pa = path[i];
             u = v;
             v = path_nodes[i];
             pa = pred_arc[v];
+            v = _target[pa];
+            path_arc[pa] = false;
             delta = std::min(_res_cap[pa], _excess[u]);
             _res_cap[pa] -= delta;
 …
             _excess[u] -= delta;
             _excess[v] += delta;
             if (_excess[v] > 0 && _excess[v] <= delta)
+            if (_excess[v] > 0 && _excess[v] <= delta) {
               _active_nodes.push_back(v);
+          }
+        }
+      }
+            }
+          }
+          path.clear();
+          // Global update heuristic
+          if (relabel_cnt >= next_global_update_limit) {
+            globalUpdate();
+            next_global_update_limit += global_update_skip;
+          }
+        }
+      }
+    }
 …
     void startPush() {
       // Paramters for heuristics
+      const int BF_HEURISTIC_EPSILON_BOUND = 1000;
+      const int BF_HEURISTIC_BOUND_FACTOR  = 3;
+      const int PRICE_REFINEMENT_LIMIT = 2;
+      const double GLOBAL_UPDATE_FACTOR = 2.0;
+      const int global_update_skip = static_cast<int>(GLOBAL_UPDATE_FACTOR *
+        (_res_node_num + _sup_node_num * _sup_node_num));
+      int next_global_update_limit = global_update_skip;
       // Perform cost scaling phases
       BoolVector hyper(_res_node_num, false);
+      LargeCostVector hyper_cost(_res_node_num);
+      int relabel_cnt = 0;
+      int eps_phase_cnt = 0;
       for ( ; _epsilon >= 1; _epsilon = _epsilon < _alpha && _epsilon > 1 ?
 : _epsilon / _alpha )
+      {
+        // "Early Termination" heuristic: use Bellman-Ford algorithm
+        // to check if the current flow is optimal
+        if (_epsilon <= BF_HEURISTIC_EPSILON_BOUND) {
+          _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());
+          BellmanFord<StaticDigraph, LargeCostArcMap> bf(_sgr, _cost_map);
+          bf.init(0);
+          bool done = false;
+          int K = int(BF_HEURISTIC_BOUND_FACTOR * sqrt(_res_node_num));
+          for (int i = 0; i < K && !done; ++i)
+            done = bf.processNextWeakRound();
+          if (done) break;
+        }
+        // Saturate arcs not satisfying the optimality condition
+        for (int a = 0; a != _res_arc_num; ++a) {
+          if (_res_cap[a] > 0 &&
+              _cost[a] + _pi[_source[a]] - _pi[_target[a]] < 0) {
+            Value delta = _res_cap[a];
+            _excess[_source[a]] -= delta;
+            _excess[_target[a]] += 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];
+        }
+        ++eps_phase_cnt;
+        // Price refinement heuristic
+        if (eps_phase_cnt >= PRICE_REFINEMENT_LIMIT) {
+          if (priceRefinement()) continue;
+        }
+        // Initialize current phase
+        initPhase();
         // Perform push and relabel operations
         while (_active_nodes.size() > 0) {
           LargeCost min_red_cost, rc;
+          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)
-        next_node:
           n = _active_nodes.front();
           last_out = _sum_supply < 0 ?
             _first_out[n+1] : _first_out[n+1] - 1;
+          last_out = _first_out[n+1];
+          pi_n = _pi[n];
           // Perform push operations if there are admissible arcs
 …
             for (a = _next_out[n]; a != last_out; ++a) {
               if (_res_cap[a] > 0 &&
                   _cost[a] + _pi[_source[a]] - _pi[_target[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 = _sum_supply < 0 ?
                   _first_out[t+1] : _first_out[t+1] - 1;
+                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[_source[ta]] - _pi[_target[ta]] < 0)
+                  if (_res_cap[ta] > 0 &&
+                      _cost[ta] + pi_t - _pi[_target[ta]] < 0)
                     ahead += _res_cap[ta];
                   if (ahead >= delta) break;
 …
                 // Push flow along the arc
                 if (ahead < delta) {
+                if (ahead < delta && !hyper[t]) {
                   _res_cap[a] -= ahead;
                   _res_cap[_reverse[a]] += 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;
 …
           // Relabel the node if it is still active (or hyper)
           if (_excess[n] > 0 || hyper[n]) {
+            min_red_cost = std::numeric_limits<LargeCost>::max() / 2;
+             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[_source[a]] - _pi[_target[a]];
+              if (_res_cap[a] > 0 && rc < min_red_cost) {
+                min_red_cost = rc;
+              if (_res_cap[a] > 0) {
+                rc = _cost[a] + pi_n - _pi[_target[a]];
+                if (rc < min_red_cost) {
+                  min_red_cost = rc;
+                }
+              }
+            }
             _pi[n] -= min_red_cost + _epsilon;
+            _next_out[n] = _first_out[n];
             hyper[n] = false;
+            // Reset the next arc
+            _next_out[n] = _first_out[n];
+          }
+            ++relabel_cnt;
+          }
           // Remove nodes that are not active nor hyper
         remove_nodes:
 …
             _active_nodes.pop_front();
+          }
+          // Global update heuristic
+          if (relabel_cnt >= next_global_update_limit) {
+            globalUpdate();
+            for (int u = 0; u != _res_node_num; ++u)
+              hyper[u] = false;
+            next_global_update_limit += global_update_skip;
+          }
+        }
+      }

lemon/counter.h

r833	r1327
22	22	#include <string>
23	23	#include <iostream>
	24
	25	#include <lemon/core.h>
24	26
25	27	///\ingroup timecount

lemon/cplex.cc

-                      r793
+                      r1347
  * This file is a part of LEMON, a generic C++ optimization library.
+ *
  * Copyright (C) 2003-2009
+ * Copyright (C) 2003-2013
  * Egervary Jeno Kombinatorikus Optimalizalasi Kutatocsoport
  * (Egervary Research Group on Combinatorial Optimization, EGRES).
 …
+  }
+  void CplexEnv::incCnt()
+  {
+    _cnt_lock->lock();
+    ++(*_cnt);
+    _cnt_lock->unlock();
+  }
+  void CplexEnv::decCnt()
+  {
+    _cnt_lock->lock();
+    --(*_cnt);
+    if (*_cnt == 0) {
+      delete _cnt;
+      _cnt_lock->unlock();
+      delete _cnt_lock;
+      CPXcloseCPLEX(&_env);
+    }
+    else _cnt_lock->unlock();
+  }
   CplexEnv::CplexEnv() {
     int status;
+    _env = CPXopenCPLEX(&status);
+    if (_env == 0)
+      throw LicenseError(status);
     _cnt = new int;
+    _env = CPXopenCPLEX(&status);
+    if (_env == 0) {
+      delete _cnt;
+      _cnt = 0;
+      throw LicenseError(status);
+    }
+    (*_cnt) = 1;
+    _cnt_lock = new bits::Lock;
+  }
 …
     _env = other._env;
     _cnt = other._cnt;
+    ++(*_cnt);
+    _cnt_lock = other._cnt_lock;
+    incCnt();
+  }
   CplexEnv& CplexEnv::operator=(const CplexEnv& other) {
+    decCnt();
     _env = other._env;
     _cnt = other._cnt;
+    ++(*_cnt);
+    _cnt_lock = other._cnt_lock;
+    incCnt();
     return *this;
+  }
   CplexEnv::~CplexEnv() {
+    --(*_cnt);
+    if (*_cnt == 0) {
+      delete _cnt;
+      CPXcloseCPLEX(&_env);
+    }
+    decCnt();
+  }
 …
+  }
   int CplexBase::_addRow(Value lb, ExprIterator b,
+  int CplexBase::_addRow(Value lb, ExprIterator b,
                          ExprIterator e, Value ub) {
     int i = CPXgetnumrows(cplexEnv(), _prob);
 …
     int status;
     _prob = CPXcreateprob(cplexEnv(), &status, "Cplex problem");
-    rows.clear();
-    cols.clear();
+  }
 …
   void CplexBase::_applyMessageLevel() {
     CPXsetintparam(cplexEnv(), CPX_PARAM_SCRIND,
+    CPXsetintparam(cplexEnv(), CPX_PARAM_SCRIND,
                    _message_enabled ? CPX_ON : CPX_OFF);
+  }
+  void CplexBase::_write(std::string file, std::string format) const
+  {
+    if(format == "MPS" || format == "LP")
+      CPXwriteprob(cplexEnv(), cplexLp(), file.c_str(), format.c_str());
+    else if(format == "SOL")
+      CPXsolwrite(cplexEnv(), cplexLp(), file.c_str());
+    else throw UnsupportedFormatError(format);
+  }
   // CplexLp members

lemon/cplex.h

-                      r793
+                      r1347
  * This file is a part of LEMON, a generic C++ optimization library.
+ *
  * Copyright (C) 2003-2009
+ * Copyright (C) 2003-2013
  * Egervary Jeno Kombinatorikus Optimalizalasi Kutatocsoport
  * (Egervary Research Group on Combinatorial Optimization, EGRES).
 …
 #include <lemon/lp_base.h>
+#include <lemon/bits/lock.h>
 struct cpxenv;
 …
     cpxenv* _env;
     mutable int* _cnt;
+    mutable bits::Lock* _cnt_lock;
+    void incCnt();
+    void decCnt();
   public:
 …
     bool _message_enabled;
+    void _write(std::string file, std::string format) const;
   public:
 …
     const cpxlp* cplexLp() const { return _prob; }
+#ifdef DOXYGEN
+    /// Write the problem or the solution to a file in the given format
+    /// This function writes the problem or the solution
+    /// to a file in the given format.
+    /// Trying to write in an unsupported format will trigger
+    /// \ref lemon::LpBase::UnsupportedFormatError "UnsupportedFormatError".
+    /// \param file The file path
+    /// \param format The output file format.
+    /// Supportted formats are "MPS", "LP" and "SOL".
+    void write(std::string file, std::string format = "MPS") const {}
+#endif
   };

lemon/cycle_canceling.h

-                      r886
+                      r1298
 /* -*- C++ -*-
+/* -*- mode: C++; indent-tabs-mode: nil; -*-
+ *
  * This file is a part of LEMON, a generic C++ optimization library
+ * This file is a part of LEMON, a generic C++ optimization library.
+ *
  * Copyright (C) 2003-2008
+ * Copyright (C) 2003-2013
  * Egervary Jeno Kombinatorikus Optimalizalasi Kutatocsoport
  * (Egervary Research Group on Combinatorial Optimization, EGRES).
 …
 #include <lemon/circulation.h>
 #include <lemon/bellman_ford.h>
+#include <lemon/howard.h>
+#include <lemon/howard_mmc.h>
+#include <lemon/hartmann_orlin_mmc.h>
 namespace lemon {
 …
   /// \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.
+  /// \cite amo93networkflows, \cite klein67primal,
+  /// \cite goldberg89cyclecanceling.
+  /// The most efficent one is the \ref CANCEL_AND_TIGHTEN
+  /// "Cancel-and-Tighten" algorithm, thus it is the default method.
+  /// It runs in strongly polynomial time \f$O(n^2 m^2 \log n)\f$,
+  /// but in practice, it is typically orders of magnitude slower than
+  /// the scaling algorithms and \ref NetworkSimplex.
+  /// (For more information, see \ref min_cost_flow_algs "the module page".)
   ///
   /// Most of the parameters of the problem (except for the digraph)
 …
   /// algorithm. By default, it is the same as \c V.
   ///
+  /// \warning Both number types must be signed and all input data must
+  /// \warning Both \c V and \c C must be signed number types.
+  /// \warning All input data (capacities, supply values, and costs) must
   /// be integer.
   /// \warning This algorithm does not support negative costs for such
   /// arcs that have infinite upper bound.
+  /// \warning This algorithm does not support negative costs for
+  /// arcs having infinite upper bound.
   ///
   /// \note For more information about the three available methods,
 …
     ///
     /// \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.
+    /// methods. By default, \ref CANCEL_AND_TIGHTEN "Cancel-and-Tighten"
+    /// is used, which is by far the most efficient and the most robust.
     /// However, the other methods can be selected using the \ref run()
     /// function with the proper parameter.
     enum Method {
       /// A simple cycle-canceling method, which uses the
+      /// \ref BellmanFord "Bellman-Ford" algorithm with limited iteration
+      /// number for detecting negative cycles in the residual network.
+      /// \ref BellmanFord "Bellman-Ford" algorithm for detecting negative
+      /// cycles in the residual network.
+      /// The number of Bellman-Ford iterations is bounded by a successively
+      /// increased limit.
       SIMPLE_CYCLE_CANCELING,
       /// The "Minimum Mean Cycle-Canceling" algorithm, which is a
       /// well-known strongly polynomial method
       /// \ref goldberg89cyclecanceling. It improves along a
+      /// \cite 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)).
+      /// Its running time complexity is \f$O(n^2 m^3 \log n)\f$.
       MINIMUM_MEAN_CYCLE_CANCELING,
       /// The "Cancel And Tighten" algorithm, which can be viewed as an
+      /// The "Cancel-and-Tighten" algorithm, which can be viewed as an
       /// improved version of the previous method
       /// \ref goldberg89cyclecanceling.
+      /// \cite 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)).
+      /// complexity is \f$O(n^2 m^2 \log n)\f$.
       CANCEL_AND_TIGHTEN
     };
 …
     TEMPLATE_DIGRAPH_TYPEDEFS(GR);
     typedef std::vector<int> IntVector;
-    typedef std::vector<char> CharVector;
     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 {
 …
       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)];
 …
         return _v[StaticDigraph::id(key)];
+      }
       void set(const Key& key, const Value& val) {
         _v[StaticDigraph::id(key)] = val;
 …
     // Parameters of the problem
     bool _have_lower;
+    bool _has_lower;
     Value _sum_supply;
 …
     IntArcMap _arc_idb;
     IntVector _first_out;
     CharVector _forward;
+    BoolVector _forward;
     IntVector _source;
     IntVector _target;
 …
     CostArcMap _cost_map;
     CostNodeMap _pi_map;
   public:
     /// \brief Constant for infinite upper bounds (capacities).
     ///
 …
         "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) {
+      _has_lower = true;
+      for (ArcIt a(_graph); a != INVALID; ++a) {
+        _lower[_arc_idf[a]] = map[a];
+      }
+      return *this;
+    }
+    /// \brief Set the upper bounds (capacities) on the arcs.
+    ///
+    /// This function sets the upper bounds (capacities) on the arcs.
+    /// If it is not used before calling \ref run(), the upper bounds
+    /// will be set to \ref INF on all arcs (i.e. the flow value will be
+    /// unbounded from above).
+    ///
+    /// \param map An arc map storing the upper bounds.
+    /// Its \c Value type must be convertible to the \c Value type
+    /// of the algorithm.
+    ///
+    /// \return <tt>(*this)</tt>
+    template<typename UpperMap>
+    CycleCanceling& upperMap(const UpperMap& map) {
+      for (ArcIt a(_graph); a != INVALID; ++a) {
+        _upper[_arc_idf[a]] = map[a];
+      }
+      return *this;
+    }
+    /// \brief Set the costs of the arcs.
+    ///
+    /// This function sets the costs of the arcs.
+    /// If it is not used before calling \ref run(), the costs
+    /// will be set to \c 1 on all arcs.
+    ///
+    /// \param map An arc map storing the costs.
+    /// Its \c Value type must be convertible to the \c Cost type
+    /// of the algorithm.
+    ///
+    /// \return <tt>(*this)</tt>
+    template<typename CostMap>
+    CycleCanceling& costMap(const CostMap& map) {
+      for (ArcIt a(_graph); a != INVALID; ++a) {
+        _cost[_arc_idf[a]] =  map[a];
+        _cost[_arc_idb[a]] = -map[a];
+      }
+      return *this;
+    }
+    /// \brief Set the supply values of the nodes.
+    ///
+    /// This function sets the supply values of the nodes.
+    /// If neither this function nor \ref stSupply() is used before
+    /// calling \ref run(), the supply of each node will be set to zero.
+    ///
+    /// \param map A node map storing the supply values.
+    /// Its \c Value type must be convertible to the \c Value type
+    /// of the algorithm.
+    ///
+    /// \return <tt>(*this)</tt>
+    template<typename SupplyMap>
+    CycleCanceling& supplyMap(const SupplyMap& map) {
+      for (NodeIt n(_graph); n != INVALID; ++n) {
+        _supply[_node_id[n]] = map[n];
+      }
+      return *this;
+    }
+    /// \brief Set single source and target nodes and a supply value.
+    ///
+    /// This function sets a single source node and a single target node
+    /// and the required flow value.
+    /// If neither this function nor \ref supplyMap() is used before
+    /// calling \ref run(), the supply of each node will be set to zero.
+    ///
+    /// Using this function has the same effect as using \ref supplyMap()
+    /// with a map in which \c k is assigned to \c s, \c -k is
+    /// assigned to \c t and all other nodes have zero supply value.
+    ///
+    /// \param s The source node.
+    /// \param t The target node.
+    /// \param k The required amount of flow from node \c s to node \c t
+    /// (i.e. the supply of \c s and the demand of \c t).
+    ///
+    /// \return <tt>(*this)</tt>
+    CycleCanceling& stSupply(const Node& s, const Node& t, Value k) {
+      for (int i = 0; i != _res_node_num; ++i) {
+        _supply[i] = 0;
+      }
+      _supply[_node_id[s]] =  k;
+      _supply[_node_id[t]] = -k;
+      return *this;
+    }
+    /// @}
+    /// \name Execution control
+    /// The algorithm can be executed using \ref run().
+    /// @{
+    /// \brief Run the algorithm.
+    ///
+    /// This function runs the algorithm.
+    /// The paramters can be specified using functions \ref lowerMap(),
+    /// \ref upperMap(), \ref costMap(), \ref supplyMap(), \ref stSupply().
+    /// For example,
+    /// \code
+    ///   CycleCanceling<ListDigraph> cc(graph);
+    ///   cc.lowerMap(lower).upperMap(upper).costMap(cost)
+    ///     .supplyMap(sup).run();
+    /// \endcode
+    ///
+    /// This function can be called more than once. All the given parameters
+    /// are kept for the next call, unless \ref resetParams() or \ref reset()
+    /// is used, thus only the modified parameters have to be set again.
+    /// If the underlying digraph was also modified after the construction
+    /// of the class (or the last \ref reset() call), then the \ref reset()
+    /// function must be called.
+    ///
+    /// \param method The cycle-canceling method that will be used.
+    /// For more information, see \ref Method.
+    ///
+    /// \return \c INFEASIBLE if no feasible flow exists,
+    /// \n \c OPTIMAL if the problem has optimal solution
+    /// (i.e. it is feasible and bounded), and the algorithm has found
+    /// optimal flow and node potentials (primal and dual solutions),
+    /// \n \c UNBOUNDED if the digraph contains an arc of negative cost
+    /// and infinite upper bound. It means that the objective function
+    /// is unbounded on that arc, however, note that it could actually be
+    /// bounded over the feasible flows, but this algroithm cannot handle
+    /// these cases.
+    ///
+    /// \see ProblemType, Method
+    /// \see resetParams(), reset()
+    ProblemType run(Method method = CANCEL_AND_TIGHTEN) {
+      ProblemType pt = init();
+      if (pt != OPTIMAL) return pt;
+      start(method);
+      return OPTIMAL;
+    }
+    /// \brief Reset all the parameters that have been given before.
+    ///
+    /// This function resets all the paramaters that have been given
+    /// before using functions \ref lowerMap(), \ref upperMap(),
+    /// \ref costMap(), \ref supplyMap(), \ref stSupply().
+    ///
+    /// It is useful for multiple \ref run() calls. Basically, all the given
+    /// parameters are kept for the next \ref run() call, unless
+    /// \ref resetParams() or \ref reset() is used.
+    /// If the underlying digraph was also modified after the construction
+    /// of the class or the last \ref reset() call, then the \ref reset()
+    /// function must be used, otherwise \ref resetParams() is sufficient.
+    ///
+    /// For example,
+    /// \code
+    ///   CycleCanceling<ListDigraph> cs(graph);
+    ///
+    ///   // First run
+    ///   cc.lowerMap(lower).upperMap(upper).costMap(cost)
+    ///     .supplyMap(sup).run();
+    ///
+    ///   // Run again with modified cost map (resetParams() is not called,
+    ///   // so only the cost map have to be set again)
+    ///   cost[e] += 100;
+    ///   cc.costMap(cost).run();
+    ///
+    ///   // Run again from scratch using resetParams()
+    ///   // (the lower bounds will be set to zero on all arcs)
+    ///   cc.resetParams();
+    ///   cc.upperMap(capacity).costMap(cost)
+    ///     .supplyMap(sup).run();
+    /// \endcode
+    ///
+    /// \return <tt>(*this)</tt>
+    ///
+    /// \see reset(), run()
+    CycleCanceling& resetParams() {
+      for (int i = 0; i != _res_node_num; ++i) {
+        _supply[i] = 0;
+      }
+      int limit = _first_out[_root];
+      for (int j = 0; j != limit; ++j) {
+        _lower[j] = 0;
+        _upper[j] = INF;
+        _cost[j] = _forward[j] ? 1 : -1;
+      }
+      for (int j = limit; j != _res_arc_num; ++j) {
+        _lower[j] = 0;
+        _upper[j] = INF;
+        _cost[j] = 0;
+        _cost[_reverse[j]] = 0;
+      }
+      _has_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);
 …
       _cost.resize(_res_arc_num);
       _supply.resize(_res_node_num);
       _res_cap.resize(_res_arc_num);
       _pi.resize(_res_node_num);
 …
         _reverse[bi] = fi;
+      }
       // Reset parameters
+      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 parameters
+    /// that have been given are kept for the next call, unless
+    /// \ref reset() is called, thus only the modified parameters
+    /// have to be set again. See \ref reset() for examples.
+    /// However, the underlying digraph must not be modified after this
+    /// class have been constructed, since it copies and extends the graph.
+    ///
+    /// \param 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
+    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 run() calls. If this function is not
+    /// used, all the parameters given before are kept for the next
+    /// \ref run() call.
+    /// However, the underlying digraph must not be modified after this
+    /// class have been constructed, since it copies and extends the graph.
+    ///
+    /// For example,
+    /// \code
+    ///   CycleCanceling<ListDigraph> cs(graph);
+    ///
+    ///   // First run
+    ///   cc.lowerMap(lower).upperMap(upper).costMap(cost)
+    ///     .supplyMap(sup).run();
+    ///
+    ///   // Run again with modified cost map (reset() 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 reset()
+    ///   // (the lower bounds will be set to zero on all arcs)
+    ///   cc.reset();
+    ///   cc.upperMap(capacity).costMap(cost)
+    ///     .supplyMap(sup).run();
+    /// \endcode
+    ///
+    /// \return <tt>(*this)</tt>
+    CycleCanceling& reset() {
+      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;
+      resetParams();
       return *this;
+    }
 …
     ///
     /// This function returns the total cost of the found flow.
     /// Its complexity is O(e).
+    /// Its complexity is O(m).
     ///
     /// \note The return type of the function can be specified as a
 …
+    }
+    /// \brief Return the flow map (the primal solution).
+    /// \brief Copy the flow values (the primal solution) into the
+    /// given map.
     ///
     /// This function copies the flow value on each arc into the given
 …
+    }
+    /// \brief Return the potential map (the dual solution).
+    /// \brief Copy the potential values (the dual solution) into the
+    /// given map.
     ///
     /// This function copies the potential (dual value) of each node
 …
+      }
       if (_sum_supply > 0) return INFEASIBLE;
+      // Check lower and upper bounds
+      LEMON_DEBUG(checkBoundMaps(),
+          "Upper bounds must be greater or equal to the lower bounds");
       // Initialize vectors
 …
+      }
       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) {
+      if (_has_lower) {
         for (int i = 0; i != _root; ++i) {
           last_out = _first_out[i+1];
 …
         sup[n] = _supply[_node_id[n]];
+      }
       if (_have_lower) {
+      if (_has_lower) {
         for (ArcIt a(_graph); a != INVALID; ++a) {
           int j = _arc_idf[a];
 …
+        }
+      }
       return OPTIMAL;
+    }
+    // Check if the upper bound is greater than or equal to the lower bound
+    // on each forward arc.
+    bool checkBoundMaps() {
+      for (int j = 0; j != _res_arc_num; ++j) {
+        if (_forward[j] && _upper[j] < _lower[j]) return false;
+      }
+      return true;
+    }
     // Build a StaticDigraph structure containing the current
     // residual network
 …
       // Handle non-zero lower bounds
       if (_have_lower) {
+      if (_has_lower) {
         int limit = _first_out[_root];
         for (int j = 0; j != limit; ++j) {
           if (!_forward[j]) _res_cap[j] += _lower[j];
+          if (_forward[j]) _res_cap[_reverse[j]] += _lower[j];
+        }
+      }
 …
       const int BF_FIRST_LIMIT  = 2;
       const double BF_LIMIT_FACTOR = 1.5;
       typedef StaticVectorMap<StaticDigraph::Arc, Value> FilterMap;
       typedef FilterArcs<StaticDigraph, FilterMap> ResDigraph;
 …
         ::template SetDistMap<CostNodeMap>
         ::template SetPredMap<PredMap>::Create BF;
       // Build the residual network
       _arc_vec.clear();
 …
     // Execute the "Minimum Mean Cycle Canceling" method
     void startMinMeanCycleCanceling() {
       typedef SimplePath<StaticDigraph> SPath;
+      typedef Path<StaticDigraph> SPath;
       typedef typename SPath::ArcIt SPathArcIt;
+      typedef typename Howard<StaticDigraph, CostArcMap>
+        ::template SetPath<SPath>::Create MMC;
+      typedef typename HowardMmc<StaticDigraph, CostArcMap>
+        ::template SetPath<SPath>::Create HwMmc;
+      typedef typename HartmannOrlinMmc<StaticDigraph, CostArcMap>
+        ::template SetPath<SPath>::Create HoMmc;
+      const double HW_ITER_LIMIT_FACTOR = 1.0;
+      const int HW_ITER_LIMIT_MIN_VALUE = 5;
+      const int hw_iter_limit =
+          std::max(static_cast<int>(HW_ITER_LIMIT_FACTOR * _node_num),
+                   HW_ITER_LIMIT_MIN_VALUE);
       SPath cycle;
       MMC mmc(_sgr, _cost_map);
       mmc.cycle(cycle);
+      HwMmc hw_mmc(_sgr, _cost_map);
+      hw_mmc.cycle(cycle);
       buildResidualNetwork();
+      while (mmc.findMinMean() && mmc.cycleLength() < 0) {
+        // Find the cycle
+        mmc.findCycle();
+      while (true) {
+        typename HwMmc::TerminationCause hw_tc =
+            hw_mmc.findCycleMean(hw_iter_limit);
+        if (hw_tc == HwMmc::ITERATION_LIMIT) {
+          // Howard's algorithm reached the iteration limit, start a
+          // strongly polynomial algorithm instead
+          HoMmc ho_mmc(_sgr, _cost_map);
+          ho_mmc.cycle(cycle);
+          // Find a minimum mean cycle (Hartmann-Orlin algorithm)
+          if (!(ho_mmc.findCycleMean() && ho_mmc.cycleCost() < 0)) break;
+          ho_mmc.findCycle();
+        } else {
+          // Find a minimum mean cycle (Howard algorithm)
+          if (!(hw_tc == HwMmc::OPTIMAL && hw_mmc.cycleCost() < 0)) break;
+          hw_mmc.findCycle();
+        }
         // Compute delta value
 …
+        }
         // Rebuild the residual network
+        // Rebuild the residual network
         buildResidualNetwork();
+      }
+    }
     // Execute the "Cancel And Tighten" method
+    // 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;
+      const double HW_ITER_LIMIT_FACTOR = 1.0;
+      const int HW_ITER_LIMIT_MIN_VALUE = 5;
+      const int hw_iter_limit =
+          std::max(static_cast<int>(HW_ITER_LIMIT_FACTOR * _node_num),
+                   HW_ITER_LIMIT_MIN_VALUE);
       // Contruct auxiliary data vectors
       DoubleVector pi(_res_node_num, 0.0);
       IntVector level(_res_node_num);
       CharVector reached(_res_node_num);
       CharVector processed(_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);
 …
+          }
         } else {
+          typedef Howard<StaticDigraph, CostArcMap> MMC;
+          typedef HowardMmc<StaticDigraph, CostArcMap> HwMmc;
+          typedef HartmannOrlinMmc<StaticDigraph, CostArcMap> HoMmc;
           typedef typename BellmanFord<StaticDigraph, CostArcMap>
             ::template SetDistMap<CostNodeMap>::Create BF;
           // Set epsilon to the minimum cycle mean
+          Cost cycle_cost = 0;
+          int cycle_size = 1;
           buildResidualNetwork();
+          MMC mmc(_sgr, _cost_map);
+          mmc.findMinMean();
+          epsilon = -mmc.cycleMean();
+          Cost cycle_cost = mmc.cycleLength();
+          int cycle_size = mmc.cycleArcNum();
+          HwMmc hw_mmc(_sgr, _cost_map);
+          if (hw_mmc.findCycleMean(hw_iter_limit) == HwMmc::ITERATION_LIMIT) {
+            // Howard's algorithm reached the iteration limit, start a
+            // strongly polynomial algorithm instead
+            HoMmc ho_mmc(_sgr, _cost_map);
+            ho_mmc.findCycleMean();
+            epsilon = -ho_mmc.cycleMean();
+            cycle_cost = ho_mmc.cycleCost();
+            cycle_size = ho_mmc.cycleSize();
+          } else {
+            // Set epsilon
+            epsilon = -hw_mmc.cycleMean();
+            cycle_cost = hw_mmc.cycleCost();
+            cycle_size = hw_mmc.cycleSize();
+          }
           // Compute feasible potentials for the current epsilon
           for (int i = 0; i != int(_cost_vec.size()); ++i) {
 …
             pi[u] = static_cast<double>(_pi[u]) / cycle_size;
+          }
           iter = limit;
+        }

lemon/dfs.h

-                      r835
+                      r1270
  * This file is a part of LEMON, a generic C++ optimization library.
+ *
  * Copyright (C) 2003-2009
+ * Copyright (C) 2003-2013
  * Egervary Jeno Kombinatorikus Optimalizalasi Kutatocsoport
  * (Egervary Research Group on Combinatorial Optimization, EGRES).
 …
     ///The type of the map that indicates which nodes are reached.
+    ///It must conform to the \ref concepts::ReadWriteMap "ReadWriteMap" concept.
+    ///It must conform to
+    ///the \ref concepts::ReadWriteMap "ReadWriteMap" concept.
     typedef typename Digraph::template NodeMap<bool> ReachedMap;
     ///Instantiates a \c ReachedMap.
 …
   ///\tparam GR The type of the digraph the algorithm runs on.
   ///The default type is \ref ListDigraph.
+  ///\tparam TR The traits class that defines various types used by the
+  ///algorithm. By default, it is \ref DfsDefaultTraits
+  ///"DfsDefaultTraits<GR>".
+  ///In most cases, this parameter should not be set directly,
+  ///consider to use the named template parameters instead.
 #ifdef DOXYGEN
   template <typename GR,
 …
     typedef PredMapPath<Digraph, PredMap> Path;
     ///The \ref DfsDefaultTraits "traits class" of the algorithm.
+    ///The \ref lemon::DfsDefaultTraits "traits class" of the algorithm.
     typedef TR Traits;
 …
     ///\ref named-templ-param "Named parameter" for setting
     ///\c ReachedMap type.
+    ///It must conform to the \ref concepts::ReadWriteMap "ReadWriteMap" concept.
+    ///It must conform to
+    ///the \ref concepts::ReadWriteMap "ReadWriteMap" concept.
     template <class T>
     struct SetReachedMap : public Dfs< Digraph, SetReachedMapTraits<T> > {
 …
     void start(Node t)
+    {
       while ( !emptyQueue() && G->target(_stack[_stack_head])!=t )
+      while ( !emptyQueue() && !(*_reached)[t] )
         processNextArc();
+    }
 …
     ///The type of the map that indicates which nodes are reached.
+    ///It must conform to the \ref concepts::ReadWriteMap "ReadWriteMap" concept.
+    ///It must conform to
+    ///the \ref concepts::ReadWriteMap "ReadWriteMap" concept.
     typedef typename Digraph::template NodeMap<bool> ReachedMap;
     ///Instantiates a ReachedMap.
 …
   /// 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
 …
+      }
       _Visitor& visitor;
+      Constraints() {}
     };
   };
 …
     ///
     /// The type of the map that indicates which nodes are reached.
+    /// It must conform to the \ref concepts::ReadWriteMap "ReadWriteMap" concept.
+    /// It must conform to the
+    /// \ref concepts::ReadWriteMap "ReadWriteMap" concept.
     typedef typename Digraph::template NodeMap<bool> ReachedMap;
 …
   /// does not observe the DFS events. If you want to observe the DFS
   /// events, you should implement your own visitor class.
   /// \tparam TR Traits class to set various data types used by the
   /// algorithm. The default traits class is
   /// \ref DfsVisitDefaultTraits "DfsVisitDefaultTraits<GR>".
   /// See \ref DfsVisitDefaultTraits for the documentation of
   /// a DFS visit traits class.
+  /// \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.
 #ifdef DOXYGEN
   template <typename GR, typename VS, typename TR>
 …
     /// with addSource() before using this function.
     void start(Node t) {
       while ( !emptyQueue() && _digraph->target(_stack[_stack_head]) != t )
+      while ( !emptyQueue() && !(*_reached)[t] )
         processNextArc();
+    }

lemon/dijkstra.h

-                      r835
+                      r1270
  * This file is a part of LEMON, a generic C++ optimization library.
+ *
  * Copyright (C) 2003-2009
+ * Copyright (C) 2003-2013
  * Egervary Jeno Kombinatorikus Optimalizalasi Kutatocsoport
  * (Egervary Research Group on Combinatorial Optimization, EGRES).
 …
   ///it is necessary. The default map type is \ref
   ///concepts::Digraph::ArcMap "GR::ArcMap<int>".
+  ///\tparam TR The traits class that defines various types used by the
+  ///algorithm. By default, it is \ref DijkstraDefaultTraits
+  ///"DijkstraDefaultTraits<GR, LEN>".
+  ///In most cases, this parameter should not be set directly,
+  ///consider to use the named template parameters instead.
 #ifdef DOXYGEN
   template <typename GR, typename LEN, typename TR>
 …
     ///The heap type used by the algorithm.
     typedef typename TR::Heap Heap;
     ///\brief The \ref DijkstraDefaultOperationTraits "operation traits class"
     ///of the algorithm.
+    /// \brief The \ref lemon::DijkstraDefaultOperationTraits
+    /// "operation traits class" of the algorithm.
     typedef typename TR::OperationTraits OperationTraits;
     ///The \ref DijkstraDefaultTraits "traits class" of the algorithm.
+    ///The \ref lemon::DijkstraDefaultTraits "traits class" of the algorithm.
     typedef TR Traits;
 …
   /// 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

lemon/dim2.h

r761	r1311
21	21
22	22	#include <iostream>
	23	#include <algorithm>
23	24
24	25	///\ingroup geomdat

lemon/dimacs.h

-                      r631
+                      r1270
  * This file is a part of LEMON, a generic C++ optimization library.
+ *
  * Copyright (C) 2003-2009
+ * Copyright (C) 2003-2013
  * Egervary Jeno Kombinatorikus Optimalizalasi Kutatocsoport
  * (Egervary Research Group on Combinatorial Optimization, EGRES).
 …
   ///This function starts seeking the beginning of the given file for the
   ///problem type and size info.
+  ///problem type and size info.
   ///The found data is returned in a special struct that can be evaluated
   ///and passed to the appropriate reader function.
 …
         std::numeric_limits<Capacity>::infinity() :
         std::numeric_limits<Capacity>::max();
     while (is >> c) {
       switch (c) {
 …
           e = g.addArc(nodes[i], nodes[j]);
           capacity.set(e, _cap);
+        }
+        }
         else if (desc.type==DimacsDescriptor::MAX) {
           is >> i >> j >> _cap;
 …
     g.addArc(s,t);
+  }
   /// \brief DIMACS plain (di)graph reader function.
   ///
   /// This function reads a plain (di)graph without any designated nodes
   /// and maps (e.g. a matching instance) from DIMACS format, i.e. from
+  /// and maps (e.g. a matching instance) from DIMACS format, i.e. from
   /// DIMACS files having a line starting with
   /// \code
 …
       nodes[k] = g.addNode();
+    }
     while (is >> c) {
       switch (c) {

lemon/edge_set.h

r834	r1270
3	3	* This file is a part of LEMON, a generic C++ optimization library.
4	4	*
5		* Copyright (C) 2003-2008
	5	* Copyright (C) 2003-2013
6	6	* Egervary Jeno Kombinatorikus Optimalizalasi Kutatocsoport
7	7	* (Egervary Research Group on Combinatorial Optimization, EGRES).

lemon/elevator.h

r628	r1328
168	168	int onLevel(int l) const
169	169	{
170		return ~~_first[l+1]-_first[l]~~;
	170	return static_cast<int>(_first[l+1]-_first[l]);
171	171	}
172	172	///Return true if level \c l is empty.
…	…
178	178	int aboveLevel(int l) const
179	179	{
180		return ~~_first[_max_level+1]-_first[l+1]~~;
	180	return static_cast<int>(_first[_max_level+1]-_first[l+1]);
181	181	}
182	182	///Return the number of active items on level \c l.
183	183	int activesOnLevel(int l) const
184	184	{
185		return ~~_last_active[l]-_first[l]+1~~;
	185	return static_cast<int>(_last_active[l]-_first[l]+1);
186	186	}
187	187	///Return true if there is no active item on level \c l.

lemon/euler.h

-                      r695
+                      r1270
  * This file is a part of LEMON, a generic C++ optimization library.
+ *
  * Copyright (C) 2003-2009
+ * Copyright (C) 2003-2013
  * Egervary Jeno Kombinatorikus Optimalizalasi Kutatocsoport
  * (Egervary Research Group on Combinatorial Optimization, EGRES).
 …
 /// \ingroup graph_properties
 /// \file
 /// \brief Euler tour iterators and a function for checking the \e Eulerian
+/// \brief Euler tour iterators and a function for checking the \e Eulerian
 /// property.
 ///
 …
   ///Euler tour iterator for digraphs.
   /// \ingroup graph_prop
+  /// \ingroup graph_properties
   ///This iterator provides an Euler tour (Eulerian circuit) of a \e directed
   ///graph (if there exists) and it converts to the \c Arc type of the digraph.
   ///
   ///For example, if the given digraph has an Euler tour (i.e it has only one
   ///non-trivial component and the in-degree is equal to the out-degree
+  ///non-trivial component and the in-degree is equal to the out-degree
   ///for all nodes), then the following code will put the arcs of \c g
   ///to the vector \c et according to an Euler tour of \c g.
 …
   ///and \c Edge types of the graph.
   ///
   ///For example, if the given graph has an Euler tour (i.e it has only one
+  ///For example, if the given graph has an Euler tour (i.e it has only one
   ///non-trivial component and the degree of each node is even),
   ///the following code will print the arc IDs according to an
 …
   ///  }
   ///\endcode
   ///Although this iterator is for undirected graphs, it still returns
+  ///Although this iterator is for undirected graphs, it still returns
   ///arcs in order to indicate the direction of the tour.
   ///(But arcs convert to edges, of course.)
 …
     /// Postfix incrementation.
     ///
     ///\warning This incrementation returns an \c Arc (which converts to
+    ///\warning This incrementation returns an \c Arc (which converts to
     ///an \c Edge), not an \ref EulerIt, as one may expect.
     Arc operator++(int)

lemon/full_graph.h

-                      r834
+                      r1270
  * This file is a part of LEMON, a generic C++ optimization library.
+ *
  * Copyright (C) 2003-2009
+ * Copyright (C) 2003-2013
  * Egervary Jeno Kombinatorikus Optimalizalasi Kutatocsoport
  * (Egervary Research Group on Combinatorial Optimization, EGRES).
 …
     /// \brief Returns the node with the given index.
     ///
     /// Returns the node with the given index. Since this structure is
+    /// 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>.
 …
     /// \brief Returns the index of the given node.
     ///
     /// Returns the index of the given node. Since this structure is
+    /// 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>.
 …
     /// \brief Returns the node with the given index.
     ///
     /// Returns the node with the given index. Since this structure is
+    /// 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>.
 …
     /// \brief Returns the index of the given node.
     ///
     /// Returns the index of the given node. Since this structure is
+    /// 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>.
 …
   };
+  class FullBpGraphBase {
+  protected:
+    int _red_num, _blue_num;
+    int _node_num, _edge_num;
+  public:
+    typedef FullBpGraphBase Graph;
+    class Node;
+    class Arc;
+    class Edge;
+    class Node {
+      friend class FullBpGraphBase;
+    protected:
+      int _id;
+      explicit 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 RedNode : public Node {
+      friend class FullBpGraphBase;
+    protected:
+      explicit RedNode(int pid) : Node(pid) {}
+    public:
+      RedNode() {}
+      RedNode(const RedNode& node) : Node(node) {}
+      RedNode(Invalid) : Node(INVALID){}
+    };
+    class BlueNode : public Node {
+      friend class FullBpGraphBase;
+    protected:
+      explicit BlueNode(int pid) : Node(pid) {}
+    public:
+      BlueNode() {}
+      BlueNode(const BlueNode& node) : Node(node) {}
+      BlueNode(Invalid) : Node(INVALID){}
+    };
+    class Edge {
+      friend class FullBpGraphBase;
+    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 FullBpGraphBase;
+    protected:
+      int _id;
+      explicit Arc(int id) { _id = id;}
+    public:
+      operator Edge() const {
+        return _id != -1 ? edgeFromId(_id / 2) : INVALID;
+      }
+      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;}
+    };
+  protected:
+    FullBpGraphBase()
+      : _red_num(0), _blue_num(0), _node_num(0), _edge_num(0) {}
+    void construct(int redNum, int blueNum) {
+      _red_num = redNum; _blue_num = blueNum;
+      _node_num = redNum + blueNum; _edge_num = redNum * blueNum;
+    }
+  public:
+    typedef True NodeNumTag;
+    typedef True EdgeNumTag;
+    typedef True ArcNumTag;
+    int nodeNum() const { return _node_num; }
+    int redNum() const { return _red_num; }
+    int blueNum() const { return _blue_num; }
+    int edgeNum() const { return _edge_num; }
+    int arcNum() const { return 2 * _edge_num; }
+    int maxNodeId() const { return _node_num - 1; }
+    int maxRedId() const { return _red_num - 1; }
+    int maxBlueId() const { return _blue_num - 1; }
+    int maxEdgeId() const { return _edge_num - 1; }
+    int maxArcId() const { return 2 * _edge_num - 1; }
+    bool red(Node n) const { return n._id < _red_num; }
+    bool blue(Node n) const { return n._id >= _red_num; }
+    static RedNode asRedNodeUnsafe(Node n) { return RedNode(n._id); }
+    static BlueNode asBlueNodeUnsafe(Node n) { return BlueNode(n._id); }
+    Node source(Arc a) const {
+      if (a._id & 1) {
+        return Node((a._id >> 1) % _red_num);
+      } else {
+        return Node((a._id >> 1) / _red_num + _red_num);
+      }
+    }
+    Node target(Arc a) const {
+      if (a._id & 1) {
+        return Node((a._id >> 1) / _red_num + _red_num);
+      } else {
+        return Node((a._id >> 1) % _red_num);
+      }
+    }
+    RedNode redNode(Edge e) const {
+      return RedNode(e._id % _red_num);
+    }
+    BlueNode blueNode(Edge e) const {
+      return BlueNode(e._id / _red_num + _red_num);
+    }
+    static bool direction(Arc a) {
+      return (a._id & 1) == 1;
+    }
+    static Arc direct(Edge e, bool d) {
+      return Arc(e._id * 2 + (d ? 1 : 0));
+    }
+    void first(Node& node) const {
+      node._id = _node_num - 1;
+    }
+    static void next(Node& node) {
+      --node._id;
+    }
+    void first(RedNode& node) const {
+      node._id = _red_num - 1;
+    }
+    static void next(RedNode& node) {
+      --node._id;
+    }
+    void first(BlueNode& node) const {
+      if (_red_num == _node_num) node._id = -1;
+      else node._id = _node_num - 1;
+    }
+    void next(BlueNode& node) const {
+      if (node._id == _red_num) node._id = -1;
+      else --node._id;
+    }
+    void first(Arc& arc) const {
+      arc._id = 2 * _edge_num - 1;
+    }
+    static void next(Arc& arc) {
+      --arc._id;
+    }
+    void first(Edge& arc) const {
+      arc._id = _edge_num - 1;
+    }
+    static void next(Edge& arc) {
+      --arc._id;
+    }
+    void firstOut(Arc &a, const Node& v) const {
+      if (v._id < _red_num) {
+        a._id = 2 * (v._id + _red_num * (_blue_num - 1)) + 1;
+      } else {
+        a._id = 2 * (_red_num - 1 + _red_num * (v._id - _red_num));
+      }
+    }
+    void nextOut(Arc &a) const {
+      if (a._id & 1) {
+        a._id -= 2 * _red_num;
+        if (a._id < 0) a._id = -1;
+      } else {
+        if (a._id % (2 * _red_num) == 0) a._id = -1;
+        else a._id -= 2;
+      }
+    }
+    void firstIn(Arc &a, const Node& v) const {
+      if (v._id < _red_num) {
+        a._id = 2 * (v._id + _red_num * (_blue_num - 1));
+      } else {
+        a._id = 2 * (_red_num - 1 + _red_num * (v._id - _red_num)) + 1;
+      }
+    }
+    void nextIn(Arc &a) const {
+      if (a._id & 1) {
+        if (a._id % (2 * _red_num) == 1) a._id = -1;
+        else a._id -= 2;
+      } else {
+        a._id -= 2 * _red_num;
+        if (a._id < 0) a._id = -1;
+      }
+    }
+    void firstInc(Edge &e, bool& d, const Node& v) const {
+      if (v._id < _red_num) {
+        d = true;
+        e._id = v._id + _red_num * (_blue_num - 1);
+      } else {
+        d = false;
+        e._id = _red_num - 1 + _red_num * (v._id - _red_num);
+      }
+    }
+    void nextInc(Edge &e, bool& d) const {
+      if (d) {
+        e._id -= _red_num;
+        if (e._id < 0) e._id = -1;
+      } else {
+        if (e._id % _red_num == 0) e._id = -1;
+        else --e._id;
+      }
+    }
+    static int id(const Node& v) { return v._id; }
+    int id(const RedNode& v) const { return v._id; }
+    int id(const BlueNode& v) const { return v._id - _red_num; }
+    static int id(Arc e) { return e._id; }
+    static int id(Edge e) { return e._id; }
+    static Node nodeFromId(int id) { return Node(id);}
+    static Arc arcFromId(int id) { return Arc(id);}
+    static Edge edgeFromId(int id) { return Edge(id);}
+    bool valid(Node n) const {
+      return n._id >= 0 && n._id < _node_num;
+    }
+    bool valid(Arc a) const {
+      return a._id >= 0 && a._id < 2 * _edge_num;
+    }
+    bool valid(Edge e) const {
+      return e._id >= 0 && e._id < _edge_num;
+    }
+    RedNode redNode(int index) const {
+      return RedNode(index);
+    }
+    int index(RedNode n) const {
+      return n._id;
+    }
+    BlueNode blueNode(int index) const {
+      return BlueNode(index + _red_num);
+    }
+    int index(BlueNode n) const {
+      return n._id - _red_num;
+    }
+    void clear() {
+      _red_num = 0; _blue_num = 0;
+      _node_num = 0; _edge_num = 0;
+    }
+    Edge edge(const Node& u, const Node& v) const {
+      if (u._id < _red_num) {
+        if (v._id < _red_num) {
+          return Edge(-1);
+        } else {
+          return Edge(u._id + _red_num * (v._id - _red_num));
+        }
+      } else {
+        if (v._id < _red_num) {
+          return Edge(v._id + _red_num * (u._id - _red_num));
+        } else {
+          return Edge(-1);
+        }
+      }
+    }
+    Arc arc(const Node& u, const Node& v) const {
+      if (u._id < _red_num) {
+        if (v._id < _red_num) {
+          return Arc(-1);
+        } else {
+          return Arc(2 * (u._id + _red_num * (v._id - _red_num)) + 1);
+        }
+      } else {
+        if (v._id < _red_num) {
+          return Arc(2 * (v._id + _red_num * (u._id - _red_num)));
+        } else {
+          return Arc(-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);
+    }
+  };
+  typedef BpGraphExtender<FullBpGraphBase> ExtendedFullBpGraphBase;
+  /// \ingroup graphs
+  ///
+  /// \brief An undirected full bipartite graph class.
+  ///
+  /// FullBpGraph is a simple and fast implmenetation of undirected
+  /// full bipartite graphs. It contains an edge between every
+  /// red-blue pairs of nodes, therefore the number of edges is
+  /// <tt>nr*nb</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::BpGraph "BpGraph 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.
+  ///
+  /// \sa FullGraph
+  class FullBpGraph : public ExtendedFullBpGraphBase {
+  public:
+    typedef ExtendedFullBpGraphBase Parent;
+    /// \brief Default constructor.
+    ///
+    /// Default constructor. The number of nodes and edges will be zero.
+    FullBpGraph() { construct(0, 0); }
+    /// \brief Constructor
+    ///
+    /// Constructor.
+    /// \param redNum The number of the red nodes.
+    /// \param blueNum The number of the blue nodes.
+    FullBpGraph(int redNum, int blueNum) { construct(redNum, blueNum); }
+    /// \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 redNum, int blueNum) {
+      Parent::notifier(Arc()).clear();
+      Parent::notifier(Edge()).clear();
+      Parent::notifier(Node()).clear();
+      Parent::notifier(BlueNode()).clear();
+      Parent::notifier(RedNode()).clear();
+      construct(redNum, blueNum);
+      Parent::notifier(RedNode()).build();
+      Parent::notifier(BlueNode()).build();
+      Parent::notifier(Node()).build();
+      Parent::notifier(Edge()).build();
+      Parent::notifier(Arc()).build();
+    }
+    using Parent::redNode;
+    using Parent::blueNode;
+    /// \brief Returns the red node with the given index.
+    ///
+    /// Returns the red node with the given index. Since this
+    /// structure is completely static, the red nodes can be indexed
+    /// with integers from the range <tt>[0..redNum()-1]</tt>.
+    /// \sa redIndex()
+    RedNode redNode(int index) const { return Parent::redNode(index); }
+    /// \brief Returns the index of the given red node.
+    ///
+    /// Returns the index of the given red node. Since this structure
+    /// is completely static, the red nodes can be indexed with
+    /// integers from the range <tt>[0..redNum()-1]</tt>.
+    ///
+    /// \sa operator()()
+    int index(RedNode node) const { return Parent::index(node); }
+    /// \brief Returns the blue node with the given index.
+    ///
+    /// Returns the blue node with the given index. Since this
+    /// structure is completely static, the blue nodes can be indexed
+    /// with integers from the range <tt>[0..blueNum()-1]</tt>.
+    /// \sa blueIndex()
+    BlueNode blueNode(int index) const { return Parent::blueNode(index); }
+    /// \brief Returns the index of the given blue node.
+    ///
+    /// Returns the index of the given blue node. Since this structure
+    /// is completely static, the blue nodes can be indexed with
+    /// integers from the range <tt>[0..blueNum()-1]</tt>.
+    ///
+    /// \sa operator()()
+    int index(BlueNode node) const { return Parent::index(node); }
+    /// \brief Returns the edge which connects the given nodes.
+    ///
+    /// Returns the edge which connects the given nodes.
+    Edge edge(const Node& u, const Node& v) const {
+      return Parent::edge(u, v);
+    }
+    /// \brief Returns the arc which connects the given nodes.
+    ///
+    /// Returns the arc which connects the given nodes.
+    Arc arc(const Node& u, const Node& v) const {
+      return Parent::arc(u, v);
+    }
+    /// \brief Number of nodes.
+    int nodeNum() const { return Parent::nodeNum(); }
+    /// \brief Number of red nodes.
+    int redNum() const { return Parent::redNum(); }
+    /// \brief Number of blue nodes.
+    int blueNum() const { return Parent::blueNum(); }
+    /// \brief Number of arcs.
+    int arcNum() const { return Parent::arcNum(); }
+    /// \brief Number of edges.
+    int edgeNum() const { return Parent::edgeNum(); }
+  };
 } //namespace lemon

lemon/glpk.cc

-                      r793
+                      r1270
  * This file is a part of LEMON, a generic C++ optimization library.
+ *
  * Copyright (C) 2003-2009
+ * Copyright (C) 2003-2013
  * Egervary Jeno Kombinatorikus Optimalizalasi Kutatocsoport
  * (Egervary Research Group on Combinatorial Optimization, EGRES).
 …
+  }
   int GlpkBase::_addRow(Value lo, ExprIterator b,
+  int GlpkBase::_addRow(Value lo, ExprIterator b,
                         ExprIterator e, Value up) {
     int i = glp_add_rows(lp, 1);
 …
       } 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) {
+      } else if (lo != up) {
         glp_set_row_bnds(lp, i, GLP_DB, lo, up);
       } else {
 …
   void GlpkBase::_clear() {
     glp_erase_prob(lp);
-    rows.clear();
-    cols.clear();
+  }
 …
       break;
+    }
+  }
+  void GlpkBase::_write(std::string file, std::string format) const
+  {
+    if(format == "MPS")
+      glp_write_mps(lp, GLP_MPS_FILE, 0, file.c_str());
+    else if(format == "LP")
+      glp_write_lp(lp, 0, file.c_str());
+    else throw UnsupportedFormatError(format);
+  }
 …
   const char* GlpkMip::_solverName() const { return "GlpkMip"; }
 } //END OF NAMESPACE LEMON

lemon/glpk.h

-                      r793
+                      r1270
  * This file is a part of LEMON, a generic C++ optimization library.
+ *
  * Copyright (C) 2003-2008
+ * Copyright (C) 2003-2013
  * Egervary Jeno Kombinatorikus Optimalizalasi Kutatocsoport
  * (Egervary Research Group on Combinatorial Optimization, EGRES).
 …
 #include <lemon/lp_base.h>
-// forward declaration
-#if !defined _GLP_PROB && !defined GLP_PROB
-#define _GLP_PROB
-#define GLP_PROB
-typedef struct { double _opaque_prob; } glp_prob;
-/* LP/MIP problem object */
-#endif
 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
 …
   protected:
+    typedef glp_prob LPX;
+    glp_prob* lp;
+    _solver_bits::VoidPtr lp;
     GlpkBase();
 …
     virtual void _messageLevel(MessageLevel level);
+    virtual void _write(std::string file, std::string format) const;
   private:
 …
+      }
     };
     static FreeEnvHelper freeEnvHelper;
   protected:
     int _message_level;
   public:
     ///Pointer to the underlying GLPK data structure.
     LPX *lpx() {return lp;}
+    _solver_bits::VoidPtr lpx() {return lp;}
     ///Const pointer to the underlying GLPK data structure.
     const LPX *lpx() const {return lp;}
+    _solver_bits::VoidPtr lpx() const {return lp;}
     ///Returns the constraint identifier understood by GLPK.
 …
     ///Returns the variable identifier understood by GLPK.
     int lpxCol(Col c) const { return cols(id(c)); }
+#ifdef DOXYGEN
+    /// Write the problem or the solution to a file in the given format
+    /// This function writes the problem or the solution
+    /// to a file in the given format.
+    /// Trying to write in an unsupported format will trigger
+    /// \ref LpBase::UnsupportedFormatError.
+    /// \param file The file path
+    /// \param format The output file format.
+    /// Supportted formats are "MPS" and "LP".
+    void write(std::string file, std::string format = "MPS") const {}
+#endif
   };

lemon/gomory_hu.h

-                      r833
+                      r1270
 /* -*- C++ -*-
+/* -*- mode: C++; indent-tabs-mode: nil; -*-
+ *
  * This file is a part of LEMON, a generic C++ optimization library
+ * This file is a part of LEMON, a generic C++ optimization library.
+ *
  * Copyright (C) 2003-2008
+ * Copyright (C) 2003-2013
  * Egervary Jeno Kombinatorikus Optimalizalasi Kutatocsoport
  * (Egervary Research Group on Combinatorial Optimization, EGRES).
 …
 /// \ingroup min_cut
 /// \file
+/// \file
 /// \brief Gomory-Hu cut tree in graphs.
 …
   /// The Gomory-Hu tree is a tree on the node set of a given graph, but it
   /// may contain edges which are not in the original graph. It has the
   /// property that the minimum capacity edge of the path between two nodes
+  /// property that the minimum capacity edge of the path between two nodes
   /// in this tree has the same weight as the minimum cut in the graph
   /// between these nodes. Moreover the components obtained by removing
 …
   /// 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
+  /// the \ref Preflow algorithm), thus it has \f$O(n^3\sqrt{m})\f$ overall
   /// time complexity. It calculates a rooted Gomory-Hu tree.
   /// The structure of the tree and the edge weights can be
 …
 #ifdef DOXYGEN
   template <typename GR,
             typename CAP>
+            typename CAP>
 #else
   template <typename GR,
             typename CAP = typename GR::template EdgeMap<int> >
+            typename CAP = typename GR::template EdgeMap<int> >
 #endif
   class GomoryHu {
 …
     /// The value type of capacities
     typedef typename Capacity::Value Value;
   private:
 …
     void createStructures() {
       if (!_pred) {
         _pred = new typename Graph::template NodeMap<Node>(_graph);
+        _pred = new typename Graph::template NodeMap<Node>(_graph);
+      }
       if (!_weight) {
         _weight = new typename Graph::template NodeMap<Value>(_graph);
+        _weight = new typename Graph::template NodeMap<Value>(_graph);
+      }
       if (!_order) {
         _order = new typename Graph::template NodeMap<int>(_graph);
+        _order = new typename Graph::template NodeMap<int>(_graph);
+      }
+    }
 …
     void destroyStructures() {
       if (_pred) {
         delete _pred;
+        delete _pred;
+      }
       if (_weight) {
         delete _weight;
+        delete _weight;
+      }
       if (_order) {
         delete _order;
+      }
+    }
+        delete _order;
+      }
+    }
   public:
 …
     /// \param graph The undirected graph the algorithm runs on.
     /// \param capacity The edge capacity map.
     GomoryHu(const Graph& graph, const Capacity& capacity)
+    GomoryHu(const Graph& graph, const Capacity& capacity)
       : _graph(graph), _capacity(capacity),
+        _pred(0), _weight(0), _order(0)
+        _pred(0), _weight(0), _order(0)
+    {
       checkConcept<concepts::ReadMap<Edge, Value>, Capacity>();
 …
   private:
     // Initialize the internal data structures
     void init() {
 …
+      }
       (*_pred)[_root] = INVALID;
       (*_weight)[_root] = std::numeric_limits<Value>::max();
+      (*_weight)[_root] = std::numeric_limits<Value>::max();
+    }
 …
       for (NodeIt n(_graph); n != INVALID; ++n) {
         if (n == _root) continue;
         Node pn = (*_pred)[n];
         fa.source(n);
         fa.target(pn);
         fa.runMinCut();
         (*_weight)[n] = fa.flowValue();
         for (NodeIt nn(_graph); nn != INVALID; ++nn) {
           if (nn != n && fa.minCut(nn) && (*_pred)[nn] == pn) {
             (*_pred)[nn] = n;
+          }
+        }
         if ((*_pred)[pn] != INVALID && fa.minCut((*_pred)[pn])) {
           (*_pred)[n] = (*_pred)[pn];
           (*_pred)[pn] = n;
           (*_weight)[n] = (*_weight)[pn];
           (*_weight)[pn] = fa.flowValue();
+        }
+        if (n == _root) continue;
+        Node pn = (*_pred)[n];
+        fa.source(n);
+        fa.target(pn);
+        fa.runMinCut();
+        (*_weight)[n] = fa.flowValue();
+        for (NodeIt nn(_graph); nn != INVALID; ++nn) {
+          if (nn != n && fa.minCut(nn) && (*_pred)[nn] == pn) {
+            (*_pred)[nn] = n;
+          }
+        }
+        if ((*_pred)[pn] != INVALID && fa.minCut((*_pred)[pn])) {
+          (*_pred)[n] = (*_pred)[pn];
+          (*_pred)[pn] = n;
+          (*_weight)[n] = (*_weight)[pn];
+          (*_weight)[pn] = fa.flowValue();
+        }
+      }
 …
       for (NodeIt n(_graph); n != INVALID; ++n) {
         std::vector<Node> st;
         Node nn = n;
         while ((*_order)[nn] == -1) {
           st.push_back(nn);
           nn = (*_pred)[nn];
+        }
         while (!st.empty()) {
           (*_order)[st.back()] = index++;
           st.pop_back();
+        }
+        std::vector<Node> st;
+        Node nn = n;
+        while ((*_order)[nn] == -1) {
+          st.push_back(nn);
+          nn = (*_pred)[nn];
+        }
+        while (!st.empty()) {
+          (*_order)[st.back()] = index++;
+          st.pop_back();
+        }
+      }
+    }
 …
     ///\name Execution Control
     ///@{
 …
       start();
+    }
     /// @}
 …
     /// Gomory-Hu tree.
     ///
     /// This function returns the weight of the predecessor edge of the
+    /// This function returns the weight of the predecessor edge of the
     /// given node in the Gomory-Hu tree.
     /// If \c node is the root of the tree, the result is undefined.
 …
     ///
     /// This function returns the minimum cut value between the nodes
     /// \c s and \c t.
+    /// \c s and \c t.
     /// It finds the nearest common ancestor of the given nodes in the
     /// Gomory-Hu tree and calculates the minimum weight edge on the
 …
       Node sn = s, tn = t;
       Value value = std::numeric_limits<Value>::max();
       while (sn != tn) {
         if ((*_order)[sn] < (*_order)[tn]) {
           if ((*_weight)[tn] <= value) value = (*_weight)[tn];
           tn = (*_pred)[tn];
         } else {
           if ((*_weight)[sn] <= value) value = (*_weight)[sn];
           sn = (*_pred)[sn];
+        }
+        if ((*_order)[sn] < (*_order)[tn]) {
+          if ((*_weight)[tn] <= value) value = (*_weight)[tn];
+          tn = (*_pred)[tn];
+        } else {
+          if ((*_weight)[sn] <= value) value = (*_weight)[sn];
+          sn = (*_pred)[sn];
+        }
+      }
       return value;
 …
       Node rn = INVALID;
       Value value = std::numeric_limits<Value>::max();
       while (sn != tn) {
         if ((*_order)[sn] < (*_order)[tn]) {
           if ((*_weight)[tn] <= value) {
             rn = tn;
+        if ((*_order)[sn] < (*_order)[tn]) {
+          if ((*_weight)[tn] <= value) {
+            rn = tn;
             s_root = false;
             value = (*_weight)[tn];
+          }
           tn = (*_pred)[tn];
         } else {
           if ((*_weight)[sn] <= value) {
             rn = sn;
+            value = (*_weight)[tn];
+          }
+          tn = (*_pred)[tn];
+        } else {
+          if ((*_weight)[sn] <= value) {
+            rn = sn;
             s_root = true;
             value = (*_weight)[sn];
+          }
           sn = (*_pred)[sn];
+        }
+            value = (*_weight)[sn];
+          }
+          sn = (*_pred)[sn];
+        }
+      }
 …
       std::vector<Node> st;
       for (NodeIt n(_graph); n != INVALID; ++n) {
         st.clear();
+        st.clear();
         Node nn = n;
         while (!reached[nn]) {
           st.push_back(nn);
           nn = (*_pred)[nn];
+        }
         while (!st.empty()) {
           cutMap.set(st.back(), cutMap[nn]);
           st.pop_back();
+        }
+      }
+        while (!reached[nn]) {
+          st.push_back(nn);
+          nn = (*_pred)[nn];
+        }
+        while (!st.empty()) {
+          cutMap.set(st.back(), cutMap[nn]);
+          st.pop_back();
+        }
+      }
       return value;
+    }
 …
     /// 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
 …
+      }
     };
     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
 …
+          }
+      }
     public:
       /// Constructor
 …
+      }
       /// Postfix incrementation
       /// Postfix incrementation.
       ///

lemon/graph_to_eps.h

-                      r833
+                      r1340
  * This file is a part of LEMON, a generic C++ optimization library.
+ *
  * Copyright (C) 2003-2009
+ * Copyright (C) 2003-2013
  * Egervary Jeno Kombinatorikus Optimalizalasi Kutatocsoport
  * (Egervary Research Group on Combinatorial Optimization, EGRES).
 …
 #include<vector>
 #ifndef WIN32
+#ifndef LEMON_WIN32
 #include<sys/time.h>
 #include<ctime>
 …
   using T::_copyright;
-  using T::NodeTextColorType;
   using T::CUST_COL;
   using T::DIST_COL;
 …
+    {
       os << "%%CreationDate: ";
 #ifndef WIN32
+#ifndef LEMON_WIN32
       timeval tv;
       gettimeofday(&tv, 0);
 …
 #else
       os << bits::getWinFormattedDate();
+      os << std::endl;
 #endif
+    }
-    os << std::endl;
     if (_autoArcWidthScale) {

lemon/hao_orlin.h

-                      r644
+                      r1270
  * This file is a part of LEMON, a generic C++ optimization library.
+ *
  * Copyright (C) 2003-2009
+ * Copyright (C) 2003-2013
  * Egervary Jeno Kombinatorikus Optimalizalasi Kutatocsoport
  * (Egervary Research Group on Combinatorial Optimization, EGRES).
 …
 /// \brief Implementation of the Hao-Orlin algorithm.
 ///
 /// Implementation of the Hao-Orlin algorithm for finding a minimum cut
+/// Implementation of the Hao-Orlin algorithm for finding a minimum cut
 /// in a digraph.
 …
   ///
   /// This class implements the Hao-Orlin algorithm for finding a minimum
   /// value cut in a directed graph \f$D=(V,A)\f$.
+  /// value cut in a directed graph \f$D=(V,A)\f$.
   /// It takes a fixed node \f$ source \in V \f$ and
   /// consists of two phases: in the first phase it determines a
 …
   /// 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.
+  /// highest-label rule), or in \f$O(nm)\f$ for unit capacities. A notable
+  /// use of this algorithm is testing network reliability.
   ///
   /// For an undirected graph you can run just the first phase of the
   /// algorithm or you can use the algorithm of Nagamochi and Ibaraki,
   /// which solves the undirected problem in \f$ O(nm + n^2 \log n) \f$
+  /// which solves the undirected problem in \f$ O(nm + n^2 \log n) \f$
   /// time. It is implemented in the NagamochiIbaraki algorithm class.
   ///
 …
   class HaoOrlin {
   public:
     /// The digraph type of the algorithm
     typedef GR Digraph;
 …
         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;
+    }
 …
     ///
     /// This function initializes the internal data structures. It creates
     /// the maps and some bucket structures for the algorithm.
+    /// the maps and some bucket structures for the algorithm.
     /// The given node is used as the source node for the push-relabel
     /// algorithm.
 …
     /// source-side (i.e. a set \f$ X\subsetneq V \f$ with
     /// \f$ source \in X \f$ and minimal outgoing capacity).
+    /// It updates the stored cut if (and only if) the newly found one
+    /// is better.
     ///
     /// \pre \ref init() must be called before using this function.
 …
     /// sink-side (i.e. a set \f$ X\subsetneq V \f$ with
     /// \f$ source \notin X \f$ and minimal outgoing capacity).
+    /// It updates the stored cut if (and only if) the newly found one
+    /// is better.
     ///
     /// \pre \ref init() must be called before using this function.
 …
     /// \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()
+    /// This function runs the algorithm. It chooses source node,
+    /// then calls \ref init(), \ref calculateOut()
     /// and \ref calculateIn().
     void run() {
 …
     /// \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().
+    /// This function runs the algorithm. It calls \ref init(),
+    /// \ref calculateOut() and \ref calculateIn() with the given
+    /// source node.
     void run(const Node& s) {
       init(s);
 …
     /// The result of the %HaoOrlin algorithm
     /// can be obtained using these functions.\n
     /// \ref run(), \ref calculateOut() or \ref calculateIn()
+    /// \ref run(), \ref calculateOut() or \ref calculateIn()
     /// should be called before using them.
 …
     /// \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()
+    /// This function returns the value of the best cut found by the
+    /// previously called \ref run(), \ref calculateOut() or \ref
+    /// calculateIn().
+    ///
+    /// \pre \ref run(), \ref calculateOut() or \ref calculateIn()
     /// must be called before using this function.
     Value minCutValue() const {
 …
     /// \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
+    /// This function gives the best cut found by the
+    /// previously called \ref run(), \ref calculateOut() or \ref
+    /// calculateIn().
+    ///
+    /// It sets \c cutMap to the characteristic vector of the found
+    /// minimum value cut - a non-empty set \f$ X\subsetneq V \f$
+    /// of minimum outgoing capacity (i.e. \c cutMap will be \c true exactly
     /// for the nodes of \f$ X \f$).
     ///
 …
     /// \return The value of the minimum cut.
     ///
     /// \pre \ref run(), \ref calculateOut() or \ref calculateIn()
+    /// \pre \ref run(), \ref calculateOut() or \ref calculateIn()
     /// must be called before using this function.
     template <typename CutMap>

lemon/kruskal.h

-                      r631
+                      r1270
  * This file is a part of LEMON, a generic C++ optimization library.
+ *
  * Copyright (C) 2003-2009
+ * Copyright (C) 2003-2013
  * Egervary Jeno Kombinatorikus Optimalizalasi Kutatocsoport
  * (Egervary Research Group on Combinatorial Optimization, EGRES).
 …
 ///\file
 ///\brief Kruskal's algorithm to compute a minimum cost spanning tree
-///
-///Kruskal's algorithm to compute a minimum cost spanning tree.
-///
 namespace lemon {

lemon/lemon.pc.in

-                      r705
+                      r1133
 prefix=@prefix@
 exec_prefix=@exec_prefix@
 libdir=@libdir@
 includedir=@includedir@
+prefix=@CMAKE_INSTALL_PREFIX@
+exec_prefix=@CMAKE_INSTALL_PREFIX@/bin
+libdir=@CMAKE_INSTALL_PREFIX@/lib
+includedir=@CMAKE_INSTALL_PREFIX@/include
 Name: @PACKAGE_NAME@
+Name: @PROJECT_NAME@
 Description: Library for Efficient Modeling and Optimization in Networks
 Version: @PACKAGE_VERSION@
+Version: @PROJECT_VERSION@
 Libs: -L${libdir} -lemon @GLPK_LIBS@ @CPLEX_LIBS@ @SOPLEX_LIBS@ @CLP_LIBS@ @CBC_LIBS@
 Cflags: -I${includedir}

lemon/lgf_reader.h

-                      r833
+                      r1270
  * This file is a part of LEMON, a generic C++ optimization library.
+ *
  * Copyright (C) 2003-2009
+ * Copyright (C) 2003-2013
  * Egervary Jeno Kombinatorikus Optimalizalasi Kutatocsoport
  * (Egervary Research Group on Combinatorial Optimization, EGRES).
 …
     };
+    template <typename Value>
+    template <typename Value,
+              typename Map = std::map<std::string, Value> >
     struct MapLookUpConverter {
       const std::map<std::string, Value>& _map;
       MapLookUpConverter(const std::map<std::string, Value>& map)
+      const Map& _map;
+      MapLookUpConverter(const Map& map)
         : _map(map) {}
       Value operator()(const std::string& str) {
+        typename std::map<std::string, Value>::const_iterator it =
+          _map.find(str);
+        typename Map::const_iterator it = _map.find(str);
         if (it == _map.end()) {
           std::ostringstream msg;
 …
+        }
         return it->second;
+      }
+    };
+    template <typename Value,
+              typename Map1 = std::map<std::string, Value>,
+              typename Map2 = std::map<std::string, Value> >
+    struct DoubleMapLookUpConverter {
+      const Map1& _map1;
+      const Map2& _map2;
+      DoubleMapLookUpConverter(const Map1& map1, const Map2& map2)
+        : _map1(map1), _map2(map2) {}
+      Value operator()(const std::string& str) {
+        typename Map1::const_iterator it1 = _map1.find(str);
+        typename Map2::const_iterator it2 = _map2.find(str);
+        if (it1 == _map1.end()) {
+          if (it2 == _map2.end()) {
+            std::ostringstream msg;
+            msg << "Item not found: " << str;
+            throw FormatError(msg.str());
+          } else {
+            return it2->second;
+          }
+        } else {
+          if (it2 == _map2.end()) {
+            return it1->second;
+          } else {
+            std::ostringstream msg;
+            msg << "Item is ambigous: " << str;
+            throw FormatError(msg.str());
+          }
+        }
+      }
     };
 …
     friend DigraphReader<TDGR> digraphReader(TDGR& digraph, std::istream& is);
     template <typename TDGR>
     friend DigraphReader<TDGR> digraphReader(TDGR& digraph,
+    friend DigraphReader<TDGR> digraphReader(TDGR& digraph,
                                              const std::string& fn);
     template <typename TDGR>
 …
         int index = 0;
         while (_reader_bits::readToken(line, map)) {
+          if(map == "-") {
+              if(index!=0)
+                throw FormatError("'-' is not allowed as a map name");
+              else if (line >> std::ws >> c)
+                throw FormatError("Extra character at the end of line");
+              else break;
+            }
           if (maps.find(map) != maps.end()) {
             std::ostringstream msg;
 …
   };
   /// \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
+  /// \brief Return a \ref lemon::DigraphReader "DigraphReader" class
+  ///
+  /// This function just returns a \ref lemon::DigraphReader
+  /// "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
 …
   ///\endcode
   ///
+  /// For a complete documentation, please see the \ref DigraphReader
+  /// For a complete documentation, please see the
+  /// \ref lemon::DigraphReader "DigraphReader"
   /// class documentation.
   /// \warning Don't forget to put the \ref DigraphReader::run() "run()"
+  /// \warning Don't forget to put the \ref lemon::DigraphReader::run() "run()"
   /// to the end of the parameter list.
   /// \relates DigraphReader
 …
   template <typename GR>
   class GraphReader;
   template <typename TGR>
   GraphReader<TGR> graphReader(TGR& graph, std::istream& is = std::cin);
 …
     friend GraphReader<TGR> graphReader(TGR& graph, std::istream& is);
     template <typename TGR>
     friend GraphReader<TGR> graphReader(TGR& graph, const std::string& fn);
+    friend GraphReader<TGR> graphReader(TGR& graph, const std::string& fn);
     template <typename TGR>
     friend GraphReader<TGR> graphReader(TGR& graph, const char *fn);
 …
         int index = 0;
         while (_reader_bits::readToken(line, map)) {
+          if(map == "-") {
+              if(index!=0)
+                throw FormatError("'-' is not allowed as a map name");
+              else if (line >> std::ws >> c)
+                throw FormatError("Extra character at the end of line");
+              else break;
+            }
           if (maps.find(map) != maps.end()) {
             std::ostringstream msg;
 …
   /// \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
+  /// \brief Return a \ref lemon::GraphReader "GraphReader" class
+  ///
+  /// This function just returns a \ref lemon::GraphReader "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
 …
   ///\endcode
   ///
+  /// For a complete documentation, please see the \ref GraphReader
+  /// For a complete documentation, please see the
+  /// \ref lemon::GraphReader "GraphReader"
   /// class documentation.
   /// \warning Don't forget to put the \ref GraphReader::run() "run()"
+  /// \warning Don't forget to put the \ref lemon::GraphReader::run() "run()"
   /// to the end of the parameter list.
   /// \relates GraphReader
 …
   GraphReader<TGR> graphReader(TGR& graph, const char* fn) {
     GraphReader<TGR> tmp(graph, fn);
+    return tmp;
+  }
+  template <typename BGR>
+  class BpGraphReader;
+  template <typename TBGR>
+  BpGraphReader<TBGR> bpGraphReader(TBGR& graph, std::istream& is = std::cin);
+  template <typename TBGR>
+  BpGraphReader<TBGR> bpGraphReader(TBGR& graph, const std::string& fn);
+  template <typename TBGR>
+  BpGraphReader<TBGR> bpGraphReader(TBGR& graph, const char *fn);
+  /// \ingroup lemon_io
+  ///
+  /// \brief \ref lgf-format "LGF" reader for bipartite graphs
+  ///
+  /// This utility reads an \ref lgf-format "LGF" file.
+  ///
+  /// It can be used almost the same way as \c GraphReader, but it
+  /// reads the red and blue nodes from separate sections, and these
+  /// sections can contain different set of maps.
+  ///
+  /// The red and blue node maps are read from the corresponding
+  /// sections. If a map is defined with the same name in both of
+  /// these sections, then it can be read as a node map.
+  template <typename BGR>
+  class BpGraphReader {
+  public:
+    typedef BGR Graph;
+  private:
+    TEMPLATE_BPGRAPH_TYPEDEFS(BGR);
+    std::istream* _is;
+    bool local_is;
+    std::string _filename;
+    BGR& _graph;
+    std::string _nodes_caption;
+    std::string _edges_caption;
+    std::string _attributes_caption;
+    typedef std::map<std::string, RedNode> RedNodeIndex;
+    RedNodeIndex _red_node_index;
+    typedef std::map<std::string, BlueNode> BlueNodeIndex;
+    BlueNodeIndex _blue_node_index;
+    typedef std::map<std::string, Edge> EdgeIndex;
+    EdgeIndex _edge_index;
+    typedef std::vector<std::pair<std::string,
+      _reader_bits::MapStorageBase<RedNode>*> > RedNodeMaps;
+    RedNodeMaps _red_node_maps;
+    typedef std::vector<std::pair<std::string,
+      _reader_bits::MapStorageBase<BlueNode>*> > BlueNodeMaps;
+    BlueNodeMaps _blue_node_maps;
+    typedef std::vector<std::pair<std::string,
+      _reader_bits::MapStorageBase<Edge>*> > EdgeMaps;
+    EdgeMaps _edge_maps;
+    typedef std::multimap<std::string, _reader_bits::ValueStorageBase*>
+      Attributes;
+    Attributes _attributes;
+    bool _use_nodes;
+    bool _use_edges;
+    bool _skip_nodes;
+    bool _skip_edges;
+    int line_num;
+    std::istringstream line;
+  public:
+    /// \brief Constructor
+    ///
+    /// Construct an undirected graph reader, which reads from the given
+    /// input stream.
+    BpGraphReader(BGR& graph, std::istream& is = std::cin)
+      : _is(&is), local_is(false), _graph(graph),
+        _use_nodes(false), _use_edges(false),
+        _skip_nodes(false), _skip_edges(false) {}
+    /// \brief Constructor
+    ///
+    /// Construct an undirected graph reader, which reads from the given
+    /// file.
+    BpGraphReader(BGR& graph, const std::string& fn)
+      : _is(new std::ifstream(fn.c_str())), local_is(true),
+        _filename(fn), _graph(graph),
+        _use_nodes(false), _use_edges(false),
+        _skip_nodes(false), _skip_edges(false) {
+      if (!(*_is)) {
+        delete _is;
+        throw IoError("Cannot open file", fn);
+      }
+    }
+    /// \brief Constructor
+    ///
+    /// Construct an undirected graph reader, which reads from the given
+    /// file.
+    BpGraphReader(BGR& graph, const char* fn)
+      : _is(new std::ifstream(fn)), local_is(true),
+        _filename(fn), _graph(graph),
+        _use_nodes(false), _use_edges(false),
+        _skip_nodes(false), _skip_edges(false) {
+      if (!(*_is)) {
+        delete _is;
+        throw IoError("Cannot open file", fn);
+      }
+    }
+    /// \brief Destructor
+    ~BpGraphReader() {
+      for (typename RedNodeMaps::iterator it = _red_node_maps.begin();
+           it != _red_node_maps.end(); ++it) {
+        delete it->second;
+      }
+      for (typename BlueNodeMaps::iterator it = _blue_node_maps.begin();
+           it != _blue_node_maps.end(); ++it) {
+        delete it->second;
+      }
+      for (typename EdgeMaps::iterator it = _edge_maps.begin();
+           it != _edge_maps.end(); ++it) {
+        delete it->second;
+      }
+      for (typename Attributes::iterator it = _attributes.begin();
+           it != _attributes.end(); ++it) {
+        delete it->second;
+      }
+      if (local_is) {
+        delete _is;
+      }
+    }
+  private:
+    template <typename TBGR>
+    friend BpGraphReader<TBGR> bpGraphReader(TBGR& graph, std::istream& is);
+    template <typename TBGR>
+    friend BpGraphReader<TBGR> bpGraphReader(TBGR& graph,
+                                             const std::string& fn);
+    template <typename TBGR>
+    friend BpGraphReader<TBGR> bpGraphReader(TBGR& graph, const char *fn);
+    BpGraphReader(BpGraphReader& other)
+      : _is(other._is), local_is(other.local_is), _graph(other._graph),
+        _use_nodes(other._use_nodes), _use_edges(other._use_edges),
+        _skip_nodes(other._skip_nodes), _skip_edges(other._skip_edges) {
+      other._is = 0;
+      other.local_is = false;
+      _red_node_index.swap(other._red_node_index);
+      _blue_node_index.swap(other._blue_node_index);
+      _edge_index.swap(other._edge_index);
+      _red_node_maps.swap(other._red_node_maps);
+      _blue_node_maps.swap(other._blue_node_maps);
+      _edge_maps.swap(other._edge_maps);
+      _attributes.swap(other._attributes);
+      _nodes_caption = other._nodes_caption;
+      _edges_caption = other._edges_caption;
+      _attributes_caption = other._attributes_caption;
+    }
+    BpGraphReader& operator=(const BpGraphReader&);
+  public:
+    /// \name Reading Rules
+    /// @{
+    /// \brief Node map reading rule
+    ///
+    /// Add a node map reading rule to the reader.
+    template <typename Map>
+    BpGraphReader& nodeMap(const std::string& caption, Map& map) {
+      checkConcept<concepts::WriteMap<Node, typename Map::Value>, Map>();
+      _reader_bits::MapStorageBase<RedNode>* red_storage =
+        new _reader_bits::MapStorage<RedNode, Map>(map);
+      _red_node_maps.push_back(std::make_pair(caption, red_storage));
+      _reader_bits::MapStorageBase<BlueNode>* blue_storage =
+        new _reader_bits::MapStorage<BlueNode, Map>(map);
+      _blue_node_maps.push_back(std::make_pair(caption, blue_storage));
+      return *this;
+    }
+    /// \brief Node map reading rule
+    ///
+    /// Add a node map reading rule with specialized converter to the
+    /// reader.
+    template <typename Map, typename Converter>
+    BpGraphReader& nodeMap(const std::string& caption, Map& map,
+                           const Converter& converter = Converter()) {
+      checkConcept<concepts::WriteMap<Node, typename Map::Value>, Map>();
+      _reader_bits::MapStorageBase<RedNode>* red_storage =
+        new _reader_bits::MapStorage<RedNode, Map, Converter>(map, converter);
+      _red_node_maps.push_back(std::make_pair(caption, red_storage));
+      _reader_bits::MapStorageBase<BlueNode>* blue_storage =
+        new _reader_bits::MapStorage<BlueNode, Map, Converter>(map, converter);
+      _blue_node_maps.push_back(std::make_pair(caption, blue_storage));
+      return *this;
+    }
+    /// Add a red node map reading rule to the reader.
+    template <typename Map>
+    BpGraphReader& redNodeMap(const std::string& caption, Map& map) {
+      checkConcept<concepts::WriteMap<RedNode, typename Map::Value>, Map>();
+      _reader_bits::MapStorageBase<RedNode>* storage =
+        new _reader_bits::MapStorage<RedNode, Map>(map);
+      _red_node_maps.push_back(std::make_pair(caption, storage));
+      return *this;
+    }
+    /// \brief Red node map reading rule
+    ///
+    /// Add a red node map node reading rule with specialized converter to
+    /// the reader.
+    template <typename Map, typename Converter>
+    BpGraphReader& redNodeMap(const std::string& caption, Map& map,
+                              const Converter& converter = Converter()) {
+      checkConcept<concepts::WriteMap<RedNode, typename Map::Value>, Map>();
+      _reader_bits::MapStorageBase<RedNode>* storage =
+        new _reader_bits::MapStorage<RedNode, Map, Converter>(map, converter);
+      _red_node_maps.push_back(std::make_pair(caption, storage));
+      return *this;
+    }
+    /// Add a blue node map reading rule to the reader.
+    template <typename Map>
+    BpGraphReader& blueNodeMap(const std::string& caption, Map& map) {
+      checkConcept<concepts::WriteMap<BlueNode, typename Map::Value>, Map>();
+      _reader_bits::MapStorageBase<BlueNode>* storage =
+        new _reader_bits::MapStorage<BlueNode, Map>(map);
+      _blue_node_maps.push_back(std::make_pair(caption, storage));
+      return *this;
+    }
+    /// \brief Blue node map reading rule
+    ///
+    /// Add a blue node map reading rule with specialized converter to
+    /// the reader.
+    template <typename Map, typename Converter>
+    BpGraphReader& blueNodeMap(const std::string& caption, Map& map,
+                               const Converter& converter = Converter()) {
+      checkConcept<concepts::WriteMap<BlueNode, typename Map::Value>, Map>();
+      _reader_bits::MapStorageBase<BlueNode>* storage =
+        new _reader_bits::MapStorage<BlueNode, Map, Converter>(map, converter);
+      _blue_node_maps.push_back(std::make_pair(caption, storage));
+      return *this;
+    }
+    /// \brief Edge map reading rule
+    ///
+    /// Add an edge map reading rule to the reader.
+    template <typename Map>
+    BpGraphReader& edgeMap(const std::string& caption, Map& map) {
+      checkConcept<concepts::WriteMap<Edge, typename Map::Value>, Map>();
+      _reader_bits::MapStorageBase<Edge>* storage =
+        new _reader_bits::MapStorage<Edge, Map>(map);
+      _edge_maps.push_back(std::make_pair(caption, storage));
+      return *this;
+    }
+    /// \brief Edge map reading rule
+    ///
+    /// Add an edge map reading rule with specialized converter to the
+    /// reader.
+    template <typename Map, typename Converter>
+    BpGraphReader& edgeMap(const std::string& caption, Map& map,
+                          const Converter& converter = Converter()) {
+      checkConcept<concepts::WriteMap<Edge, typename Map::Value>, Map>();
+      _reader_bits::MapStorageBase<Edge>* storage =
+        new _reader_bits::MapStorage<Edge, Map, Converter>(map, converter);
+      _edge_maps.push_back(std::make_pair(caption, storage));
+      return *this;
+    }
+    /// \brief Arc map reading rule
+    ///
+    /// Add an arc map reading rule to the reader.
+    template <typename Map>
+    BpGraphReader& arcMap(const std::string& caption, Map& map) {
+      checkConcept<concepts::WriteMap<Arc, typename Map::Value>, Map>();
+      _reader_bits::MapStorageBase<Edge>* forward_storage =
+        new _reader_bits::GraphArcMapStorage<Graph, true, Map>(_graph, map);
+      _edge_maps.push_back(std::make_pair('+' + caption, forward_storage));
+      _reader_bits::MapStorageBase<Edge>* backward_storage =
+        new _reader_bits::GraphArcMapStorage<BGR, false, Map>(_graph, map);
+      _edge_maps.push_back(std::make_pair('-' + caption, backward_storage));
+      return *this;
+    }
+    /// \brief Arc map reading rule
+    ///
+    /// Add an arc map reading rule with specialized converter to the
+    /// reader.
+    template <typename Map, typename Converter>
+    BpGraphReader& arcMap(const std::string& caption, Map& map,
+                          const Converter& converter = Converter()) {
+      checkConcept<concepts::WriteMap<Arc, typename Map::Value>, Map>();
+      _reader_bits::MapStorageBase<Edge>* forward_storage =
+        new _reader_bits::GraphArcMapStorage<BGR, 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<BGR, false, Map, Converter>
+        (_graph, map, converter);
+      _edge_maps.push_back(std::make_pair('-' + caption, backward_storage));
+      return *this;
+    }
+    /// \brief Attribute reading rule
+    ///
+    /// Add an attribute reading rule to the reader.
+    template <typename Value>
+    BpGraphReader& attribute(const std::string& caption, Value& value) {
+      _reader_bits::ValueStorageBase* storage =
+        new _reader_bits::ValueStorage<Value>(value);
+      _attributes.insert(std::make_pair(caption, storage));
+      return *this;
+    }
+    /// \brief Attribute reading rule
+    ///
+    /// Add an attribute reading rule with specialized converter to the
+    /// reader.
+    template <typename Value, typename Converter>
+    BpGraphReader& attribute(const std::string& caption, Value& value,
+                             const Converter& converter = Converter()) {
+      _reader_bits::ValueStorageBase* storage =
+        new _reader_bits::ValueStorage<Value, Converter>(value, converter);
+      _attributes.insert(std::make_pair(caption, storage));
+      return *this;
+    }
+    /// \brief Node reading rule
+    ///
+    /// Add a node reading rule to reader.
+    BpGraphReader& node(const std::string& caption, Node& node) {
+      typedef _reader_bits::DoubleMapLookUpConverter<
+        Node, RedNodeIndex, BlueNodeIndex> Converter;
+      Converter converter(_red_node_index, _blue_node_index);
+      _reader_bits::ValueStorageBase* storage =
+        new _reader_bits::ValueStorage<Node, Converter>(node, converter);
+      _attributes.insert(std::make_pair(caption, storage));
+      return *this;
+    }
+    /// \brief Red node reading rule
+    ///
+    /// Add a red node reading rule to reader.
+    BpGraphReader& redNode(const std::string& caption, RedNode& node) {
+      typedef _reader_bits::MapLookUpConverter<RedNode> Converter;
+      Converter converter(_red_node_index);
+      _reader_bits::ValueStorageBase* storage =
+        new _reader_bits::ValueStorage<RedNode, Converter>(node, converter);
+      _attributes.insert(std::make_pair(caption, storage));
+      return *this;
+    }
+    /// \brief Blue node reading rule
+    ///
+    /// Add a blue node reading rule to reader.
+    BpGraphReader& blueNode(const std::string& caption, BlueNode& node) {
+      typedef _reader_bits::MapLookUpConverter<BlueNode> Converter;
+      Converter converter(_blue_node_index);
+      _reader_bits::ValueStorageBase* storage =
+        new _reader_bits::ValueStorage<BlueNode, Converter>(node, converter);
+      _attributes.insert(std::make_pair(caption, storage));
+      return *this;
+    }
+    /// \brief Edge reading rule
+    ///
+    /// Add an edge reading rule to reader.
+    BpGraphReader& edge(const std::string& caption, Edge& edge) {
+      typedef _reader_bits::MapLookUpConverter<Edge> Converter;
+      Converter converter(_edge_index);
+      _reader_bits::ValueStorageBase* storage =
+        new _reader_bits::ValueStorage<Edge, Converter>(edge, converter);
+      _attributes.insert(std::make_pair(caption, storage));
+      return *this;
+    }
+    /// \brief Arc reading rule
+    ///
+    /// Add an arc reading rule to reader.
+    BpGraphReader& arc(const std::string& caption, Arc& arc) {
+      typedef _reader_bits::GraphArcLookUpConverter<BGR> Converter;
+      Converter converter(_graph, _edge_index);
+      _reader_bits::ValueStorageBase* storage =
+        new _reader_bits::ValueStorage<Arc, Converter>(arc, converter);
+      _attributes.insert(std::make_pair(caption, storage));
+      return *this;
+    }
+    /// @}
+    /// \name Select Section by Name
+    /// @{
+    /// \brief Set \c \@nodes section to be read
+    ///
+    /// Set \c \@nodes section to be read.
+    BpGraphReader& nodes(const std::string& caption) {
+      _nodes_caption = caption;
+      return *this;
+    }
+    /// \brief Set \c \@edges section to be read
+    ///
+    /// Set \c \@edges section to be read.
+    BpGraphReader& edges(const std::string& caption) {
+      _edges_caption = caption;
+      return *this;
+    }
+    /// \brief Set \c \@attributes section to be read
+    ///
+    /// Set \c \@attributes section to be read.
+    BpGraphReader& attributes(const std::string& caption) {
+      _attributes_caption = caption;
+      return *this;
+    }
+    /// @}
+    /// \name Using Previously Constructed Node or Edge Set
+    /// @{
+    /// \brief Use previously constructed node set
+    ///
+    /// Use previously constructed node set, and specify the node
+    /// label map.
+    template <typename Map>
+    BpGraphReader& useNodes(const Map& map) {
+      checkConcept<concepts::ReadMap<Node, typename Map::Value>, Map>();
+      LEMON_ASSERT(!_use_nodes, "Multiple usage of useNodes() member");
+      _use_nodes = true;
+      _writer_bits::DefaultConverter<typename Map::Value> converter;
+      for (RedNodeIt n(_graph); n != INVALID; ++n) {
+        _red_node_index.insert(std::make_pair(converter(map[n]), n));
+      }
+      for (BlueNodeIt n(_graph); n != INVALID; ++n) {
+        _blue_node_index.insert(std::make_pair(converter(map[n]), n));
+      }
+      return *this;
+    }
+    /// \brief Use previously constructed node set
+    ///
+    /// Use previously constructed node set, and specify the node
+    /// label map and a functor which converts the label map values to
+    /// \c std::string.
+    template <typename Map, typename Converter>
+    BpGraphReader& useNodes(const Map& map,
+                            const Converter& converter = Converter()) {
+      checkConcept<concepts::ReadMap<Node, typename Map::Value>, Map>();
+      LEMON_ASSERT(!_use_nodes, "Multiple usage of useNodes() member");
+      _use_nodes = true;
+      for (RedNodeIt n(_graph); n != INVALID; ++n) {
+        _red_node_index.insert(std::make_pair(converter(map[n]), n));
+      }
+      for (BlueNodeIt n(_graph); n != INVALID; ++n) {
+        _blue_node_index.insert(std::make_pair(converter(map[n]), n));
+      }
+      return *this;
+    }
+    /// \brief Use previously constructed edge set
+    ///
+    /// Use previously constructed edge set, and specify the edge
+    /// label map.
+    template <typename Map>
+    BpGraphReader& useEdges(const Map& map) {
+      checkConcept<concepts::ReadMap<Edge, typename Map::Value>, Map>();
+      LEMON_ASSERT(!_use_edges, "Multiple usage of useEdges() member");
+      _use_edges = true;
+      _writer_bits::DefaultConverter<typename Map::Value> converter;
+      for (EdgeIt a(_graph); a != INVALID; ++a) {
+        _edge_index.insert(std::make_pair(converter(map[a]), a));
+      }
+      return *this;
+    }
+    /// \brief Use previously constructed edge set
+    ///
+    /// Use previously constructed edge set, and specify the edge
+    /// label map and a functor which converts the label map values to
+    /// \c std::string.
+    template <typename Map, typename Converter>
+    BpGraphReader& useEdges(const Map& map,
+                            const Converter& converter = Converter()) {
+      checkConcept<concepts::ReadMap<Edge, typename Map::Value>, Map>();
+      LEMON_ASSERT(!_use_edges, "Multiple usage of useEdges() member");
+      _use_edges = true;
+      for (EdgeIt a(_graph); a != INVALID; ++a) {
+        _edge_index.insert(std::make_pair(converter(map[a]), a));
+      }
+      return *this;
+    }
+    /// \brief Skip the reading of node section
+    ///
+    /// Omit the reading of the node section. This implies that each node
+    /// map reading rule will be abandoned, and the nodes of the graph
+    /// will not be constructed, which usually cause that the edge set
+    /// could not be read due to lack of node name
+    /// could not be read due to lack of node name resolving.
+    /// Therefore \c skipEdges() function should also be used, or
+    /// \c useNodes() should be used to specify the label of the nodes.
+    BpGraphReader& skipNodes() {
+      LEMON_ASSERT(!_skip_nodes, "Skip nodes already set");
+      _skip_nodes = true;
+      return *this;
+    }
+    /// \brief Skip the reading of edge section
+    ///
+    /// Omit the reading of the edge section. This implies that each edge
+    /// map reading rule will be abandoned, and the edges of the graph
+    /// will not be constructed.
+    BpGraphReader& skipEdges() {
+      LEMON_ASSERT(!_skip_edges, "Skip edges already set");
+      _skip_edges = true;
+      return *this;
+    }
+    /// @}
+  private:
+    bool readLine() {
+      std::string str;
+      while(++line_num, std::getline(*_is, str)) {
+        line.clear(); line.str(str);
+        char c;
+        if (line >> std::ws >> c && c != '#') {
+          line.putback(c);
+          return true;
+        }
+      }
+      return false;
+    }
+    bool readSuccess() {
+      return static_cast<bool>(*_is);
+    }
+    void skipSection() {
+      char c;
+      while (readSuccess() && line >> c && c != '@') {
+        readLine();
+      }
+      if (readSuccess()) {
+        line.putback(c);
+      }
+    }
+    void readRedNodes() {
+      std::vector<int> map_index(_red_node_maps.size());
+      int map_num, label_index;
+      char c;
+      if (!readLine() || !(line >> c) || c == '@') {
+        if (readSuccess() && line) line.putback(c);
+        if (!_red_node_maps.empty())
+          throw FormatError("Cannot find map names");
+        return;
+      }
+      line.putback(c);
+      {
+        std::map<std::string, int> maps;
+        std::string map;
+        int index = 0;
+        while (_reader_bits::readToken(line, map)) {
+          if (maps.find(map) != maps.end()) {
+            std::ostringstream msg;
+            msg << "Multiple occurence of red node map: " << map;
+            throw FormatError(msg.str());
+          }
+          maps.insert(std::make_pair(map, index));
+          ++index;
+        }
+        for (int i = 0; i < static_cast<int>(_red_node_maps.size()); ++i) {
+          std::map<std::string, int>::iterator jt =
+            maps.find(_red_node_maps[i].first);
+          if (jt == maps.end()) {
+            std::ostringstream msg;
+            msg << "Map not found: " << _red_node_maps[i].first;
+            throw FormatError(msg.str());
+          }
+          map_index[i] = jt->second;
+        }
+        {
+          std::map<std::string, int>::iterator jt = maps.find("label");
+          if (jt != maps.end()) {
+            label_index = jt->second;
+          } else {
+            label_index = -1;
+          }
+        }
+        map_num = maps.size();
+      }
+      while (readLine() && line >> c && c != '@') {
+        line.putback(c);
+        std::vector<std::string> tokens(map_num);
+        for (int i = 0; i < map_num; ++i) {
+          if (!_reader_bits::readToken(line, tokens[i])) {
+            std::ostringstream msg;
+            msg << "Column not found (" << i + 1 << ")";
+            throw FormatError(msg.str());
+          }
+        }
+        if (line >> std::ws >> c)
+          throw FormatError("Extra character at the end of line");
+        RedNode n;
+        if (!_use_nodes) {
+          n = _graph.addRedNode();
+          if (label_index != -1)
+            _red_node_index.insert(std::make_pair(tokens[label_index], n));
+        } else {
+          if (label_index == -1)
+            throw FormatError("Label map not found");
+          typename std::map<std::string, RedNode>::iterator it =
+            _red_node_index.find(tokens[label_index]);
+          if (it == _red_node_index.end()) {
+            std::ostringstream msg;
+            msg << "Node with label not found: " << tokens[label_index];
+            throw FormatError(msg.str());
+          }
+          n = it->second;
+        }
+        for (int i = 0; i < static_cast<int>(_red_node_maps.size()); ++i) {
+          _red_node_maps[i].second->set(n, tokens[map_index[i]]);
+        }
+      }
+      if (readSuccess()) {
+        line.putback(c);
+      }
+    }
+    void readBlueNodes() {
+      std::vector<int> map_index(_blue_node_maps.size());
+      int map_num, label_index;
+      char c;
+      if (!readLine() || !(line >> c) || c == '@') {
+        if (readSuccess() && line) line.putback(c);
+        if (!_blue_node_maps.empty())
+          throw FormatError("Cannot find map names");
+        return;
+      }
+      line.putback(c);
+      {
+        std::map<std::string, int> maps;
+        std::string map;
+        int index = 0;
+        while (_reader_bits::readToken(line, map)) {
+          if (maps.find(map) != maps.end()) {
+            std::ostringstream msg;
+            msg << "Multiple occurence of blue node map: " << map;
+            throw FormatError(msg.str());
+          }
+          maps.insert(std::make_pair(map, index));
+          ++index;
+        }
+        for (int i = 0; i < static_cast<int>(_blue_node_maps.size()); ++i) {
+          std::map<std::string, int>::iterator jt =
+            maps.find(_blue_node_maps[i].first);
+          if (jt == maps.end()) {
+            std::ostringstream msg;
+            msg << "Map not found: " << _blue_node_maps[i].first;
+            throw FormatError(msg.str());
+          }
+          map_index[i] = jt->second;
+        }
+        {
+          std::map<std::string, int>::iterator jt = maps.find("label");
+          if (jt != maps.end()) {
+            label_index = jt->second;
+          } else {
+            label_index = -1;
+          }
+        }
+        map_num = maps.size();
+      }
+      while (readLine() && line >> c && c != '@') {
+        line.putback(c);
+        std::vector<std::string> tokens(map_num);
+        for (int i = 0; i < map_num; ++i) {
+          if (!_reader_bits::readToken(line, tokens[i])) {
+            std::ostringstream msg;
+            msg << "Column not found (" << i + 1 << ")";
+            throw FormatError(msg.str());
+          }
+        }
+        if (line >> std::ws >> c)
+          throw FormatError("Extra character at the end of line");
+        BlueNode n;
+        if (!_use_nodes) {
+          n = _graph.addBlueNode();
+          if (label_index != -1)
+            _blue_node_index.insert(std::make_pair(tokens[label_index], n));
+        } else {
+          if (label_index == -1)
+            throw FormatError("Label map not found");
+          typename std::map<std::string, BlueNode>::iterator it =
+            _blue_node_index.find(tokens[label_index]);
+          if (it == _blue_node_index.end()) {
+            std::ostringstream msg;
+            msg << "Node with label not found: " << tokens[label_index];
+            throw FormatError(msg.str());
+          }
+          n = it->second;
+        }
+        for (int i = 0; i < static_cast<int>(_blue_node_maps.size()); ++i) {
+          _blue_node_maps[i].second->set(n, tokens[map_index[i]]);
+        }
+      }
+      if (readSuccess()) {
+        line.putback(c);
+      }
+    }
+    void readEdges() {
+      std::vector<int> map_index(_edge_maps.size());
+      int map_num, label_index;
+      char c;
+      if (!readLine() || !(line >> c) || c == '@') {
+        if (readSuccess() && line) line.putback(c);
+        if (!_edge_maps.empty())
+          throw FormatError("Cannot find map names");
+        return;
+      }
+      line.putback(c);
+      {
+        std::map<std::string, int> maps;
+        std::string map;
+        int index = 0;
+        while (_reader_bits::readToken(line, map)) {
+          if (maps.find(map) != maps.end()) {
+            std::ostringstream msg;
+            msg << "Multiple occurence of edge map: " << map;
+            throw FormatError(msg.str());
+          }
+          maps.insert(std::make_pair(map, index));
+          ++index;
+        }
+        for (int i = 0; i < static_cast<int>(_edge_maps.size()); ++i) {
+          std::map<std::string, int>::iterator jt =
+            maps.find(_edge_maps[i].first);
+          if (jt == maps.end()) {
+            std::ostringstream msg;
+            msg << "Map not found: " << _edge_maps[i].first;
+            throw FormatError(msg.str());
+          }
+          map_index[i] = jt->second;
+        }
+        {
+          std::map<std::string, int>::iterator jt = maps.find("label");
+          if (jt != maps.end()) {
+            label_index = jt->second;
+          } else {
+            label_index = -1;
+          }
+        }
+        map_num = maps.size();
+      }
+      while (readLine() && line >> c && c != '@') {
+        line.putback(c);
+        std::string source_token;
+        std::string target_token;
+        if (!_reader_bits::readToken(line, source_token))
+          throw FormatError("Red node not found");
+        if (!_reader_bits::readToken(line, target_token))
+          throw FormatError("Blue node not found");
+        std::vector<std::string> tokens(map_num);
+        for (int i = 0; i < map_num; ++i) {
+          if (!_reader_bits::readToken(line, tokens[i])) {
+            std::ostringstream msg;
+            msg << "Column not found (" << i + 1 << ")";
+            throw FormatError(msg.str());
+          }
+        }
+        if (line >> std::ws >> c)
+          throw FormatError("Extra character at the end of line");
+        Edge e;
+        if (!_use_edges) {
+          typename RedNodeIndex::iterator rit =
+            _red_node_index.find(source_token);
+          if (rit == _red_node_index.end()) {
+            std::ostringstream msg;
+            msg << "Item not found: " << source_token;
+            throw FormatError(msg.str());
+          }
+          RedNode source = rit->second;
+          typename BlueNodeIndex::iterator it =
+            _blue_node_index.find(target_token);
+          if (it == _blue_node_index.end()) {
+            std::ostringstream msg;
+            msg << "Item not found: " << target_token;
+            throw FormatError(msg.str());
+          }
+          BlueNode target = it->second;
+          // It is checked that source is red and
+          // target is blue, so this should be safe:
+          e = _graph.addEdge(source, target);
+          if (label_index != -1)
+            _edge_index.insert(std::make_pair(tokens[label_index], e));
+        } else {
+          if (label_index == -1)
+            throw FormatError("Label map not found");
+          typename std::map<std::string, Edge>::iterator it =
+            _edge_index.find(tokens[label_index]);
+          if (it == _edge_index.end()) {
+            std::ostringstream msg;
+            msg << "Edge with label not found: " << tokens[label_index];
+            throw FormatError(msg.str());
+          }
+          e = it->second;
+        }
+        for (int i = 0; i < static_cast<int>(_edge_maps.size()); ++i) {
+          _edge_maps[i].second->set(e, tokens[map_index[i]]);
+        }
+      }
+      if (readSuccess()) {
+        line.putback(c);
+      }
+    }
+    void readAttributes() {
+      std::set<std::string> read_attr;
+      char c;
+      while (readLine() && line >> c && c != '@') {
+        line.putback(c);
+        std::string attr, token;
+        if (!_reader_bits::readToken(line, attr))
+          throw FormatError("Attribute name not found");
+        if (!_reader_bits::readToken(line, token))
+          throw FormatError("Attribute value not found");
+        if (line >> c)
+          throw FormatError("Extra character at the end of line");
+        {
+          std::set<std::string>::iterator it = read_attr.find(attr);
+          if (it != read_attr.end()) {
+            std::ostringstream msg;
+            msg << "Multiple occurence of attribute: " << attr;
+            throw FormatError(msg.str());
+          }
+          read_attr.insert(attr);
+        }
+        {
+          typename Attributes::iterator it = _attributes.lower_bound(attr);
+          while (it != _attributes.end() && it->first == attr) {
+            it->second->set(token);
+            ++it;
+          }
+        }
+      }
+      if (readSuccess()) {
+        line.putback(c);
+      }
+      for (typename Attributes::iterator it = _attributes.begin();
+           it != _attributes.end(); ++it) {
+        if (read_attr.find(it->first) == read_attr.end()) {
+          std::ostringstream msg;
+          msg << "Attribute not found: " << it->first;
+          throw FormatError(msg.str());
+        }
+      }
+    }
+  public:
+    /// \name Execution of the Reader
+    /// @{
+    /// \brief Start the batch processing
+    ///
+    /// This function starts the batch processing
+    void run() {
+      LEMON_ASSERT(_is != 0, "This reader assigned to an other reader");
+      bool red_nodes_done = _skip_nodes;
+      bool blue_nodes_done = _skip_nodes;
+      bool edges_done = _skip_edges;
+      bool attributes_done = false;
+      line_num = 0;
+      readLine();
+      skipSection();
+      while (readSuccess()) {
+        try {
+          char c;
+          std::string section, caption;
+          line >> c;
+          _reader_bits::readToken(line, section);
+          _reader_bits::readToken(line, caption);
+          if (line >> c)
+            throw FormatError("Extra character at the end of line");
+          if (section == "red_nodes" && !red_nodes_done) {
+            if (_nodes_caption.empty() || _nodes_caption == caption) {
+              readRedNodes();
+              red_nodes_done = true;
+            }
+          } else if (section == "blue_nodes" && !blue_nodes_done) {
+            if (_nodes_caption.empty() || _nodes_caption == caption) {
+              readBlueNodes();
+              blue_nodes_done = true;
+            }
+          } else if ((section == "edges" || section == "arcs") &&
+                     !edges_done) {
+            if (_edges_caption.empty() || _edges_caption == caption) {
+              readEdges();
+              edges_done = true;
+            }
+          } else if (section == "attributes" && !attributes_done) {
+            if (_attributes_caption.empty() || _attributes_caption == caption) {
+              readAttributes();
+              attributes_done = true;
+            }
+          } else {
+            readLine();
+            skipSection();
+          }
+        } catch (FormatError& error) {
+          error.line(line_num);
+          error.file(_filename);
+          throw;
+        }
+      }
+      if (!red_nodes_done) {
+        throw FormatError("Section @red_nodes not found");
+      }
+      if (!blue_nodes_done) {
+        throw FormatError("Section @blue_nodes not found");
+      }
+      if (!edges_done) {
+        throw FormatError("Section @edges not found");
+      }
+      if (!attributes_done && !_attributes.empty()) {
+        throw FormatError("Section @attributes not found");
+      }
+    }
+    /// @}
+  };
+  /// \ingroup lemon_io
+  ///
+  /// \brief Return a \ref lemon::BpGraphReader "BpGraphReader" class
+  ///
+  /// This function just returns a \ref lemon::BpGraphReader
+  /// "BpGraphReader" 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 bipartite 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
+  ///ListBpGraph graph;
+  ///ListBpGraph::EdgeMap<int> weight(graph);
+  ///bpGraphReader(graph, std::cin).
+  ///  edgeMap("weight", weight).
+  ///  run();
+  ///\endcode
+  ///
+  /// For a complete documentation, please see the
+  /// \ref lemon::BpGraphReader "BpGraphReader"
+  /// class documentation.
+  /// \warning Don't forget to put the \ref lemon::BpGraphReader::run() "run()"
+  /// to the end of the parameter list.
+  /// \relates BpGraphReader
+  /// \sa bpGraphReader(TBGR& graph, const std::string& fn)
+  /// \sa bpGraphReader(TBGR& graph, const char* fn)
+  template <typename TBGR>
+  BpGraphReader<TBGR> bpGraphReader(TBGR& graph, std::istream& is) {
+    BpGraphReader<TBGR> tmp(graph, is);
+    return tmp;
+  }
+  /// \brief Return a \ref BpGraphReader class
+  ///
+  /// This function just returns a \ref BpGraphReader class.
+  /// \relates BpGraphReader
+  /// \sa bpGraphReader(TBGR& graph, std::istream& is)
+  template <typename TBGR>
+  BpGraphReader<TBGR> bpGraphReader(TBGR& graph, const std::string& fn) {
+    BpGraphReader<TBGR> tmp(graph, fn);
+    return tmp;
+  }
+  /// \brief Return a \ref BpGraphReader class
+  ///
+  /// This function just returns a \ref BpGraphReader class.
+  /// \relates BpGraphReader
+  /// \sa bpGraphReader(TBGR& graph, std::istream& is)
+  template <typename TBGR>
+  BpGraphReader<TBGR> bpGraphReader(TBGR& graph, const char* fn) {
+    BpGraphReader<TBGR> tmp(graph, fn);
     return tmp;
+  }

lemon/lgf_writer.h

-                      r646
+                      r1270
  * This file is a part of LEMON, a generic C++ optimization library.
+ *
  * Copyright (C) 2003-2009
+ * Copyright (C) 2003-2013
  * Egervary Jeno Kombinatorikus Optimalizalasi Kutatocsoport
  * (Egervary Research Group on Combinatorial Optimization, EGRES).
 …
     };
+    template <typename Value>
+    template <typename Value,
+              typename Map = std::map<Value, std::string> >
     struct MapLookUpConverter {
       const std::map<Value, std::string>& _map;
       MapLookUpConverter(const std::map<Value, std::string>& map)
+      const Map& _map;
+      MapLookUpConverter(const Map& map)
         : _map(map) {}
+      std::string operator()(const Value& str) {
+        typename std::map<Value, std::string>::const_iterator it =
+          _map.find(str);
+      std::string operator()(const Value& value) {
+        typename Map::const_iterator it = _map.find(value);
         if (it == _map.end()) {
           throw FormatError("Item not found");
+        }
         return it->second;
+      }
+    };
+    template <typename Value,
+              typename Map1 = std::map<Value, std::string>,
+              typename Map2 = std::map<Value, std::string> >
+    struct DoubleMapLookUpConverter {
+      const Map1& _map1;
+      const Map2& _map2;
+      DoubleMapLookUpConverter(const Map1& map1, const Map2& map2)
+        : _map1(map1), _map2(map2) {}
+      std::string operator()(const Value& value) {
+        typename Map1::const_iterator it1 = _map1.find(value);
+        typename Map1::const_iterator it2 = _map2.find(value);
+        if (it1 == _map1.end()) {
+          if (it2 == _map2.end()) {
+            throw FormatError("Item not found");
+          } else {
+            return it2->second;
+          }
+        } else {
+          if (it2 == _map2.end()) {
+            return it1->second;
+          } else {
+            throw FormatError("Item is ambigous");
+          }
+        }
+      }
     };
 …
   template <typename TDGR>
   DigraphWriter<TDGR> digraphWriter(const TDGR& digraph,
+  DigraphWriter<TDGR> digraphWriter(const TDGR& digraph,
                                    std::ostream& os = std::cout);
   template <typename TDGR>
 …
     template <typename TDGR>
     friend DigraphWriter<TDGR> digraphWriter(const TDGR& digraph,
+    friend DigraphWriter<TDGR> digraphWriter(const TDGR& digraph,
                                              std::ostream& os);
     template <typename TDGR>
 …
   /// \ingroup lemon_io
   ///
+  /// \brief Return a \ref DigraphWriter class
+  ///
+  /// This function just returns a \ref DigraphWriter class.
+  /// \brief Return a \ref lemon::DigraphWriter "DigraphWriter" class
+  ///
+  /// This function just returns a \ref lemon::DigraphWriter
+  /// "DigraphWriter" class.
   ///
   /// With this function a digraph can be write to a file or output
 …
   ///\endcode
   ///
+  /// For a complete documentation, please see the \ref DigraphWriter
+  /// For a complete documentation, please see the
+  /// \ref lemon::DigraphWriter "DigraphWriter"
   /// class documentation.
   /// \warning Don't forget to put the \ref DigraphWriter::run() "run()"
+  /// \warning Don't forget to put the \ref lemon::DigraphWriter::run() "run()"
   /// to the end of the parameter list.
   /// \relates DigraphWriter
 …
   /// \sa digraphWriter(const TDGR& digraph, std::ostream& os)
   template <typename TDGR>
   DigraphWriter<TDGR> digraphWriter(const TDGR& digraph,
+  DigraphWriter<TDGR> digraphWriter(const TDGR& digraph,
                                     const std::string& fn) {
     DigraphWriter<TDGR> tmp(digraph, fn);
 …
   /// \ingroup lemon_io
   ///
   /// \brief \ref lgf-format "LGF" writer for directed graphs
+  /// \brief \ref lgf-format "LGF" writer for undirected graphs
   ///
   /// This utility writes an \ref lgf-format "LGF" file.
 …
     /// \brief Constructor
     ///
     /// Construct a directed graph writer, which writes to the given
     /// output stream.
+    /// Construct an undirected graph writer, which writes to the
+    /// given output stream.
     GraphWriter(const GR& graph, std::ostream& os = std::cout)
       : _os(&os), local_os(false), _graph(graph),
 …
     /// \brief Constructor
     ///
     /// Construct a directed graph writer, which writes to the given
+    /// Construct a undirected graph writer, which writes to the given
     /// output file.
     GraphWriter(const GR& graph, const std::string& fn)
 …
     /// \brief Constructor
     ///
     /// Construct a directed graph writer, which writes to the given
+    /// Construct a undirected graph writer, which writes to the given
     /// output file.
     GraphWriter(const GR& graph, const char* fn)
 …
     friend GraphWriter<TGR> graphWriter(const TGR& graph, std::ostream& os);
     template <typename TGR>
     friend GraphWriter<TGR> graphWriter(const TGR& graph,
+    friend GraphWriter<TGR> graphWriter(const TGR& graph,
                                         const std::string& fn);
     template <typename TGR>
     friend GraphWriter<TGR> graphWriter(const TGR& graph, const char *fn);
     GraphWriter(GraphWriter& other)
       : _os(other._os), local_os(other.local_os), _graph(other._graph),
 …
+    }
     /// \brief Add an additional caption to the \c \@arcs section
     ///
     /// Add an additional caption to the \c \@arcs section.
+    /// \brief Add an additional caption to the \c \@edges section
+    ///
+    /// Add an additional caption to the \c \@edges section.
     GraphWriter& edges(const std::string& caption) {
       _edges_caption = caption;
 …
   /// \ingroup lemon_io
   ///
   /// \brief Return a \ref GraphWriter class
   ///
   /// This function just returns a \ref GraphWriter class.
+  /// \brief Return a \ref lemon::GraphWriter "GraphWriter" class
+  ///
+  /// This function just returns a \ref lemon::GraphWriter "GraphWriter" class.
   ///
   /// With this function a graph can be write to a file or output
 …
   ///\endcode
   ///
+  /// For a complete documentation, please see the \ref GraphWriter
+  /// For a complete documentation, please see the
+  /// \ref lemon::GraphWriter "GraphWriter"
   /// class documentation.
   /// \warning Don't forget to put the \ref GraphWriter::run() "run()"
+  /// \warning Don't forget to put the \ref lemon::GraphWriter::run() "run()"
   /// to the end of the parameter list.
   /// \relates GraphWriter
 …
   GraphWriter<TGR> graphWriter(const TGR& graph, const char* fn) {
     GraphWriter<TGR> tmp(graph, fn);
+    return tmp;
+  }
+  template <typename BGR>
+  class BpGraphWriter;
+  template <typename TBGR>
+  BpGraphWriter<TBGR> bpGraphWriter(const TBGR& graph,
+                                    std::ostream& os = std::cout);
+  template <typename TBGR>
+  BpGraphWriter<TBGR> bpGraphWriter(const TBGR& graph, const std::string& fn);
+  template <typename TBGR>
+  BpGraphWriter<TBGR> bpGraphWriter(const TBGR& graph, const char* fn);
+  /// \ingroup lemon_io
+  ///
+  /// \brief \ref lgf-format "LGF" writer for undirected bipartite graphs
+  ///
+  /// This utility writes an \ref lgf-format "LGF" file.
+  ///
+  /// It can be used almost the same way as \c GraphWriter, but it
+  /// reads the red and blue nodes from separate sections, and these
+  /// sections can contain different set of maps.
+  ///
+  /// The red and blue node maps are written to the corresponding
+  /// sections. The node maps are written to both of these sections
+  /// with the same map name.
+  template <typename BGR>
+  class BpGraphWriter {
+  public:
+    typedef BGR BpGraph;
+    TEMPLATE_BPGRAPH_TYPEDEFS(BGR);
+  private:
+    std::ostream* _os;
+    bool local_os;
+    const BGR& _graph;
+    std::string _nodes_caption;
+    std::string _edges_caption;
+    std::string _attributes_caption;
+    typedef std::map<Node, std::string> RedNodeIndex;
+    RedNodeIndex _red_node_index;
+    typedef std::map<Node, std::string> BlueNodeIndex;
+    BlueNodeIndex _blue_node_index;
+    typedef std::map<Edge, std::string> EdgeIndex;
+    EdgeIndex _edge_index;
+    typedef std::vector<std::pair<std::string,
+      _writer_bits::MapStorageBase<RedNode>* > > RedNodeMaps;
+    RedNodeMaps _red_node_maps;
+    typedef std::vector<std::pair<std::string,
+      _writer_bits::MapStorageBase<BlueNode>* > > BlueNodeMaps;
+    BlueNodeMaps _blue_node_maps;
+    typedef std::vector<std::pair<std::string,
+      _writer_bits::MapStorageBase<Edge>* > >EdgeMaps;
+    EdgeMaps _edge_maps;
+    typedef std::vector<std::pair<std::string,
+      _writer_bits::ValueStorageBase*> > Attributes;
+    Attributes _attributes;
+    bool _skip_nodes;
+    bool _skip_edges;
+  public:
+    /// \brief Constructor
+    ///
+    /// Construct a bipartite graph writer, which writes to the given
+    /// output stream.
+    BpGraphWriter(const BGR& graph, std::ostream& os = std::cout)
+      : _os(&os), local_os(false), _graph(graph),
+        _skip_nodes(false), _skip_edges(false) {}
+    /// \brief Constructor
+    ///
+    /// Construct a bipartite graph writer, which writes to the given
+    /// output file.
+    BpGraphWriter(const BGR& graph, const std::string& fn)
+      : _os(new std::ofstream(fn.c_str())), local_os(true), _graph(graph),
+        _skip_nodes(false), _skip_edges(false) {
+      if (!(*_os)) {
+        delete _os;
+        throw IoError("Cannot write file", fn);
+      }
+    }
+    /// \brief Constructor
+    ///
+    /// Construct a bipartite graph writer, which writes to the given
+    /// output file.
+    BpGraphWriter(const BGR& graph, const char* fn)
+      : _os(new std::ofstream(fn)), local_os(true), _graph(graph),
+        _skip_nodes(false), _skip_edges(false) {
+      if (!(*_os)) {
+        delete _os;
+        throw IoError("Cannot write file", fn);
+      }
+    }
+    /// \brief Destructor
+    ~BpGraphWriter() {
+      for (typename RedNodeMaps::iterator it = _red_node_maps.begin();
+           it != _red_node_maps.end(); ++it) {
+        delete it->second;
+      }
+      for (typename BlueNodeMaps::iterator it = _blue_node_maps.begin();
+           it != _blue_node_maps.end(); ++it) {
+        delete it->second;
+      }
+      for (typename EdgeMaps::iterator it = _edge_maps.begin();
+           it != _edge_maps.end(); ++it) {
+        delete it->second;
+      }
+      for (typename Attributes::iterator it = _attributes.begin();
+           it != _attributes.end(); ++it) {
+        delete it->second;
+      }
+      if (local_os) {
+        delete _os;
+      }
+    }
+  private:
+    template <typename TBGR>
+    friend BpGraphWriter<TBGR> bpGraphWriter(const TBGR& graph,
+                                             std::ostream& os);
+    template <typename TBGR>
+    friend BpGraphWriter<TBGR> bpGraphWriter(const TBGR& graph,
+                                             const std::string& fn);
+    template <typename TBGR>
+    friend BpGraphWriter<TBGR> bpGraphWriter(const TBGR& graph, const char *fn);
+    BpGraphWriter(BpGraphWriter& other)
+      : _os(other._os), local_os(other.local_os), _graph(other._graph),
+        _skip_nodes(other._skip_nodes), _skip_edges(other._skip_edges) {
+      other._os = 0;
+      other.local_os = false;
+      _red_node_index.swap(other._red_node_index);
+      _blue_node_index.swap(other._blue_node_index);
+      _edge_index.swap(other._edge_index);
+      _red_node_maps.swap(other._red_node_maps);
+      _blue_node_maps.swap(other._blue_node_maps);
+      _edge_maps.swap(other._edge_maps);
+      _attributes.swap(other._attributes);
+      _nodes_caption = other._nodes_caption;
+      _edges_caption = other._edges_caption;
+      _attributes_caption = other._attributes_caption;
+    }
+    BpGraphWriter& operator=(const BpGraphWriter&);
+  public:
+    /// \name Writing Rules
+    /// @{
+    /// \brief Node map writing rule
+    ///
+    /// Add a node map writing rule to the writer.
+    template <typename Map>
+    BpGraphWriter& nodeMap(const std::string& caption, const Map& map) {
+      checkConcept<concepts::ReadMap<Node, typename Map::Value>, Map>();
+      _writer_bits::MapStorageBase<RedNode>* red_storage =
+        new _writer_bits::MapStorage<RedNode, Map>(map);
+      _red_node_maps.push_back(std::make_pair(caption, red_storage));
+      _writer_bits::MapStorageBase<BlueNode>* blue_storage =
+        new _writer_bits::MapStorage<BlueNode, Map>(map);
+      _blue_node_maps.push_back(std::make_pair(caption, blue_storage));
+      return *this;
+    }
+    /// \brief Node map writing rule
+    ///
+    /// Add a node map writing rule with specialized converter to the
+    /// writer.
+    template <typename Map, typename Converter>
+    BpGraphWriter& nodeMap(const std::string& caption, const Map& map,
+                           const Converter& converter = Converter()) {
+      checkConcept<concepts::ReadMap<Node, typename Map::Value>, Map>();
+      _writer_bits::MapStorageBase<RedNode>* red_storage =
+        new _writer_bits::MapStorage<RedNode, Map, Converter>(map, converter);
+      _red_node_maps.push_back(std::make_pair(caption, red_storage));
+      _writer_bits::MapStorageBase<BlueNode>* blue_storage =
+        new _writer_bits::MapStorage<BlueNode, Map, Converter>(map, converter);
+      _blue_node_maps.push_back(std::make_pair(caption, blue_storage));
+      return *this;
+    }
+    /// \brief Red node map writing rule
+    ///
+    /// Add a red node map writing rule to the writer.
+    template <typename Map>
+    BpGraphWriter& redNodeMap(const std::string& caption, const Map& map) {
+      checkConcept<concepts::ReadMap<RedNode, typename Map::Value>, Map>();
+      _writer_bits::MapStorageBase<RedNode>* storage =
+        new _writer_bits::MapStorage<RedNode, Map>(map);
+      _red_node_maps.push_back(std::make_pair(caption, storage));
+      return *this;
+    }
+    /// \brief Red node map writing rule
+    ///
+    /// Add a red node map writing rule with specialized converter to the
+    /// writer.
+    template <typename Map, typename Converter>
+    BpGraphWriter& redNodeMap(const std::string& caption, const Map& map,
+                              const Converter& converter = Converter()) {
+      checkConcept<concepts::ReadMap<RedNode, typename Map::Value>, Map>();
+      _writer_bits::MapStorageBase<RedNode>* storage =
+        new _writer_bits::MapStorage<RedNode, Map, Converter>(map, converter);
+      _red_node_maps.push_back(std::make_pair(caption, storage));
+      return *this;
+    }
+    /// \brief Blue node map writing rule
+    ///
+    /// Add a blue node map writing rule to the writer.
+    template <typename Map>
+    BpGraphWriter& blueNodeMap(const std::string& caption, const Map& map) {
+      checkConcept<concepts::ReadMap<BlueNode, typename Map::Value>, Map>();
+      _writer_bits::MapStorageBase<BlueNode>* storage =
+        new _writer_bits::MapStorage<BlueNode, Map>(map);
+      _blue_node_maps.push_back(std::make_pair(caption, storage));
+      return *this;
+    }
+    /// \brief Blue node map writing rule
+    ///
+    /// Add a blue node map writing rule with specialized converter to the
+    /// writer.
+    template <typename Map, typename Converter>
+    BpGraphWriter& blueNodeMap(const std::string& caption, const Map& map,
+                               const Converter& converter = Converter()) {
+      checkConcept<concepts::ReadMap<BlueNode, typename Map::Value>, Map>();
+      _writer_bits::MapStorageBase<BlueNode>* storage =
+        new _writer_bits::MapStorage<BlueNode, Map, Converter>(map, converter);
+      _blue_node_maps.push_back(std::make_pair(caption, storage));
+      return *this;
+    }
+    /// \brief Edge map writing rule
+    ///
+    /// Add an edge map writing rule to the writer.
+    template <typename Map>
+    BpGraphWriter& edgeMap(const std::string& caption, const Map& map) {
+      checkConcept<concepts::ReadMap<Edge, typename Map::Value>, Map>();
+      _writer_bits::MapStorageBase<Edge>* storage =
+        new _writer_bits::MapStorage<Edge, Map>(map);
+      _edge_maps.push_back(std::make_pair(caption, storage));
+      return *this;
+    }
+    /// \brief Edge map writing rule
+    ///
+    /// Add an edge map writing rule with specialized converter to the
+    /// writer.
+    template <typename Map, typename Converter>
+    BpGraphWriter& edgeMap(const std::string& caption, const Map& map,
+                          const Converter& converter = Converter()) {
+      checkConcept<concepts::ReadMap<Edge, typename Map::Value>, Map>();
+      _writer_bits::MapStorageBase<Edge>* storage =
+        new _writer_bits::MapStorage<Edge, Map, Converter>(map, converter);
+      _edge_maps.push_back(std::make_pair(caption, storage));
+      return *this;
+    }
+    /// \brief Arc map writing rule
+    ///
+    /// Add an arc map writing rule to the writer.
+    template <typename Map>
+    BpGraphWriter& arcMap(const std::string& caption, const Map& map) {
+      checkConcept<concepts::ReadMap<Arc, typename Map::Value>, Map>();
+      _writer_bits::MapStorageBase<Edge>* forward_storage =
+        new _writer_bits::GraphArcMapStorage<BGR, true, Map>(_graph, map);
+      _edge_maps.push_back(std::make_pair('+' + caption, forward_storage));
+      _writer_bits::MapStorageBase<Edge>* backward_storage =
+        new _writer_bits::GraphArcMapStorage<BGR, false, Map>(_graph, map);
+      _edge_maps.push_back(std::make_pair('-' + caption, backward_storage));
+      return *this;
+    }
+    /// \brief Arc map writing rule
+    ///
+    /// Add an arc map writing rule with specialized converter to the
+    /// writer.
+    template <typename Map, typename Converter>
+    BpGraphWriter& arcMap(const std::string& caption, const Map& map,
+                          const Converter& converter = Converter()) {
+      checkConcept<concepts::ReadMap<Arc, typename Map::Value>, Map>();
+      _writer_bits::MapStorageBase<Edge>* forward_storage =
+        new _writer_bits::GraphArcMapStorage<BGR, 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<BGR, false, Map, Converter>
+        (_graph, map, converter);
+      _edge_maps.push_back(std::make_pair('-' + caption, backward_storage));
+      return *this;
+    }
+    /// \brief Attribute writing rule
+    ///
+    /// Add an attribute writing rule to the writer.
+    template <typename Value>
+    BpGraphWriter& attribute(const std::string& caption, const Value& value) {
+      _writer_bits::ValueStorageBase* storage =
+        new _writer_bits::ValueStorage<Value>(value);
+      _attributes.push_back(std::make_pair(caption, storage));
+      return *this;
+    }
+    /// \brief Attribute writing rule
+    ///
+    /// Add an attribute writing rule with specialized converter to the
+    /// writer.
+    template <typename Value, typename Converter>
+    BpGraphWriter& attribute(const std::string& caption, const Value& value,
+                             const Converter& converter = Converter()) {
+      _writer_bits::ValueStorageBase* storage =
+        new _writer_bits::ValueStorage<Value, Converter>(value, converter);
+      _attributes.push_back(std::make_pair(caption, storage));
+      return *this;
+    }
+    /// \brief Node writing rule
+    ///
+    /// Add a node writing rule to the writer.
+    BpGraphWriter& node(const std::string& caption, const Node& node) {
+      typedef _writer_bits::DoubleMapLookUpConverter<
+        Node, RedNodeIndex, BlueNodeIndex> Converter;
+      Converter converter(_red_node_index, _blue_node_index);
+      _writer_bits::ValueStorageBase* storage =
+        new _writer_bits::ValueStorage<Node, Converter>(node, converter);
+      _attributes.push_back(std::make_pair(caption, storage));
+      return *this;
+    }
+    /// \brief Red node writing rule
+    ///
+    /// Add a red node writing rule to the writer.
+    BpGraphWriter& redNode(const std::string& caption, const RedNode& node) {
+      typedef _writer_bits::MapLookUpConverter<Node> Converter;
+      Converter converter(_red_node_index);
+      _writer_bits::ValueStorageBase* storage =
+        new _writer_bits::ValueStorage<Node, Converter>(node, converter);
+      _attributes.push_back(std::make_pair(caption, storage));
+      return *this;
+    }
+    /// \brief Blue node writing rule
+    ///
+    /// Add a blue node writing rule to the writer.
+    BpGraphWriter& blueNode(const std::string& caption, const BlueNode& node) {
+      typedef _writer_bits::MapLookUpConverter<Node> Converter;
+      Converter converter(_blue_node_index);
+      _writer_bits::ValueStorageBase* storage =
+        new _writer_bits::ValueStorage<Node, Converter>(node, converter);
+      _attributes.push_back(std::make_pair(caption, storage));
+      return *this;
+    }
+    /// \brief Edge writing rule
+    ///
+    /// Add an edge writing rule to writer.
+    BpGraphWriter& edge(const std::string& caption, const Edge& edge) {
+      typedef _writer_bits::MapLookUpConverter<Edge> Converter;
+      Converter converter(_edge_index);
+      _writer_bits::ValueStorageBase* storage =
+        new _writer_bits::ValueStorage<Edge, Converter>(edge, converter);
+      _attributes.push_back(std::make_pair(caption, storage));
+      return *this;
+    }
+    /// \brief Arc writing rule
+    ///
+    /// Add an arc writing rule to writer.
+    BpGraphWriter& arc(const std::string& caption, const Arc& arc) {
+      typedef _writer_bits::GraphArcLookUpConverter<BGR> Converter;
+      Converter converter(_graph, _edge_index);
+      _writer_bits::ValueStorageBase* storage =
+        new _writer_bits::ValueStorage<Arc, Converter>(arc, converter);
+      _attributes.push_back(std::make_pair(caption, storage));
+      return *this;
+    }
+    /// \name Section Captions
+    /// @{
+    /// \brief Add an additional caption to the \c \@red_nodes and
+    /// \c \@blue_nodes section
+    ///
+    /// Add an additional caption to the \c \@red_nodes and \c
+    /// \@blue_nodes section.
+    BpGraphWriter& nodes(const std::string& caption) {
+      _nodes_caption = caption;
+      return *this;
+    }
+    /// \brief Add an additional caption to the \c \@edges section
+    ///
+    /// Add an additional caption to the \c \@edges section.
+    BpGraphWriter& edges(const std::string& caption) {
+      _edges_caption = caption;
+      return *this;
+    }
+    /// \brief Add an additional caption to the \c \@attributes section
+    ///
+    /// Add an additional caption to the \c \@attributes section.
+    BpGraphWriter& attributes(const std::string& caption) {
+      _attributes_caption = caption;
+      return *this;
+    }
+    /// \name Skipping Section
+    /// @{
+    /// \brief Skip writing the node set
+    ///
+    /// The \c \@red_nodes and \c \@blue_nodes section will not be
+    /// written to the stream.
+    BpGraphWriter& skipNodes() {
+      LEMON_ASSERT(!_skip_nodes, "Multiple usage of skipNodes() member");
+      _skip_nodes = true;
+      return *this;
+    }
+    /// \brief Skip writing edge set
+    ///
+    /// The \c \@edges section will not be written to the stream.
+    BpGraphWriter& skipEdges() {
+      LEMON_ASSERT(!_skip_edges, "Multiple usage of skipEdges() member");
+      _skip_edges = true;
+      return *this;
+    }
+    /// @}
+  private:
+    void writeRedNodes() {
+      _writer_bits::MapStorageBase<RedNode>* label = 0;
+      for (typename RedNodeMaps::iterator it = _red_node_maps.begin();
+           it != _red_node_maps.end(); ++it) {
+        if (it->first == "label") {
+          label = it->second;
+          break;
+        }
+      }
+      *_os << "@red_nodes";
+      if (!_nodes_caption.empty()) {
+        _writer_bits::writeToken(*_os << ' ', _nodes_caption);
+      }
+      *_os << std::endl;
+      if (label == 0) {
+        *_os << "label" << '\t';
+      }
+      for (typename RedNodeMaps::iterator it = _red_node_maps.begin();
+           it != _red_node_maps.end(); ++it) {
+        _writer_bits::writeToken(*_os, it->first) << '\t';
+      }
+      *_os << std::endl;
+      std::vector<RedNode> nodes;
+      for (RedNodeIt n(_graph); n != INVALID; ++n) {
+        nodes.push_back(n);
+      }
+      if (label == 0) {
+        IdMap<BGR, Node> id_map(_graph);
+        _writer_bits::MapLess<IdMap<BGR, Node> > id_less(id_map);
+        std::sort(nodes.begin(), nodes.end(), id_less);
+      } else {
+        label->sort(nodes);
+      }
+      for (int i = 0; i < static_cast<int>(nodes.size()); ++i) {
+        RedNode n = nodes[i];
+        if (label == 0) {
+          std::ostringstream os;
+          os << _graph.id(static_cast<Node>(n));
+          _writer_bits::writeToken(*_os, os.str());
+          *_os << '\t';
+          _red_node_index.insert(std::make_pair(n, os.str()));
+        }
+        for (typename RedNodeMaps::iterator it = _red_node_maps.begin();
+             it != _red_node_maps.end(); ++it) {
+          std::string value = it->second->get(n);
+          _writer_bits::writeToken(*_os, value);
+          if (it->first == "label") {
+            _red_node_index.insert(std::make_pair(n, value));
+          }
+          *_os << '\t';
+        }
+        *_os << std::endl;
+      }
+    }
+    void writeBlueNodes() {
+      _writer_bits::MapStorageBase<BlueNode>* label = 0;
+      for (typename BlueNodeMaps::iterator it = _blue_node_maps.begin();
+           it != _blue_node_maps.end(); ++it) {
+        if (it->first == "label") {
+          label = it->second;
+          break;
+        }
+      }
+      *_os << "@blue_nodes";
+      if (!_nodes_caption.empty()) {
+        _writer_bits::writeToken(*_os << ' ', _nodes_caption);
+      }
+      *_os << std::endl;
+      if (label == 0) {
+        *_os << "label" << '\t';
+      }
+      for (typename BlueNodeMaps::iterator it = _blue_node_maps.begin();
+           it != _blue_node_maps.end(); ++it) {
+        _writer_bits::writeToken(*_os, it->first) << '\t';
+      }
+      *_os << std::endl;
+      std::vector<BlueNode> nodes;
+      for (BlueNodeIt n(_graph); n != INVALID; ++n) {
+        nodes.push_back(n);
+      }
+      if (label == 0) {
+        IdMap<BGR, Node> id_map(_graph);
+        _writer_bits::MapLess<IdMap<BGR, Node> > id_less(id_map);
+        std::sort(nodes.begin(), nodes.end(), id_less);
+      } else {
+        label->sort(nodes);
+      }
+      for (int i = 0; i < static_cast<int>(nodes.size()); ++i) {
+        BlueNode n = nodes[i];
+        if (label == 0) {
+          std::ostringstream os;
+          os << _graph.id(static_cast<Node>(n));
+          _writer_bits::writeToken(*_os, os.str());
+          *_os << '\t';
+          _blue_node_index.insert(std::make_pair(n, os.str()));
+        }
+        for (typename BlueNodeMaps::iterator it = _blue_node_maps.begin();
+             it != _blue_node_maps.end(); ++it) {
+          std::string value = it->second->get(n);
+          _writer_bits::writeToken(*_os, value);
+          if (it->first == "label") {
+            _blue_node_index.insert(std::make_pair(n, value));
+          }
+          *_os << '\t';
+        }
+        *_os << std::endl;
+      }
+    }
+    void createRedNodeIndex() {
+      _writer_bits::MapStorageBase<RedNode>* label = 0;
+      for (typename RedNodeMaps::iterator it = _red_node_maps.begin();
+           it != _red_node_maps.end(); ++it) {
+        if (it->first == "label") {
+          label = it->second;
+          break;
+        }
+      }
+      if (label == 0) {
+        for (RedNodeIt n(_graph); n != INVALID; ++n) {
+          std::ostringstream os;
+          os << _graph.id(n);
+          _red_node_index.insert(std::make_pair(n, os.str()));
+        }
+      } else {
+        for (RedNodeIt n(_graph); n != INVALID; ++n) {
+          std::string value = label->get(n);
+          _red_node_index.insert(std::make_pair(n, value));
+        }
+      }
+    }
+    void createBlueNodeIndex() {
+      _writer_bits::MapStorageBase<BlueNode>* label = 0;
+      for (typename BlueNodeMaps::iterator it = _blue_node_maps.begin();
+           it != _blue_node_maps.end(); ++it) {
+        if (it->first == "label") {
+          label = it->second;
+          break;
+        }
+      }
+      if (label == 0) {
+        for (BlueNodeIt n(_graph); n != INVALID; ++n) {
+          std::ostringstream os;
+          os << _graph.id(n);
+          _blue_node_index.insert(std::make_pair(n, os.str()));
+        }
+      } else {
+        for (BlueNodeIt n(_graph); n != INVALID; ++n) {
+          std::string value = label->get(n);
+          _blue_node_index.insert(std::make_pair(n, value));
+        }
+      }
+    }
+    void writeEdges() {
+      _writer_bits::MapStorageBase<Edge>* label = 0;
+      for (typename EdgeMaps::iterator it = _edge_maps.begin();
+           it != _edge_maps.end(); ++it) {
+        if (it->first == "label") {
+          label = it->second;
+          break;
+        }
+      }
+      *_os << "@edges";
+      if (!_edges_caption.empty()) {
+        _writer_bits::writeToken(*_os << ' ', _edges_caption);
+      }
+      *_os << std::endl;
+      *_os << '\t' << '\t';
+      if (label == 0) {
+        *_os << "label" << '\t';
+      }
+      for (typename EdgeMaps::iterator it = _edge_maps.begin();
+           it != _edge_maps.end(); ++it) {
+        _writer_bits::writeToken(*_os, it->first) << '\t';
+      }
+      *_os << std::endl;
+      std::vector<Edge> edges;
+      for (EdgeIt n(_graph); n != INVALID; ++n) {
+        edges.push_back(n);
+      }
+      if (label == 0) {
+        IdMap<BGR, Edge> id_map(_graph);
+        _writer_bits::MapLess<IdMap<BGR, Edge> > id_less(id_map);
+        std::sort(edges.begin(), edges.end(), id_less);
+      } else {
+        label->sort(edges);
+      }
+      for (int i = 0; i < static_cast<int>(edges.size()); ++i) {
+        Edge e = edges[i];
+        _writer_bits::writeToken(*_os, _red_node_index.
+                                 find(_graph.redNode(e))->second);
+        *_os << '\t';
+        _writer_bits::writeToken(*_os, _blue_node_index.
+                                 find(_graph.blueNode(e))->second);
+        *_os << '\t';
+        if (label == 0) {
+          std::ostringstream os;
+          os << _graph.id(e);
+          _writer_bits::writeToken(*_os, os.str());
+          *_os << '\t';
+          _edge_index.insert(std::make_pair(e, os.str()));
+        }
+        for (typename EdgeMaps::iterator it = _edge_maps.begin();
+             it != _edge_maps.end(); ++it) {
+          std::string value = it->second->get(e);
+          _writer_bits::writeToken(*_os, value);
+          if (it->first == "label") {
+            _edge_index.insert(std::make_pair(e, value));
+          }
+          *_os << '\t';
+        }
+        *_os << std::endl;
+      }
+    }
+    void createEdgeIndex() {
+      _writer_bits::MapStorageBase<Edge>* label = 0;
+      for (typename EdgeMaps::iterator it = _edge_maps.begin();
+           it != _edge_maps.end(); ++it) {
+        if (it->first == "label") {
+          label = it->second;
+          break;
+        }
+      }
+      if (label == 0) {
+        for (EdgeIt e(_graph); e != INVALID; ++e) {
+          std::ostringstream os;
+          os << _graph.id(e);
+          _edge_index.insert(std::make_pair(e, os.str()));
+        }
+      } else {
+        for (EdgeIt e(_graph); e != INVALID; ++e) {
+          std::string value = label->get(e);
+          _edge_index.insert(std::make_pair(e, value));
+        }
+      }
+    }
+    void writeAttributes() {
+      if (_attributes.empty()) return;
+      *_os << "@attributes";
+      if (!_attributes_caption.empty()) {
+        _writer_bits::writeToken(*_os << ' ', _attributes_caption);
+      }
+      *_os << std::endl;
+      for (typename Attributes::iterator it = _attributes.begin();
+           it != _attributes.end(); ++it) {
+        _writer_bits::writeToken(*_os, it->first) << ' ';
+        _writer_bits::writeToken(*_os, it->second->get());
+        *_os << std::endl;
+      }
+    }
+  public:
+    /// \name Execution of the Writer
+    /// @{
+    /// \brief Start the batch processing
+    ///
+    /// This function starts the batch processing.
+    void run() {
+      if (!_skip_nodes) {
+        writeRedNodes();
+        writeBlueNodes();
+      } else {
+        createRedNodeIndex();
+        createBlueNodeIndex();
+      }
+      if (!_skip_edges) {
+        writeEdges();
+      } else {
+        createEdgeIndex();
+      }
+      writeAttributes();
+    }
+    /// \brief Give back the stream of the writer
+    ///
+    /// Give back the stream of the writer
+    std::ostream& ostream() {
+      return *_os;
+    }
+    /// @}
+  };
+  /// \ingroup lemon_io
+  ///
+  /// \brief Return a \ref lemon::BpGraphWriter "BpGraphWriter" class
+  ///
+  /// This function just returns a \ref lemon::BpGraphWriter
+  /// "BpGraphWriter" class.
+  ///
+  /// With this function a bipartite 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 bipartite
+  /// weighted matching problem can be written to the standard output,
+  /// i.e. a graph with a \e weight map on the edges:
+  ///
+  ///\code
+  ///ListBpGraph graph;
+  ///ListBpGraph::EdgeMap<int> weight(graph);
+  ///  // Setting the weight map
+  ///bpGraphWriter(graph, std::cout).
+  ///  edgeMap("weight", weight).
+  ///  run();
+  ///\endcode
+  ///
+  /// For a complete documentation, please see the
+  /// \ref lemon::BpGraphWriter "BpGraphWriter"
+  /// class documentation.
+  /// \warning Don't forget to put the \ref lemon::BpGraphWriter::run() "run()"
+  /// to the end of the parameter list.
+  /// \relates BpGraphWriter
+  /// \sa bpGraphWriter(const TBGR& graph, const std::string& fn)
+  /// \sa bpGraphWriter(const TBGR& graph, const char* fn)
+  template <typename TBGR>
+  BpGraphWriter<TBGR> bpGraphWriter(const TBGR& graph, std::ostream& os) {
+    BpGraphWriter<TBGR> tmp(graph, os);
+    return tmp;
+  }
+  /// \brief Return a \ref BpGraphWriter class
+  ///
+  /// This function just returns a \ref BpGraphWriter class.
+  /// \relates BpGraphWriter
+  /// \sa graphWriter(const TBGR& graph, std::ostream& os)
+  template <typename TBGR>
+  BpGraphWriter<TBGR> bpGraphWriter(const TBGR& graph, const std::string& fn) {
+    BpGraphWriter<TBGR> tmp(graph, fn);
+    return tmp;
+  }
+  /// \brief Return a \ref BpGraphWriter class
+  ///
+  /// This function just returns a \ref BpGraphWriter class.
+  /// \relates BpGraphWriter
+  /// \sa graphWriter(const TBGR& graph, std::ostream& os)
+  template <typename TBGR>
+  BpGraphWriter<TBGR> bpGraphWriter(const TBGR& graph, const char* fn) {
+    BpGraphWriter<TBGR> tmp(graph, fn);
     return tmp;
+  }

lemon/list_graph.h

-                      r835
+                      r1357
  * This file is a part of LEMON, a generic C++ optimization library.
+ *
  * Copyright (C) 2003-2009
+ * Copyright (C) 2003-2013
  * Egervary Jeno Kombinatorikus Optimalizalasi Kutatocsoport
  * (Egervary Research Group on Combinatorial Optimization, EGRES).
 …
     ///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
+    ///iterators are invalidated for the incoming arcs of \c v.
+    ///Moreover all iterators referencing node \c v or the removed
     ///loops are also invalidated. Other iterators remain valid.
     ///
 …
     /// restore() function.
     ///
     /// \note After a state is restored, you cannot restore a later state,
+    /// \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.
 …
+        }
         virtual void add(const std::vector<Node>& nodes) {
           for (int i = nodes.size() - 1; i >= 0; ++i) {
+          for (int i = nodes.size() - 1; i >= 0; --i) {
             snapshot.addNode(nodes[i]);
+          }
 …
+        }
         virtual void add(const std::vector<Arc>& arcs) {
           for (int i = arcs.size() - 1; i >= 0; ++i) {
+          for (int i = arcs.size() - 1; i >= 0; --i) {
             snapshot.addArc(arcs[i]);
+          }
 …
     /// 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
+    /// Moreover all iterators referencing node \c b or the removed
     /// loops are also invalidated. Other iterators remain valid.
     ///
 …
     /// using the restore() function.
     ///
     /// \note After a state is restored, you cannot restore a later state,
+    /// \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.
 …
+        }
         virtual void add(const std::vector<Node>& nodes) {
           for (int i = nodes.size() - 1; i >= 0; ++i) {
+          for (int i = nodes.size() - 1; i >= 0; --i) {
             snapshot.addNode(nodes[i]);
+          }
 …
+        }
         virtual void add(const std::vector<Edge>& edges) {
           for (int i = edges.size() - 1; i >= 0; ++i) {
+          for (int i = edges.size() - 1; i >= 0; --i) {
             snapshot.addEdge(edges[i]);
+          }
 …
   /// @}
+  class ListBpGraphBase {
+  protected:
+    struct NodeT {
+      int first_out;
+      int prev, next;
+      int partition_prev, partition_next;
+      int partition_index;
+      bool red;
+    };
+    struct ArcT {
+      int target;
+      int prev_out, next_out;
+    };
+    std::vector<NodeT> nodes;
+    int first_node, first_red, first_blue;
+    int max_red, max_blue;
+    int first_free_red, first_free_blue;
+    std::vector<ArcT> arcs;
+    int first_free_arc;
+  public:
+    typedef ListBpGraphBase BpGraph;
+    class Node {
+      friend class ListBpGraphBase;
+    protected:
+      int id;
+      explicit Node(int pid) { id = pid;}
+    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 RedNode : public Node {
+      friend class ListBpGraphBase;
+    protected:
+      explicit RedNode(int pid) : Node(pid) {}
+    public:
+      RedNode() {}
+      RedNode(const RedNode& node) : Node(node) {}
+      RedNode(Invalid) : Node(INVALID){}
+    };
+    class BlueNode : public Node {
+      friend class ListBpGraphBase;
+    protected:
+      explicit BlueNode(int pid) : Node(pid) {}
+    public:
+      BlueNode() {}
+      BlueNode(const BlueNode& node) : Node(node) {}
+      BlueNode(Invalid) : Node(INVALID){}
+    };
+    class Edge {
+      friend class ListBpGraphBase;
+    protected:
+      int id;
+      explicit Edge(int pid) { id = pid;}
+    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 ListBpGraphBase;
+    protected:
+      int id;
+      explicit Arc(int pid) { id = pid;}
+    public:
+      operator Edge() const {
+        return id != -1 ? edgeFromId(id / 2) : INVALID;
+      }
+      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;}
+    };
+    ListBpGraphBase()
+      : nodes(), first_node(-1),
+        first_red(-1), first_blue(-1),
+        max_red(-1), max_blue(-1),
+        first_free_red(-1), first_free_blue(-1),
+        arcs(), first_free_arc(-1) {}
+    bool red(Node n) const { return nodes[n.id].red; }
+    bool blue(Node n) const { return !nodes[n.id].red; }
+    static RedNode asRedNodeUnsafe(Node n) { return RedNode(n.id); }
+    static BlueNode asBlueNodeUnsafe(Node n) { return BlueNode(n.id); }
+    int maxNodeId() const { return nodes.size()-1; }
+    int maxRedId() const { return max_red; }
+    int maxBlueId() const { return max_blue; }
+    int maxEdgeId() const { return arcs.size() / 2 - 1; }
+    int maxArcId() const { return arcs.size()-1; }
+    Node source(Arc e) const { return Node(arcs[e.id ^ 1].target); }
+    Node target(Arc e) const { return Node(arcs[e.id].target); }
+    RedNode redNode(Edge e) const {
+      return RedNode(arcs[2 * e.id].target);
+    }
+    BlueNode blueNode(Edge e) const {
+      return BlueNode(arcs[2 * e.id + 1].target);
+    }
+    static bool direction(Arc e) {
+      return (e.id & 1) == 1;
+    }
+    static Arc direct(Edge e, bool d) {
+      return Arc(e.id * 2 + (d ? 1 : 0));
+    }
+    void first(Node& node) const {
+      node.id = first_node;
+    }
+    void next(Node& node) const {
+      node.id = nodes[node.id].next;
+    }
+    void first(RedNode& node) const {
+      node.id = first_red;
+    }
+    void next(RedNode& node) const {
+      node.id = nodes[node.id].partition_next;
+    }
+    void first(BlueNode& node) const {
+      node.id = first_blue;
+    }
+    void next(BlueNode& node) const {
+      node.id = nodes[node.id].partition_next;
+    }
+    void first(Arc& e) const {
+      int n = first_node;
+      while (n != -1 && nodes[n].first_out == -1) {
+        n = nodes[n].next;
+      }
+      e.id = (n == -1) ? -1 : nodes[n].first_out;
+    }
+    void next(Arc& e) const {
+      if (arcs[e.id].next_out != -1) {
+        e.id = arcs[e.id].next_out;
+      } else {
+        int n = nodes[arcs[e.id ^ 1].target].next;
+        while(n != -1 && nodes[n].first_out == -1) {
+          n = nodes[n].next;
+        }
+        e.id = (n == -1) ? -1 : nodes[n].first_out;
+      }
+    }
+    void first(Edge& e) const {
+      int n = first_node;
+      while (n != -1) {
+        e.id = nodes[n].first_out;
+        while ((e.id & 1) != 1) {
+          e.id = arcs[e.id].next_out;
+        }
+        if (e.id != -1) {
+          e.id /= 2;
+          return;
+        }
+        n = nodes[n].next;
+      }
+      e.id = -1;
+    }
+    void next(Edge& e) const {
+      int n = arcs[e.id * 2].target;
+      e.id = arcs[(e.id * 2) | 1].next_out;
+      while ((e.id & 1) != 1) {
+        e.id = arcs[e.id].next_out;
+      }
+      if (e.id != -1) {
+        e.id /= 2;
+        return;
+      }
+      n = nodes[n].next;
+      while (n != -1) {
+        e.id = nodes[n].first_out;
+        while ((e.id & 1) != 1) {
+          e.id = arcs[e.id].next_out;
+        }
+        if (e.id != -1) {
+          e.id /= 2;
+          return;
+        }
+        n = nodes[n].next;
+      }
+      e.id = -1;
+    }
+    void firstOut(Arc &e, const Node& v) const {
+      e.id = nodes[v.id].first_out;
+    }
+    void nextOut(Arc &e) const {
+      e.id = arcs[e.id].next_out;
+    }
+    void firstIn(Arc &e, const Node& v) const {
+      e.id = ((nodes[v.id].first_out) ^ 1);
+      if (e.id == -2) e.id = -1;
+    }
+    void nextIn(Arc &e) const {
+      e.id = ((arcs[e.id ^ 1].next_out) ^ 1);
+      if (e.id == -2) e.id = -1;
+    }
+    void firstInc(Edge &e, bool& d, const Node& v) const {
+      int a = nodes[v.id].first_out;
+      if (a != -1 ) {
+        e.id = a / 2;
+        d = ((a & 1) == 1);
+      } else {
+        e.id = -1;
+        d = true;
+      }
+    }
+    void nextInc(Edge &e, bool& d) const {
+      int a = (arcs[(e.id * 2) | (d ? 1 : 0)].next_out);
+      if (a != -1 ) {
+        e.id = a / 2;
+        d = ((a & 1) == 1);
+      } else {
+        e.id = -1;
+        d = true;
+      }
+    }
+    static int id(Node v) { return v.id; }
+    int id(RedNode v) const { return nodes[v.id].partition_index; }
+    int id(BlueNode v) const { return nodes[v.id].partition_index; }
+    static int id(Arc e) { return e.id; }
+    static int id(Edge e) { return e.id; }
+    static Node nodeFromId(int id) { return Node(id);}
+    static Arc arcFromId(int id) { return Arc(id);}
+    static Edge edgeFromId(int id) { return Edge(id);}
+    bool valid(Node n) const {
+      return n.id >= 0 && n.id < static_cast<int>(nodes.size()) &&
+        nodes[n.id].prev != -2;
+    }
+    bool valid(Arc a) const {
+      return a.id >= 0 && a.id < static_cast<int>(arcs.size()) &&
+        arcs[a.id].prev_out != -2;
+    }
+    bool valid(Edge e) const {
+      return e.id >= 0 && 2 * e.id < static_cast<int>(arcs.size()) &&
+        arcs[2 * e.id].prev_out != -2;
+    }
+    RedNode addRedNode() {
+      int n;
+      if(first_free_red==-1) {
+        n = nodes.size();
+        nodes.push_back(NodeT());
+        nodes[n].partition_index = ++max_red;
+        nodes[n].red = true;
+      } else {
+        n = first_free_red;
+        first_free_red = nodes[n].next;
+      }
+      nodes[n].next = first_node;
+      if (first_node != -1) nodes[first_node].prev = n;
+      first_node = n;
+      nodes[n].prev = -1;
+      nodes[n].partition_next = first_red;
+      if (first_red != -1) nodes[first_red].partition_prev = n;
+      first_red = n;
+      nodes[n].partition_prev = -1;
+      nodes[n].first_out = -1;
+      return RedNode(n);
+    }
+    BlueNode addBlueNode() {
+      int n;
+      if(first_free_blue==-1) {
+        n = nodes.size();
+        nodes.push_back(NodeT());
+        nodes[n].partition_index = ++max_blue;
+        nodes[n].red = false;
+      } else {
+        n = first_free_blue;
+        first_free_blue = nodes[n].next;
+      }
+      nodes[n].next = first_node;
+      if (first_node != -1) nodes[first_node].prev = n;
+      first_node = n;
+      nodes[n].prev = -1;
+      nodes[n].partition_next = first_blue;
+      if (first_blue != -1) nodes[first_blue].partition_prev = n;
+      first_blue = n;
+      nodes[n].partition_prev = -1;
+      nodes[n].first_out = -1;
+      return BlueNode(n);
+    }
+    Edge addEdge(Node u, 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.id;
+      arcs[n | 1].target = v.id;
+      arcs[n].next_out = nodes[v.id].first_out;
+      if (nodes[v.id].first_out != -1) {
+        arcs[nodes[v.id].first_out].prev_out = n;
+      }
+      arcs[n].prev_out = -1;
+      nodes[v.id].first_out = n;
+      arcs[n | 1].next_out = nodes[u.id].first_out;
+      if (nodes[u.id].first_out != -1) {
+        arcs[nodes[u.id].first_out].prev_out = (n | 1);
+      }
+      arcs[n | 1].prev_out = -1;
+      nodes[u.id].first_out = (n | 1);
+      return Edge(n / 2);
+    }
+    void erase(const Node& node) {
+      int n = node.id;
+      if(nodes[n].next != -1) {
+        nodes[nodes[n].next].prev = nodes[n].prev;
+      }
+      if(nodes[n].prev != -1) {
+        nodes[nodes[n].prev].next = nodes[n].next;
+      } else {
+        first_node = nodes[n].next;
+      }
+      if (nodes[n].partition_next != -1) {
+        nodes[nodes[n].partition_next].partition_prev = nodes[n].partition_prev;
+      }
+      if (nodes[n].partition_prev != -1) {
+        nodes[nodes[n].partition_prev].partition_next = nodes[n].partition_next;
+      } else {
+        if (nodes[n].red) {
+          first_red = nodes[n].partition_next;
+        } else {
+          first_blue = nodes[n].partition_next;
+        }
+      }
+      if (nodes[n].red) {
+        nodes[n].next = first_free_red;
+        first_free_red = n;
+      } else {
+        nodes[n].next = first_free_blue;
+        first_free_blue = n;
+      }
+      nodes[n].prev = -2;
+    }
+    void erase(const Edge& edge) {
+      int n = edge.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;
+      arcs[n].prev_out = -2;
+      arcs[n | 1].prev_out = -2;
+    }
+    void clear() {
+      arcs.clear();
+      nodes.clear();
+      first_node = first_free_arc = first_red = first_blue =
+        max_red = max_blue = first_free_red = first_free_blue = -1;
+    }
+  protected:
+    void changeRed(Edge e, RedNode n) {
+      if(arcs[(2 * e.id) | 1].next_out != -1) {
+        arcs[arcs[(2 * e.id) | 1].next_out].prev_out =
+          arcs[(2 * e.id) | 1].prev_out;
+      }
+      if(arcs[(2 * e.id) | 1].prev_out != -1) {
+        arcs[arcs[(2 * e.id) | 1].prev_out].next_out =
+          arcs[(2 * e.id) | 1].next_out;
+      } else {
+        nodes[arcs[2 * e.id].target].first_out =
+          arcs[(2 * e.id) | 1].next_out;
+      }
+      if (nodes[n.id].first_out != -1) {
+        arcs[nodes[n.id].first_out].prev_out = ((2 * e.id) | 1);
+      }
+      arcs[2 * e.id].target = n.id;
+      arcs[(2 * e.id) | 1].prev_out = -1;
+      arcs[(2 * e.id) | 1].next_out = nodes[n.id].first_out;
+      nodes[n.id].first_out = ((2 * e.id) | 1);
+    }
+    void changeBlue(Edge e, BlueNode n) {
+       if(arcs[2 * e.id].next_out != -1) {
+        arcs[arcs[2 * e.id].next_out].prev_out = arcs[2 * e.id].prev_out;
+      }
+      if(arcs[2 * e.id].prev_out != -1) {
+        arcs[arcs[2 * e.id].prev_out].next_out =
+          arcs[2 * e.id].next_out;
+      } else {
+        nodes[arcs[(2 * e.id) | 1].target].first_out =
+          arcs[2 * e.id].next_out;
+      }
+      if (nodes[n.id].first_out != -1) {
+        arcs[nodes[n.id].first_out].prev_out = 2 * e.id;
+      }
+      arcs[(2 * e.id) | 1].target = n.id;
+      arcs[2 * e.id].prev_out = -1;
+      arcs[2 * e.id].next_out = nodes[n.id].first_out;
+      nodes[n.id].first_out = 2 * e.id;
+    }
+  };
+  typedef BpGraphExtender<ListBpGraphBase> ExtendedListBpGraphBase;
+  /// \addtogroup graphs
+  /// @{
+  ///A general undirected graph structure.
+  ///\ref ListBpGraph is a versatile and fast undirected graph
+  ///implementation based on linked lists that are stored in
+  ///\c std::vector structures.
+  ///
+  ///This type fully conforms to the \ref concepts::BpGraph "BpGraph concept"
+  ///and it also provides several useful additional functionalities.
+  ///Most of its member functions and nested classes are documented
+  ///only in the concept class.
+  ///
+  ///This class provides only linear time counting for nodes, edges and arcs.
+  ///
+  ///\sa concepts::BpGraph
+  ///\sa ListDigraph
+  class ListBpGraph : public ExtendedListBpGraphBase {
+    typedef ExtendedListBpGraphBase Parent;
+  private:
+    /// BpGraphs are \e not copy constructible. Use BpGraphCopy instead.
+    ListBpGraph(const ListBpGraph &) :ExtendedListBpGraphBase()  {};
+    /// \brief Assignment of a graph to another one is \e not allowed.
+    /// Use BpGraphCopy instead.
+    void operator=(const ListBpGraph &) {}
+  public:
+    /// Constructor
+    /// Constructor.
+    ///
+    ListBpGraph() {}
+    typedef Parent::OutArcIt IncEdgeIt;
+    /// \brief Add a new red node to the graph.
+    ///
+    /// This function adds a red new node to the graph.
+    /// \return The new node.
+    RedNode addRedNode() { return Parent::addRedNode(); }
+    /// \brief Add a new blue node to the graph.
+    ///
+    /// This function adds a blue new node to the graph.
+    /// \return The new node.
+    BlueNode addBlueNode() { return Parent::addBlueNode(); }
+    /// \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(RedNode u, BlueNode v) {
+      return Parent::addEdge(u, v);
+    }
+    Edge addEdge(BlueNode v, RedNode u) {
+      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); }
+    /// 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
+    /// added to the graph.
+    bool valid(Node n) const { return Parent::valid(n); }
+    /// 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
+    /// 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 red node of an edge.
+    ///
+    /// This function changes the red 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.
+    ///
+    ///\warning This functionality cannot be used together with the
+    ///Snapshot feature.
+    void changeRed(Edge e, RedNode n) {
+      Parent::changeRed(e, n);
+    }
+    /// \brief Change the blue node of an edge.
+    ///
+    /// This function changes the blue 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.
+    ///
+    ///\warning This functionality cannot be used together with the
+    ///Snapshot feature.
+    void changeBlue(Edge e, BlueNode n) {
+      Parent::changeBlue(e, n);
+    }
+    ///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
+    /// it later.
+    ///
+    /// Class to make a snapshot of the graph and restore it later.
+    ///
+    /// The newly added nodes and edges can be removed
+    /// 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.
+    class Snapshot {
+    protected:
+      typedef Parent::NodeNotifier NodeNotifier;
+      class NodeObserverProxy : public NodeNotifier::ObserverBase {
+      public:
+        NodeObserverProxy(Snapshot& _snapshot)
+          : snapshot(_snapshot) {}
+        using NodeNotifier::ObserverBase::attach;
+        using NodeNotifier::ObserverBase::detach;
+        using NodeNotifier::ObserverBase::attached;
+      protected:
+        virtual void add(const Node& node) {
+          snapshot.addNode(node);
+        }
+        virtual void add(const std::vector<Node>& nodes) {
+          for (int i = nodes.size() - 1; i >= 0; --i) {
+            snapshot.addNode(nodes[i]);
+          }
+        }
+        virtual void erase(const Node& node) {
+          snapshot.eraseNode(node);
+        }
+        virtual void erase(const std::vector<Node>& nodes) {
+          for (int i = 0; i < int(nodes.size()); ++i) {
+            snapshot.eraseNode(nodes[i]);
+          }
+        }
+        virtual void build() {
+          Node node;
+          std::vector<Node> nodes;
+          for (notifier()->first(node); node != INVALID;
+               notifier()->next(node)) {
+            nodes.push_back(node);
+          }
+          for (int i = nodes.size() - 1; i >= 0; --i) {
+            snapshot.addNode(nodes[i]);
+          }
+        }
+        virtual void clear() {
+          Node node;
+          for (notifier()->first(node); node != INVALID;
+               notifier()->next(node)) {
+            snapshot.eraseNode(node);
+          }
+        }
+        Snapshot& snapshot;
+      };
+      class EdgeObserverProxy : public EdgeNotifier::ObserverBase {
+      public:
+        EdgeObserverProxy(Snapshot& _snapshot)
+          : snapshot(_snapshot) {}
+        using EdgeNotifier::ObserverBase::attach;
+        using EdgeNotifier::ObserverBase::detach;
+        using EdgeNotifier::ObserverBase::attached;
+      protected:
+        virtual void add(const Edge& edge) {
+          snapshot.addEdge(edge);
+        }
+        virtual void add(const std::vector<Edge>& edges) {
+          for (int i = edges.size() - 1; i >= 0; --i) {
+            snapshot.addEdge(edges[i]);
+          }
+        }
+        virtual void erase(const Edge& edge) {
+          snapshot.eraseEdge(edge);
+        }
+        virtual void erase(const std::vector<Edge>& edges) {
+          for (int i = 0; i < int(edges.size()); ++i) {
+            snapshot.eraseEdge(edges[i]);
+          }
+        }
+        virtual void build() {
+          Edge edge;
+          std::vector<Edge> edges;
+          for (notifier()->first(edge); edge != INVALID;
+               notifier()->next(edge)) {
+            edges.push_back(edge);
+          }
+          for (int i = edges.size() - 1; i >= 0; --i) {
+            snapshot.addEdge(edges[i]);
+          }
+        }
+        virtual void clear() {
+          Edge edge;
+          for (notifier()->first(edge); edge != INVALID;
+               notifier()->next(edge)) {
+            snapshot.eraseEdge(edge);
+          }
+        }
+        Snapshot& snapshot;
+      };
+      ListBpGraph *graph;
+      NodeObserverProxy node_observer_proxy;
+      EdgeObserverProxy edge_observer_proxy;
+      std::list<Node> added_nodes;
+      std::list<Edge> added_edges;
+      void addNode(const Node& node) {
+        added_nodes.push_front(node);
+      }
+      void eraseNode(const Node& node) {
+        std::list<Node>::iterator it =
+          std::find(added_nodes.begin(), added_nodes.end(), node);
+        if (it == added_nodes.end()) {
+          clear();
+          edge_observer_proxy.detach();
+          throw NodeNotifier::ImmediateDetach();
+        } else {
+          added_nodes.erase(it);
+        }
+      }
+      void addEdge(const Edge& edge) {
+        added_edges.push_front(edge);
+      }
+      void eraseEdge(const Edge& edge) {
+        std::list<Edge>::iterator it =
+          std::find(added_edges.begin(), added_edges.end(), edge);
+        if (it == added_edges.end()) {
+          clear();
+          node_observer_proxy.detach();
+          throw EdgeNotifier::ImmediateDetach();
+        } else {
+          added_edges.erase(it);
+        }
+      }
+      void attach(ListBpGraph &_graph) {
+        graph = &_graph;
+        node_observer_proxy.attach(graph->notifier(Node()));
+        edge_observer_proxy.attach(graph->notifier(Edge()));
+      }
+      void detach() {
+        node_observer_proxy.detach();
+        edge_observer_proxy.detach();
+      }
+      bool attached() const {
+        return node_observer_proxy.attached();
+      }
+      void clear() {
+        added_nodes.clear();
+        added_edges.clear();
+      }
+    public:
+      /// \brief Default constructor.
+      ///
+      /// Default constructor.
+      /// You have to call save() to actually make a snapshot.
+      Snapshot()
+        : graph(0), node_observer_proxy(*this),
+          edge_observer_proxy(*this) {}
+      /// \brief Constructor that immediately makes a snapshot.
+      ///
+      /// This constructor immediately makes a snapshot of the given graph.
+      Snapshot(ListBpGraph &gr)
+        : node_observer_proxy(*this),
+          edge_observer_proxy(*this) {
+        attach(gr);
+      }
+      /// \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
+      /// call, the previous snapshot gets lost.
+      void save(ListBpGraph &gr) {
+        if (attached()) {
+          detach();
+          clear();
+        }
+        attach(gr);
+      }
+      /// \brief Undo the changes until the last snapshot.
+      ///
+      /// This function undos the changes until the last snapshot
+      /// created by save() or Snapshot(ListBpGraph&).
+      ///
+      /// \warning This method invalidates the snapshot, i.e. repeated
+      /// restoring is not supported unless you call save() again.
+      void restore() {
+        detach();
+        for(std::list<Edge>::iterator it = added_edges.begin();
+            it != added_edges.end(); ++it) {
+          graph->erase(*it);
+        }
+        for(std::list<Node>::iterator it = added_nodes.begin();
+            it != added_nodes.end(); ++it) {
+          graph->erase(*it);
+        }
+        clear();
+      }
+      /// \brief Returns \c true if the snapshot is valid.
+      ///
+      /// This function returns \c true if the snapshot is valid.
+      bool valid() const {
+        return attached();
+      }
+    };
+  };
+  /// @}
 } //namespace lemon

lemon/lp.h

-                      r674
+                      r1340
  * This file is a part of LEMON, a generic C++ optimization library.
+ *
  * Copyright (C) 2003-2008
+ * Copyright (C) 2003-2013
  * Egervary Jeno Kombinatorikus Optimalizalasi Kutatocsoport
  * (Egervary Research Group on Combinatorial Optimization, EGRES).
 …
 #ifdef LEMON_HAVE_GLPK
+#if LEMON_DEFAULT_LP == LEMON_GLPK_ || LEMON_DEFAULT_MIP == LEMON_GLPK_
 #include <lemon/glpk.h>
+#elif LEMON_HAVE_CPLEX
+#endif
+#if LEMON_DEFAULT_LP == LEMON_CPLEX_ || LEMON_DEFAULT_MIP == LEMON_CPLEX_
 #include <lemon/cplex.h>
+#elif LEMON_HAVE_SOPLEX
+#endif
+#if LEMON_DEFAULT_LP == LEMON_SOPLEX_
 #include <lemon/soplex.h>
+#elif LEMON_HAVE_CLP
+#endif
+#if LEMON_DEFAULT_LP == LEMON_CLP_
 #include <lemon/clp.h>
+#endif
+#if LEMON_DEFAULT_MIP == LEMON_CBC_
+#include <lemon/cbc.h>
 #endif
 …
   ///\ingroup lp_group
   ///
   ///Currently, the possible values are \c GLPK, \c CPLEX,
   ///\c SOPLEX or \c CLP
+  ///Currently, the possible values are \c LEMON_GLPK_, \c LEMON_CPLEX_,
+  ///\c LEMON_SOPLEX_ or \c LEMON_CLP_
 #define LEMON_DEFAULT_LP SOLVER
   ///The default LP solver
 …
   ///\ingroup lp_group
   ///
+  ///Currently, the possible values are \c GLPK or \c CPLEX
+  ///Currently, the possible values are \c LEMON_GLPK_, \c LEMON_CPLEX_
+  ///or \c LEMON_CBC_
 #define LEMON_DEFAULT_MIP SOLVER
   ///The default MIP solver.
 …
   ///\ingroup lp_group
   ///
   ///Currently, it is either \c GlpkMip or \c CplexMip
+  ///Currently, it is either \c GlpkMip, \c CplexMip , \c CbcMip
   typedef GlpkMip Mip;
 #else
+#ifdef LEMON_HAVE_GLPK
+# define LEMON_DEFAULT_LP GLPK
+#if LEMON_DEFAULT_LP == LEMON_GLPK_
   typedef GlpkLp Lp;
+# define LEMON_DEFAULT_MIP GLPK
+#elif LEMON_DEFAULT_LP == LEMON_CPLEX_
+  typedef CplexLp Lp;
+#elif LEMON_DEFAULT_LP == LEMON_SOPLEX_
+  typedef SoplexLp Lp;
+#elif LEMON_DEFAULT_LP == LEMON_CLP_
+  typedef ClpLp Lp;
+#endif
+#if LEMON_DEFAULT_MIP == LEMON_GLPK_
   typedef GlpkMip Mip;
+#elif LEMON_HAVE_CPLEX
+# define LEMON_DEFAULT_LP CPLEX
+  typedef CplexLp Lp;
+# define LEMON_DEFAULT_MIP CPLEX
+#elif LEMON_DEFAULT_MIP == LEMON_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;
+#elif LEMON_DEFAULT_MIP == LEMON_CBC_
+  typedef CbcMip Mip;
 #endif
 #endif

lemon/lp_base.cc

r557	r1270
3	3	* This file is a part of LEMON, a generic C++ optimization library.
4	4	*
5		* Copyright (C) 2003-2008
	5	* Copyright (C) 2003-2013
6	6	* Egervary Jeno Kombinatorikus Optimalizalasi Kutatocsoport
7	7	* (Egervary Research Group on Combinatorial Optimization, EGRES).

lemon/lp_base.h

-                      r833
+                      r1270
  * This file is a part of LEMON, a generic C++ optimization library.
+ *
  * Copyright (C) 2003-2008
+ * Copyright (C) 2003-2013
  * Egervary Jeno Kombinatorikus Optimalizalasi Kutatocsoport
  * (Egervary Research Group on Combinatorial Optimization, EGRES).
 …
       MESSAGE_VERBOSE
     };
     ///The floating point type used by the solver
 …
       typedef True LpCol;
       /// Default constructor
       /// \warning The default constructor sets the Col to an
       /// undefined value.
       Col() {}
       /// Invalid constructor \& conversion.
       /// This constructor initializes the Col to be invalid.
       /// \sa Invalid for more details.
+      /// \sa Invalid for more details.
       Col(const Invalid&) : _id(-1) {}
       /// Equality operator
 …
     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.
       ///
 …
+      }
       /// 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.
       ///
 …
       typedef True LpRow;
       /// Default constructor
       /// \warning The default constructor sets the Row to an
       /// undefined value.
       Row() {}
       /// Invalid constructor \& conversion.
       /// This constructor initializes the Row to be invalid.
       /// \sa Invalid for more details.
+      /// \sa Invalid for more details.
       Row(const Invalid&) : _id(-1) {}
       /// Equality operator
 …
       bool operator==(Row r) const  {return _id == r._id;}
       /// Inequality operator
       /// \sa operator==(Row r)
       ///
 …
     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.
       ///
 …
+      }
       /// 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.
       ///
 …
       typedef True SolverExpr;
       /// Default constructor
       /// Construct an empty expression, the coefficients and
       /// the constant component are initialized to zero.
 …
       ///Iterator over the expression
       ///The iterator iterates over the terms of the expression.
       ///
+      ///The iterator iterates over the terms of the expression.
+      ///
       ///\code
       ///double s=0;
 …
         /// Sets the iterator to the first term
         /// Sets the iterator to the first term of the expression.
         ///
 …
         const Value& operator*() const { return _it->second; }
         /// Next term
         /// Assign the iterator to the next term.
         ///
 …
       /// Const iterator over the expression
       ///The iterator iterates over the terms of the expression.
       ///
+      ///The iterator iterates over the terms of the expression.
+      ///
       ///\code
       ///double s=0;
 …
         /// Sets the iterator to the first term
         /// Sets the iterator to the first term of the expression.
         ///
 …
         /// Next term
         /// Assign the iterator to the next term.
         ///
 …
       typedef True SolverExpr;
       /// Default constructor
       /// Construct an empty expression, the coefficients are
       /// initialized to zero.
 …
+      }
       /// \brief Removes the coefficients which's absolute value does
       /// not exceed \c epsilon.
+      /// not exceed \c epsilon.
       void simplify(Value epsilon = 0.0) {
         std::map<int, Value>::iterator it=comps.begin();
 …
       ///Iterator over the expression
       ///The iterator iterates over the terms of the expression.
       ///
+      ///The iterator iterates over the terms of the expression.
+      ///
       ///\code
       ///double s=0;
 …
         /// Sets the iterator to the first term
         /// Sets the iterator to the first term of the expression.
         ///
 …
         /// Next term
         /// Assign the iterator to the next term.
         ///
 …
       ///Iterator over the expression
       ///The iterator iterates over the terms of the expression.
       ///
+      ///The iterator iterates over the terms of the expression.
+      ///
       ///\code
       ///double s=0;
 …
         /// Sets the iterator to the first term
         /// Sets the iterator to the first term of the expression.
         ///
 …
         /// Next term
         /// Assign the iterator to the next term.
         ///
 …
     LpBase() : rows(), cols(), obj_const_comp(0) {}
+  public:
+    ///Unsupported file format exception
+    class UnsupportedFormatError : public Exception
+    {
+      std::string _format;
+      mutable std::string _what;
+    public:
+      explicit UnsupportedFormatError(std::string format) throw()
+        : _format(format) { }
+      virtual ~UnsupportedFormatError() throw() {}
+      virtual const char* what() const throw() {
+        try {
+          _what.clear();
+          std::ostringstream oss;
+          oss << "lemon::UnsupportedFormatError: " << _format;
+          _what = oss.str();
+        }
+        catch (...) {}
+        if (!_what.empty()) return _what.c_str();
+        else return "lemon::UnsupportedFormatError";
+      }
+    };
+  protected:
+    virtual void _write(std::string, std::string format) const
+    {
+      throw UnsupportedFormatError(format);
+    }
   public:
 …
       Row r;
       c.expr().simplify();
       r._id = _addRowId(_addRow(c.lowerBounded()?c.lowerBound():-INF,
+      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():INF));
+                                c.upperBounded()?c.upperBound()-*c.expr():INF));
       return r;
+    }
 …
     void min() { _setSense(MIN); }
     ///Clears the problem
     void clear() { _clear(); }
     /// Sets the message level of the solver
+    ///Clear the problem
+    void clear() { _clear(); rows.clear(); cols.clear(); }
+    /// Set the message level of the solver
     void messageLevel(MessageLevel level) { _messageLevel(level); }
+    /// Write the problem to a file in the given format
+    /// This function writes the problem to a file in the given format.
+    /// Different solver backends may support different formats.
+    /// Trying to write in an unsupported format will trigger
+    /// \ref UnsupportedFormatError. For the supported formats,
+    /// visit the documentation of the base class of the related backends
+    /// (\ref CplexBase, \ref GlpkBase etc.)
+    /// \param file The file path
+    /// \param format The output file format.
+    void write(std::string file, std::string format = "MPS") const
+    {
+      _write(file.c_str(),format.c_str());
+    }
     ///@}
 …
   inline LpBase::Constr operator<=(const LpBase::Expr &e,
                                    const LpBase::Expr &f) {
     return LpBase::Constr(0, f - e, LpBase::INF);
+    return LpBase::Constr(0, f - e, LpBase::NaN);
+  }
 …
   inline LpBase::Constr operator<=(const LpBase::Expr &e,
                                    const LpBase::Value &f) {
     return LpBase::Constr(- LpBase::INF, e, f);
+    return LpBase::Constr(LpBase::NaN, e, f);
+  }
 …
   inline LpBase::Constr operator>=(const LpBase::Expr &e,
                                    const LpBase::Expr &f) {
     return LpBase::Constr(0, e - f, LpBase::INF);
+    return LpBase::Constr(0, e - f, LpBase::NaN);
+  }
 …
   inline LpBase::Constr operator>=(const LpBase::Expr &e,
                                    const LpBase::Value &f) {
     return LpBase::Constr(f, e, LpBase::INF);
+    return LpBase::Constr(f, e, LpBase::NaN);
+  }
 …
     enum VarStatus {
       /// The variable is in the basis
       BASIC,
+      BASIC,
       /// The variable is free, but not basic
       FREE,
       /// The variable has active lower bound
+      /// The variable has active lower bound
       LOWER,
       /// The variable has active upper bound
 …
+    }
     /// 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
 …
     /// 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
 …
+    }
     ///The value of the objective function
     ///\return
     ///- \ref INF or -\ref INF means either infeasibility or unboundedness

lemon/lp_skeleton.cc

-                      r793
+                      r1270
  * This file is a part of LEMON, a generic C++ optimization library.
+ *
  * Copyright (C) 2003-2008
+ * Copyright (C) 2003-2013
  * Egervary Jeno Kombinatorikus Optimalizalasi Kutatocsoport
  * (Egervary Research Group on Combinatorial Optimization, EGRES).
 …
   void SkeletonSolverBase::_messageLevel(MessageLevel) {}
+  void SkeletonSolverBase::_write(std::string, std::string) const {}
   LpSkeleton::SolveExitStatus LpSkeleton::_solve() { return SOLVED; }

lemon/lp_skeleton.h

-                      r793
+                      r1270
  * This file is a part of LEMON, a generic C++ optimization library.
+ *
  * Copyright (C) 2003-2008
+ * Copyright (C) 2003-2013
  * Egervary Jeno Kombinatorikus Optimalizalasi Kutatocsoport
  * (Egervary Research Group on Combinatorial Optimization, EGRES).
 …
 ///\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.
 …
   ///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.
 …
     ///\e
     virtual void _messageLevel(MessageLevel);
+    ///\e
+    virtual void _write(std::string file, std::string format) const;
   };
 …
     ///\e
     virtual const char* _solverName() const;
   };

lemon/maps.h

-                      r839
+                      r1270
  * This file is a part of LEMON, a generic C++ optimization library.
+ *
  * Copyright (C) 2003-2009
+ * Copyright (C) 2003-2013
  * Egervary Jeno Kombinatorikus Optimalizalasi Kutatocsoport
  * (Egervary Research Group on Combinatorial Optimization, EGRES).
 …
   /// heap types and \c UnionFind, when the used items are small
   /// integers. This map conforms to the \ref concepts::ReferenceMap
   /// "ReferenceMap" concept.
+  /// "ReferenceMap" concept.
   ///
   /// The simplest way of using this map is through the rangeMap()
 …
   /// \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
+  /// 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
 …
       typename Container::const_iterator it;
     };
     /// Alias for \c ValueIt
     typedef ValueIt ValueIterator;
 …
       return it != _inv_map.end() ? it->second : INVALID;
+    }
     /// \brief Returns the number of items with the given value.
     ///
 …
     return RangeIdMap<GR, K>(graph);
+  }
   /// \brief Dynamic iterable \c bool map.
   ///
 …
       /// \param value The value.
       ItemIt(const IterableBoolMap& map, bool value)
         : Parent(value ?
+        : Parent(value ?
                  (map._sep > 0 ?
                   map._array[map._sep - 1] : INVALID) :
 …
     virtual void add(const Key& key) {
       Parent::add(key);
       unlace(key);
+      lace(key);
+    }
 …
     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
+  /// 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
 …
     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;

lemon/matching.h

-                      r698
+                      r1270
  * This file is a part of LEMON, a generic C++ optimization library.
+ *
  * Copyright (C) 2003-2009
+ * Copyright (C) 2003-2013
  * Egervary Jeno Kombinatorikus Optimalizalasi Kutatocsoport
  * (Egervary Research Group on Combinatorial Optimization, EGRES).
 …
  */
 #ifndef LEMON_MAX_MATCHING_H
 #define LEMON_MAX_MATCHING_H
+#ifndef LEMON_MATCHING_H
+#define LEMON_MATCHING_H
 #include <vector>
 …
 #include <lemon/bin_heap.h>
 #include <lemon/maps.h>
+#include <lemon/fractional_matching.h>
 ///\ingroup matching
 …
   /// This class implements Edmonds' alternating forest matching algorithm
   /// for finding a maximum cardinality matching in a general undirected graph.
   /// It can be started from an arbitrary initial matching
+  /// It can be started from an arbitrary initial matching
   /// (the default is the empty one).
   ///
 …
     ///\brief Status constants for Gallai-Edmonds decomposition.
     ///
     ///These constants are used for indicating the Gallai-Edmonds
+    ///These constants are used for indicating the Gallai-Edmonds
     ///decomposition of a graph. The nodes with status \c EVEN (or \c D)
     ///induce a subgraph with factor-critical components, the nodes with
     ///status \c ODD (or \c A) form the canonical barrier, and the nodes
     ///with status \c MATCHED (or \c C) induce a subgraph having a
+    ///with status \c MATCHED (or \c C) induce a subgraph having a
     ///perfect matching.
     enum Status {
 …
+    }
     /// \brief Start Edmonds' algorithm with a heuristic improvement
+    /// \brief Start Edmonds' algorithm with a heuristic improvement
     /// for dense graphs
     ///
 …
     /// \brief Run Edmonds' algorithm
     ///
     /// This function runs Edmonds' algorithm. An additional heuristic of
     /// postponing shrinks is used for relatively dense graphs
+    /// This function runs Edmonds' algorithm. An additional heuristic of
+    /// postponing shrinks is used for relatively dense graphs
     /// (for which <tt>m>=2*n</tt> holds).
     void run() {
 …
     /// \brief Return the size (cardinality) of the matching.
     ///
     /// This function returns the size (cardinality) of the current matching.
+    /// This function returns the size (cardinality) of the current matching.
     /// After run() it returns the size of the maximum matching in the graph.
     int matchingSize() const {
 …
     /// \brief Return \c true if the given edge is in the matching.
     ///
     /// This function returns \c true if the given edge is in the current
+    /// This function returns \c true if the given edge is in the current
     /// matching.
     bool matching(const Edge& edge) const {
 …
     ///
     /// This function returns the matching arc (or edge) incident to the
     /// given node in the current matching or \c INVALID if the node is
+    /// given node in the current matching or \c INVALID if the node is
     /// not covered by the matching.
     Arc matching(const Node& n) const {
 …
     /// \brief Return the mate of the given node.
     ///
     /// This function returns the mate of the given node in the current
+    /// This function returns the mate of the given node in the current
     /// matching or \c INVALID if the node is not covered by the matching.
     Node mate(const Node& n) const {
 …
     /// \name Dual Solution
     /// Functions to get the dual solution, i.e. the Gallai-Edmonds
+    /// Functions to get the dual solution, i.e. the Gallai-Edmonds
     /// decomposition.
 …
   /// \f$O(nm\log n)\f$ time complexity.
   ///
   /// The maximum weighted matching problem is to find a subset of the
   /// edges in an undirected graph with maximum overall weight for which
+  /// The maximum weighted matching problem is to find a subset of the
+  /// edges in an undirected graph with maximum overall weight for which
   /// each node has at most one incident edge.
   /// It can be formulated with the following linear program.
 …
       \frac{\vert B \vert - 1}{2}z_B\f] */
   ///
   /// The algorithm can be executed with the run() function.
+  /// The algorithm can be executed with the run() function.
   /// After it the matching (the primal solution) and the dual solution
   /// can be obtained using the query functions and the
   /// \ref MaxWeightedMatching::BlossomIt "BlossomIt" nested class,
   /// which is able to iterate on the nodes of a blossom.
+  /// can be obtained using the query functions and the
+  /// \ref MaxWeightedMatching::BlossomIt "BlossomIt" nested class,
+  /// which is able to iterate on the nodes of a blossom.
   /// If the value type is integer, then the dual solution is multiplied
   /// by \ref MaxWeightedMatching::dualScale "4".
   ///
   /// \tparam GR The undirected graph type the algorithm runs on.
   /// \tparam WM The type edge weight map. The default type is
+  /// \tparam WM The type edge weight map. The default type is
   /// \ref concepts::Graph::EdgeMap "GR::EdgeMap<int>".
 #ifdef DOXYGEN
 …
     enum Status {
       EVEN = -1, MATCHED = 0, ODD = 1, UNMATCHED = -2
+      EVEN = -1, MATCHED = 0, ODD = 1
     };
 …
     Value _delta_sum;
+    int _unmatched;
+    typedef MaxWeightedFractionalMatching<Graph, WeightMap> FractionalMatching;
+    FractionalMatching *_fractional;
     void createStructures() {
 …
         _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);
+      }
 …
         _node_heap_index = new IntArcMap(_graph);
         _node_data = new RangeMap<NodeData>(_node_num,
+                                              NodeData(*_node_heap_index));
+                                            NodeData(*_node_heap_index));
+      } else {
+        delete _node_data;
+        _node_data = new RangeMap<NodeData>(_node_num,
+                                            NodeData(*_node_heap_index));
+      }
 …
         _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() {
-      _node_num = countNodes(_graph);
-      _blossom_num = _node_num * 3 / 2;
       if (_matching) {
         delete _matching;
 …
             if (_delta3->state(e) != _delta3->IN_HEAP && blossom != vb) {
               _delta3->push(e, rw / 2);
+            }
-          } else if ((*_blossom_data)[vb].status == UNMATCHED) {
-            if (_delta3->state(e) != _delta3->IN_HEAP) {
-              _delta3->push(e, rw);
+            }
           } else {
 …
                                (*_blossom_data)[vb].offset);
                 } else if ((*_delta2)[vb] > _blossom_set->classPrio(vb) -
                            (*_blossom_data)[vb].offset){
+                           (*_blossom_data)[vb].offset) {
                   _delta2->decrease(vb, _blossom_set->classPrio(vb) -
                                    (*_blossom_data)[vb].offset);
 …
       if (!_blossom_set->trivial(blossom)) {
         _delta4->push(blossom, (*_blossom_data)[blossom].pot / 2 +
                      (*_blossom_data)[blossom].offset);
+                      (*_blossom_data)[blossom].offset);
+      }
+    }
 …
+                }
+              }
+            }
-          } else if ((*_blossom_data)[vb].status == UNMATCHED) {
-            if (_delta3->state(e) == _delta3->IN_HEAP) {
-              _delta3->erase(e);
+            }
           } else {
 …
           std::numeric_limits<Value>::max()) {
         _delta2->push(blossom, _blossom_set->classPrio(blossom) -
                        (*_blossom_data)[blossom].offset);
+                      (*_blossom_data)[blossom].offset);
+      }
 …
             if (_delta3->state(e) != _delta3->IN_HEAP && blossom != vb) {
               _delta3->push(e, rw / 2);
+            }
-          } else if ((*_blossom_data)[vb].status == UNMATCHED) {
-            if (_delta3->state(e) != _delta3->IN_HEAP) {
-              _delta3->push(e, rw);
+            }
           } else {
 …
+    }
-    void matchedToUnmatched(int blossom) {
-      if (_delta2->state(blossom) == _delta2->IN_HEAP) {
-        _delta2->erase(blossom);
+      }
-      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();
-        for (OutArcIt e(_graph, n); e != INVALID; ++e) {
-          Node v = _graph.target(e);
-          int vb = _blossom_set->find(v);
-          int vi = (*_node_index)[v];
-          Value rw = (*_node_data)[ni].pot + (*_node_data)[vi].pot -
-            dualScale * _weight[e];
-          if ((*_blossom_data)[vb].status == EVEN) {
-            if (_delta3->state(e) != _delta3->IN_HEAP) {
-              _delta3->push(e, rw);
+            }
+          }
+        }
+      }
+    }
-    void unmatchedToMatched(int blossom) {
-      for (typename BlossomSet::ItemIt n(*_blossom_set, blossom);
-           n != INVALID; ++n) {
-        int ni = (*_node_index)[n];
-        for (InArcIt e(_graph, n); e != INVALID; ++e) {
-          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);
-            Arc r = _graph.oppositeArc(e);
-            typename std::map<int, Arc>::iterator it =
-              (*_node_data)[ni].heap_index.find(vt);
-            if (it != (*_node_data)[ni].heap_index.end()) {
-              if ((*_node_data)[ni].heap[it->second] > rw) {
-                (*_node_data)[ni].heap.replace(it->second, r);
-                (*_node_data)[ni].heap.decrease(r, rw);
-                it->second = r;
+              }
-            } else {
-              (*_node_data)[ni].heap.push(r, rw);
-              (*_node_data)[ni].heap_index.insert(std::make_pair(vt, r));
+            }
-            if ((*_blossom_set)[n] > (*_node_data)[ni].heap.prio()) {
-              _blossom_set->decrease(n, (*_node_data)[ni].heap.prio());
-              if (_delta2->state(blossom) != _delta2->IN_HEAP) {
-                _delta2->push(blossom, _blossom_set->classPrio(blossom) -
-                             (*_blossom_data)[blossom].offset);
-              } else if ((*_delta2)[blossom] > _blossom_set->classPrio(blossom)-
-                         (*_blossom_data)[blossom].offset){
-                _delta2->decrease(blossom, _blossom_set->classPrio(blossom) -
-                                 (*_blossom_data)[blossom].offset);
+              }
+            }
-          } else if ((*_blossom_data)[vb].status == UNMATCHED) {
-            if (_delta3->state(e) == _delta3->IN_HEAP) {
-              _delta3->erase(e);
+            }
+          }
+        }
+      }
+    }
     void alternatePath(int even, int tree) {
       int odd;
 …
       destroyTree(tree);
-      (*_blossom_data)[blossom].status = UNMATCHED;
       (*_blossom_data)[blossom].base = node;
+      matchedToUnmatched(blossom);
+    }
+      (*_blossom_data)[blossom].next = INVALID;
+    }
     void augmentOnEdge(const Edge& edge) {
 …
       int right = _blossom_set->find(_graph.v(edge));
+      if ((*_blossom_data)[left].status == EVEN) {
+        int left_tree = _tree_set->find(left);
+        alternatePath(left, left_tree);
+        destroyTree(left_tree);
+      } else {
+        (*_blossom_data)[left].status = MATCHED;
+        unmatchedToMatched(left);
+      }
+      if ((*_blossom_data)[right].status == EVEN) {
+        int right_tree = _tree_set->find(right);
+        alternatePath(right, right_tree);
+        destroyTree(right_tree);
+      } else {
+        (*_blossom_data)[right].status = MATCHED;
+        unmatchedToMatched(right);
+      }
+      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);
+    }
 …
           (*_blossom_data)[sb].pred = pred;
           (*_blossom_data)[sb].next =
                            _graph.oppositeArc((*_blossom_data)[tb].next);
+            _graph.oppositeArc((*_blossom_data)[tb].next);
           pred = (*_blossom_data)[ub].next;
 …
       for (int i = 0; i < int(blossoms.size()); ++i) {
         if ((*_blossom_data)[blossoms[i]].status == MATCHED) {
+        if ((*_blossom_data)[blossoms[i]].next != INVALID) {
           Value offset = (*_blossom_data)[blossoms[i]].offset;
 …
         _delta4_index(0), _delta4(0),
+        _delta_sum() {}
+        _delta_sum(), _unmatched(0),
+        _fractional(0)
+    {}
     ~MaxWeightedMatching() {
       destroyStructures();
+      if (_fractional) {
+        delete _fractional;
+      }
+    }
 …
       createStructures();
+      _blossom_node_list.clear();
+      _blossom_potential.clear();
       for (ArcIt e(_graph); e != INVALID; ++e) {
         (*_node_heap_index)[e] = BinHeap<Value, IntArcMap>::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;
 …
+        }
         (*_node_index)[n] = index;
+        (*_node_data)[index].heap_index.clear();
+        (*_node_data)[index].heap.clear();
         (*_node_data)[index].pot = max;
         _delta1->push(n, max);
 …
+    }
+    /// \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() must be called before using this function.
+    /// \pre \ref init() or \ref fractionalInit() must be called
+    /// before using this function.
     void start() {
       enum OpType {
 …
       };
+      int unmatched = _node_num;
+      while (unmatched > 0) {
+      while (_unmatched > 0) {
         Value d1 = !_delta1->empty() ?
           _delta1->prio() : std::numeric_limits<Value>::max();
 …
           _delta4->prio() : std::numeric_limits<Value>::max();
+        _delta_sum = d1; OpType ot = D1;
+        _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 (d3 < _delta_sum) { _delta_sum = d3; ot = D3; }
         if (d4 < _delta_sum) { _delta_sum = d4; ot = D4; }
         switch (ot) {
 …
             Node n = _delta1->top();
             unmatchNode(n);
             --unmatched;
+            --_unmatched;
+          }
           break;
 …
             int blossom = _delta2->top();
             Node n = _blossom_set->classTop(blossom);
+            Arc e = (*_node_data)[(*_node_index)[n]].heap.top();
+            extendOnArc(e);
+            Arc a = (*_node_data)[(*_node_index)[n]].heap.top();
+            if ((*_blossom_data)[blossom].next == INVALID) {
+              augmentOnArc(a);
+              --_unmatched;
+            } else {
+              extendOnArc(a);
+            }
+          }
           break;
 …
               _delta3->pop();
             } else {
+              int left_tree;
+              if ((*_blossom_data)[left_blossom].status == EVEN) {
+                left_tree = _tree_set->find(left_blossom);
+              } else {
+                left_tree = -1;
+                ++unmatched;
+              }
+              int right_tree;
+              if ((*_blossom_data)[right_blossom].status == EVEN) {
+                right_tree = _tree_set->find(right_blossom);
+              } else {
+                right_tree = -1;
+                ++unmatched;
+              }
+              int left_tree = _tree_set->find(left_blossom);
+              int right_tree = _tree_set->find(right_blossom);
               if (left_tree == right_tree) {
 …
               } else {
                 augmentOnEdge(e);
                 unmatched -= 2;
+                _unmatched -= 2;
+              }
+            }
 …
     /// \note mwm.run() is just a shortcut of the following code.
     /// \code
     ///   mwm.init();
+    ///   mwm.fractionalInit();
     ///   mwm.start();
     /// \endcode
     void run() {
       init();
+      fractionalInit();
       start();
+    }
 …
     /// \name Primal Solution
     /// Functions to get the primal solution, i.e. the maximum weighted
+    /// Functions to get the primal solution, i.e. the maximum weighted
     /// matching.\n
     /// Either \ref run() or \ref start() function should be called before
 …
+        }
+      }
       return sum /= 2;
+      return sum / 2;
+    }
 …
     /// \brief Return \c true if the given edge is in the matching.
     ///
     /// This function returns \c true if the given edge is in the found
+    /// This function returns \c true if the given edge is in the found
     /// matching.
     ///
 …
     ///
     /// This function returns the matching arc (or edge) incident to the
     /// given node in the found matching or \c INVALID if the node is
+    /// given node in the found matching or \c INVALID if the node is
     /// not covered by the matching.
     ///
 …
     /// \brief Return the mate of the given node.
     ///
     /// This function returns the mate of the given node in the found
+    /// This function returns the mate of the given node in the found
     /// matching or \c INVALID if the node is not covered by the matching.
     ///
 …
     /// \brief Return the value of the dual solution.
     ///
     /// This function returns the value of the dual solution.
     /// It should be equal to the primal value scaled by \ref dualScale
+    /// This function returns the value of the dual solution.
+    /// It should be equal to the primal value scaled by \ref dualScale
     /// "dual scale".
     ///
 …
     /// \brief Iterator for obtaining the nodes of a blossom.
     ///
     /// This class provides an iterator for obtaining the nodes of the
+    /// This class provides an iterator for obtaining the nodes of the
     /// given blossom. It lists a subset of the nodes.
     /// Before using this iterator, you must allocate a
+    /// Before using this iterator, you must allocate a
     /// MaxWeightedMatching class and execute it.
     class BlossomIt {
 …
       /// Constructor to get the nodes of the given variable.
       ///
       /// \pre Either \ref MaxWeightedMatching::run() "algorithm.run()" or
       /// \ref MaxWeightedMatching::start() "algorithm.start()" must be
+      /// \pre Either \ref MaxWeightedMatching::run() "algorithm.run()" or
+      /// \ref MaxWeightedMatching::start() "algorithm.start()" must be
       /// called before initializing this iterator.
       BlossomIt(const MaxWeightedMatching& algorithm, int variable)
 …
   /// \f$O(nm\log n)\f$ time complexity.
   ///
   /// The maximum weighted perfect matching problem is to find a subset of
   /// the edges in an undirected graph with maximum overall weight for which
+  /// The maximum weighted perfect matching problem is to find a subset of
+  /// the edges in an undirected graph with maximum overall weight for which
   /// each node has exactly one incident edge.
   /// It can be formulated with the following linear program.
 …
       \frac{\vert B \vert - 1}{2}z_B\f] */
   ///
   /// The algorithm can be executed with the run() function.
+  /// The algorithm can be executed with the run() function.
   /// After it the matching (the primal solution) and the dual solution
   /// can be obtained using the query functions and the
   /// \ref MaxWeightedPerfectMatching::BlossomIt "BlossomIt" nested class,
   /// which is able to iterate on the nodes of a blossom.
+  /// can be obtained using the query functions and the
+  /// \ref MaxWeightedPerfectMatching::BlossomIt "BlossomIt" nested class,
+  /// which is able to iterate on the nodes of a blossom.
   /// If the value type is integer, then the dual solution is multiplied
   /// by \ref MaxWeightedMatching::dualScale "4".
   ///
   /// \tparam GR The undirected graph type the algorithm runs on.
   /// \tparam WM The type edge weight map. The default type is
+  /// \tparam WM The type edge weight map. The default type is
   /// \ref concepts::Graph::EdgeMap "GR::EdgeMap<int>".
 #ifdef DOXYGEN
 …
     Value _delta_sum;
+    int _unmatched;
+    typedef MaxWeightedPerfectFractionalMatching<Graph, WeightMap>
+    FractionalMatching;
+    FractionalMatching *_fractional;
     void createStructures() {
 …
         _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);
+      }
 …
         _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));
+      }
 …
         _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() {
-      _node_num = countNodes(_graph);
-      _blossom_num = _node_num * 3 / 2;
       if (_matching) {
         delete _matching;
 …
         _delta4_index(0), _delta4(0),
+        _delta_sum() {}
+        _delta_sum(), _unmatched(0),
+        _fractional(0)
+    {}
     ~MaxWeightedPerfectMatching() {
       destroyStructures();
+      if (_fractional) {
+        delete _fractional;
+      }
+    }
 …
       createStructures();
+      _blossom_node_list.clear();
+      _blossom_potential.clear();
       for (ArcIt e(_graph); e != INVALID; ++e) {
         (*_node_heap_index)[e] = BinHeap<Value, IntArcMap>::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;
 …
+        }
         (*_node_index)[n] = index;
+        (*_node_data)[index].heap_index.clear();
+        (*_node_data)[index].heap.clear();
         (*_node_data)[index].pot = max;
         int blossom =
 …
+    }
+    /// \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() must be called before using this function.
+    /// \pre \ref init() or \ref fractionalInit() must be called before
+    /// using this function.
     bool start() {
       enum OpType {
 …
       };
+      int unmatched = _node_num;
+      while (unmatched > 0) {
+      if (_unmatched == -1) return false;
+      while (_unmatched > 0) {
         Value d2 = !_delta2->empty() ?
           _delta2->prio() : std::numeric_limits<Value>::max();
 …
           _delta4->prio() : std::numeric_limits<Value>::max();
         _delta_sum = d2; OpType ot = D2;
         if (d3 < _delta_sum) { _delta_sum = d3; ot = D3; }
+        _delta_sum = d3; OpType ot = D3;
+        if (d2 < _delta_sum) { _delta_sum = d2; ot = D2; }
         if (d4 < _delta_sum) { _delta_sum = d4; ot = D4; }
 …
               } else {
                 augmentOnEdge(e);
                 unmatched -= 2;
+                _unmatched -= 2;
+              }
+            }
 …
     /// \note mwpm.run() is just a shortcut of the following code.
     /// \code
     ///   mwpm.init();
+    ///   mwpm.fractionalInit();
     ///   mwpm.start();
     /// \endcode
     bool run() {
       init();
+      fractionalInit();
       return start();
+    }
 …
     /// \name Primal Solution
     /// Functions to get the primal solution, i.e. the maximum weighted
+    /// Functions to get the primal solution, i.e. the maximum weighted
     /// perfect matching.\n
     /// Either \ref run() or \ref start() function should be called before
 …
+        }
+      }
       return sum /= 2;
+      return sum / 2;
+    }
     /// \brief Return \c true if the given edge is in the matching.
     ///
     /// This function returns \c true if the given edge is in the found
+    /// This function returns \c true if the given edge is in the found
     /// matching.
     ///
 …
     ///
     /// This function returns the matching arc (or edge) incident to the
     /// given node in the found matching or \c INVALID if the node is
+    /// given node in the found matching or \c INVALID if the node is
     /// not covered by the matching.
     ///
 …
     /// \brief Return the mate of the given node.
     ///
     /// This function returns the mate of the given node in the found
+    /// This function returns the mate of the given node in the found
     /// matching or \c INVALID if the node is not covered by the matching.
     ///
 …
     /// \brief Return the value of the dual solution.
     ///
     /// This function returns the value of the dual solution.
     /// It should be equal to the primal value scaled by \ref dualScale
+    /// This function returns the value of the dual solution.
+    /// It should be equal to the primal value scaled by \ref dualScale
     /// "dual scale".
     ///
 …
     /// \brief Iterator for obtaining the nodes of a blossom.
     ///
     /// This class provides an iterator for obtaining the nodes of the
+    /// This class provides an iterator for obtaining the nodes of the
     /// given blossom. It lists a subset of the nodes.
     /// Before using this iterator, you must allocate a
+    /// Before using this iterator, you must allocate a
     /// MaxWeightedPerfectMatching class and execute it.
     class BlossomIt {
 …
       /// Constructor to get the nodes of the given variable.
       ///
       /// \pre Either \ref MaxWeightedPerfectMatching::run() "algorithm.run()"
       /// or \ref MaxWeightedPerfectMatching::start() "algorithm.start()"
+      /// \pre Either \ref MaxWeightedPerfectMatching::run() "algorithm.run()"
+      /// or \ref MaxWeightedPerfectMatching::start() "algorithm.start()"
       /// must be called before initializing this iterator.
       BlossomIt(const MaxWeightedPerfectMatching& algorithm, int variable)
 …
 } //END OF NAMESPACE LEMON
 #endif //LEMON_MAX_MATCHING_H
+#endif //LEMON_MATCHING_H

lemon/math.h

-                      r558
+                      r1311
  * This file is a part of LEMON, a generic C++ optimization library.
+ *
  * Copyright (C) 2003-2009
+ * Copyright (C) 2003-2013
  * Egervary Jeno Kombinatorikus Optimalizalasi Kutatocsoport
  * (Egervary Research Group on Combinatorial Optimization, EGRES).
 …
   ///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
 …
+    }
+  ///Round a value to its closest integer
+  inline double round(double r) {
+    return (r > 0.0) ? std::floor(r + 0.5) : std::ceil(r - 0.5);
+  }
   /// @}
 } //namespace lemon
 #endif //LEMON_TOLERANCE_H
+#endif //LEMON_MATH_H

lemon/min_cost_arborescence.h

-                      r760
+                      r1270
  * This file is a part of LEMON, a generic C++ optimization library.
+ *
  * Copyright (C) 2003-2008
+ * Copyright (C) 2003-2013
  * Egervary Jeno Kombinatorikus Optimalizalasi Kutatocsoport
  * (Egervary Research Group on Combinatorial Optimization, EGRES).
 …
   /// 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).
+  /// sources. The time complexity of the algorithm is O(n<sup>2</sup>+m).
   ///
   /// The algorithm also provides an optimal dual solution, therefore
 …
   /// it is necessary. The default map type is \ref
   /// concepts::Digraph::ArcMap "Digraph::ArcMap<int>".
+  /// \param TR Traits class to set various data types used
+  /// by the algorithm. The default traits class is
+  /// \ref MinCostArborescenceDefaultTraits
+  /// \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,
 …
               MinCostArborescenceDefaultTraits<GR, CM> >
 #else
   template <typename GR, typename CM, typedef TR>
+  template <typename GR, typename CM, typename TR>
 #endif
   class MinCostArborescence {
   public:
     /// \brief The \ref MinCostArborescenceDefaultTraits "traits class"
     /// of the algorithm.
+    /// \brief The \ref lemon::MinCostArborescenceDefaultTraits "traits class"
+    /// of the algorithm.
     typedef TR Traits;
     /// The type of the underlying digraph.
 …
     /// \ref named-templ-param "Named parameter" for setting
     /// \c PredMap type.
     /// It must meet the \ref concepts::WriteMap "WriteMap" concept,
+    /// It must meet the \ref concepts::WriteMap "WriteMap" concept,
     /// and its value type must be the \c Arc type of the digraph.
     template <class T>

lemon/network_simplex.h

-                      r878
+                      r1318
  * This file is a part of LEMON, a generic C++ optimization library.
+ *
  * Copyright (C) 2003-2009
+ * Copyright (C) 2003-2013
  * Egervary Jeno Kombinatorikus Optimalizalasi Kutatocsoport
  * (Egervary Research Group on Combinatorial Optimization, EGRES).
 …
   /// \ref NetworkSimplex implements the primal Network Simplex algorithm
   /// for finding a \ref min_cost_flow "minimum cost flow"
   /// \ref amo93networkflows, \ref dantzig63linearprog,
   /// \ref kellyoneill91netsimplex.
+  /// \cite amo93networkflows, \cite dantzig63linearprog,
+  /// \cite 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.
+  /// In general, \ref NetworkSimplex and \ref CostScaling are the fastest
+  /// implementations available in LEMON for solving this problem.
+  /// (For more information, see \ref min_cost_flow_algs "the module page".)
+  /// Furthermore, this class 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)
 …
   /// algorithm. By default, it is the same as \c V.
   ///
+  /// \warning Both number types must be signed and all input data must
+  /// \warning Both \c V and \c C must be signed number types.
+  /// \warning All input data (capacities, supply values, and costs) must
   /// be integer.
   ///
 …
       UNBOUNDED
     };
     /// \brief Constants for selecting the type of the supply constraints.
     ///
 …
       LEQ
     };
     /// \brief Constants for selecting the pivot rule.
     ///
 …
     /// the \ref run() function.
     ///
     /// \ref NetworkSimplex provides five different pivot rule
     /// implementations that significantly affect the running time
+    /// \ref NetworkSimplex provides five different implementations for
+    /// the pivot strategy that significantly affects 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.
+    /// According to experimental tests conducted on various problem
+    /// instances, \ref BLOCK_SEARCH "Block Search" and
+    /// \ref ALTERING_LIST "Altering Candidate List" rules turned out
+    /// to be the most efficient.
+    /// Since \ref BLOCK_SEARCH "Block Search" is a simpler strategy that
+    /// seemed to be slightly more robust, it is used by default.
+    /// However, another pivot rule can easily be selected using the
+    /// \ref run() function with the proper parameter.
     enum PivotRule {
 …
       /// 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
+      /// It keeps only a few of the best eligible arcs from the former
       /// candidate list and extends this list in every iteration.
       ALTERING_LIST
     };
   private:
 …
     typedef std::vector<int> IntVector;
-    typedef std::vector<char> CharVector;
     typedef std::vector<Value> ValueVector;
     typedef std::vector<Cost> CostVector;
+    typedef std::vector<signed char> CharVector;
+    // Note: vector<signed char> is used instead of vector<ArcState> and
+    // vector<ArcDirection> for efficiency reasons
     // State constants for arcs
     enum ArcStateEnum {
+    enum ArcState {
       STATE_UPPER = -1,
       STATE_TREE  =  0,
       STATE_LOWER =  1
+    };
+    // Direction constants for tree arcs
+    enum ArcDirection {
+      DIR_DOWN = -1,
+      DIR_UP   =  1
     };
 …
     // Parameters of the problem
     bool _have_lower;
+    bool _has_lower;
     SupplyType _stype;
     Value _sum_supply;
 …
     IntVector _source;
     IntVector _target;
+    bool _arc_mixing;
     // Node and arc data
 …
     IntVector _succ_num;
     IntVector _last_succ;
+    CharVector _pred_dir;
+    CharVector _state;
     IntVector _dirty_revs;
-    CharVector _forward;
-    CharVector _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).
     ///
 …
       bool findEnteringArc() {
         Cost c;
         for (int e = _next_arc; e < _search_arc_num; ++e) {
+        for (int e = _next_arc; e != _search_arc_num; ++e) {
           c = _state[e] * (_cost[e] + _pi[_source[e]] - _pi[_target[e]]);
           if (c < 0) {
 …
+          }
+        }
         for (int e = 0; e < _next_arc; ++e) {
+        for (int e = 0; e != _next_arc; ++e) {
           c = _state[e] * (_cost[e] + _pi[_source[e]] - _pi[_target[e]]);
           if (c < 0) {
 …
       bool findEnteringArc() {
         Cost c, min = 0;
         for (int e = 0; e < _search_arc_num; ++e) {
+        for (int e = 0; e != _search_arc_num; ++e) {
           c = _state[e] * (_cost[e] + _pi[_source[e]] - _pi[_target[e]]);
           if (c < min) {
 …
+      {
         // The main parameters of the pivot rule
         const double BLOCK_SIZE_FACTOR = 0.5;
+        const double BLOCK_SIZE_FACTOR = 1.0;
         const int MIN_BLOCK_SIZE = 10;
 …
         int cnt = _block_size;
         int e;
         for (e = _next_arc; e < _search_arc_num; ++e) {
+        for (e = _next_arc; e != _search_arc_num; ++e) {
           c = _state[e] * (_cost[e] + _pi[_source[e]] - _pi[_target[e]]);
           if (c < min) {
 …
+          }
+        }
         for (e = 0; e < _next_arc; ++e) {
+        for (e = 0; e != _next_arc; ++e) {
           c = _state[e] * (_cost[e] + _pi[_source[e]] - _pi[_target[e]]);
           if (c < min) {
 …
         min = 0;
         _curr_length = 0;
         for (e = _next_arc; e < _search_arc_num; ++e) {
+        for (e = _next_arc; e != _search_arc_num; ++e) {
           c = _state[e] * (_cost[e] + _pi[_source[e]] - _pi[_target[e]]);
           if (c < 0) {
 …
+          }
+        }
         for (e = 0; e < _next_arc; ++e) {
+        for (e = 0; e != _next_arc; ++e) {
           c = _state[e] * (_cost[e] + _pi[_source[e]] - _pi[_target[e]]);
           if (c < 0) {
 …
+        }
         if (_curr_length == 0) return false;
       search_end:
+      search_end:
         _minor_count = 1;
         _next_arc = e;
 …
         SortFunc(const CostVector &map) : _map(map) {}
         bool operator()(int left, int right) {
           return _map[left] > _map[right];
+          return _map[left] < _map[right];
+        }
       };
 …
         const double BLOCK_SIZE_FACTOR = 1.0;
         const int MIN_BLOCK_SIZE = 10;
         const double HEAD_LENGTH_FACTOR = 0.1;
+        const double HEAD_LENGTH_FACTOR = 0.01;
         const int MIN_HEAD_LENGTH = 3;
 …
         // Check the current candidate list
         int e;
+        for (int i = 0; i < _curr_length; ++i) {
+        Cost c;
+        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) {
+          c = _state[e] * (_cost[e] + _pi[_source[e]] - _pi[_target[e]]);
+          if (c < 0) {
+            _cand_cost[e] = c;
+          } else {
             _candidates[i--] = _candidates[--_curr_length];
+          }
 …
         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) {
+        for (e = _next_arc; e != _search_arc_num; ++e) {
+          c = _state[e] * (_cost[e] + _pi[_source[e]] - _pi[_target[e]]);
+          if (c < 0) {
+            _cand_cost[e] = c;
             _candidates[_curr_length++] = e;
+          }
 …
+          }
+        }
         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) {
+        for (e = 0; e != _next_arc; ++e) {
+          c = _state[e] * (_cost[e] + _pi[_source[e]] - _pi[_target[e]]);
+          if (c < 0) {
+            _cand_cost[e] = c;
             _candidates[_curr_length++] = e;
+          }
 …
+        }
         if (_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
+        // Perform partial sort operation on the candidate list
+        int new_length = std::min(_head_length + 1, _curr_length);
+        std::partial_sort(_candidates.begin(), _candidates.begin() + new_length,
+                          _candidates.begin() + _curr_length, _sort_func);
+        // Select the entering arc and remove it from the list
         _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);
+        _candidates[0] = _candidates[new_length - 1];
+        _curr_length = new_length - 1;
         return true;
+      }
 …
     ///
     /// \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) :
+    /// \param arc_mixing Indicate if the arcs will be stored in a
+    /// mixed order in the internal data structure.
+    /// In general, it leads to similar performance as using the original
+    /// arc order, but it makes the algorithm more robust and in special
+    /// cases, even significantly faster. Therefore, it is enabled by default.
+    NetworkSimplex(const GR& graph, bool arc_mixing = true) :
       _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 ?
 …
       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) {
+      _has_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>
+    ///
+    /// \sa supplyType()
+    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 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;
+      }
+      _has_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);
 …
       _parent.resize(all_node_num);
       _pred.resize(all_node_num);
       _forward.resize(all_node_num);
+      _pred_dir.resize(all_node_num);
       _thread.resize(all_node_num);
       _rev_thread.resize(all_node_num);
 …
         _node_id[n] = i;
+      }
       if (arc_mixing) {
+      if (_arc_mixing && _node_num > 1) {
         // Store the arcs in a mixed order
         int k = std::max(int(std::sqrt(double(_arc_num))), 10);
+        const int skip = std::max(_arc_num / _node_num, 3);
         int i = 0, j = 0;
         for (ArcIt a(_graph); a != INVALID; ++a) {
 …
           _source[i] = _node_id[_graph.source(a)];
           _target[i] = _node_id[_graph.target(a)];
           if ((i += k) >= _arc_num) i = ++j;
+          if ((i += skip) >= _arc_num) i = ++j;
+        }
       } else {
 …
+        }
+      }
       // Reset parameters
+      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 parameters
+    /// that have been given are kept for the next call, unless
+    /// \ref reset() is called, thus only the modified parameters
+    /// have to be set again. See \ref reset() for examples.
+    /// However, the underlying digraph must not be modified after this
+    /// class have been constructed, since it copies and extends the graph.
+    ///
+    /// \param pivot_rule The pivot rule that will be used during the
+    /// algorithm. For more information, see \ref PivotRule.
+    ///
+    /// \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
+    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 run() calls. If this function is not
+    /// used, all the parameters given before are kept for the next
+    /// \ref run() call.
+    /// However, the underlying digraph must not be modified after this
+    /// class have been constructed, since it copies and extends the graph.
+    ///
+    /// For example,
+    /// \code
+    ///   NetworkSimplex<ListDigraph> ns(graph);
+    ///
+    ///   // First run
+    ///   ns.lowerMap(lower).upperMap(upper).costMap(cost)
+    ///     .supplyMap(sup).run();
+    ///
+    ///   // Run again with modified cost map (reset() is not called,
+    ///   // so only the cost map have to be set again)
+    ///   cost[e] += 100;
+    ///   ns.costMap(cost).run();
+    ///
+    ///   // Run again from scratch using reset()
+    ///   // (the lower bounds will be set to zero on all arcs)
+    ///   ns.reset();
+    ///   ns.upperMap(capacity).costMap(cost)
+    ///     .supplyMap(sup).run();
+    /// \endcode
+    ///
+    /// \return <tt>(*this)</tt>
+    NetworkSimplex& reset() {
+      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;
+      resetParams();
       return *this;
+    }
 …
     ///
     /// This function returns the total cost of the found flow.
     /// Its complexity is O(e).
+    /// Its complexity is O(m).
     ///
     /// \note The return type of the function can be specified as a
 …
+    }
+    /// \brief Return the flow map (the primal solution).
+    /// \brief Copy the flow values (the primal solution) into the
+    /// given map.
     ///
     /// This function copies the flow value on each arc into the given
 …
+    }
+    /// \brief Return the potential map (the dual solution).
+    /// \brief Copy the potential values (the dual solution) into the
+    /// given map.
     ///
     /// This function copies the potential (dual value) of each node
 …
              (_stype == LEQ && _sum_supply >= 0)) ) return false;
+      // Check lower and upper bounds
+      LEMON_DEBUG(checkBoundMaps(),
+          "Upper bounds must be greater or equal to the lower bounds");
       // Remove non-zero lower bounds
       if (_have_lower) {
+      if (_has_lower) {
         for (int i = 0; i != _arc_num; ++i) {
           Value c = _lower[i];
 …
         ART_COST = std::numeric_limits<Cost>::max() / 2 + 1;
       } else {
         ART_COST = std::numeric_limits<Cost>::min();
+        ART_COST = 0;
         for (int i = 0; i != _arc_num; ++i) {
           if (_cost[i] > ART_COST) ART_COST = _cost[i];
 …
         _state[i] = STATE_LOWER;
+      }
       // Set data for the artificial root node
       _root = _node_num;
 …
           _state[e] = STATE_TREE;
           if (_supply[u] >= 0) {
             _forward[u] = true;
+            _pred_dir[u] = DIR_UP;
             _pi[u] = 0;
             _source[e] = u;
 …
             _cost[e] = 0;
           } else {
             _forward[u] = false;
+            _pred_dir[u] = DIR_DOWN;
             _pi[u] = ART_COST;
             _source[e] = _root;
 …
           _last_succ[u] = u;
           if (_supply[u] >= 0) {
             _forward[u] = true;
+            _pred_dir[u] = DIR_UP;
             _pi[u] = 0;
             _pred[u] = e;
 …
             _state[e] = STATE_TREE;
           } else {
             _forward[u] = false;
+            _pred_dir[u] = DIR_DOWN;
             _pi[u] = ART_COST;
             _pred[u] = f;
 …
           _last_succ[u] = u;
           if (_supply[u] <= 0) {
             _forward[u] = false;
+            _pred_dir[u] = DIR_DOWN;
             _pi[u] = 0;
             _pred[u] = e;
 …
             _state[e] = STATE_TREE;
           } else {
             _forward[u] = true;
+            _pred_dir[u] = DIR_UP;
             _pi[u] = -ART_COST;
             _pred[u] = f;
 …
+    }
+    // Check if the upper bound is greater than or equal to the lower bound
+    // on each arc.
+    bool checkBoundMaps() {
+      for (int j = 0; j != _arc_num; ++j) {
+        if (_upper[j] < _lower[j]) return false;
+      }
+      return true;
+    }
     // Find the join node
     void findJoinNode() {
 …
       // Initialize first and second nodes according to the direction
       // of the cycle
+      int first, second;
       if (_state[in_arc] == STATE_LOWER) {
         first  = _source[in_arc];
 …
       delta = _cap[in_arc];
       int result = 0;
       Value d;
+      Value c, d;
       int e;
       // Search the cycle along the path form the first node to the root
+      // Search the cycle form the first node to the join node
       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]);
+        d = _flow[e];
+        if (_pred_dir[u] == DIR_DOWN) {
+          c = _cap[e];
+          d = c >= MAX ? INF : c - d;
+        }
         if (d < delta) {
           delta = d;
 …
+        }
+      }
+      // Search the cycle along the path form the second node to the root
+      // Search the cycle form the second node to the join node
       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];
+        d = _flow[e];
+        if (_pred_dir[u] == DIR_UP) {
+          c = _cap[e];
+          d = c >= MAX ? INF : c - d;
+        }
         if (d <= delta) {
           delta = d;
 …
         _flow[in_arc] += val;
         for (int u = _source[in_arc]; u != join; u = _parent[u]) {
           _flow[_pred[u]] += _forward[u] ? -val : val;
+          _flow[_pred[u]] -= _pred_dir[u] * val;
+        }
         for (int u = _target[in_arc]; u != join; u = _parent[u]) {
           _flow[_pred[u]] += _forward[u] ? val : -val;
+          _flow[_pred[u]] += _pred_dir[u] * val;
+        }
+      }
 …
     // 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];
 …
       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]];
+      // Check if u_in and u_out coincide
+      if (u_in == u_out) {
+        // Update _parent, _pred, _pred_dir
+        _parent[u_in] = v_in;
+        _pred[u_in] = in_arc;
+        _pred_dir[u_in] = u_in == _source[in_arc] ? DIR_UP : DIR_DOWN;
+        // Update _thread and _rev_thread
+        if (_thread[v_in] != u_out) {
+          int after = _thread[old_last_succ];
+          _thread[old_rev_thread] = after;
+          _rev_thread[after] = old_rev_thread;
+          after = _thread[v_in];
+          _thread[v_in] = u_out;
+          _rev_thread[u_out] = v_in;
+          _thread[old_last_succ] = after;
+          _rev_thread[after] = old_last_succ;
+        }
       } 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;
+        // Handle the case when old_rev_thread equals to v_in
+        // (it also means that join and v_out coincide)
+        int thread_continue = old_rev_thread == v_in ?
+          _thread[old_last_succ] : _thread[v_in];
+        // Update _thread and _parent along the stem nodes (i.e. the nodes
+        // between u_in and u_out, whose parent have to be changed)
+        int stem = u_in;              // the current stem node
+        int par_stem = v_in;          // the new parent of stem
+        int next_stem;                // the next stem node
+        int last = _last_succ[u_in];  // the last successor of stem
+        int before, after = _thread[last];
+        _thread[v_in] = u_in;
+        _dirty_revs.clear();
+        _dirty_revs.push_back(v_in);
+        while (stem != u_out) {
+          // Insert the next stem node into the thread list
+          next_stem = _parent[stem];
+          _thread[last] = next_stem;
+          _dirty_revs.push_back(last);
+          // Remove the subtree of stem from the thread list
+          before = _rev_thread[stem];
+          _thread[before] = after;
+          _rev_thread[after] = before;
+          // Change the parent node and shift stem nodes
+          _parent[stem] = par_stem;
+          par_stem = stem;
+          stem = next_stem;
+          // Update last and after
+          last = _last_succ[stem] == _last_succ[par_stem] ?
+            _rev_thread[par_stem] : _last_succ[stem];
+          after = _thread[last];
+        }
+        _parent[u_out] = par_stem;
+        _thread[last] = thread_continue;
+        _rev_thread[thread_continue] = last;
+        _last_succ[u_out] = last;
+        // Remove the subtree of u_out from the thread list except for
+        // the case when old_rev_thread equals to v_in
+        if (old_rev_thread != v_in) {
+          _thread[old_rev_thread] = after;
+          _rev_thread[after] = old_rev_thread;
+        }
+        // Update _rev_thread using the new _thread values
+        for (int i = 0; i != int(_dirty_revs.size()); ++i) {
+          int u = _dirty_revs[i];
+          _rev_thread[_thread[u]] = u;
+        }
+        // Update _pred, _pred_dir, _last_succ and _succ_num for the
+        // stem nodes from u_out to u_in
+        int tmp_sc = 0, tmp_ls = _last_succ[u_out];
+        for (int u = u_out, p = _parent[u]; u != u_in; u = p, p = _parent[u]) {
+          _pred[u] = _pred[p];
+          _pred_dir[u] = -_pred_dir[p];
+          tmp_sc += _succ_num[u] - _succ_num[p];
+          _succ_num[u] = tmp_sc;
+          _last_succ[p] = tmp_ls;
+        }
+        _pred[u_in] = in_arc;
+        _pred_dir[u_in] = u_in == _source[in_arc] ? DIR_UP : DIR_DOWN;
+        _succ_num[u_in] = old_succ_num;
+      }
       // 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];
+      }
+      int up_limit_out = _last_succ[join] == v_in ? join : -1;
+      int last_succ_out = _last_succ[u_out];
+      for (int u = v_in; u != -1 && _last_succ[u] == v_in; u = _parent[u]) {
+        _last_succ[u] = last_succ_out;
+      }
       // 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;
+        for (int 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;
+      }
+      else if (last_succ_out != old_last_succ) {
+        for (int u = v_out; u != up_limit_out && _last_succ[u] == old_last_succ;
              u = _parent[u]) {
           _last_succ[u] = _last_succ[u_out];
+          _last_succ[u] = last_succ_out;
+        }
+      }
       // Update _succ_num from v_in to join
       for (u = v_in; u != join; u = _parent[u]) {
+      for (int 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]) {
+      for (int u = v_out; u != join; u = _parent[u]) {
         _succ_num[u] -= old_succ_num;
+      }
+    }
     // Update potentials
+    // Update potentials in the subtree that has been moved
     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
+      Cost sigma = _pi[v_in] - _pi[u_in] -
+                   _pred_dir[u_in] * _cost[in_arc];
       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 incoming 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;
+    }
 …
       PivotRuleImpl pivot(*this);
+      // Perform heuristic initial pivots
+      if (!initialPivots()) return UNBOUNDED;
       // Execute the Network Simplex algorithm
       while (pivot.findEnteringArc()) {
 …
+        }
+      }
       // Check feasibility
       for (int e = _search_arc_num; e != _all_arc_num; ++e) {
 …
       // Transform the solution and the supply map to the original form
       if (_have_lower) {
+      if (_has_lower) {
         for (int i = 0; i != _arc_num; ++i) {
           Value c = _lower[i];
 …
+        }
+      }
       // 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>::min();
+          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];

lemon/path.h

-                      r868
+                      r1270
  * This file is a part of LEMON, a generic C++ optimization library.
+ *
  * Copyright (C) 2003-2009
+ * Copyright (C) 2003-2013
  * Egervary Jeno Kombinatorikus Optimalizalasi Kutatocsoport
  * (Egervary Research Group on Combinatorial Optimization, EGRES).
 …
   ///
   /// In a sense, the path can be treated as a list of arcs. The
   /// lemon path type stores just this list. As a consequence, it
+  /// LEMON path type stores just this list. As a consequence, it
   /// cannot enumerate the nodes of the path and the source node of
   /// a zero length path is undefined.
 …
     Path() {}
+    /// \brief Copy constructor
+    ///
+    Path(const Path& cpath) {
+      pathCopy(cpath, *this);
+    }
     /// \brief Template copy constructor
     ///
 …
     Path(const CPath& cpath) {
       pathCopy(cpath, *this);
+    }
+    /// \brief Copy assignment
+    ///
+    Path& operator=(const Path& cpath) {
+      pathCopy(cpath, *this);
+      return *this;
+    }
 …
     void clear() { head.clear(); tail.clear(); }
     /// \brief The nth arc.
+    /// \brief The n-th arc.
     ///
     /// \pre \c n is in the <tt>[0..length() - 1]</tt> range.
 …
+    }
     /// \brief Initialize arc iterator to point to the nth arc
+    /// \brief Initialize arc iterator to point to the n-th arc
     ///
     /// \pre \c n is in the <tt>[0..length() - 1]</tt> range.
 …
   ///
   /// In a sense, the path can be treated as a list of arcs. The
   /// lemon path type stores just this list. As a consequence it
+  /// LEMON path type stores just this list. As a consequence it
   /// cannot enumerate the nodes in the path and the zero length paths
   /// cannot store the source.
 …
     SimplePath() {}
+    /// \brief Copy constructor
+    ///
+    SimplePath(const SimplePath& cpath) {
+      pathCopy(cpath, *this);
+    }
     /// \brief Template copy constructor
     ///
 …
     SimplePath(const CPath& cpath) {
       pathCopy(cpath, *this);
+    }
+    /// \brief Copy assignment
+    ///
+    SimplePath& operator=(const SimplePath& cpath) {
+      pathCopy(cpath, *this);
+      return *this;
+    }
 …
       /// Constructor with starting point
       ArcIt(const SimplePath &_path, int _idx)
         : idx(_idx), path(&_path) {}
+        : path(&_path), idx(_idx) {}
     public:
 …
     void clear() { data.clear(); }
     /// \brief The nth arc.
+    /// \brief The n-th arc.
     ///
     /// \pre \c n is in the <tt>[0..length() - 1]</tt> range.
 …
+    }
     /// \brief  Initializes arc iterator to point to the nth arc.
+    /// \brief  Initializes arc iterator to point to the n-th arc.
     ArcIt nthIt(int n) const {
       return ArcIt(*this, n);
 …
   ///
   /// In a sense, the path can be treated as a list of arcs. The
   /// lemon path type stores just this list. As a consequence it
+  /// LEMON path type stores just this list. As a consequence it
   /// cannot enumerate the nodes in the path and the zero length paths
   /// cannot store the source.
 …
     ListPath() : first(0), last(0) {}
+    /// \brief Copy constructor
+    ///
+    ListPath(const ListPath& cpath) : first(0), last(0) {
+      pathCopy(cpath, *this);
+    }
     /// \brief Template copy constructor
     ///
 …
     ~ListPath() {
       clear();
+    }
+    /// \brief Copy assignment
+    ///
+    ListPath& operator=(const ListPath& cpath) {
+      pathCopy(cpath, *this);
+      return *this;
+    }
 …
     };
     /// \brief The nth arc.
     ///
     /// This function looks for the nth arc in O(n) time.
+    /// \brief The n-th arc.
+    ///
+    /// This function looks for the n-th arc in O(n) time.
     /// \pre \c n is in the <tt>[0..length() - 1]</tt> range.
     const Arc& nth(int n) const {
 …
+    }
     /// \brief Initializes arc iterator to point to the nth arc.
+    /// \brief Initializes arc iterator to point to the n-th arc.
     ArcIt nthIt(int n) const {
       Node *node = first;
 …
   ///
   /// In a sense, the path can be treated as a list of arcs. The
   /// lemon path type stores just this list. As a consequence it
+  /// LEMON path type stores just this list. As a consequence it
   /// cannot enumerate the nodes in the path and the source node of
   /// a zero length path is undefined.
 …
     StaticPath() : len(0), arcs(0) {}
+    /// \brief Copy constructor
+    ///
+    StaticPath(const StaticPath& cpath) : arcs(0) {
+      pathCopy(cpath, *this);
+    }
     /// \brief Template copy constructor
     ///
 …
     ~StaticPath() {
       if (arcs) delete[] arcs;
+    }
+    /// \brief Copy assignment
+    ///
+    StaticPath& operator=(const StaticPath& cpath) {
+      pathCopy(cpath, *this);
+      return *this;
+    }
 …
     };
     /// \brief The nth arc.
+    /// \brief The n-th arc.
     ///
     /// \pre \c n is in the <tt>[0..length() - 1]</tt> range.
 …
+    }
     /// \brief The arc iterator pointing to the nth arc.
+    /// \brief The arc iterator pointing to the n-th arc.
     ArcIt nthIt(int n) const {
       return ArcIt(*this, n);
 …
     };
     template <typename From, typename To,
               bool revEnable = RevPathTagIndicator<From>::value>
 …
       static void copy(const From& from, To& to) {
         PathCopySelectorForward<From, To>::copy(from, to);
+      }
+      }
     };
 …
       static void copy(const From& from, To& to) {
         PathCopySelectorBackward<From, To>::copy(from, to);
+      }
+      }
     };
 …
   ///
   /// In a sense, the path can be treated as a list of arcs. The
   /// lemon path type stores only this list. As a consequence, it
+  /// LEMON path type stores only this list. As a consequence, it
   /// cannot enumerate the nodes in the path and the zero length paths
   /// cannot have a source node.

lemon/planarity.h

-                      r862
+                      r1270
  * This file is a part of LEMON, a generic C++ optimization library.
+ *
  * Copyright (C) 2003-2009
+ * Copyright (C) 2003-2013
  * Egervary Jeno Kombinatorikus Optimalizalasi Kutatocsoport
  * (Egervary Research Group on Combinatorial Optimization, EGRES).
 …
       void discover(const Arc& arc) {
-        Node source = _graph.source(arc);
         Node target = _graph.target(arc);
 …
     class PlanarityChecking {
     private:
       TEMPLATE_GRAPH_TYPEDEFS(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;
 …
           for (typename MergeRoots::Value::iterator it =
                  merge_roots[node].begin();
+                 merge_roots[node].begin();
                it != merge_roots[node].end(); ++it) {
             int rn = *it;
 …
               bool rd;
               if (!external(xnode, rorder, child_lists,
+              if (!external(xnode, rorder, child_lists,
                             ancestor_map, low_map)) {
                 rd = true;
 …
   ///
   /// This function implements the Boyer-Myrvold algorithm for
   /// planarity checking of an undirected graph. It is a simplified
+  /// 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 not computed.
+  /// the embedding nor the Kuratowski subdivisons are computed.
   template <typename GR>
   bool checkPlanarity(const GR& graph) {
 …
   ///
   /// This class implements the Boyer-Myrvold algorithm for planar
   /// embedding of an undirected graph. The planar embedding is an
+  /// 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 \f$ K_5 \f$ (full graph
   /// with 5 nodes) or a \f$ K_{3,3} \f$ (complete bipartite graph on
   /// 3 ANode and 3 BNode) subdivision.
+  /// 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
+  /// \f$ O(n) \f$.
+  /// Kuratowski subdivision. The running time of the algorithm is O(n).
+  ///
+  /// \see PlanarDrawing, checkPlanarity()
   template <typename Graph>
   class PlanarEmbedding {
 …
   public:
+    /// \brief The map for store of embedding
+    /// \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
     ///
+    /// \note The graph should be simple, i.e. parallel and loop arc
+    /// free.
+    /// 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 Runs the algorithm.
+    /// \brief Run the algorithm.
     ///
     /// Runs the algorithm.
     /// \param kuratowski If the parameter is false, then the
+    /// 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 %True when the graph is planar.
+    /// \return \c true if the graph is planar.
     bool run(bool kuratowski = true) {
       typedef _planarity_bits::PlanarityVisitor<Graph> Visitor;
 …
+    }
     /// \brief Gives back the successor of an arc
+    /// \brief Give back the successor of an arc
     ///
     /// Gives back the successor of an arc. This function makes
+    /// This function gives back the successor of an arc. It makes
     /// possible to query the cyclic order of the outgoing arcs from
     /// a node.
 …
+    }
     /// \brief Gives back the calculated embedding map
+    /// \brief Give back the calculated embedding map
     ///
+    /// The returned map contains the successor of each arc in the
+    /// graph.
+    /// 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 Gives back true if the undirected arc is in the
     /// kuratowski subdivision
+    /// \brief Give back \c true if the given edge is in the Kuratowski
+    /// subdivision
     ///
+    /// Gives back true if the undirected arc is in the kuratowski
+    /// subdivision
+    /// \note The \c run() had to be called with true value.
+    bool kuratowski(const Edge& edge) {
+    /// 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];
+    }
 …
   ///
   /// The planar drawing algorithm calculates positions for the nodes
   /// in the plane which coordinates satisfy that if the arcs are
   /// represented with straight lines then they will not intersect
+  /// 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 \c (n-2,n-2) size grid,
   /// i.e. each node will be located in the \c [0,n-2]x[0,n-2] square.
+  /// 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 {
 …
     TEMPLATE_GRAPH_TYPEDEFS(Graph);
     /// \brief The point type for store coordinates
+    /// \brief The point type for storing coordinates
     typedef dim2::Point<int> Point;
     /// \brief The map type for store coordinates
+    /// \brief The map type for storing the coordinates of the nodes
     typedef typename Graph::template NodeMap<Point> PointMap;
 …
     ///
     /// Constructor
+    /// \pre The graph should be simple, i.e. loop and parallel arc free.
+    /// \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) {}
 …
   public:
     /// \brief Calculates the node positions
+    /// \brief Calculate the node positions
     ///
     /// This function calculates the node positions.
     /// \return %True if the graph is planar.
+    /// This function calculates the node positions on the plane.
+    /// \return \c true if the graph is planar.
     bool run() {
       PlanarEmbedding<Graph> pe(_graph);
 …
+    }
     /// \brief Calculates the node positions according to a
+    /// \brief Calculate the node positions according to a
     /// combinatorical embedding
     ///
+    /// This function calculates the node locations. The \c embedding
+    /// parameter should contain a valid combinatorical embedding, i.e.
+    /// a valid cyclic order of the arcs.
+    /// 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) {
 …
     /// \brief The coordinate of the given node
     ///
     /// 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 Returns the grid embedding in a \e NodeMap.
+    /// \brief Return the grid embedding in a node map
     ///
+    /// Returns the grid embedding in a \e NodeMap of \c dim2::Point<int> .
+    /// This function returns the grid embedding in a node map of
+    /// \c dim2::Point<int> coordinates.
     const PointMap& coords() const {
       return _point_map;
 …
   ///
   /// The graph coloring problem is the coloring of the graph nodes
   /// that there are not adjacent nodes with the same color. The
   /// planar graphs can be always colored with four colors, it is
   /// proved by Appel and Haken and their proofs provide a quadratic
+  /// 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 efficient algorithm. The five and six coloring can be
   /// made in linear time, but in this class the five coloring has
+  /// 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 the planar graph is three colorable is
+  /// NP-complete.
+  /// 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 as in each phase the node with least
   /// outgoing arcs to unprocessed nodes is chosen. This order
+  /// 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
 …
     TEMPLATE_GRAPH_TYPEDEFS(Graph);
     /// \brief The map type for store color indexes
+    /// \brief The map type for storing color indices
     typedef typename Graph::template NodeMap<int> IndexMap;
+    /// \brief The map type for store colors
+    /// \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 should be simple, i.e. loop and parallel arc free.
+    /// 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) {
 …
+    }
     /// \brief Returns the \e NodeMap of color indexes
+    /// \brief Return the node map of color indices
     ///
     /// Returns the \e NodeMap of color indexes. The values are in the
     /// range \c [0..4] or \c [0..5] according to the coloring method.
+    /// 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 Returns the \e NodeMap of colors
+    /// \brief Return the node map of colors
     ///
     /// Returns the \e NodeMap of colors. The values are five or six
     /// distinct \ref lemon::Color "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 Returns the color index of the node
+    /// \brief Return the color index of the node
     ///
     /// Returns the color index of the node. The values are in the
     /// range \c [0..4] or \c [0..5] according to the coloring method.
+    /// 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 Returns the color of the node
+    /// \brief Return the color of the node
     ///
     /// Returns the color of the node. The values are five or six
     /// distinct \ref lemon::Color "colors".
+    /// 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 Calculates a coloring with at most six colors
+    /// \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 %True when the algorithm could color the graph with six color.
     /// If the algorithm fails, then the graph could not be planar.
     /// \note This function can return true if the graph is not
     /// planar but it can be colored with 6 colors.
+    /// \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() {
 …
   public:
     /// \brief Calculates a coloring with at most five colors
+    /// \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) {
 …
+    }
     /// \brief Calculates a coloring with at most five colors
+    /// \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 %True when the graph is planar.
+    /// \return \c true if the graph is planar.
     bool runFiveColoring() {
       PlanarEmbedding<Graph> pe(_graph);

lemon/preflow.h

-                      r835
+                      r1270
  * This file is a part of LEMON, a generic C++ optimization library.
+ *
  * Copyright (C) 2003-2009
+ * Copyright (C) 2003-2013
  * Egervary Jeno Kombinatorikus Optimalizalasi Kutatocsoport
  * (Egervary Research Group on Combinatorial Optimization, EGRES).
 …
   /// This class provides an implementation of Goldberg-Tarjan's \e preflow
   /// \e push-relabel algorithm producing a \ref max_flow
   /// "flow of maximum value" in a digraph \ref clrs01algorithms,
   /// \ref amo93networkflows, \ref goldberg88newapproach.
+  /// "flow of maximum value" in a digraph \cite clrs01algorithms,
+  /// \cite amo93networkflows, \cite 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 worst case time complexity of the algorithm is \f$O(n^2\sqrt{m})\f$.
   ///
   /// The algorithm consists of two phases. After the first phase
 …
   /// 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>
 …
   public:
     ///The \ref PreflowDefaultTraits "traits class" of the algorithm.
+    ///The \ref lemon::PreflowDefaultTraits "traits class" of the algorithm.
     typedef TR Traits;
     ///The type of the digraph the algorithm runs on.
 …
           _flow->set(e, (*_capacity)[e]);
           (*_excess)[u] += rem;
-          if (u != _target && !_level->active(u)) {
-            _level->activate(u);
+          }
+        }
+      }
 …
           _flow->set(e, 0);
           (*_excess)[v] += rem;
+          if (v != _target && !_level->active(v)) {
+            _level->activate(v);
+          }
+        }
+      }
+        }
+      }
+      for (NodeIt n(_graph); n != INVALID; ++n)
+        if(n!=_source && n!=_target && _tolerance.positive((*_excess)[n]))
+          _level->activate(n);
       return true;
+    }
 …
       _phase = true;
+      Node n = _level->highestActive();
+      int level = _level->highestActiveLevel();
+      while (n != INVALID) {
+      while (true) {
         int num = _node_num;
+        while (num > 0 && n != INVALID) {
+        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();
 …
             _level->deactivate(n);
+          }
+          n = _level->highestActive();
+          level = _level->highestActiveLevel();
+        }
+        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;
+        }
+        num = _node_num * 20;
+        while (num > 0 && n != INVALID) {
           Value excess = (*_excess)[n];
           int new_level = _level->maxLevel();
 …
             _level->deactivate(n);
+          }
+          while (level >= 0 && _level->activeFree(level)) {
+            --level;
+          }
+          if (level == -1) {
+            n = _level->highestActive();
+            level = _level->highestActiveLevel();
+          } else {
+            n = _level->activeOn(level);
+          }
+          --num;
+        }
+      }
+        }
+      }
+    first_phase_done:;
+    }

lemon/radix_sort.h

-                      r606
+                      r1328
  * This file is a part of LEMON, a generic C++ optimization library.
+ *
  * Copyright (C) 2003-2009
+ * Copyright (C) 2003-2013
  * Egervary Jeno Kombinatorikus Optimalizalasi Kutatocsoport
  * (Egervary Research Group on Combinatorial Optimization, EGRES).
 …
   namespace _radix_sort_bits {
+    template <typename Iterator>
+    bool unitRange(Iterator first, Iterator last) {
+      ++first;
+      return first == last;
+    }
     template <typename Value>
     struct Identity {
 …
       std::iter_swap(first, last);
       ++first;
-      if (!(first < last)) {
-        return first;
+      }
       while (true) {
         while (!(functor(*first) & mask)) {
 …
           --last;
+        }
         if (!(first < last)) {
+        if (unitRange(last, first)) {
           return first;
+        }
 …
       std::iter_swap(first, last);
       ++first;
-      if (!(first < last)) {
-        return first;
+      }
       while (true) {
         while (functor(*first) < 0) {
 …
           --last;
+        }
         if (!(first < last)) {
+        if (unitRange(last, first)) {
           return first;
+        }
 …
     void radixIntroSort(Iterator first, Iterator last,
                         Functor functor, Value mask) {
       while (mask != 0 && last - first > 1) {
+      while (mask != 0 && first != last && !unitRange(first, last)) {
         Iterator cut = radixSortPartition(first, last, functor, mask);
         mask >>= 1;
 …
       Allocator allocator;
       int length = std::distance(first, last);
+      int length = static_cast<int>(std::distance(first, last));
       Key* buffer = allocator.allocate(2 * length);
       try {

lemon/random.h

-                      r631
+                      r1340
 #define LEMON_RANDOM_H
+#include <lemon/config.h>
 #include <algorithm>
 #include <iterator>
 …
 #include <lemon/dim2.h>
 #ifndef WIN32
+#ifndef LEMON_WIN32
 #include <sys/time.h>
 #include <ctime>
 …
         initState(init);
         num = length > end - begin ? length : end - begin;
+        num = static_cast<int>(length > end - begin ? length : end - begin);
         while (num--) {
           curr[0] = (curr[0] ^ ((curr[1] ^ (curr[1] >> (bits - 2))) * mul1))
 …
+        }
         num = length - 1; cnt = length - (curr - state) - 1;
+        num = length - 1; cnt = static_cast<int>(length - (curr - state) - 1);
         while (num--) {
           curr[0] = (curr[0] ^ ((curr[1] ^ (curr[1] >> (bits - 2))) * mul2))
 …
     /// \return Currently always \c true.
     bool seed() {
 #ifndef WIN32
+#ifndef LEMON_WIN32
       if (seedFromFile("/dev/urandom", 0)) return true;
 #endif
 …
     /// \param offset The offset, from the file read.
     /// \return \c true when the seeding successes.
 #ifndef WIN32
+#ifndef LEMON_WIN32
     bool seedFromFile(const std::string& file = "/dev/urandom", int offset = 0)
 #else
 …
     /// \return Currently always \c true.
     bool seedFromTime() {
 #ifndef WIN32
+#ifndef LEMON_WIN32
       timeval tv;
       gettimeofday(&tv, 0);

lemon/smart_graph.h

-                      r834
+                      r1270
  * This file is a part of LEMON, a generic C++ optimization library.
+ *
  * Copyright (C) 2003-2009
+ * Copyright (C) 2003-2013
  * Egervary Jeno Kombinatorikus Optimalizalasi Kutatocsoport
  * (Egervary Research Group on Combinatorial Optimization, EGRES).
 …
   ///\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
+  ///that it does not support node and arc deletion
   ///(except for the Snapshot feature).
   ///
 …
     ///arcs from a SmartDigraph structure.
     ///
     ///\note After a state is restored, you cannot restore a later state,
+    ///\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.
 …
     std::vector<ArcT> arcs;
-    int first_free_arc;
   public:
 …
   /// \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
+  /// that it does not support node and edge deletion
   /// (except for the Snapshot feature).
   ///
 …
     ///edges from a SmartGraph structure.
     ///
     ///\note After a state is restored, you cannot restore a later state,
+    ///\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.
 …
   };
+  class SmartBpGraphBase {
+  protected:
+    struct NodeT {
+      int first_out;
+      int partition_next;
+      int partition_index;
+      bool red;
+    };
+    struct ArcT {
+      int target;
+      int next_out;
+    };
+    std::vector<NodeT> nodes;
+    std::vector<ArcT> arcs;
+    int first_red, first_blue;
+    int max_red, max_blue;
+  public:
+    typedef SmartBpGraphBase Graph;
+    class Node;
+    class Arc;
+    class Edge;
+    class Node {
+      friend class SmartBpGraphBase;
+    protected:
+      int _id;
+      explicit 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 RedNode : public Node {
+      friend class SmartBpGraphBase;
+    protected:
+      explicit RedNode(int pid) : Node(pid) {}
+    public:
+      RedNode() {}
+      RedNode(const RedNode& node) : Node(node) {}
+      RedNode(Invalid) : Node(INVALID){}
+    };
+    class BlueNode : public Node {
+      friend class SmartBpGraphBase;
+    protected:
+      explicit BlueNode(int pid) : Node(pid) {}
+    public:
+      BlueNode() {}
+      BlueNode(const BlueNode& node) : Node(node) {}
+      BlueNode(Invalid) : Node(INVALID){}
+    };
+    class Edge {
+      friend class SmartBpGraphBase;
+    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 SmartBpGraphBase;
+    protected:
+      int _id;
+      explicit Arc(int id) { _id = id;}
+    public:
+      operator Edge() const {
+        return _id != -1 ? edgeFromId(_id / 2) : INVALID;
+      }
+      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;}
+    };
+    SmartBpGraphBase()
+      : nodes(), arcs(), first_red(-1), first_blue(-1),
+        max_red(-1), max_blue(-1) {}
+    typedef True NodeNumTag;
+    typedef True EdgeNumTag;
+    typedef True ArcNumTag;
+    int nodeNum() const { return nodes.size(); }
+    int redNum() const { return max_red + 1; }
+    int blueNum() const { return max_blue + 1; }
+    int edgeNum() const { return arcs.size() / 2; }
+    int arcNum() const { return arcs.size(); }
+    int maxNodeId() const { return nodes.size()-1; }
+    int maxRedId() const { return max_red; }
+    int maxBlueId() const { return max_blue; }
+    int maxEdgeId() const { return arcs.size() / 2 - 1; }
+    int maxArcId() const { return arcs.size()-1; }
+    bool red(Node n) const { return nodes[n._id].red; }
+    bool blue(Node n) const { return !nodes[n._id].red; }
+    static RedNode asRedNodeUnsafe(Node n) { return RedNode(n._id); }
+    static BlueNode asBlueNodeUnsafe(Node n) { return BlueNode(n._id); }
+    Node source(Arc a) const { return Node(arcs[a._id ^ 1].target); }
+    Node target(Arc a) const { return Node(arcs[a._id].target); }
+    RedNode redNode(Edge e) const {
+      return RedNode(arcs[2 * e._id].target);
+    }
+    BlueNode blueNode(Edge e) const {
+      return BlueNode(arcs[2 * e._id + 1].target);
+    }
+    static bool direction(Arc a) {
+      return (a._id & 1) == 1;
+    }
+    static Arc direct(Edge e, bool d) {
+      return Arc(e._id * 2 + (d ? 1 : 0));
+    }
+    void first(Node& node) const {
+      node._id = nodes.size() - 1;
+    }
+    static void next(Node& node) {
+      --node._id;
+    }
+    void first(RedNode& node) const {
+      node._id = first_red;
+    }
+    void next(RedNode& node) const {
+      node._id = nodes[node._id].partition_next;
+    }
+    void first(BlueNode& node) const {
+      node._id = first_blue;
+    }
+    void next(BlueNode& node) const {
+      node._id = nodes[node._id].partition_next;
+    }
+    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& v) const {
+      arc._id = nodes[v._id].first_out;
+    }
+    void nextOut(Arc &arc) const {
+      arc._id = arcs[arc._id].next_out;
+    }
+    void firstIn(Arc &arc, const Node& v) const {
+      arc._id = ((nodes[v._id].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& d, const Node& v) const {
+      int de = nodes[v._id].first_out;
+      if (de != -1) {
+        arc._id = de / 2;
+        d = ((de & 1) == 1);
+      } else {
+        arc._id = -1;
+        d = true;
+      }
+    }
+    void nextInc(Edge &arc, bool& d) const {
+      int de = (arcs[(arc._id * 2) | (d ? 1 : 0)].next_out);
+      if (de != -1) {
+        arc._id = de / 2;
+        d = ((de & 1) == 1);
+      } else {
+        arc._id = -1;
+        d = true;
+      }
+    }
+    static int id(Node v) { return v._id; }
+    int id(RedNode v) const { return nodes[v._id].partition_index; }
+    int id(BlueNode v) const { return nodes[v._id].partition_index; }
+    static int id(Arc e) { return e._id; }
+    static int id(Edge e) { return e._id; }
+    static Node nodeFromId(int id) { return Node(id);}
+    static Arc arcFromId(int id) { return Arc(id);}
+    static Edge edgeFromId(int id) { return Edge(id);}
+    bool valid(Node n) const {
+      return n._id >= 0 && n._id < static_cast<int>(nodes.size());
+    }
+    bool valid(Arc a) const {
+      return a._id >= 0 && a._id < static_cast<int>(arcs.size());
+    }
+    bool valid(Edge e) const {
+      return e._id >= 0 && 2 * e._id < static_cast<int>(arcs.size());
+    }
+    RedNode addRedNode() {
+      int n = nodes.size();
+      nodes.push_back(NodeT());
+      nodes[n].first_out = -1;
+      nodes[n].red = true;
+      nodes[n].partition_index = ++max_red;
+      nodes[n].partition_next = first_red;
+      first_red = n;
+      return RedNode(n);
+    }
+    BlueNode addBlueNode() {
+      int n = nodes.size();
+      nodes.push_back(NodeT());
+      nodes[n].first_out = -1;
+      nodes[n].red = false;
+      nodes[n].partition_index = ++max_blue;
+      nodes[n].partition_next = first_blue;
+      first_blue = n;
+      return BlueNode(n);
+    }
+    Edge addEdge(RedNode u, BlueNode v) {
+      int n = arcs.size();
+      arcs.push_back(ArcT());
+      arcs.push_back(ArcT());
+      arcs[n].target = u._id;
+      arcs[n | 1].target = v._id;
+      arcs[n].next_out = nodes[v._id].first_out;
+      nodes[v._id].first_out = n;
+      arcs[n | 1].next_out = nodes[u._id].first_out;
+      nodes[u._id].first_out = (n | 1);
+      return Edge(n / 2);
+    }
+    void clear() {
+      arcs.clear();
+      nodes.clear();
+      first_red = -1;
+      first_blue = -1;
+      max_blue = -1;
+      max_red = -1;
+    }
+  };
+  typedef BpGraphExtender<SmartBpGraphBase> ExtendedSmartBpGraphBase;
+  /// \ingroup graphs
+  ///
+  /// \brief A smart undirected bipartite graph class.
+  ///
+  /// \ref SmartBpGraph is a simple and fast bipartite 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 type fully conforms to the \ref concepts::BpGraph "BpGraph concept"
+  /// and it also provides some additional functionalities.
+  /// Most of its member functions and nested classes are documented
+  /// only in the concept class.
+  ///
+  /// This class provides constant time counting for nodes, edges and arcs.
+  ///
+  /// \sa concepts::BpGraph
+  /// \sa SmartGraph
+  class SmartBpGraph : public ExtendedSmartBpGraphBase {
+    typedef ExtendedSmartBpGraphBase Parent;
+  private:
+    /// Graphs are \e not copy constructible. Use GraphCopy instead.
+    SmartBpGraph(const SmartBpGraph &) : ExtendedSmartBpGraphBase() {};
+    /// \brief Assignment of a graph to another one is \e not allowed.
+    /// Use GraphCopy instead.
+    void operator=(const SmartBpGraph &) {}
+  public:
+    /// Constructor
+    /// Constructor.
+    ///
+    SmartBpGraph() {}
+    /// \brief Add a new red node to the graph.
+    ///
+    /// This function adds a red new node to the graph.
+    /// \return The new node.
+    RedNode addRedNode() { return Parent::addRedNode(); }
+    /// \brief Add a new blue node to the graph.
+    ///
+    /// This function adds a blue new node to the graph.
+    /// \return The new node.
+    BlueNode addBlueNode() { return Parent::addBlueNode(); }
+    /// \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(RedNode u, BlueNode v) {
+      return Parent::addEdge(u, v);
+    }
+    Edge addEdge(BlueNode v, RedNode u) {
+      return Parent::addEdge(u, v);
+    }
+    /// \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.
+    ///
+    /// \warning A removed node (using Snapshot) could become valid again
+    /// if new nodes are added to the graph.
+    bool valid(Node n) const { return Parent::valid(n); }
+    /// \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.
+    ///
+    /// \warning A removed edge (using Snapshot) could become valid again
+    /// if 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.
+    ///
+    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:
+    class Snapshot;
+  protected:
+    void saveSnapshot(Snapshot &s)
+    {
+      s._graph = this;
+      s.node_num = nodes.size();
+      s.arc_num = arcs.size();
+    }
+    void restoreSnapshot(const Snapshot &s)
+    {
+      while(s.arc_num<arcs.size()) {
+        int n=arcs.size()-1;
+        Edge arc=edgeFromId(n/2);
+        Parent::notifier(Edge()).erase(arc);
+        std::vector<Arc> dir;
+        dir.push_back(arcFromId(n));
+        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;
+        arcs.pop_back();
+        arcs.pop_back();
+      }
+      while(s.node_num<nodes.size()) {
+        int n=nodes.size()-1;
+        Node node = nodeFromId(n);
+        if (Parent::red(node)) {
+          first_red = nodes[n].partition_next;
+          if (first_red != -1) {
+            max_red = nodes[first_red].partition_index;
+          } else {
+            max_red = -1;
+          }
+          Parent::notifier(RedNode()).erase(asRedNodeUnsafe(node));
+        } else {
+          first_blue = nodes[n].partition_next;
+          if (first_blue != -1) {
+            max_blue = nodes[first_blue].partition_index;
+          } else {
+            max_blue = -1;
+          }
+          Parent::notifier(BlueNode()).erase(asBlueNodeUnsafe(node));
+        }
+        Parent::notifier(Node()).erase(node);
+        nodes.pop_back();
+      }
+    }
+  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 SmartBpGraph 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 Snapshot
+    {
+      SmartBpGraph *_graph;
+    protected:
+      friend class SmartBpGraph;
+      unsigned int node_num;
+      unsigned int arc_num;
+    public:
+      ///Default constructor.
+      ///Default constructor.
+      ///You have to call save() to actually make a snapshot.
+      Snapshot() : _graph(0) {}
+      ///Constructor that immediately makes a snapshot
+      /// This constructor immediately makes a snapshot of the given graph.
+      ///
+      Snapshot(SmartBpGraph &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
+      ///call, the previous snapshot gets lost.
+      void save(SmartBpGraph &gr)
+      {
+        gr.saveSnapshot(*this);
+      }
+      ///Undo the changes until the last snapshot.
+      ///This function undos the changes until the last snapshot
+      ///created by save() or Snapshot(SmartBpGraph&).
+      void restore()
+      {
+        _graph->restoreSnapshot(*this);
+      }
+    };
+  };
 } //namespace lemon

lemon/soplex.cc

-                      r793
+                      r1270
  * This file is a part of LEMON, a generic C++ optimization library.
+ *
  * Copyright (C) 2003-2008
+ * Copyright (C) 2003-2013
  * Egervary Jeno Kombinatorikus Optimalizalasi Kutatocsoport
  * (Egervary Research Group on Combinatorial Optimization, EGRES).
 …
     _clear_temporals();
     _applyMessageLevel();

lemon/soplex.h

r793	r1270
3	3	* This file is a part of LEMON, a generic C++ optimization library.
4	4	*
5		* Copyright (C) 2003-2008
	5	* Copyright (C) 2003-2013
6	6	* Egervary Jeno Kombinatorikus Optimalizalasi Kutatocsoport
7	7	* (Egervary Research Group on Combinatorial Optimization, EGRES).

lemon/static_graph.h

-                      r834
+                      r1328
 /* -*- C++ -*-
+/* -*- mode: C++; indent-tabs-mode: nil; -*-
+ *
  * This file is a part of LEMON, a generic C++ optimization library
+ * This file is a part of LEMON, a generic C++ optimization library.
+ *
  * Copyright (C) 2003-2008
+ * Copyright (C) 2003-2010
  * Egervary Jeno Kombinatorikus Optimalizalasi Kutatocsoport
  * (Egervary Research Group on Combinatorial Optimization, EGRES).
 …
   public:
     StaticDigraphBase()
       : built(false), node_num(0), arc_num(0),
+    StaticDigraphBase()
+      : built(false), node_num(0), arc_num(0),
         node_first_out(NULL), node_first_in(NULL),
         arc_source(NULL), arc_target(NULL),
+        arc_source(NULL), arc_target(NULL),
         arc_next_in(NULL), arc_next_out(NULL) {}
     ~StaticDigraphBase() {
       if (built) {
 …
     class Arc {
       friend class StaticDigraphBase;
+      friend class StaticDigraphBase;
     protected:
       int id;
 …
     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] ?
+    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;
+    }
 …
       typedef typename Digraph::Arc Arc;
       ArcLess(const Digraph &_graph, const NodeRefMap& _nodeRef)
+      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)];
+        return nodeRef[digraph.target(left)] < nodeRef[digraph.target(right)];
+      }
     private:
 …
       const NodeRefMap& nodeRef;
     };
   public:
     typedef True BuildTag;
     void clear() {
       if (built) {
 …
       arc_num = 0;
+    }
     template <typename Digraph, typename NodeRefMap, typename ArcRefMap>
     void build(const Digraph& digraph, NodeRefMap& nodeRef, ArcRefMap& arcRef) {
 …
             int target = nodeRef[digraph.target(*it)].id;
             arcRef[*it] = Arc(arc_index);
             arc_source[arc_index] = source;
+            arc_source[arc_index] = source;
             arc_target[arc_index] = target;
             arc_next_in[arc_index] = node_first_in[target];
 …
       node_first_out[node_num] = arc_num;
+    }
     template <typename ArcListIterator>
     void build(int n, ArcListIterator first, ArcListIterator last) {
 …
       node_num = n;
       arc_num = std::distance(first, last);
+      arc_num = static_cast<int>(std::distance(first, last));
       node_first_out = new int[node_num + 1];
 …
       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) {
 …
   /// 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.
+  /// 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()
 …
     typedef ExtendedStaticDigraphBase Parent;
   public:
     /// \brief Constructor
     ///
 …
     /// 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.
 …
       Parent::build(digraph, nodeRef, arcRef);
+    }
     /// \brief Build the digraph from an arc list.
     ///
 …
     using Parent::fastNextOut;
     using Parent::fastLastOut;
   public:
 …
       OutArcIt(const StaticDigraph& digraph, const Node& node) {
         digraph.fastFirstOut(*this, node);
         digraph.fastLastOut(last, node);
+        digraph.fastFirstOut(*this, node);
+        digraph.fastLastOut(last, node);
         if (last == *this) *this = INVALID;
+      }
 …
+      }
       OutArcIt& operator++() {
+      OutArcIt& operator++() {
         StaticDigraph::fastNextOut(*this);
         if (last == *this) *this = INVALID;
         return *this;
+        return *this;
+      }

lemon/suurballe.h

-                      r670
+                      r1270
  * This file is a part of LEMON, a generic C++ optimization library.
+ *
  * Copyright (C) 2003-2009
+ * Copyright (C) 2003-2013
  * Egervary Jeno Kombinatorikus Optimalizalasi Kutatocsoport
  * (Egervary Research Group on Combinatorial Optimization, EGRES).
 …
 #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
 …
   /// "minimum cost flow problem". This implementation is actually an
   /// efficient specialized version of the \ref CapacityScaling
   /// "Successive Shortest Path" algorithm directly for this problem.
+  /// "successive shortest path" algorithm directly for this problem.
   /// Therefore this class provides query functions for flow values and
   /// node potentials (the dual solution) just like the minimum cost flow
 …
   /// The default value is <tt>GR::ArcMap<int></tt>.
   ///
   /// \warning Length values should be \e non-negative \e integers.
+  /// \warning Length values should be \e non-negative.
   ///
   /// \note For finding node-disjoint paths this algorithm can be used
+  /// \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>
+  template <typename GR, typename LEN, typename TR>
 #else
   template < typename GR,
+             typename LEN = typename GR::template ArcMap<int> >
+             typename LEN = typename GR::template ArcMap<int>,
+             typename TR = SuurballeDefaultTraits<GR, LEN> >
 #endif
   class Suurballe
 …
   public:
     /// The type of the digraph the algorithm runs on.
     typedef GR Digraph;
+    /// The type of the digraph.
+    typedef typename TR::Digraph Digraph;
     /// The type of the length map.
     typedef LEN LengthMap;
+    typedef typename TR::LengthMap LengthMap;
     /// The type of the lengths.
     typedef typename LengthMap::Value Length;
+#ifdef DOXYGEN
+    typedef typename TR::Length Length;
     /// The type of the flow map.
     typedef GR::ArcMap<int> FlowMap;
+    typedef typename TR::FlowMap FlowMap;
     /// The type of the potential map.
+    typedef GR::NodeMap<Length> PotentialMap;
+#else
+    /// The type of the flow map.
+    typedef typename Digraph::template ArcMap<int> FlowMap;
+    /// The type of the potential map.
+    typedef typename Digraph::template NodeMap<Length> PotentialMap;
+#endif
+    typedef typename TR::PotentialMap PotentialMap;
     /// The type of the path structures.
+    typedef SimplePath<GR> Path;
+    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 lemon::SuurballeDefaultTraits "traits class" of the algorithm.
+    typedef TR Traits;
   private:
 …
     class ResidualDijkstra
+    {
-      typedef typename Digraph::template NodeMap<int> HeapCrossRef;
-      typedef BinHeap<Length, HeapCrossRef> Heap;
     private:
-      // The digraph the algorithm runs on
       const Digraph &_graph;
+      // The main maps
+      const LengthMap &_length;
       const FlowMap &_flow;
+      const LengthMap &_length;
+      PotentialMap &_potential;
+      // The distance map
+      PotentialMap _dist;
+      // The pred arc map
+      PotentialMap &_pi;
       PredMap &_pred;
-      // The processed (i.e. permanently labeled) nodes
-      std::vector<Node> _proc_nodes;
       Node _s;
       Node _t;
+      PotentialMap _dist;
+      std::vector<Node> _proc_nodes;
     public:
+      /// Constructor.
+      ResidualDijkstra( const Digraph &graph,
+                        const FlowMap &flow,
+                        const LengthMap &length,
+                        PotentialMap &potential,
+                        PredMap &pred,
+                        Node s, Node t ) :
+        _graph(graph), _flow(flow), _length(length), _potential(potential),
+        _dist(graph), _pred(pred), _s(s), _t(t) {}
+      /// \brief Run the algorithm. It returns \c true if a path is found
+      /// from the source node to the target node.
+      bool run() {
+      // 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);
 …
         while (!heap.empty() && heap.top() != _t) {
           Node u = heap.top(), v;
           Length d = heap.prio() + _potential[u], nd;
+          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
 …
               v = _graph.target(e);
               switch(heap.state(v)) {
+              case Heap::PRE_HEAP:
+                heap.push(v, d + _length[e] - _potential[v]);
+                _pred[v] = e;
+                break;
+              case Heap::IN_HEAP:
+                nd = d + _length[e] - _potential[v];
+                if (nd < heap[v]) {
+                  heap.decrease(v, nd);
+                case Heap::PRE_HEAP:
+                  heap.push(v, d + _length[e] - _pi[v]);
                   _pred[v] = e;
+                }
+                break;
+              case Heap::POST_HEAP:
+                break;
+                  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;
+              }
+            }
 …
               v = _graph.source(e);
               switch(heap.state(v)) {
+              case Heap::PRE_HEAP:
+                heap.push(v, d - _length[e] - _potential[v]);
+                _pred[v] = e;
+                break;
+              case Heap::IN_HEAP:
+                nd = d - _length[e] - _potential[v];
+                if (nd < heap[v]) {
+                  heap.decrease(v, nd);
+                case Heap::PRE_HEAP:
+                  heap.push(v, d - _length[e] - _pi[v]);
                   _pred[v] = e;
+                }
+                break;
+              case Heap::POST_HEAP:
+                break;
+                  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;
+              }
+            }
 …
         Length t_dist = heap.prio();
         for (int i = 0; i < int(_proc_nodes.size()); ++i)
           _potential[_proc_nodes[i]] += _dist[_proc_nodes[i]] - t_dist;
+          _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 source node
     Node _source;
+    Node _s;
     // The target node
     Node _target;
+    Node _t;
     // Container to store the found paths
     std::vector< SimplePath<Digraph> > paths;
+    std::vector<Path> _paths;
     int _path_num;
     // The pred arc map
     PredMap _pred;
+    // Implementation of the Dijkstra algorithm for finding augmenting
+    // shortest paths in the residual network
+    ResidualDijkstra *_dijkstra;
+    // Data for full init
+    PotentialMap *_init_dist;
+    PredMap *_init_pred;
+    bool _full_init;
+  protected:
+    Suurballe() {}
   public:
 …
                const LengthMap &length ) :
       _graph(graph), _length(length), _flow(0), _local_flow(false),
+      _potential(0), _local_potential(false), _pred(graph)
+    {
+      LEMON_ASSERT(std::numeric_limits<Length>::is_integer,
+        "The length type of Suurballe must be integer");
+    }
+      _potential(0), _local_potential(false), _pred(graph),
+      _init_dist(0), _init_pred(0)
+    {}
     /// Destructor.
 …
       if (_local_flow) delete _flow;
       if (_local_potential) delete _potential;
+      delete _dijkstra;
+      delete _init_dist;
+      delete _init_pred;
+    }
 …
     /// \name Execution Control
     /// The simplest way to execute the algorithm is to call the run()
+    /// function.
+    /// \n
+    /// 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, you may call init() and findFlow().
+    /// arc-disjoint paths, then you may call findFlow() instead of
+    /// start().
     /// @{
 …
     /// \code
     ///   s.init(s);
+    ///   s.findFlow(t, k);
+    ///   s.findPaths();
+    ///   s.start(t, k);
     /// \endcode
     int run(const Node& s, const Node& t, int k = 2) {
       init(s);
+      findFlow(t, k);
+      findPaths();
+      start(t, k);
       return _path_num;
+    }
 …
     /// \brief Initialize the algorithm.
     ///
     /// This function initializes the algorithm.
+    /// This function initializes the algorithm with the given source node.
     ///
     /// \param s The source node.
     void init(const Node& s) {
       _source = s;
+      _s = s;
       // Initialize maps
 …
         _local_potential = true;
+      }
+      for (ArcIt e(_graph); e != INVALID; ++e) (*_flow)[e] = 0;
+      for (NodeIt n(_graph); n != INVALID; ++n) (*_potential)[n] = 0;
+      _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;
+    }
 …
     /// \pre \ref init() must be called before using this function.
     int findFlow(const Node& t, int k = 2) {
+      _target = t;
+      _dijkstra =
+        new ResidualDijkstra( _graph, *_flow, _length, *_potential, _pred,
+                              _source, _target );
+      _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
-      _path_num = 0;
       while (_path_num < k) {
         // Run Dijkstra
         if (!_dijkstra->run()) break;
+        if (!dijkstra.run(_path_num)) break;
         ++_path_num;
         // Set the flow along the found shortest path
         Node u = _target;
+        Node u = _t;
         Arc e;
         while ((e = _pred[u]) != INVALID) {
 …
     /// \brief Compute the paths from the flow.
     ///
     /// This function computes the paths from the found minimum cost flow,
     /// which is the union of some arc-disjoint paths.
+    /// 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
 …
       for(ArcIt a(_graph); a != INVALID; ++a) res_flow[a] = (*_flow)[a];
       paths.clear();
       paths.resize(_path_num);
+      _paths.clear();
+      _paths.resize(_path_num);
       for (int i = 0; i < _path_num; ++i) {
         Node n = _source;
         while (n != _target) {
+        Node n = _s;
+        while (n != _t) {
           OutArcIt e(_graph, n);
           for ( ; res_flow[e] == 0; ++e) ;
           n = _graph.target(e);
           paths[i].addBack(e);
+          _paths[i].addBack(e);
           res_flow[e] = 0;
+        }
 …
     /// 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).
+    /// The complexity of the function is O(m).
     ///
     /// \pre \ref run() or \ref findFlow() must be called before using
 …
     /// \pre \ref run() or \ref findPaths() must be called before using
     /// this function.
     Path path(int i) const {
       return paths[i];
+    const Path& path(int i) const {
+      return _paths[i];
+    }

lemon/time_measure.h

-                      r833
+                      r1340
  * This file is a part of LEMON, a generic C++ optimization library.
+ *
  * Copyright (C) 2003-2009
+ * Copyright (C) 2003-2013
  * Egervary Jeno Kombinatorikus Optimalizalasi Kutatocsoport
  * (Egervary Research Group on Combinatorial Optimization, EGRES).
 …
 ///\brief Tools for measuring cpu usage
+#ifdef WIN32
+#include <lemon/config.h>
+#ifdef LEMON_WIN32
 #include <lemon/bits/windows.h>
 #else
 …
 #include <fstream>
 #include <iostream>
+#include <lemon/math.h>
 namespace lemon {
 …
     double rtime;
+  public:
+    ///Display format specifier
+    ///\e
+    ///
+    enum Format {
+      /// Reports all measured values
+      NORMAL = 0,
+      /// Only real time and an error indicator is displayed
+      SHORT = 1
+    };
+  private:
+    static Format _format;
     void _reset() {
       utime = stime = cutime = cstime = rtime = 0;
 …
   public:
+    ///Set output format
+    ///Set output format.
+    ///
+    ///The output format is global for all timestamp instances.
+    static void format(Format f) { _format = f; }
+    ///Retrieve the current output format
+    ///Retrieve the current output format
+    ///
+    ///The output format is global for all timestamp instances.
+    static Format format() { return _format; }
     ///Read the current time values of the process
     void stamp()
+    {
 #ifndef WIN32
+#ifndef LEMON_WIN32
       timeval tv;
       gettimeofday(&tv, 0);
 …
   inline std::ostream& operator<<(std::ostream& os,const TimeStamp &t)
+  {
+    os << "u: " << t.userTime() <<
+      "s, s: " << t.systemTime() <<
+      "s, cu: " << t.cUserTime() <<
+      "s, cs: " << t.cSystemTime() <<
+      "s, real: " << t.realTime() << "s";
+    switch(t._format)
+      {
+      case TimeStamp::NORMAL:
+        os << "u: " << t.userTime() <<
+          "s, s: " << t.systemTime() <<
+          "s, cu: " << t.cUserTime() <<
+          "s, cs: " << t.cSystemTime() <<
+          "s, real: " << t.realTime() << "s";
+        break;
+      case TimeStamp::SHORT:
+        double total = t.userTime()+t.systemTime()+
+          t.cUserTime()+t.cSystemTime();
+        os << t.realTime()
+           << "s (err: " << round((t.realTime()-total)/
+                                  t.realTime()*10000)/100
+           << "%)";
+        break;
+      }
     return os;
+  }
 …
     std::string _title;
     std::ostream &_os;
+    bool _active;
   public:
     ///Constructor
 …
     ///\param os The stream to print the report to.
     ///\param run Sets whether the timer should start immediately.
+    TimeReport(std::string title,std::ostream &os=std::cerr,bool run=true)
+      : Timer(run), _title(title), _os(os){}
+    ///\param active Sets whether the report should actually be printed
+    ///       on destruction.
+    TimeReport(std::string title,std::ostream &os=std::cerr,bool run=true,
+               bool active=true)
+      : Timer(run), _title(title), _os(os), _active(active) {}
     ///Destructor that prints the ellapsed time
     ~TimeReport()
+    {
+      _os << _title << *this << std::endl;
+    }
+      if(_active) _os << _title << *this << std::endl;
+    }
+    ///Retrieve the activity status
+    ///\e
+    ///
+    bool active() const { return _active; }
+    ///Set the activity status
+    /// This function set whether the time report should actually be printed
+    /// on destruction.
+    void active(bool a) { _active=a; }
   };

lemon/unionfind.h

-                      r864
+                      r1270
  * This file is a part of LEMON, a generic C++ optimization library.
+ *
  * Copyright (C) 2003-2009
+ * Copyright (C) 2003-2013
  * Egervary Jeno Kombinatorikus Optimalizalasi Kutatocsoport
  * (Egervary Research Group on Combinatorial Optimization, EGRES).
 …
         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.
     ///

test/CMakeLists.txt

-                      r863
+                      r1264
+)
+SET(TEST_WITH_VALGRIND "NO" CACHE STRING
+  "Run the test with valgrind (YES/NO).")
+SET(VALGRIND_FLAGS "" CACHE STRING "Valgrind flags used by the tests.")
 SET(TESTS
   adaptors_test
+  arc_look_up_test
   bellman_ford_test
   bfs_test
+  bpgraph_test
   circulation_test
   connectivity_test
 …
   error_test
   euler_test
+  fractional_matching_test
   gomory_hu_test
   graph_copy_test
 …
   heap_test
   kruskal_test
+  lgf_reader_writer_test
+  lgf_test
   maps_test
   matching_test
+  max_cardinality_search_test
+  max_clique_test
+  max_flow_test
   min_cost_arborescence_test
   min_cost_flow_test
   min_mean_cycle_test
+  nagamochi_ibaraki_test
   path_test
   planarity_test
-  preflow_test
   radix_sort_test
   random_test
   suurballe_test
   time_measure_test
+  tsp_test
   unionfind_test
+)
 IF(LEMON_HAVE_LP)
+  ADD_EXECUTABLE(lp_test lp_test.cc)
+  IF(${CMAKE_BUILD_TYPE} STREQUAL "Maintainer")
+    ADD_EXECUTABLE(lp_test lp_test.cc)
+  ELSE()
+    ADD_EXECUTABLE(lp_test EXCLUDE_FROM_ALL lp_test.cc)
+  ENDIF()
   SET(LP_TEST_LIBS lemon)
 …
   ENDIF()
   IF(LEMON_HAVE_CPLEX)
     SET(LP_TEST_LIBS ${LP_TEST_LIBS} ${CPLEX_LIBRARIES})
+    SET(LP_TEST_LIBS ${LP_TEST_LIBS} ${ILOG_LIBRARIES})
   ENDIF()
   IF(LEMON_HAVE_CLP)
     SET(LP_TEST_LIBS ${LP_TEST_LIBS} ${COIN_CLP_LIBRARIES})
   ENDIF()
+  IF(LEMON_HAVE_SOPLEX)
+    SET(LP_TEST_LIBS ${LP_TEST_LIBS} ${SOPLEX_LIBRARIES})
+  ENDIF()
   TARGET_LINK_LIBRARIES(lp_test ${LP_TEST_LIBS})
   ADD_TEST(lp_test lp_test)
+  ADD_DEPENDENCIES(check lp_test)
   IF(WIN32 AND LEMON_HAVE_GLPK)
 …
     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}
+      COMMAND ${CMAKE_COMMAND} -E copy ${ILOG_CPLEX_DLL} ${TARGET_PATH}
+    )
   ENDIF()
 …
 IF(LEMON_HAVE_MIP)
+  ADD_EXECUTABLE(mip_test mip_test.cc)
+  IF(${CMAKE_BUILD_TYPE} STREQUAL "Maintainer")
+    ADD_EXECUTABLE(mip_test mip_test.cc)
+  ELSE()
+    ADD_EXECUTABLE(mip_test EXCLUDE_FROM_ALL mip_test.cc)
+  ENDIF()
   SET(MIP_TEST_LIBS lemon)
 …
   ENDIF()
   IF(LEMON_HAVE_CPLEX)
     SET(MIP_TEST_LIBS ${MIP_TEST_LIBS} ${CPLEX_LIBRARIES})
+    SET(MIP_TEST_LIBS ${MIP_TEST_LIBS} ${ILOG_LIBRARIES})
   ENDIF()
   IF(LEMON_HAVE_CBC)
 …
   TARGET_LINK_LIBRARIES(mip_test ${MIP_TEST_LIBS})
   ADD_TEST(mip_test mip_test)
+  ADD_DEPENDENCIES(check mip_test)
   IF(WIN32 AND LEMON_HAVE_GLPK)
 …
     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}
+      COMMAND ${CMAKE_COMMAND} -E copy ${ILOG_CPLEX_DLL} ${TARGET_PATH}
+    )
   ENDIF()
 …
 FOREACH(TEST_NAME ${TESTS})
+  ADD_EXECUTABLE(${TEST_NAME} ${TEST_NAME}.cc)
+  IF(${CMAKE_BUILD_TYPE} STREQUAL "Maintainer")
+    ADD_EXECUTABLE(${TEST_NAME} ${TEST_NAME}.cc)
+  ELSE()
+    ADD_EXECUTABLE(${TEST_NAME} EXCLUDE_FROM_ALL ${TEST_NAME}.cc)
+  ENDIF()
   TARGET_LINK_LIBRARIES(${TEST_NAME} lemon)
+  ADD_TEST(${TEST_NAME} ${TEST_NAME})
+    IF(TEST_WITH_VALGRIND)
+      ADD_TEST(${TEST_NAME}
+        valgrind --error-exitcode=1 ${VALGRIND_FLAGS}
+        ${CMAKE_CURRENT_BINARY_DIR}/${TEST_NAME} )
+    ELSE()
+      ADD_TEST(${TEST_NAME} ${TEST_NAME})
+    ENDIF()
+  ADD_DEPENDENCIES(check ${TEST_NAME})
 ENDFOREACH()

test/adaptors_test.cc

-                      r550
+                      r1270
  * This file is a part of LEMON, a generic C++ optimization library.
+ *
  * Copyright (C) 2003-2009
+ * Copyright (C) 2003-2013
  * Egervary Jeno Kombinatorikus Optimalizalasi Kutatocsoport
  * (Egervary Research Group on Combinatorial Optimization, EGRES).
 …
   Digraph::Arc a2 = digraph.addArc(n1, n3);
   Digraph::Arc a3 = digraph.addArc(n2, n3);
+  ::lemon::ignore_unused_variable_warning(a3);
   // Check the adaptor
 …
   Adaptor::Arc a7 = adaptor.addArc(n1, n4);
   Adaptor::Arc a8 = adaptor.addArc(n1, n2);
+  ::lemon::ignore_unused_variable_warning(a6,a7,a8);
   adaptor.erase(a1);
 …
   Digraph::Arc a2 = digraph.addArc(n1, n3);
   Digraph::Arc a3 = digraph.addArc(n2, n3);
+  ::lemon::ignore_unused_variable_warning(a1,a2,a3);
   checkGraphNodeList(adaptor, 6);
 …
   // Apply several adaptors on the grid graph
+  typedef SplitNodes<Orienter< const GridGraph, GridGraph::EdgeMap<bool> > >
+    SplitGridGraph;
+  typedef Orienter< const GridGraph, GridGraph::EdgeMap<bool> >
+    OrientedGridGraph;
+  typedef SplitNodes<OrientedGridGraph> SplitGridGraph;
   typedef Undirector<const SplitGridGraph> USplitGridGraph;
   checkConcept<concepts::Digraph, SplitGridGraph>();
   checkConcept<concepts::Graph, USplitGridGraph>();
+  SplitGridGraph adaptor = splitNodes(orienter(graph, dir_map));
+  OrientedGridGraph oadaptor = orienter(graph, dir_map);
+  SplitGridGraph adaptor = splitNodes(oadaptor);
   USplitGridGraph uadaptor = undirector(adaptor);

test/bellman_ford_test.cc

-                      r838
+                      r1270
  * This file is a part of LEMON, a generic C++ optimization library.
+ *
  * Copyright (C) 2003-2009
+ * Copyright (C) 2003-2013
  * Egervary Jeno Kombinatorikus Optimalizalasi Kutatocsoport
  * (Egervary Research Group on Combinatorial Optimization, EGRES).
 …
   Arc e;
   Value l;
+  ::lemon::ignore_unused_variable_warning(l);
   int k=3;
   bool b;
+  ::lemon::ignore_unused_variable_warning(b);
   BF::DistMap d(gr);
   BF::PredMap p(gr);
 …
     pp = const_bf_test.path(t);
     pp = const_bf_test.negativeCycle();
     for (BF::ActiveIt it(const_bf_test); it != INVALID; ++it) {}
+  }
 …
     concepts::ReadWriteMap<Node,Arc> pred_map;
     concepts::ReadWriteMap<Node,Value> dist_map;
     bf_test
       .lengthMap(length_map)
 …
   Digraph g;
   bool b;
+  ::lemon::ignore_unused_variable_warning(b);
   bellmanFord(g,LengthMap()).run(Node());
   b = bellmanFord(g,LengthMap()).run(Node(),Node());
 …
   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;
+  Value dist = 0;
   bool reached = bellmanFord(gr,length).path(path).dist(dist).run(s,t);
 …
   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);
 …
           "Wrong negative cycle.");
+  }
   length[a2] = 0;
+  {
     BellmanFord<SmartDigraph, IntArcMap> bf(gr, length);
 …
           "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);

test/bfs_test.cc

-                      r632
+                      r1270
  * This file is a part of LEMON, a generic C++ optimization library.
+ *
  * Copyright (C) 2003-2009
+ * Copyright (C) 2003-2013
  * Egervary Jeno Kombinatorikus Optimalizalasi Kutatocsoport
  * (Egervary Research Group on Combinatorial Optimization, EGRES).
 …
   Arc e;
   int l, i;
+  ::lemon::ignore_unused_variable_warning(l,i);
   bool b;
   BType::DistMap d(G);
 …
     b = const_bfs_test.emptyQueue();
     i = const_bfs_test.queueSize();
     bfs_test.start();
     bfs_test.start(t);
 …
       ::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)
 …
     bfs_test.run(s,t);
     bfs_test.run();
     bfs_test.init();
     bfs_test.addSource(s);
 …
     b = bfs_test.emptyQueue();
     i = bfs_test.queueSize();
     bfs_test.start();
     bfs_test.start(t);
 …
   Digraph g;
   bool b;
+  ::lemon::ignore_unused_variable_warning(b);
   bfs(g).run(Node());
   b=bfs(g).run(Node(),Node());

test/circulation_test.cc

-                      r736
+                      r1270
  * This file is a part of LEMON, a generic C++ optimization library.
+ *
  * Copyright (C) 2003-2009
+ * Copyright (C) 2003-2013
  * Egervary Jeno Kombinatorikus Optimalizalasi Kutatocsoport
  * (Egervary Research Group on Combinatorial Optimization, EGRES).
 …
   VType v;
   bool b;
+  ::lemon::ignore_unused_variable_warning(v,b);
   typedef Circulation<Digraph, CapMap, CapMap, SupplyMap>
 …
   CirculationType circ_test(g, lcap, ucap, supply);
   const CirculationType& const_circ_test = circ_test;
   circ_test
     .lowerMap(lcap)
 …
     .supplyMap(supply)
     .flowMap(flow);
   const CirculationType::Elevator& elev = const_circ_test.elevator();
   circ_test.elevator(const_cast<CirculationType::Elevator&>(elev));
 …
   b = const_circ_test.barrier(n);
   const_circ_test.barrierMap(bar);
   ignore_unused_variable_warning(fm);
+  ::lemon::ignore_unused_variable_warning(fm);
+}

test/connectivity_test.cc

-                      r696
+                      r1270
  * This file is a part of LEMON, a generic C++ optimization library.
+ *
  * Copyright (C) 2003-2009
+ * Copyright (C) 2003-2013
  * Egervary Jeno Kombinatorikus Optimalizalasi Kutatocsoport
  * (Egervary Research Group on Combinatorial Optimization, EGRES).
 …
   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,
 …
     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.");
 …
     Graph g(d);
     Digraph::Node n = d.addNode();
+    ::lemon::ignore_unused_variable_warning(n);
     check(stronglyConnected(d), "This digraph is strongly 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.");
 …
+  {
+    ListGraph g;
+    ListGraph::NodeMap<bool> map(g);
+    ListGraph::Node n1 = g.addNode();
+    ListGraph::Node n2 = g.addNode();
+    ListGraph::Edge e1 = g.addEdge(n1, n2);
+    ::lemon::ignore_unused_variable_warning(e1);
+    check(biNodeConnected(g), "Graph is bi-node-connected");
+    ListGraph::Node n3 = g.addNode();
+    ::lemon::ignore_unused_variable_warning(n3);
+    check(!biNodeConnected(g), "Graph is not bi-node-connected");
+  }
+  {
     Digraph d;
     Digraph::NodeMap<int> order(d);
     Graph g(d);
     Digraph::Node n1 = d.addNode();
     Digraph::Node n2 = d.addNode();
 …
     Digraph::Node n5 = d.addNode();
     Digraph::Node n6 = d.addNode();
     d.addArc(n1, n3);
     d.addArc(n3, n2);
 …
     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();
 …
     d.addArc(n6, n7);
     d.addArc(n7, n6);
     check(!stronglyConnected(d), "This digraph is not strongly connected");
     check(countStronglyConnectedComponents(d) == 3,
 …
     Digraph d;
     Digraph::NodeMap<int> order(d);
     Digraph::Node belt = d.addNode();
     Digraph::Node trousers = d.addNode();
 …
     Digraph::Node watch = d.addNode();
     Digraph::Node pants = d.addNode();
+    ::lemon::ignore_unused_variable_warning(watch);
     d.addArc(socks, shoe);
 …
     d.addArc(shirt, necktie);
     d.addArc(necktie, coat);
     check(dag(d), "This digraph is DAG.");
     topologicalSort(d, order);
 …
     ListGraph g;
     ListGraph::NodeMap<bool> map(g);
     ListGraph::Node n1 = g.addNode();
     ListGraph::Node n2 = g.addNode();
 …
     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()");

test/dfs_test.cc

-                      r632
+                      r1270
  * This file is a part of LEMON, a generic C++ optimization library.
+ *
  * Copyright (C) 2003-2009
+ * Copyright (C) 2003-2013
  * Egervary Jeno Kombinatorikus Optimalizalasi Kutatocsoport
  * (Egervary Research Group on Combinatorial Optimization, EGRES).
 …
   "@attributes\n"
   "source 0\n"
+  "target 5\n";
+  "target 5\n"
+  "source1 6\n"
+  "target1 3\n";
 void checkDfsCompile()
 …
   int l, i;
   bool b;
+  ::lemon::ignore_unused_variable_warning(l,i,b);
   DType::DistMap d(G);
   DType::PredMap p(G);
 …
     b = const_dfs_test.emptyQueue();
     i = const_dfs_test.queueSize();
     dfs_test.start();
     dfs_test.start(t);
 …
     concepts::ReadWriteMap<Node,bool> reached_map;
     concepts::WriteMap<Node,bool> processed_map;
     dfs_test
       .predMap(pred_map)
 …
     b = dfs_test.emptyQueue();
     i = dfs_test.queueSize();
     dfs_test.start();
     dfs_test.start(t);
 …
   Digraph g;
   bool b;
+  ::lemon::ignore_unused_variable_warning(b);
   dfs(g).run(Node());
   b=dfs(g).run(Node(),Node());
 …
   Digraph G;
   Node s, t;
+  Node s1, t1;
   std::istringstream input(test_lgf);
 …
     node("source", s).
     node("target", t).
+    node("source1", s1).
+    node("target1", t1).
     run();
 …
+  {
+  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);

test/digraph_test.cc

-                      r827
+                      r1270
  * This file is a part of LEMON, a generic C++ optimization library.
+ *
  * Copyright (C) 2003-2009
+ * Copyright (C) 2003-2013
  * Egervary Jeno Kombinatorikus Optimalizalasi Kutatocsoport
  * (Egervary Research Group on Combinatorial Optimization, EGRES).
 …
       a3 = G.addArc(n2, n3),
       a4 = G.addArc(n2, n3);
+  ::lemon::ignore_unused_variable_warning(a2,a3,a4);
   checkGraphNodeList(G, 3);
 …
   Arc a1 = G.addArc(n1, n2), a2 = G.addArc(n2, n1),
       a3 = G.addArc(n2, n3), a4 = G.addArc(n2, n3);
+  ::lemon::ignore_unused_variable_warning(a1,a2,a3,a4);
   Node n4 = G.split(n2);
 …
       a3 = G.addArc(n4, n3), a4 = G.addArc(n4, n3),
       a5 = G.addArc(n2, n4);
+  ::lemon::ignore_unused_variable_warning(a1,a2,a3,a5);
   checkGraphNodeList(G, 4);
 …
       a3 = G.addArc(n4, n3), a4 = G.addArc(n3, n1),
       a5 = G.addArc(n2, n4);
+  ::lemon::ignore_unused_variable_warning(a2,a3,a4,a5);
   // Check arc deletion
 …
   Arc a1 = G.addArc(n1, n2), a2 = G.addArc(n2, n1),
       a3 = G.addArc(n2, n3), a4 = G.addArc(n2, n3);
+  ::lemon::ignore_unused_variable_warning(a1,a2,a3,a4);
   typename Digraph::Snapshot snapshot(G);
 …
     e1 = g.addArc(n1, n2),
     e2 = g.addArc(n2, n3);
+  ::lemon::ignore_unused_variable_warning(e2);
   check(g.valid(n1), "Wrong validity check");
 …
   SmartDigraph::NodeMap<StaticDigraph::Node> nref(g);
   SmartDigraph::ArcMap<StaticDigraph::Arc> aref(g);
   StaticDigraph G;
   checkGraphNodeList(G, 0);
   checkGraphArcList(G, 0);
 …
     a3 = g.addArc(n2, n3),
     a4 = g.addArc(n2, n3);
+  ::lemon::ignore_unused_variable_warning(a2,a3,a4);
   digraphCopy(g, G).nodeRef(nref).run();
 …
   G.build(6, arcs.begin(), arcs.end());
   checkGraphNodeList(G, 6);
   checkGraphArcList(G, 9);
 …
   checkGraphNodeMap(G);
   checkGraphArcMap(G);
   int n = G.nodeNum();
   int m = G.arcNum();

test/dijkstra_test.cc

-                      r632
+                      r1270
  * This file is a part of LEMON, a generic C++ optimization library.
+ *
  * Copyright (C) 2003-2009
+ * Copyright (C) 2003-2013
  * Egervary Jeno Kombinatorikus Optimalizalasi Kutatocsoport
  * (Egervary Research Group on Combinatorial Optimization, EGRES).
 …
   int i;
   bool b;
+  ::lemon::ignore_unused_variable_warning(l,i,b);
   DType::DistMap d(G);
   DType::PredMap p(G);
 …
     b = const_dijkstra_test.emptyQueue();
     i = const_dijkstra_test.queueSize();
     dijkstra_test.start();
     dijkstra_test.start(t);
 …
       ::SetHeap<BinHeap<VType, concepts::ReadWriteMap<Node,int> > >
       ::SetStandardHeap<BinHeap<VType, concepts::ReadWriteMap<Node,int> > >
       ::SetHeap<BinHeap<VType, concepts::ReadWriteMap<Node,int> >,
+      ::SetHeap<BinHeap<VType, concepts::ReadWriteMap<Node,int> >,
                 concepts::ReadWriteMap<Node,int> >
       ::Create dijkstra_test(G,length);
 …
     concepts::ReadWriteMap<Node,int> heap_cross_ref;
     BinHeap<VType, concepts::ReadWriteMap<Node,int> > heap(heap_cross_ref);
     dijkstra_test
       .lengthMap(length_map)
 …
     b = dijkstra_test.emptyQueue();
     i = dijkstra_test.queueSize();
     dijkstra_test.start();
     dijkstra_test.start(t);
 …
   Digraph g;
   bool b;
+  ::lemon::ignore_unused_variable_warning(b);
   dijkstra(g,LengthMap()).run(Node());
   b=dijkstra(g,LengthMap()).run(Node(),Node());

test/edge_set_test.cc

-                      r559
+                      r1270
  * This file is a part of LEMON, a generic C++ optimization library.
+ *
  * Copyright (C) 2003-2008
+ * Copyright (C) 2003-2013
  * Egervary Jeno Kombinatorikus Optimalizalasi Kutatocsoport
  * (Egervary Research Group on Combinatorial Optimization, EGRES).
 …
   Digraph::Arc ga1 = digraph.addArc(n1, n2);
+  ::lemon::ignore_unused_variable_warning(ga1);
   ArcSet arc_set(digraph);
   Digraph::Arc ga2 = digraph.addArc(n2, n1);
+  ::lemon::ignore_unused_variable_warning(ga2);
   checkGraphNodeList(arc_set, 2);
 …
     a3 = arc_set.addArc(n2, n3),
     a4 = arc_set.addArc(n2, n3);
+  ::lemon::ignore_unused_variable_warning(a2,a3,a4);
   checkGraphNodeList(arc_set, 3);
   checkGraphArcList(arc_set, 4);
 …
   Digraph::Arc ga1 = digraph.addArc(n1, n2);
+  ::lemon::ignore_unused_variable_warning(ga1);
   ArcSet arc_set(digraph);
   Digraph::Arc ga2 = digraph.addArc(n2, n1);
+  ::lemon::ignore_unused_variable_warning(ga2);
   checkGraphNodeList(arc_set, 2);
 …
     a3 = arc_set.addArc(n2, n3),
     a4 = arc_set.addArc(n2, n3);
+  ::lemon::ignore_unused_variable_warning(a2,a3,a4);
   checkGraphNodeList(arc_set, 3);
   checkGraphArcList(arc_set, 4);
 …
   Digraph::Arc ga1 = digraph.addArc(n1, n2);
+  ::lemon::ignore_unused_variable_warning(ga1);
   EdgeSet edge_set(digraph);
   Digraph::Arc ga2 = digraph.addArc(n2, n1);
+  ::lemon::ignore_unused_variable_warning(ga2);
   checkGraphNodeList(edge_set, 2);
 …
     e3 = edge_set.addEdge(n2, n3),
     e4 = edge_set.addEdge(n2, n3);
+  ::lemon::ignore_unused_variable_warning(e2,e3,e4);
   checkGraphNodeList(edge_set, 3);
   checkGraphEdgeList(edge_set, 4);
 …
   Digraph::Arc ga1 = digraph.addArc(n1, n2);
+  ::lemon::ignore_unused_variable_warning(ga1);
   EdgeSet edge_set(digraph);
   Digraph::Arc ga2 = digraph.addArc(n2, n1);
+  ::lemon::ignore_unused_variable_warning(ga2);
   checkGraphNodeList(edge_set, 2);
 …
     e3 = edge_set.addEdge(n2, n3),
     e4 = edge_set.addEdge(n2, n3);
+  ::lemon::ignore_unused_variable_warning(e2,e3,e4);
   checkGraphNodeList(edge_set, 3);
   checkGraphEdgeList(edge_set, 4);

test/euler_test.cc

-                      r639
+                      r1270
  * This file is a part of LEMON, a generic C++ optimization library.
+ *
  * Copyright (C) 2003-2009
+ * Copyright (C) 2003-2013
  * Egervary Jeno Kombinatorikus Optimalizalasi Kutatocsoport
  * (Egervary Research Group on Combinatorial Optimization, EGRES).
 …
   typedef ListDigraph Digraph;
   typedef Undirector<Digraph> Graph;
+  {
     Digraph d;
     Graph g(d);
+  {
+    Digraph d;
+    Graph g(d);
     checkDiEulerIt(d);
     checkDiEulerIt(g);
 …
     Graph g(d);
     Digraph::Node n = d.addNode();
+    ::lemon::ignore_unused_variable_warning(n);
     checkDiEulerIt(d);
 …
     Digraph::Node n2 = d.addNode();
     Digraph::Node n3 = d.addNode();
     d.addArc(n1, n2);
     d.addArc(n2, n1);
 …
     Digraph::Node n5 = d.addNode();
     Digraph::Node n6 = d.addNode();
     d.addArc(n1, n2);
     d.addArc(n2, n4);
 …
     Digraph::Node n4 = d.addNode();
     Digraph::Node n5 = d.addNode();
+    ::lemon::ignore_unused_variable_warning(n0,n4,n5);
     d.addArc(n1, n2);
     d.addArc(n2, n3);
 …
     Digraph::Node n2 = d.addNode();
     Digraph::Node n3 = d.addNode();
     d.addArc(n1, n2);
     d.addArc(n2, n3);

test/gomory_hu_test.cc

-                      r643
+                      r1270
+/* -*- mode: C++; indent-tabs-mode: nil; -*-
+ *
+ * This file is a part of LEMON, a generic C++ optimization library.
+ *
+ * Copyright (C) 2003-2013
+ * 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>
 …
   "source 0\n"
   "target 3\n";
 void checkGomoryHuCompile()
+{
 …
   Value v;
   int d;
+  ::lemon::ignore_unused_variable_warning(v,d);
   GomoryHu<Graph, CapMap> gh_test(g, cap);
 …
 int cutValue(const Graph& graph, const BoolNodeMap& cut,
              const IntEdgeMap& capacity) {
+             const IntEdgeMap& capacity) {
   int sum = 0;
 …
       int sum=0;
       for(GomoryHu<Graph>::MinCutEdgeIt a(ght, u, v);a!=INVALID;++a)
         sum+=capacity[a];
+        sum+=capacity[a];
       check(sum == ght.minCutValue(u, v), "Problem with MinCutEdgeIt");
 …
+    }
+  }
   return 0;
+}

test/graph_copy_test.cc

-                      r463
+                      r1270
  * This file is a part of LEMON, a generic C++ optimization library.
+ *
  * Copyright (C) 2003-2009
+ * Copyright (C) 2003-2013
  * Egervary Jeno Kombinatorikus Optimalizalasi Kutatocsoport
  * (Egervary Research Group on Combinatorial Optimization, EGRES).
 …
 #include <lemon/smart_graph.h>
 #include <lemon/list_graph.h>
+#include <lemon/static_graph.h>
 #include <lemon/lgf_reader.h>
 #include <lemon/error.h>
 …
 using namespace lemon;
+template <typename GR>
 void digraph_copy_test() {
   const int nn = 10;
+  // Build a digraph
   SmartDigraph from;
   SmartDigraph::NodeMap<int> fnm(from);
 …
+  }
+  ListDigraph to;
+  ListDigraph::NodeMap<int> tnm(to);
+  ListDigraph::ArcMap<int> tam(to);
+  ListDigraph::Node tn;
+  ListDigraph::Arc ta;
+  SmartDigraph::NodeMap<ListDigraph::Node> nr(from);
+  SmartDigraph::ArcMap<ListDigraph::Arc> er(from);
+  ListDigraph::NodeMap<SmartDigraph::Node> ncr(to);
+  ListDigraph::ArcMap<SmartDigraph::Arc> ecr(to);
+  // Test digraph copy
+  GR to;
+  typename GR::template NodeMap<int> tnm(to);
+  typename GR::template ArcMap<int> tam(to);
+  typename GR::Node tn;
+  typename GR::Arc ta;
+  SmartDigraph::NodeMap<typename GR::Node> nr(from);
+  SmartDigraph::ArcMap<typename GR::Arc> er(from);
+  typename GR::template NodeMap<SmartDigraph::Node> ncr(to);
+  typename GR::template ArcMap<SmartDigraph::Arc> ecr(to);
   digraphCopy(from, to).
 …
     node(fn, tn).arc(fa, ta).run();
+  check(countNodes(from) == countNodes(to), "Wrong copy.");
+  check(countArcs(from) == countArcs(to), "Wrong copy.");
   for (SmartDigraph::NodeIt it(from); it != INVALID; ++it) {
     check(ncr[nr[it]] == it, "Wrong copy.");
 …
+  }
   for (ListDigraph::NodeIt it(to); it != INVALID; ++it) {
+  for (typename GR::NodeIt it(to); it != INVALID; ++it) {
     check(nr[ncr[it]] == it, "Wrong copy.");
+  }
   for (ListDigraph::ArcIt it(to); it != INVALID; ++it) {
+  for (typename GR::ArcIt it(to); it != INVALID; ++it) {
     check(er[ecr[it]] == it, "Wrong copy.");
+  }
   check(tn == nr[fn], "Wrong copy.");
   check(ta == er[fa], "Wrong copy.");
+  // Test repeated copy
+  digraphCopy(from, to).run();
+  check(countNodes(from) == countNodes(to), "Wrong copy.");
+  check(countArcs(from) == countArcs(to), "Wrong copy.");
+}
+template <typename GR>
 void graph_copy_test() {
   const int nn = 10;
+  // Build a graph
   SmartGraph from;
   SmartGraph::NodeMap<int> fnm(from);
 …
+  }
+  ListGraph to;
+  ListGraph::NodeMap<int> tnm(to);
+  ListGraph::ArcMap<int> tam(to);
+  ListGraph::EdgeMap<int> tem(to);
+  ListGraph::Node tn;
+  ListGraph::Arc ta;
+  ListGraph::Edge te;
+  SmartGraph::NodeMap<ListGraph::Node> nr(from);
+  SmartGraph::ArcMap<ListGraph::Arc> ar(from);
+  SmartGraph::EdgeMap<ListGraph::Edge> er(from);
+  ListGraph::NodeMap<SmartGraph::Node> ncr(to);
+  ListGraph::ArcMap<SmartGraph::Arc> acr(to);
+  ListGraph::EdgeMap<SmartGraph::Edge> ecr(to);
+  // Test graph copy
+  GR to;
+  typename GR::template NodeMap<int> tnm(to);
+  typename GR::template ArcMap<int> tam(to);
+  typename GR::template EdgeMap<int> tem(to);
+  typename GR::Node tn;
+  typename GR::Arc ta;
+  typename GR::Edge te;
+  SmartGraph::NodeMap<typename GR::Node> nr(from);
+  SmartGraph::ArcMap<typename GR::Arc> ar(from);
+  SmartGraph::EdgeMap<typename GR::Edge> er(from);
+  typename GR::template NodeMap<SmartGraph::Node> ncr(to);
+  typename GR::template ArcMap<SmartGraph::Arc> acr(to);
+  typename GR::template EdgeMap<SmartGraph::Edge> ecr(to);
   graphCopy(from, to).
 …
     node(fn, tn).arc(fa, ta).edge(fe, te).run();
+  check(countNodes(from) == countNodes(to), "Wrong copy.");
+  check(countEdges(from) == countEdges(to), "Wrong copy.");
+  check(countArcs(from) == countArcs(to), "Wrong copy.");
   for (SmartGraph::NodeIt it(from); it != INVALID; ++it) {
     check(ncr[nr[it]] == it, "Wrong copy.");
 …
+  }
   for (ListGraph::NodeIt it(to); it != INVALID; ++it) {
+  for (typename GR::NodeIt it(to); it != INVALID; ++it) {
     check(nr[ncr[it]] == it, "Wrong copy.");
+  }
   for (ListGraph::ArcIt it(to); it != INVALID; ++it) {
+  for (typename GR::ArcIt it(to); it != INVALID; ++it) {
     check(ar[acr[it]] == it, "Wrong copy.");
+  }
   for (ListGraph::EdgeIt it(to); it != INVALID; ++it) {
+  for (typename GR::EdgeIt it(to); it != INVALID; ++it) {
     check(er[ecr[it]] == it, "Wrong copy.");
+  }
 …
   check(ta == ar[fa], "Wrong copy.");
   check(te == er[fe], "Wrong copy.");
+  // Test repeated copy
+  graphCopy(from, to).run();
+  check(countNodes(from) == countNodes(to), "Wrong copy.");
+  check(countEdges(from) == countEdges(to), "Wrong copy.");
+  check(countArcs(from) == countArcs(to), "Wrong copy.");
+}
+template <typename GR>
+void bpgraph_copy_test() {
+  const int nn = 10;
+  // Build a graph
+  SmartBpGraph from;
+  SmartBpGraph::NodeMap<int> fnm(from);
+  SmartBpGraph::RedNodeMap<int> frnm(from);
+  SmartBpGraph::BlueNodeMap<int> fbnm(from);
+  SmartBpGraph::ArcMap<int> fam(from);
+  SmartBpGraph::EdgeMap<int> fem(from);
+  SmartBpGraph::Node fn = INVALID;
+  SmartBpGraph::RedNode frn = INVALID;
+  SmartBpGraph::BlueNode fbn = INVALID;
+  SmartBpGraph::Arc fa = INVALID;
+  SmartBpGraph::Edge fe = INVALID;
+  std::vector<SmartBpGraph::RedNode> frnv;
+  for (int i = 0; i < nn; ++i) {
+    SmartBpGraph::RedNode node = from.addRedNode();
+    frnv.push_back(node);
+    fnm[node] = i * i;
+    frnm[node] = i + i;
+    if (i == 0) {
+      fn = node;
+      frn = node;
+    }
+  }
+  std::vector<SmartBpGraph::BlueNode> fbnv;
+  for (int i = 0; i < nn; ++i) {
+    SmartBpGraph::BlueNode node = from.addBlueNode();
+    fbnv.push_back(node);
+    fnm[node] = i * i;
+    fbnm[node] = i + i;
+    if (i == 0) fbn = node;
+  }
+  for (int i = 0; i < nn; ++i) {
+    for (int j = 0; j < nn; ++j) {
+      SmartBpGraph::Edge edge = from.addEdge(frnv[i], fbnv[j]);
+      fem[edge] = i * i + j * j;
+      fam[from.direct(edge, true)] = i + j * j;
+      fam[from.direct(edge, false)] = i * i + j;
+      if (i == 0 && j == 0) fa = from.direct(edge, true);
+      if (i == 0 && j == 0) fe = edge;
+    }
+  }
+  // Test graph copy
+  GR to;
+  typename GR::template NodeMap<int> tnm(to);
+  typename GR::template RedNodeMap<int> trnm(to);
+  typename GR::template BlueNodeMap<int> tbnm(to);
+  typename GR::template ArcMap<int> tam(to);
+  typename GR::template EdgeMap<int> tem(to);
+  typename GR::Node tn;
+  typename GR::RedNode trn;
+  typename GR::BlueNode tbn;
+  typename GR::Arc ta;
+  typename GR::Edge te;
+  SmartBpGraph::NodeMap<typename GR::Node> nr(from);
+  SmartBpGraph::RedNodeMap<typename GR::RedNode> rnr(from);
+  SmartBpGraph::BlueNodeMap<typename GR::BlueNode> bnr(from);
+  SmartBpGraph::ArcMap<typename GR::Arc> ar(from);
+  SmartBpGraph::EdgeMap<typename GR::Edge> er(from);
+  typename GR::template NodeMap<SmartBpGraph::Node> ncr(to);
+  typename GR::template RedNodeMap<SmartBpGraph::RedNode> rncr(to);
+  typename GR::template BlueNodeMap<SmartBpGraph::BlueNode> bncr(to);
+  typename GR::template ArcMap<SmartBpGraph::Arc> acr(to);
+  typename GR::template EdgeMap<SmartBpGraph::Edge> ecr(to);
+  bpGraphCopy(from, to).
+    nodeMap(fnm, tnm).
+    redNodeMap(frnm, trnm).blueNodeMap(fbnm, tbnm).
+    arcMap(fam, tam).edgeMap(fem, tem).
+    nodeRef(nr).redRef(rnr).blueRef(bnr).
+    arcRef(ar).edgeRef(er).
+    nodeCrossRef(ncr).redCrossRef(rncr).blueCrossRef(bncr).
+    arcCrossRef(acr).edgeCrossRef(ecr).
+    node(fn, tn).redNode(frn, trn).blueNode(fbn, tbn).
+    arc(fa, ta).edge(fe, te).run();
+  check(countNodes(from) == countNodes(to), "Wrong copy.");
+  check(countRedNodes(from) == countRedNodes(to), "Wrong copy.");
+  check(countBlueNodes(from) == countBlueNodes(to), "Wrong copy.");
+  check(countEdges(from) == countEdges(to), "Wrong copy.");
+  check(countArcs(from) == countArcs(to), "Wrong copy.");
+  for (SmartBpGraph::NodeIt it(from); it != INVALID; ++it) {
+    check(ncr[nr[it]] == it, "Wrong copy.");
+    check(fnm[it] == tnm[nr[it]], "Wrong copy.");
+  }
+  for (SmartBpGraph::RedNodeIt it(from); it != INVALID; ++it) {
+    check(ncr[nr[it]] == it, "Wrong copy.");
+    check(fnm[it] == tnm[nr[it]], "Wrong copy.");
+    check(rnr[it] == nr[it], "Wrong copy.");
+    check(rncr[rnr[it]] == it, "Wrong copy.");
+    check(frnm[it] == trnm[rnr[it]], "Wrong copy.");
+    check(to.red(rnr[it]), "Wrong copy.");
+  }
+  for (SmartBpGraph::BlueNodeIt it(from); it != INVALID; ++it) {
+    check(ncr[nr[it]] == it, "Wrong copy.");
+    check(fnm[it] == tnm[nr[it]], "Wrong copy.");
+    check(bnr[it] == nr[it], "Wrong copy.");
+    check(bncr[bnr[it]] == it, "Wrong copy.");
+    check(fbnm[it] == tbnm[bnr[it]], "Wrong copy.");
+    check(to.blue(bnr[it]), "Wrong copy.");
+  }
+  for (SmartBpGraph::ArcIt it(from); it != INVALID; ++it) {
+    check(acr[ar[it]] == it, "Wrong copy.");
+    check(fam[it] == tam[ar[it]], "Wrong copy.");
+    check(nr[from.source(it)] == to.source(ar[it]), "Wrong copy.");
+    check(nr[from.target(it)] == to.target(ar[it]), "Wrong copy.");
+  }
+  for (SmartBpGraph::EdgeIt it(from); it != INVALID; ++it) {
+    check(ecr[er[it]] == it, "Wrong copy.");
+    check(fem[it] == tem[er[it]], "Wrong copy.");
+    check(nr[from.u(it)] == to.u(er[it]) || nr[from.u(it)] == to.v(er[it]),
+          "Wrong copy.");
+    check(nr[from.v(it)] == to.u(er[it]) || nr[from.v(it)] == to.v(er[it]),
+          "Wrong copy.");
+    check((from.u(it) != from.v(it)) == (to.u(er[it]) != to.v(er[it])),
+          "Wrong copy.");
+  }
+  for (typename GR::NodeIt it(to); it != INVALID; ++it) {
+    check(nr[ncr[it]] == it, "Wrong copy.");
+  }
+  for (typename GR::RedNodeIt it(to); it != INVALID; ++it) {
+    check(rncr[it] == ncr[it], "Wrong copy.");
+    check(rnr[rncr[it]] == it, "Wrong copy.");
+  }
+  for (typename GR::BlueNodeIt it(to); it != INVALID; ++it) {
+    check(bncr[it] == ncr[it], "Wrong copy.");
+    check(bnr[bncr[it]] == it, "Wrong copy.");
+  }
+  for (typename GR::ArcIt it(to); it != INVALID; ++it) {
+    check(ar[acr[it]] == it, "Wrong copy.");
+  }
+  for (typename GR::EdgeIt it(to); it != INVALID; ++it) {
+    check(er[ecr[it]] == it, "Wrong copy.");
+  }
+  check(tn == nr[fn], "Wrong copy.");
+  check(trn == rnr[frn], "Wrong copy.");
+  check(tbn == bnr[fbn], "Wrong copy.");
+  check(ta == ar[fa], "Wrong copy.");
+  check(te == er[fe], "Wrong copy.");
+  // Test repeated copy
+  bpGraphCopy(from, to).run();
+  check(countNodes(from) == countNodes(to), "Wrong copy.");
+  check(countRedNodes(from) == countRedNodes(to), "Wrong copy.");
+  check(countBlueNodes(from) == countBlueNodes(to), "Wrong copy.");
+  check(countEdges(from) == countEdges(to), "Wrong copy.");
+  check(countArcs(from) == countArcs(to), "Wrong copy.");
+}
 int main() {
+  digraph_copy_test();
+  graph_copy_test();
+  digraph_copy_test<SmartDigraph>();
+  digraph_copy_test<ListDigraph>();
+  digraph_copy_test<StaticDigraph>();
+  graph_copy_test<SmartGraph>();
+  graph_copy_test<ListGraph>();
+  bpgraph_copy_test<SmartBpGraph>();
+  bpgraph_copy_test<ListBpGraph>();
   return 0;

test/graph_test.cc

-                      r787
+                      r1270
  * This file is a part of LEMON, a generic C++ optimization library.
+ *
  * Copyright (C) 2003-2009
+ * Copyright (C) 2003-2013
  * Egervary Jeno Kombinatorikus Optimalizalasi Kutatocsoport
  * (Egervary Research Group on Combinatorial Optimization, EGRES).
 …
   Edge e2 = G.addEdge(n2, n1),
        e3 = G.addEdge(n2, n3);
+  ::lemon::ignore_unused_variable_warning(e2,e3);
   checkGraphNodeList(G, 3);
 …
        e3 = G.addEdge(n2, n3), e4 = G.addEdge(n1, n4),
        e5 = G.addEdge(n4, n3);
+  ::lemon::ignore_unused_variable_warning(e1,e3,e4,e5);
   checkGraphNodeList(G, 4);
 …
        e3 = G.addEdge(n2, n3), e4 = G.addEdge(n1, n4),
        e5 = G.addEdge(n4, n3);
+  ::lemon::ignore_unused_variable_warning(e1,e3,e4,e5);
   // Check edge deletion
 …
   Edge e1 = G.addEdge(n1, n2), e2 = G.addEdge(n2, n1),
        e3 = G.addEdge(n2, n3);
+  ::lemon::ignore_unused_variable_warning(e1,e2,e3);
   checkGraphNodeList(G, 3);
 …
   checkGraphEdgeList(G, 3);
   checkGraphArcList(G, 6);
   G.addEdge(G.addNode(), G.addNode());
 …
     e1 = g.addEdge(n1, n2),
     e2 = g.addEdge(n2, n3);
+  ::lemon::ignore_unused_variable_warning(e2);
   check(g.valid(n1), "Wrong validity check");
 …
   G.resize(dim);
   check(G.dimension() == dim, "Wrong dimension");
   checkGraphNodeList(G, 1 << dim);
   checkGraphEdgeList(G, dim * (1 << (dim-1)));
 …
   Node n = G.nodeFromId(dim);
+  ::lemon::ignore_unused_variable_warning(n);
   for (NodeIt n(G); n != INVALID; ++n) {

test/graph_test.h

-                      r463
+                      r1270
  * This file is a part of LEMON, a generic C++ optimization library.
+ *
  * Copyright (C) 2003-2009
+ * Copyright (C) 2003-2013
  * Egervary Jeno Kombinatorikus Optimalizalasi Kutatocsoport
  * (Egervary Research Group on Combinatorial Optimization, EGRES).
 …
   template<class Graph>
+  void checkGraphRedNodeList(const Graph &G, int cnt)
+  {
+    typename Graph::RedNodeIt n(G);
+    for(int i=0;i<cnt;i++) {
+      check(n!=INVALID,"Wrong red Node list linking.");
+      check(G.red(n),"Wrong node set check.");
+      check(!G.blue(n),"Wrong node set check.");
+      typename Graph::Node nn = n;
+      check(G.asRedNodeUnsafe(nn) == n,"Wrong node conversion.");
+      check(G.asRedNode(nn) == n,"Wrong node conversion.");
+      check(G.asBlueNode(nn) == INVALID,"Wrong node conversion.");
+      ++n;
+    }
+    check(n==INVALID,"Wrong red Node list linking.");
+    check(countRedNodes(G)==cnt,"Wrong red Node number.");
+  }
+  template<class Graph>
+  void checkGraphBlueNodeList(const Graph &G, int cnt)
+  {
+    typename Graph::BlueNodeIt n(G);
+    for(int i=0;i<cnt;i++) {
+      check(n!=INVALID,"Wrong blue Node list linking.");
+      check(G.blue(n),"Wrong node set check.");
+      check(!G.red(n),"Wrong node set check.");
+      typename Graph::Node nn = n;
+      check(G.asBlueNodeUnsafe(nn) == n,"Wrong node conversion.");
+      check(G.asBlueNode(nn) == n,"Wrong node conversion.");
+      check(G.asRedNode(nn) == INVALID,"Wrong node conversion.");
+      ++n;
+    }
+    check(n==INVALID,"Wrong blue Node list linking.");
+    check(countBlueNodes(G)==cnt,"Wrong blue Node number.");
+  }
+  template<class Graph>
   void checkGraphArcList(const Graph &G, int cnt)
+  {
 …
   template <typename Graph>
   void checkNodeIds(const Graph& G) {
+    typedef typename Graph::Node Node;
     std::set<int> values;
     for (typename Graph::NodeIt n(G); n != INVALID; ++n) {
 …
       values.insert(G.id(n));
+    }
+    check(G.maxId(Node()) <= G.maxNodeId(), "Wrong maximum id");
+  }
+  template <typename Graph>
+  void checkRedNodeIds(const Graph& G) {
+    typedef typename Graph::RedNode RedNode;
+    std::set<int> values;
+    for (typename Graph::RedNodeIt n(G); n != INVALID; ++n) {
+      check(G.red(n), "Wrong partition");
+      check(values.find(G.id(n)) == values.end(), "Wrong id");
+      check(G.id(n) <= G.maxRedId(), "Wrong maximum id");
+      values.insert(G.id(n));
+    }
+    check(G.maxId(RedNode()) == G.maxRedId(), "Wrong maximum id");
+  }
+  template <typename Graph>
+  void checkBlueNodeIds(const Graph& G) {
+    typedef typename Graph::BlueNode BlueNode;
+    std::set<int> values;
+    for (typename Graph::BlueNodeIt n(G); n != INVALID; ++n) {
+      check(G.blue(n), "Wrong partition");
+      check(values.find(G.id(n)) == values.end(), "Wrong id");
+      check(G.id(n) <= G.maxBlueId(), "Wrong maximum id");
+      values.insert(G.id(n));
+    }
+    check(G.maxId(BlueNode()) == G.maxBlueId(), "Wrong maximum id");
+  }
   template <typename Graph>
   void checkArcIds(const Graph& G) {
+    typedef typename Graph::Arc Arc;
     std::set<int> values;
     for (typename Graph::ArcIt a(G); a != INVALID; ++a) {
 …
       values.insert(G.id(a));
+    }
+    check(G.maxId(Arc()) <= G.maxArcId(), "Wrong maximum id");
+  }
   template <typename Graph>
   void checkEdgeIds(const Graph& G) {
+    typedef typename Graph::Edge Edge;
     std::set<int> values;
     for (typename Graph::EdgeIt e(G); e != INVALID; ++e) {
 …
       values.insert(G.id(e));
+    }
+    check(G.maxId(Edge()) <= G.maxEdgeId(), "Wrong maximum id");
+  }
 …
   template <typename Graph>
+  void checkGraphRedNodeMap(const Graph& G) {
+    typedef typename Graph::Node Node;
+    typedef typename Graph::RedNodeIt RedNodeIt;
+    typedef typename Graph::template RedNodeMap<int> IntRedNodeMap;
+    IntRedNodeMap map(G, 42);
+    for (RedNodeIt it(G); it != INVALID; ++it) {
+      check(map[it] == 42, "Wrong map constructor.");
+    }
+    int s = 0;
+    for (RedNodeIt it(G); it != INVALID; ++it) {
+      map[it] = 0;
+      check(map[it] == 0, "Wrong operator[].");
+      map.set(it, s);
+      check(map[it] == s, "Wrong set.");
+      ++s;
+    }
+    s = s * (s - 1) / 2;
+    for (RedNodeIt it(G); it != INVALID; ++it) {
+      s -= map[it];
+    }
+    check(s == 0, "Wrong sum.");
+    // map = constMap<Node>(12);
+    // for (NodeIt it(G); it != INVALID; ++it) {
+    //   check(map[it] == 12, "Wrong operator[].");
+    // }
+  }
+  template <typename Graph>
+  void checkGraphBlueNodeMap(const Graph& G) {
+    typedef typename Graph::Node Node;
+    typedef typename Graph::BlueNodeIt BlueNodeIt;
+    typedef typename Graph::template BlueNodeMap<int> IntBlueNodeMap;
+    IntBlueNodeMap map(G, 42);
+    for (BlueNodeIt it(G); it != INVALID; ++it) {
+      check(map[it] == 42, "Wrong map constructor.");
+    }
+    int s = 0;
+    for (BlueNodeIt it(G); it != INVALID; ++it) {
+      map[it] = 0;
+      check(map[it] == 0, "Wrong operator[].");
+      map.set(it, s);
+      check(map[it] == s, "Wrong set.");
+      ++s;
+    }
+    s = s * (s - 1) / 2;
+    for (BlueNodeIt it(G); it != INVALID; ++it) {
+      s -= map[it];
+    }
+    check(s == 0, "Wrong sum.");
+    // map = constMap<Node>(12);
+    // for (NodeIt it(G); it != INVALID; ++it) {
+    //   check(map[it] == 12, "Wrong operator[].");
+    // }
+  }
+  template <typename Graph>
   void checkGraphArcMap(const Graph& G) {
     typedef typename Graph::Arc Arc;

test/hao_orlin_test.cc

-                      r644
+                      r1270
  * This file is a part of LEMON, a generic C++ optimization library.
+ *
  * Copyright (C) 2003-2009
+ * Copyright (C) 2003-2013
  * Egervary Jeno Kombinatorikus Optimalizalasi Kutatocsoport
  * (Egervary Research Group on Combinatorial Optimization, EGRES).
 …
   CutMap cut;
   Value v;
+  ::lemon::ignore_unused_variable_warning(v);
   HaoOrlin<Digraph, CapMap> ho_test(g, cap);
 …
 template <typename Graph, typename CapMap, typename CutMap>
 typename CapMap::Value
+typename CapMap::Value
   cutValue(const Graph& graph, const CapMap& cap, const CutMap& cut)
+{
 …
     ho.run();
     ho.minCutMap(cut);
     check(ho.minCutValue() == 1, "Wrong cut value");
     check(ho.minCutValue() == cutValue(graph, cap1, cut), "Wrong cut value");
 …
     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");
 …
     ho.run();
     ho.minCutMap(cut);
     check(ho.minCutValue() == 5, "Wrong cut value");
     check(ho.minCutValue() == cutValue(ugraph, cap2, cut), "Wrong cut value");
 …
     ho.run();
     ho.minCutMap(cut);
     check(ho.minCutValue() == 5, "Wrong cut value");
     check(ho.minCutValue() == cutValue(ugraph, cap3, cut), "Wrong cut value");

test/heap_test.cc

-                      r749
+                      r1270
  * This file is a part of LEMON, a generic C++ optimization library.
+ *
  * Copyright (C) 2003-2009
+ * Copyright (C) 2003-2013
  * Egervary Jeno Kombinatorikus Optimalizalasi Kutatocsoport
  * (Egervary Research Group on Combinatorial Optimization, EGRES).
 …
 #include <lemon/bin_heap.h>
 #include <lemon/fourary_heap.h>
 #include <lemon/kary_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/binom_heap.h>
+#include <lemon/binomial_heap.h>
 #include <lemon/bucket_heap.h>
 …
+  }
   // FouraryHeap
+  {
     typedef FouraryHeap<Prio, ItemIntMap> IntHeap;
     checkConcept<Heap<Prio, ItemIntMap>, IntHeap>();
     heapSortTest<IntHeap>();
     heapIncreaseTest<IntHeap>();
     typedef FouraryHeap<Prio, IntNodeMap > NodeHeap;
     checkConcept<Heap<Prio, IntNodeMap >, NodeHeap>();
     dijkstraHeapTest<NodeHeap>(digraph, length, source);
+  }
   // KaryHeap
+  {
     typedef KaryHeap<Prio, ItemIntMap> IntHeap;
     checkConcept<Heap<Prio, ItemIntMap>, IntHeap>();
     heapSortTest<IntHeap>();
     heapIncreaseTest<IntHeap>();
     typedef KaryHeap<Prio, IntNodeMap > NodeHeap;
+  // 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);
 …
+  }
   // BinomHeap
+  {
     typedef BinomHeap<Prio, ItemIntMap> IntHeap;
     checkConcept<Heap<Prio, ItemIntMap>, IntHeap>();
     heapSortTest<IntHeap>();
     heapIncreaseTest<IntHeap>();
     typedef BinomHeap<Prio, IntNodeMap > NodeHeap;
+  // 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);
 …
+  }
+  {
+    typedef FibHeap<Prio, ItemIntMap> IntHeap;
+    checkConcept<Heap<Prio, ItemIntMap>, IntHeap>();
+    heapSortTest<IntHeap>();
+    heapIncreaseTest<IntHeap>();
+    typedef FibHeap<Prio, IntNodeMap > NodeHeap;
+    checkConcept<Heap<Prio, IntNodeMap >, NodeHeap>();
+    dijkstraHeapTest<NodeHeap>(digraph, length, source);
+  }
+  {
+    typedef RadixHeap<ItemIntMap> IntHeap;
+    checkConcept<Heap<Prio, ItemIntMap>, IntHeap>();
+    heapSortTest<IntHeap>();
+    heapIncreaseTest<IntHeap>();
+    typedef RadixHeap<IntNodeMap > NodeHeap;
+    checkConcept<Heap<Prio, IntNodeMap >, NodeHeap>();
+    dijkstraHeapTest<NodeHeap>(digraph, length, source);
+  }
+  {
+    typedef BucketHeap<ItemIntMap> IntHeap;
+    checkConcept<Heap<Prio, ItemIntMap>, IntHeap>();
+    heapSortTest<IntHeap>();
+    heapIncreaseTest<IntHeap>();
+    typedef BucketHeap<IntNodeMap > NodeHeap;
+    checkConcept<Heap<Prio, IntNodeMap >, NodeHeap>();
+    dijkstraHeapTest<NodeHeap>(digraph, length, source);
+  }
   return 0;
+}

test/lp_test.cc

-                      r678
+                      r1300
  * This file is a part of LEMON, a generic C++ optimization library.
+ *
  * Copyright (C) 2003-2009
+ * Copyright (C) 2003-2013
  * Egervary Jeno Kombinatorikus Optimalizalasi Kutatocsoport
  * (Egervary Research Group on Combinatorial Optimization, EGRES).
 …
 #endif
+#ifdef LEMON_HAVE_LP
+#include <lemon/lp.h>
+#endif
 using namespace lemon;
+int countCols(LpBase & lp) {
+  int count=0;
+  for (LpBase::ColIt c(lp); c!=INVALID; ++c) ++count;
+  return count;
+}
+int countRows(LpBase & lp) {
+  int count=0;
+  for (LpBase::RowIt r(lp); r!=INVALID; ++r) ++count;
+  return count;
+}
 void lpTest(LpSolver& lp)
 …
   typedef LpSolver LP;
+  // Test LpBase::clear()
+  check(countRows(lp)==0, "Wrong number of rows");
+  check(countCols(lp)==0, "Wrong number of cols");
+  lp.addCol(); lp.addRow(); lp.addRow();
+  check(countRows(lp)==2, "Wrong number of rows");
+  check(countCols(lp)==1, "Wrong number of cols");
+  lp.clear();
+  check(countRows(lp)==0, "Wrong number of rows");
+  check(countCols(lp)==0, "Wrong number of cols");
+  lp.addCol(); lp.addCol(); lp.addCol(); lp.addRow();
+  check(countRows(lp)==1, "Wrong number of rows");
+  check(countCols(lp)==3, "Wrong number of cols");
+  lp.clear();
   std::vector<LP::Col> x(10);
 …
     c = ((2 >= p1) >= 3);
+    { //Tests for #430
+      LP::Col v=lp.addCol();
+      LP::Constr c = v >= -3;
+      c = c <= 4;
+      LP::Constr c2;
+#if ( __GNUC__ == 4 ) && ( __GNUC_MINOR__ == 3 )
+      c2 = ( -3 <= v ) <= 4;
+#else
+      c2 = -3 <= v <= 4;
+#endif
+    }
     e[x[3]]=2;
     e[x[3]]=4;
 …
+  {
     LP::DualExpr e,f,g;
+    LP::Row p1 = INVALID, p2 = INVALID, p3 = INVALID,
+      p4 = INVALID, p5 = INVALID;
+    LP::Row p1 = INVALID, p2 = INVALID;
     e[p1]=2;
 …
   lpTest(lp_skel);
+#ifdef LEMON_HAVE_LP
+  {
+    Lp lp,lp2;
+    lpTest(lp);
+    aTest(lp2);
+    cloneTest<Lp>();
+  }
+#endif
 #ifdef LEMON_HAVE_GLPK
+  {

test/maps_test.cc

-                      r836
+                      r1270
  * This file is a part of LEMON, a generic C++ optimization library.
+ *
  * Copyright (C) 2003-2009
+ * Copyright (C) 2003-2013
  * Egervary Jeno Kombinatorikus Optimalizalasi Kutatocsoport
  * (Egervary Research Group on Combinatorial Optimization, EGRES).
 …
     NullMap<A,B> map1;
     NullMap<A,B> map2 = map1;
+    ::lemon::ignore_unused_variable_warning(map2);
     map1 = nullMap<A,B>();
+  }
 …
     ConstMap<A,B> map2 = B();
     ConstMap<A,B> map3 = map1;
+    ::lemon::ignore_unused_variable_warning(map2,map3);
     map1 = constMap<A>(B());
     map1 = constMap<A,B>();
 …
     ConstMap<A,C> map4(C(1));
     ConstMap<A,C> map5 = map4;
+    ::lemon::ignore_unused_variable_warning(map5);
     map4 = constMap<A>(C(2));
     map4.setAll(C(3));
 …
     IdentityMap<A> map1;
     IdentityMap<A> map2 = map1;
+    ::lemon::ignore_unused_variable_warning(map2);
     map1 = identityMap<A>();
 …
     checkConcept<ReadMap<B,double>, CompMap>();
     CompMap map1 = CompMap(DoubleMap(),ReadMap<B,A>());
+    ::lemon::ignore_unused_variable_warning(map1);
     CompMap map2 = composeMap(DoubleMap(), ReadMap<B,A>());
+    ::lemon::ignore_unused_variable_warning(map2);
     SparseMap<double, bool> m1(false); m1[3.14] = true;
 …
     checkConcept<ReadMap<A,double>, CombMap>();
     CombMap map1 = CombMap(DoubleMap(), DoubleMap());
+    ::lemon::ignore_unused_variable_warning(map1);
     CombMap map2 = combineMap(DoubleMap(), DoubleMap(), std::plus<double>());
+    ::lemon::ignore_unused_variable_warning(map2);
     check(combineMap(constMap<B,int,2>(), identityMap<B>(), &binc)[B()] == 3,
 …
     FunctorToMap<F> map1;
     FunctorToMap<F> map2 = FunctorToMap<F>(F());
+    ::lemon::ignore_unused_variable_warning(map2);
     B b = functorToMap(F())[A()];
+    ::lemon::ignore_unused_variable_warning(b);
     checkConcept<ReadMap<A,B>, MapToFunctor<ReadMap<A,B> > >();
+    MapToFunctor<ReadMap<A,B> > map = MapToFunctor<ReadMap<A,B> >(ReadMap<A,B>());
+    MapToFunctor<ReadMap<A,B> > map =
+      MapToFunctor<ReadMap<A,B> >(ReadMap<A,B>());
+    ::lemon::ignore_unused_variable_warning(map);
     check(functorToMap(&func)[A()] == 3,
 …
       ConvertMap<ReadMap<double, int>, double> >();
     ConvertMap<RangeMap<bool>, int> map1(rangeMap(1, true));
+    ::lemon::ignore_unused_variable_warning(map1);
     ConvertMap<RangeMap<bool>, int> map2 = convertMap<int>(rangeMap(2, false));
+    ::lemon::ignore_unused_variable_warning(map2);
+  }
 …
           it != map2.end(); ++it )
       check(v1[i++] == *it, "Something is wrong with LoggerBoolMap");
     typedef ListDigraph Graph;
     DIGRAPH_TYPEDEFS(Graph);
 …
     Node n2 = gr.addNode();
     Node n3 = gr.addNode();
     gr.addArc(n3, n0);
     gr.addArc(n3, n2);
 …
     gr.addArc(n2, n1);
     gr.addArc(n0, n1);
+    {
       std::vector<Node> v;
 …
       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
+  {
 …
     checkConcept<ReadMap<Node, int>, RangeIdMap<Graph, Node> >();
     checkConcept<ReadMap<Arc, int>, RangeIdMap<Graph, Arc> >();
     Graph gr;
     IdMap<Graph, Node> nmap(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.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[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(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(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> >();
 …
     Node n1 = gr.addNode();
     Node n2 = gr.addNode();
     gr.addEdge(n0,n1);
     gr.addEdge(n1,n2);
 …
     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))),
 …
     typedef Orienter<Graph, const ConstMap<Edge, bool> > Digraph;
+    Digraph dgr(gr, constMap<Edge, bool>(true));
+    ConstMap<Edge, bool> true_edge_map(true);
+    Digraph dgr(gr, true_edge_map);
     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(idm[n0] == 1 && idm[n1] == 3 && idm[n2] == 3, "Wrong InDegMap");
+  }
   // CrossRefMap
+  {
 …
     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.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');
 …
     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');
 …
           it == map.endValue(), "Wrong value iterator");
+  }
   // Iterable bool map
+  {
 …
     const int num = 10;
     Graph g;
+    Ibm map0(g, true);
     std::vector<Item> items;
     for (int i = 0; i < num; ++i) {
 …
     const int num = 10;
     Graph g;
+    Iim map0(g, 0);
     std::vector<Item> items;
     for (int i = 0; i < num; ++i) {
 …
     const int num = 10;
     Graph g;
+    Ivm map0(g, 0.0);
     std::vector<Item> items;
     for (int i = 0; i < num; ++i) {
 …
+  }
   // Graph map utilities:
   // mapMin(), mapMax(), mapMinValue(), mapMaxValue()
 …
     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()");
 …
     Arc a3 = g.addArc(n2, n3);
     Arc a4 = g.addArc(n3, n1);
     map2[a1] = 'b';
     map2[a2] = 'a';
 …
     check(mapCountIf(g, map2, Less<char>('a')) == 0,
           "Wrong mapCountIf()");
     // MapIt, ConstMapIt
 /*
 …
     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));
 …
     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()");
+    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()");
+    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(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<Arc>('z'), map2), "Wrong mapCopy()");
+  }
   return 0;
+}

test/matching_test.cc

-                      r641
+                      r1270
  * This file is a part of LEMON, a generic C++ optimization library.
+ *
  * Copyright (C) 2003-2009
+ * Copyright (C) 2003-2013
  * Egervary Jeno Kombinatorikus Optimalizalasi Kutatocsoport
  * (Egervary Research Group on Combinatorial Optimization, EGRES).
 …
   mat_test.startDense();
   mat_test.run();
   const_mat_test.matchingSize();
   const_mat_test.matching(e);
 …
   const_mat_test.mate(n);
   MaxMatching<Graph>::Status stat =
+  MaxMatching<Graph>::Status stat =
     const_mat_test.status(n);
+  ::lemon::ignore_unused_variable_warning(stat);
   const MaxMatching<Graph>::StatusMap& smap =
     const_mat_test.statusMap();
 …
   mat_test.start();
   mat_test.run();
   const_mat_test.matchingWeight();
   const_mat_test.matchingSize();
 …
   e = mmap[n];
   const_mat_test.mate(n);
   int k = 0;
   const_mat_test.dualValue();
 …
   mat_test.start();
   mat_test.run();
   const_mat_test.matchingWeight();
   const_mat_test.matching(e);
 …
   e = mmap[n];
   const_mat_test.mate(n);
   int k = 0;
   const_mat_test.dualValue();
 …
       edgeMap("weight", weight).run();
+    MaxMatching<SmartGraph> mm(graph);
+    mm.run();
+    checkMatching(graph, mm);
+    MaxWeightedMatching<SmartGraph> mwm(graph, weight);
+    mwm.run();
+    checkWeightedMatching(graph, weight, mwm);
+    MaxWeightedPerfectMatching<SmartGraph> mwpm(graph, weight);
+    bool perfect = mwpm.run();
+    check(perfect == (mm.matchingSize() * 2 == countNodes(graph)),
+          "Perfect matching found");
+    if (perfect) {
+      checkWeightedPerfectMatching(graph, weight, mwpm);
+    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);
+      }
+    }
+  }

test/min_cost_arborescence_test.cc

-                      r672
+                      r1270
  * This file is a part of LEMON, a generic C++ optimization library.
+ *
  * Copyright (C) 2003-2008
+ * Copyright (C) 2003-2013
  * Egervary Jeno Kombinatorikus Optimalizalasi Kutatocsoport
  * (Egervary Research Group on Combinatorial Optimization, EGRES).
 …
   VType c;
   bool b;
+  ::lemon::ignore_unused_variable_warning(c,b);
   int i;
   CostMap cost;
 …
   b = const_mcarb_test.emptyQueue();
   i = const_mcarb_test.queueSize();
   c = const_mcarb_test.arborescenceCost();
   b = const_mcarb_test.arborescence(e);
 …
   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);
+  ::lemon::ignore_unused_variable_warning(am);
+  ::lemon::ignore_unused_variable_warning(pm);
+}

test/min_cost_flow_test.cc

-                      r885
+                      r1318
  * This file is a part of LEMON, a generic C++ optimization library.
+ *
  * Copyright (C) 2003-2009
+ * Copyright (C) 2003-2013
  * Egervary Jeno Kombinatorikus Optimalizalasi Kutatocsoport
  * (Egervary Research Group on Combinatorial Optimization, EGRES).
 …
   "   11     0    0    0    0  -10    0\n"
   "   12   -20  -27    0  -30  -30  -20\n"
   "\n"
+  "\n"
   "@arcs\n"
   "       cost  cap low1 low2 low3\n"
 …
   "6 7     30      0  -1000\n"
   "7 5   -120      0      0\n";
 char test_neg2_lgf[] =
   "@nodes\n"
 …
     void constraints() {
       checkConcept<concepts::Digraph, GR>();
       const Constraints& me = *this;
 …
       const MCF& const_mcf = mcf;
       b = mcf.reset()
+      b = mcf.reset().resetParams()
              .lowerMap(me.lower)
              .upperMap(me.upper)
 …
     typedef concepts::WriteMap<Arc, Value> FlowMap;
     typedef concepts::WriteMap<Node, Cost> PotMap;
     GR g;
     VAM lower;
 …
            typename CM, typename SM, typename FM, typename PM >
 bool checkPotential( const GR& gr, const LM& lower, const UM& upper,
                      const CM& cost, const SM& supply, const FM& flow,
+                     const CM& cost, const SM& supply, const FM& flow,
                      const PM& pi, SupplyType type )
+{
 …
           (red_cost < 0 && flow[e] == upper[e]);
+  }
   for (NodeIt n(gr); opt && n != INVALID; ++n) {
     typename SM::Value sum = 0;
 …
+    }
+  }
   return opt;
+}
 …
+    }
+  }
   for (NodeIt n(gr); n != INVALID; ++n) {
     dual_cost -= red_supply[n] * pi[n];
 …
     dual_cost -= (upper[a] - lower[a]) * std::max(-red_cost, 0);
+  }
   return dual_cost == total;
+}
 …
+{
   MCF mcf1(gr), mcf2(neg1_gr), mcf3(neg2_gr);
   // Basic tests
   mcf1.upperMap(u).costMap(c).supplyMap(s1);
 …
   checkMcf(mcf1, mcf1.run(param), gr, l2, u, c, s2,
            mcf1.OPTIMAL, true,     8010, test_str + "-4");
   mcf1.reset().supplyMap(s1);
+  mcf1.resetParams().supplyMap(s1);
   checkMcf(mcf1, mcf1.run(param), gr, l1, cu, cc, s1,
            mcf1.OPTIMAL, true,       74, test_str + "-5");
 …
   // Tests for the GEQ form
   mcf1.reset().upperMap(u).costMap(c).supplyMap(s5);
+  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);
 …
   checkMcf(mcf2, mcf2.run(param), neg1_gr, neg1_l1, neg1_u2, neg1_c, neg1_s,
            mcf2.OPTIMAL, true,   -40000, test_str + "-14");
   mcf2.reset().lowerMap(neg1_l2).costMap(neg1_c).supplyMap(neg1_s);
+  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");
 …
   checkMcf(mcf3, mcf3.run(param), neg2_gr, neg2_l, neg2_u, neg2_c, neg2_s,
            mcf3.OPTIMAL, true,     -300, test_str + "-18", GEQ);
+  // Tests for empty graph
+  Digraph gr0;
+  MCF mcf0(gr0);
+  mcf0.run(param);
+  check(mcf0.totalCost() == 0, "Wrong total cost");
+}
 …
     .node("target", w)
     .run();
   std::istringstream neg_inp1(test_neg1_lgf);
   DigraphReader<Digraph>(neg1_gr, neg_inp1)
 …
     .nodeMap("sup", neg1_s)
     .run();
   std::istringstream neg_inp2(test_neg2_lgf);
   DigraphReader<Digraph>(neg2_gr, neg_inp2)
 …
     .nodeMap("sup", neg2_s)
     .run();
   // Check the interface of NetworkSimplex
+  {
 …
   // Test NetworkSimplex
+  {
+  {
     typedef NetworkSimplex<Digraph> MCF;
     runMcfGeqTests<MCF>(MCF::FIRST_ELIGIBLE, "NS-FE", true);
 …
     runMcfLeqTests<MCF>(MCF::ALTERING_LIST,  "NS-AL");
+  }
   // Test CapacityScaling
+  {

test/min_mean_cycle_test.cc

-                      r816
+                      r1270
  * This file is a part of LEMON, a generic C++ optimization library.
+ *
  * Copyright (C) 2003-2009
+ * Copyright (C) 2003-2013
  * Egervary Jeno Kombinatorikus Optimalizalasi Kutatocsoport
  * (Egervary Research Group on Combinatorial Optimization, EGRES).
 …
 #include <lemon/concept_check.h>
 #include <lemon/karp.h>
 #include <lemon/hartmann_orlin.h>
 #include <lemon/howard.h>
+#include <lemon/karp_mmc.h>
+#include <lemon/hartmann_orlin_mmc.h>
+#include <lemon/howard_mmc.h>
 #include "test_tools.h"
 …
   "7 7    4    4    4   -1   0  0  0  1\n";
 // Check the interface of an MMC algorithm
 template <typename GR, typename Value>
+template <typename GR, typename Cost>
 struct MmcClassConcept
+{
 …
       typedef typename MMC
         ::template SetPath<ListPath<GR> >
         ::template SetLargeValue<Value>
+        ::template SetLargeCost<Cost>
         ::Create MmcAlg;
       MmcAlg mmc(me.g, me.length);
+      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.findMinMean();
+      b = mmc.findCycleMean();
       b = mmc.findCycle();
       v = const_mmc.cycleLength();
       i = const_mmc.cycleArcNum();
+      v = const_mmc.cycleCost();
+      i = const_mmc.cycleSize();
       d = const_mmc.cycleMean();
       p = const_mmc.cycle();
+    }
     typedef concepts::ReadMap<typename GR::Arc, Value> LM;
+    typedef concepts::ReadMap<typename GR::Arc, Cost> CM;
     GR g;
     LM length;
+    CM cost;
     ListPath<GR> p;
     Value v;
+    Cost v;
     int i;
     double d;
 …
                  const SmartDigraph::ArcMap<int>& lm,
                  const SmartDigraph::ArcMap<int>& cm,
                  int length, int size) {
+                 int cost, int size) {
   MMC alg(gr, lm);
   alg.findMinMean();
   check(alg.cycleMean() == static_cast<double>(length) / size,
+  check(alg.findCycleMean(), "Wrong result");
+  check(alg.cycleMean() == static_cast<double>(cost) / size,
         "Wrong cycle mean");
   alg.findCycle();
   check(alg.cycleLength() == length && alg.cycleArcNum() == size,
+  check(alg.cycleCost() == cost && alg.cycleSize() == size,
         "Wrong path");
   SmartDigraph::ArcMap<int> cycle(gr, 0);
 …
     typedef concepts::Digraph GR;
     // Karp
+    // KarpMmc
     checkConcept< MmcClassConcept<GR, int>,
                   Karp<GR, concepts::ReadMap<GR::Arc, int> > >();
+                  KarpMmc<GR, concepts::ReadMap<GR::Arc, int> > >();
     checkConcept< MmcClassConcept<GR, float>,
                   Karp<GR, concepts::ReadMap<GR::Arc, float> > >();
     // HartmannOrlin
+                  KarpMmc<GR, concepts::ReadMap<GR::Arc, float> > >();
+    // HartmannOrlinMmc
     checkConcept< MmcClassConcept<GR, int>,
                   HartmannOrlin<GR, concepts::ReadMap<GR::Arc, int> > >();
+                  HartmannOrlinMmc<GR, concepts::ReadMap<GR::Arc, int> > >();
     checkConcept< MmcClassConcept<GR, float>,
                   HartmannOrlin<GR, concepts::ReadMap<GR::Arc, float> > >();
     // Howard
+                  HartmannOrlinMmc<GR, concepts::ReadMap<GR::Arc, float> > >();
+    // HowardMmc
     checkConcept< MmcClassConcept<GR, int>,
                   Howard<GR, concepts::ReadMap<GR::Arc, int> > >();
+                  HowardMmc<GR, concepts::ReadMap<GR::Arc, int> > >();
     checkConcept< MmcClassConcept<GR, float>,
                   Howard<GR, concepts::ReadMap<GR::Arc, float> > >();
     if (IsSameType<Howard<GR, concepts::ReadMap<GR::Arc, int> >::LargeValue,
           long_int>::result == 0) check(false, "Wrong LargeValue type");
     if (IsSameType<Howard<GR, concepts::ReadMap<GR::Arc, float> >::LargeValue,
           double>::result == 0) check(false, "Wrong LargeValue type");
+                  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");
+  }
 …
     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).
 …
     // Karp
     checkMmcAlg<Karp<GR, IntArcMap> >(gr, l1, c1,  6, 3);
     checkMmcAlg<Karp<GR, IntArcMap> >(gr, l2, c2,  5, 2);
     checkMmcAlg<Karp<GR, IntArcMap> >(gr, l3, c3,  0, 1);
     checkMmcAlg<Karp<GR, IntArcMap> >(gr, l4, c4, -1, 1);
+    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<HartmannOrlin<GR, IntArcMap> >(gr, l1, c1,  6, 3);
     checkMmcAlg<HartmannOrlin<GR, IntArcMap> >(gr, l2, c2,  5, 2);
     checkMmcAlg<HartmannOrlin<GR, IntArcMap> >(gr, l3, c3,  0, 1);
     checkMmcAlg<HartmannOrlin<GR, IntArcMap> >(gr, l4, c4, -1, 1);
+    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<Howard<GR, IntArcMap> >(gr, l1, c1,  6, 3);
+    checkMmcAlg<Howard<GR, IntArcMap> >(gr, l2, c2,  5, 2);
+    checkMmcAlg<Howard<GR, IntArcMap> >(gr, l3, c3,  0, 1);
+    checkMmcAlg<Howard<GR, IntArcMap> >(gr, l4, c4, -1, 1);
+    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);
+    // Howard with iteration limit
+    HowardMmc<GR, IntArcMap> mmc(gr, l1);
+    check((mmc.findCycleMean(2) == HowardMmc<GR, IntArcMap>::ITERATION_LIMIT),
+      "Wrong termination cause");
+    check((mmc.findCycleMean(4) == HowardMmc<GR, IntArcMap>::OPTIMAL),
+      "Wrong termination cause");
+  }

test/mip_test.cc

-                      r795
+                      r1300
 #ifdef LEMON_HAVE_CBC
 #include <lemon/cbc.h>
+#endif
+#ifdef LEMON_HAVE_MIP
+#include <lemon/lp.h>
 #endif
 …
+{
+#ifdef LEMON_HAVE_MIP
+  {
+    Mip mip1;
+    aTest(mip1);
+    cloneTest<Mip>();
+  }
+#endif
 #ifdef LEMON_HAVE_GLPK
+  {

test/path_test.cc

-                      r463
+                      r1270
  * This file is a part of LEMON, a generic C++ optimization library.
+ *
  * Copyright (C) 2003-2009
+ * Copyright (C) 2003-2013
  * Egervary Jeno Kombinatorikus Optimalizalasi Kutatocsoport
  * (Egervary Research Group on Combinatorial Optimization, EGRES).
 …
 #include <lemon/concepts/path.h>
 #include <lemon/concepts/digraph.h>
+#include <lemon/concept_check.h>
 #include <lemon/path.h>
 …
 using namespace lemon;
+void check_concepts() {
+  checkConcept<concepts::Path<ListDigraph>, concepts::Path<ListDigraph> >();
+  checkConcept<concepts::Path<ListDigraph>, Path<ListDigraph> >();
+  checkConcept<concepts::Path<ListDigraph>, SimplePath<ListDigraph> >();
+  checkConcept<concepts::Path<ListDigraph>, StaticPath<ListDigraph> >();
+  checkConcept<concepts::Path<ListDigraph>, ListPath<ListDigraph> >();
+}
+template <typename GR>
+void checkConcepts() {
+  checkConcept<concepts::Path<GR>, concepts::Path<GR> >();
+  checkConcept<concepts::Path<GR>, Path<GR> >();
+  checkConcept<concepts::Path<GR>, SimplePath<GR> >();
+  checkConcept<concepts::Path<GR>, StaticPath<GR> >();
+  checkConcept<concepts::Path<GR>, ListPath<GR> >();
+}
+// Conecpt checking for path structures
+void checkPathConcepts() {
+  checkConcepts<concepts::Digraph>();
+  checkConcepts<ListDigraph>();
+}
+// Check if proper copy consructor is called (use valgrind for testing)
+template <typename GR, typename P1, typename P2>
+void checkCopy(typename GR::Arc a) {
+  P1 p;
+  p.addBack(a);
+  P1 q;
+  q = p;
+  P1 r(p);
+  P2 q2;
+  q2 = p;
+  P2 r2(p);
+}
+// Tests for copy constructors and assignment operators of paths
+void checkPathCopy() {
+  ListDigraph g;
+  ListDigraph::Arc a = g.addArc(g.addNode(), g.addNode());
+  typedef Path<ListDigraph> Path1;
+  typedef SimplePath<ListDigraph> Path2;
+  typedef ListPath<ListDigraph> Path3;
+  typedef StaticPath<ListDigraph> Path4;
+  checkCopy<ListDigraph, Path1, Path2>(a);
+  checkCopy<ListDigraph, Path1, Path3>(a);
+  checkCopy<ListDigraph, Path1, Path4>(a);
+  checkCopy<ListDigraph, Path2, Path1>(a);
+  checkCopy<ListDigraph, Path2, Path3>(a);
+  checkCopy<ListDigraph, Path2, Path4>(a);
+  checkCopy<ListDigraph, Path3, Path1>(a);
+  checkCopy<ListDigraph, Path3, Path2>(a);
+  checkCopy<ListDigraph, Path3, Path4>(a);
+}
+// Class for testing path functions
+class CheckPathFunctions {
+  typedef ListDigraph GR;
+  DIGRAPH_TYPEDEFS(GR);
+  GR gr;
+  const GR& cgr;
+  Node n1, n2, n3, n4;
+  Node tmp_n;
+  Arc a1, a2, a3, a4;
+  Arc tmp_a;
+public:
+  CheckPathFunctions() : cgr(gr) {
+    n1 = gr.addNode();
+    n2 = gr.addNode();
+    n3 = gr.addNode();
+    n4 = gr.addNode();
+    a1 = gr.addArc(n1, n2);
+    a2 = gr.addArc(n2, n3);
+    a3 = gr.addArc(n3, n4);
+    a4 = gr.addArc(n4, n1);
+  }
+  void run() {
+    checkBackAndFrontInsertablePath<Path<GR> >();
+    checkBackAndFrontInsertablePath<ListPath<GR> >();
+    checkBackInsertablePath<SimplePath<GR> >();
+    checkListPathSplitAndSplice();
+  }
+private:
+  template <typename P>
+  void checkBackInsertablePath() {
+    // Create and check empty path
+    P p;
+    const P& cp = p;
+    check(cp.empty(), "The path is not empty");
+    check(cp.length() == 0, "The path is not empty");
+//    check(cp.front() == INVALID, "Wrong front()");
+//    check(cp.back() == INVALID, "Wrong back()");
+    typename P::ArcIt ai(cp);
+    check(ai == INVALID, "Wrong ArcIt");
+    check(pathSource(cgr, cp) == INVALID, "Wrong pathSource()");
+    check(pathTarget(cgr, cp) == INVALID, "Wrong pathTarget()");
+    check(checkPath(cgr, cp), "Wrong checkPath()");
+    PathNodeIt<P> ni(cgr, cp);
+    check(ni == INVALID, "Wrong PathNodeIt");
+    // Check single-arc path
+    p.addBack(a1);
+    check(!cp.empty(), "Wrong empty()");
+    check(cp.length() == 1, "Wrong length");
+    check(cp.front() == a1, "Wrong front()");
+    check(cp.back() == a1, "Wrong back()");
+    check(cp.nth(0) == a1, "Wrong nth()");
+    ai = cp.nthIt(0);
+    check((tmp_a = ai) == a1, "Wrong nthIt()");
+    check(++ai == INVALID, "Wrong nthIt()");
+    typename P::ArcIt ai2(cp);
+    check((tmp_a = ai2) == a1, "Wrong ArcIt");
+    check(++ai2 == INVALID, "Wrong ArcIt");
+    check(pathSource(cgr, cp) == n1, "Wrong pathSource()");
+    check(pathTarget(cgr, cp) == n2, "Wrong pathTarget()");
+    check(checkPath(cgr, cp), "Wrong checkPath()");
+    PathNodeIt<P> ni2(cgr, cp);
+    check((tmp_n = ni2) == n1, "Wrong PathNodeIt");
+    check((tmp_n = ++ni2) == n2, "Wrong PathNodeIt");
+    check(++ni2 == INVALID, "Wrong PathNodeIt");
+    // Check adding more arcs
+    p.addBack(a2);
+    p.addBack(a3);
+    check(!cp.empty(), "Wrong empty()");
+    check(cp.length() == 3, "Wrong length");
+    check(cp.front() == a1, "Wrong front()");
+    check(cp.back() == a3, "Wrong back()");
+    check(cp.nth(0) == a1, "Wrong nth()");
+    check(cp.nth(1) == a2, "Wrong nth()");
+    check(cp.nth(2) == a3, "Wrong nth()");
+    typename P::ArcIt ai3(cp);
+    check((tmp_a = ai3) == a1, "Wrong ArcIt");
+    check((tmp_a = ++ai3) == a2, "Wrong nthIt()");
+    check((tmp_a = ++ai3) == a3, "Wrong nthIt()");
+    check(++ai3 == INVALID, "Wrong nthIt()");
+    ai = cp.nthIt(0);
+    check((tmp_a = ai) == a1, "Wrong nthIt()");
+    check((tmp_a = ++ai) == a2, "Wrong nthIt()");
+    ai = cp.nthIt(2);
+    check((tmp_a = ai) == a3, "Wrong nthIt()");
+    check(++ai == INVALID, "Wrong nthIt()");
+    check(pathSource(cgr, cp) == n1, "Wrong pathSource()");
+    check(pathTarget(cgr, cp) == n4, "Wrong pathTarget()");
+    check(checkPath(cgr, cp), "Wrong checkPath()");
+    PathNodeIt<P> ni3(cgr, cp);
+    check((tmp_n = ni3) == n1, "Wrong PathNodeIt");
+    check((tmp_n = ++ni3) == n2, "Wrong PathNodeIt");
+    check((tmp_n = ++ni3) == n3, "Wrong PathNodeIt");
+    check((tmp_n = ++ni3) == n4, "Wrong PathNodeIt");
+    check(++ni3 == INVALID, "Wrong PathNodeIt");
+    // Check arc removal and addition
+    p.eraseBack();
+    p.eraseBack();
+    p.addBack(a2);
+    check(!cp.empty(), "Wrong empty()");
+    check(cp.length() == 2, "Wrong length");
+    check(cp.front() == a1, "Wrong front()");
+    check(cp.back() == a2, "Wrong back()");
+    check(pathSource(cgr, cp) == n1, "Wrong pathSource()");
+    check(pathTarget(cgr, cp) == n3, "Wrong pathTarget()");
+    check(checkPath(cgr, cp), "Wrong checkPath()");
+    // Check clear()
+    p.clear();
+    check(cp.empty(), "The path is not empty");
+    check(cp.length() == 0, "The path is not empty");
+    // Check inconsistent path
+    p.addBack(a4);
+    p.addBack(a2);
+    p.addBack(a1);
+    check(!cp.empty(), "Wrong empty()");
+    check(cp.length() == 3, "Wrong length");
+    check(cp.front() == a4, "Wrong front()");
+    check(cp.back() == a1, "Wrong back()");
+    check(pathSource(cgr, cp) == n4, "Wrong pathSource()");
+    check(pathTarget(cgr, cp) == n2, "Wrong pathTarget()");
+    check(!checkPath(cgr, cp), "Wrong checkPath()");
+  }
+  template <typename P>
+  void checkBackAndFrontInsertablePath() {
+    // Include back insertable test cases
+    checkBackInsertablePath<P>();
+    // Check front and back insertion
+    P p;
+    const P& cp = p;
+    p.addFront(a4);
+    p.addBack(a1);
+    p.addFront(a3);
+    check(!cp.empty(), "Wrong empty()");
+    check(cp.length() == 3, "Wrong length");
+    check(cp.front() == a3, "Wrong front()");
+    check(cp.back() == a1, "Wrong back()");
+    check(cp.nth(0) == a3, "Wrong nth()");
+    check(cp.nth(1) == a4, "Wrong nth()");
+    check(cp.nth(2) == a1, "Wrong nth()");
+    typename P::ArcIt ai(cp);
+    check((tmp_a = ai) == a3, "Wrong ArcIt");
+    check((tmp_a = ++ai) == a4, "Wrong nthIt()");
+    check((tmp_a = ++ai) == a1, "Wrong nthIt()");
+    check(++ai == INVALID, "Wrong nthIt()");
+    ai = cp.nthIt(0);
+    check((tmp_a = ai) == a3, "Wrong nthIt()");
+    check((tmp_a = ++ai) == a4, "Wrong nthIt()");
+    ai = cp.nthIt(2);
+    check((tmp_a = ai) == a1, "Wrong nthIt()");
+    check(++ai == INVALID, "Wrong nthIt()");
+    check(pathSource(cgr, cp) == n3, "Wrong pathSource()");
+    check(pathTarget(cgr, cp) == n2, "Wrong pathTarget()");
+    check(checkPath(cgr, cp), "Wrong checkPath()");
+    // Check eraseFront()
+    p.eraseFront();
+    p.addBack(a2);
+    check(!cp.empty(), "Wrong empty()");
+    check(cp.length() == 3, "Wrong length");
+    check(cp.front() == a4, "Wrong front()");
+    check(cp.back() == a2, "Wrong back()");
+    check(cp.nth(0) == a4, "Wrong nth()");
+    check(cp.nth(1) == a1, "Wrong nth()");
+    check(cp.nth(2) == a2, "Wrong nth()");
+    typename P::ArcIt ai2(cp);
+    check((tmp_a = ai2) == a4, "Wrong ArcIt");
+    check((tmp_a = ++ai2) == a1, "Wrong nthIt()");
+    check((tmp_a = ++ai2) == a2, "Wrong nthIt()");
+    check(++ai2 == INVALID, "Wrong nthIt()");
+    ai = cp.nthIt(0);
+    check((tmp_a = ai) == a4, "Wrong nthIt()");
+    check((tmp_a = ++ai) == a1, "Wrong nthIt()");
+    ai = cp.nthIt(2);
+    check((tmp_a = ai) == a2, "Wrong nthIt()");
+    check(++ai == INVALID, "Wrong nthIt()");
+    check(pathSource(cgr, cp) == n4, "Wrong pathSource()");
+    check(pathTarget(cgr, cp) == n3, "Wrong pathTarget()");
+    check(checkPath(cgr, cp), "Wrong checkPath()");
+  }
+  void checkListPathSplitAndSplice() {
+    // Build a path with spliceFront() and spliceBack()
+    ListPath<GR> p1, p2, p3, p4;
+    p1.addBack(a3);
+    p1.addFront(a2);
+    p2.addBack(a1);
+    p1.spliceFront(p2);
+    p3.addFront(a4);
+    p1.spliceBack(p3);
+    check(p1.length() == 4, "Wrong length");
+    check(p1.front() == a1, "Wrong front()");
+    check(p1.back() == a4, "Wrong back()");
+    ListPath<GR>::ArcIt ai(p1);
+    check((tmp_a = ai) == a1, "Wrong ArcIt");
+    check((tmp_a = ++ai) == a2, "Wrong nthIt()");
+    check((tmp_a = ++ai) == a3, "Wrong nthIt()");
+    check((tmp_a = ++ai) == a4, "Wrong nthIt()");
+    check(++ai == INVALID, "Wrong nthIt()");
+    check(checkPath(cgr, p1), "Wrong checkPath()");
+    // Check split()
+    p1.split(p1.nthIt(2), p2);
+    check(p1.length() == 2, "Wrong length");
+    ai = p1.nthIt(0);
+    check((tmp_a = ai) == a1, "Wrong ArcIt");
+    check((tmp_a = ++ai) == a2, "Wrong nthIt()");
+    check(++ai == INVALID, "Wrong nthIt()");
+    check(checkPath(cgr, p1), "Wrong checkPath()");
+    check(p2.length() == 2, "Wrong length");
+    ai = p2.nthIt(0);
+    check((tmp_a = ai) == a3, "Wrong ArcIt");
+    check((tmp_a = ++ai) == a4, "Wrong nthIt()");
+    check(++ai == INVALID, "Wrong nthIt()");
+    check(checkPath(cgr, p2), "Wrong checkPath()");
+    // Check split() and splice()
+    p1.spliceFront(p2);
+    p1.split(p1.nthIt(2), p2);
+    p2.split(p2.nthIt(1), p3);
+    p2.spliceBack(p1);
+    p2.splice(p2.nthIt(1), p3);
+    check(p2.length() == 4, "Wrong length");
+    check(p2.front() == a1, "Wrong front()");
+    check(p2.back() == a4, "Wrong back()");
+    ai = p2.nthIt(0);
+    check((tmp_a = ai) == a1, "Wrong ArcIt");
+    check((tmp_a = ++ai) == a2, "Wrong nthIt()");
+    check((tmp_a = ++ai) == a3, "Wrong nthIt()");
+    check((tmp_a = ++ai) == a4, "Wrong nthIt()");
+    check(++ai == INVALID, "Wrong nthIt()");
+    check(checkPath(cgr, p2), "Wrong checkPath()");
+  }
+};
 int main() {
+  check_concepts();
+  checkPathConcepts();
+  checkPathCopy();
+  CheckPathFunctions cpf;
+  cpf.run();
   return 0;
+}

test/radix_sort_test.cc

-                      r467
+                      r1341
  * This file is a part of LEMON, a generic C++ optimization library.
+ *
  * Copyright (C) 2003-2009
+ * Copyright (C) 2003-2013
  * Egervary Jeno Kombinatorikus Optimalizalasi Kutatocsoport
  * (Egervary Research Group on Combinatorial Optimization, EGRES).
 …
+ *
  */
+#include <lemon/core.h>
 #include <lemon/time_measure.h>
 …
 #include <vector>
+#include <list>
 #include <algorithm>
 …
 int negate(int a) { return - a; }
+void generateIntSequence(int n, std::vector<int>& data) {
+template<class T>
+bool isTheSame(T &a, T&b)
+{
+  typename T::iterator ai=a.begin();
+  typename T::iterator bi=b.begin();
+  for(;ai!=a.end()||bi!=b.end();++ai,++bi)
+    if(*ai!=*bi) return false;
+  return ai==a.end()&&bi==b.end();
+}
+template<class T>
+T listsort(typename T::iterator b, typename T::iterator e)
+{
+  if(b==e) return T();
+  typename T::iterator bn=b;
+  if(++bn==e) {
+    T l;
+    l.push_back(*b);
+    return l;
+  }
+  typename T::iterator m=b;
+  bool x=false;
+  for(typename T::iterator i=b;i!=e;++i,x=!x)
+    if(x) ++m;
+  T l1(listsort<T>(b,m));
+  T l2(listsort<T>(m,e));
+  T l;
+  while((!l1.empty())&&(!l2.empty()))
+    if(l1.front()<=l2.front())
+      {
+        l.push_back(l1.front());
+        l1.pop_front();
+      }
+    else {
+      l.push_back(l2.front());
+      l2.pop_front();
+    }
+  while(!l1.empty())
+    {
+      l.push_back(l1.front());
+      l1.pop_front();
+    }
+  while(!l2.empty())
+    {
+      l.push_back(l2.front());
+      l2.pop_front();
+    }
+  return l;
+}
+template<class T>
+void generateIntSequence(int n, T & data) {
   int prime = 9973;
   int root = 136, value = 1;
 …
+}
+void generateCharSequence(int n, std::vector<unsigned char>& data) {
+template<class T>
+void generateCharSequence(int n, T & data) {
   int prime = 251;
   int root = 3, value = root;
 …
+    }
+    radixSort(data2.begin(), data2.end(), Negate());
+    // 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");
+    }
+  }
+  {
+    std::list<int> data1;
+    generateIntSequence(n, data1);
+    std::list<int> data2(listsort<std::list<int> >(data1.begin(), data1.end()));
+    radixSort(data1.begin(), data1.end());
+    check(isTheSame(data1,data2), "Test failed");
+    // radixSort(data2.begin(), data2.end(), Negate());
+    // check(isTheSame(data1,data2), "Test failed");
+    // 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::list<unsigned char> data1(n);
+    generateCharSequence(n, data1);
+    std::list<unsigned char> data2(listsort<std::list<unsigned char> >
+                                   (data1.begin(),
+                                    data1.end()));
+    radixSort(data1.begin(), data1.end());
+    check(isTheSame(data1,data2), "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");
+    }
     radixSort(data2.begin(), data2.end(), negate);
+    stableRadixSort(data2.begin(), data2.end(), negate);
     for (int i = 0; i < n; ++i) {
       check(data1[i] == data2[n - 1 - 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");
+    }
+  {
+    std::list<int> data1;
+    generateIntSequence(n, data1);
+    std::list<int> data2(listsort<std::list<int> >(data1.begin(),
+                                                   data1.end()));
+    stableRadixSort(data1.begin(), data1.end());
+    check(isTheSame(data1,data2), "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::list<unsigned char> data1(n);
+    generateCharSequence(n, data1);
+    std::list<unsigned char> data2(listsort<std::list<unsigned char> >
+                                   (data1.begin(),
+                                    data1.end()));
+    radixSort(data1.begin(), data1.end());
+    check(isTheSame(data1,data2), "Test failed");
+  }

test/suurballe_test.cc

-                      r670
+                      r1270
  * This file is a part of LEMON, a generic C++ optimization library.
+ *
  * Copyright (C) 2003-2009
+ * Copyright (C) 2003-2013
  * Egervary Jeno Kombinatorikus Optimalizalasi Kutatocsoport
  * (Egervary Research Group on Combinatorial Optimization, EGRES).
 …
 #include <lemon/suurballe.h>
 #include <lemon/concepts/digraph.h>
+#include <lemon/concepts/heap.h>
 #include "test_tools.h"
 …
   typedef Digraph::Arc Arc;
   typedef concepts::ReadMap<Arc, VType> LengthMap;
+  typedef Suurballe<Digraph, LengthMap> SuurballeType;
+  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;
 …
   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;
+  ::lemon::ignore_unused_variable_warning(f,c);
   c = const_suurb_test.totalLength();
   f = const_suurb_test.flow(e);
 …
   k = const_suurb_test.pathNum();
   Path<Digraph> p = const_suurb_test.path(k);
   ignore_unused_variable_warning(fm);
   ignore_unused_variable_warning(pm);
+  ::lemon::ignore_unused_variable_warning(fm);
+  ::lemon::ignore_unused_variable_warning(pm);
+}
 …
     run();
   // Find 2 paths
+  // 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),
 …
     for (int i = 0; i < suurballe.pathNum(); ++i)
       check(checkPath(digraph, suurballe.path(i), s, t), "Wrong path");
+  }
+  // Find 3 paths
+  {
+    Suurballe<ListDigraph> suurballe(digraph, length);
+    // Find 3 paths
     check(suurballe.run(s, t, 3) == 3, "Wrong number of paths");
     check(checkFlow(digraph, suurballe.flowMap(), s, t, 3),
 …
     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)
+  {
+    Suurballe<ListDigraph> suurballe(digraph, length);
+    // 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),
 …
+  }
+  // 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;
+}

test/test_tools.h

-                      r810
+                      r956
  * This file is a part of LEMON, a generic C++ optimization library.
+ *
  * Copyright (C) 2003-2009
+ * Copyright (C) 2003-2010
  * Egervary Jeno Kombinatorikus Optimalizalasi Kutatocsoport
  * (Egervary Research Group on Combinatorial Optimization, EGRES).
 …
     } else { }                                                          \
   }                                                                     \
 #endif

test/time_measure_test.cc

-                      r605
+                      r1270
  * This file is a part of LEMON, a generic C++ optimization library.
+ *
  * Copyright (C) 2003-2009
+ * Copyright (C) 2003-2013
  * Egervary Jeno Kombinatorikus Optimalizalasi Kutatocsoport
  * (Egervary Research Group on Combinatorial Optimization, EGRES).
 …
 #include <lemon/time_measure.h>
+#include <lemon/concept_check.h>
 using namespace lemon;
 …
   for(int i=0;i<1000;i++)
+    TimeStamp x(T);
+    {
+      TimeStamp x(T);
+      ::lemon::ignore_unused_variable_warning(x);
+    }
+}

tools/dimacs-solver.cc

-                      r691
+                      r1271
  * This file is a part of LEMON, a generic C++ optimization library.
+ *
  * Copyright (C) 2003-2009
+ * Copyright (C) 2003-2013
  * Egervary Jeno Kombinatorikus Optimalizalasi Kutatocsoport
  * (Egervary Research Group on Combinatorial Optimization, EGRES).
 …
   pre.run();
   if(report) std::cerr << "Run Preflow: " << ti << '\n';
   if(report) std::cerr << "\nMax flow value: " << pre.flowValue() << '\n';
+}
 template<class Value>
+  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)
 …
   if (report) std::cerr << "Read the file: " << ti << '\n';
+  ti.restart();
+  NetworkSimplex<Digraph, Value> ns(g);
+  typedef NetworkSimplex<Digraph, Value> MCF;
+  ti.restart();
+  MCF 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();
+  typename MCF::ProblemType 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.totalCost() << '\n';
+    std::cerr << "Feasible flow: " << (res == MCF::OPTIMAL ? "found" :
+                                       "not found") << '\n';
+    if (res) std::cerr << "Min flow cost: "
+                       << ns.template totalCost<LargeValue>() << '\n';
+  }
+}
 …
   if(report) std::cerr << "Run MaxMatching: " << ti << '\n';
   if(report) std::cerr << "\nCardinality of max matching: "
                        << mat.matchingSize() << '\n';
+}
 template<class Value>
+                       << mat.matchingSize() << '\n';
+}
+template<class Value, class LargeValue>
 void solve(ArgParser &ap, std::istream &is, std::ostream &os,
            DimacsDescriptor &desc)
 …
       exit(1);
+    }
   switch(desc.type)
+    {
     case DimacsDescriptor::MIN:
       solve_min<Value>(ap,is,os,infty,desc);
+      solve_min<Value, LargeValue>(ap,is,os,infty,desc);
       break;
     case DimacsDescriptor::MAX:
 …
 int main(int argc, const char *argv[]) {
-  typedef SmartDigraph Digraph;
-  typedef Digraph::Arc Arc;
   std::string inputName;
 …
   DimacsDescriptor desc = dimacsType(is);
   if(!ap.given("q"))
+    {
 …
       std::cout << "\n\n";
+    }
   if(ap.given("double"))
     solve<double>(ap,is,os,desc);
+    solve<double, double>(ap,is,os,desc);
   else if(ap.given("ldouble"))
     solve<long double>(ap,is,os,desc);
+    solve<long double, long double>(ap,is,os,desc);
 #ifdef LEMON_HAVE_LONG_LONG
   else if(ap.given("long"))
+    solve<long long>(ap,is,os,desc);
+    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
-  else solve<int>(ap,is,os,desc);
   return 0;

tools/lgf-gen.cc

-                      r701
+                      r1308
   struct BeachIt;
   typedef std::multimap<double, BeachIt> SpikeHeap;
+  typedef std::multimap<double, BeachIt*> SpikeHeap;
   typedef std::multimap<Part, SpikeHeap::iterator, YLess> Beach;
 …
       if (bit->second != spikeheap.end()) {
+        delete bit->second->second;
         spikeheap.erase(bit->second);
+      }
 …
           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 =
+        pit = spikeheap.insert(std::make_pair(x, new BeachIt(beach.end())));
+        pit->second->it =
           beach.insert(std::make_pair(Part(prev, curr, site), pit));
       } else {
 …
           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 =
+        nit = spikeheap.insert(std::make_pair(x, new BeachIt(beach.end())));
+        nit->second->it =
           beach.insert(std::make_pair(Part(site, curr, next), nit));
       } else {
 …
       sweep = spit->first;
       Beach::iterator bit = spit->second.it;
+      Beach::iterator bit = spit->second->it;
       int prev = bit->first.prev;
 …
       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);
+      if (bit->second != spikeheap.end())
+        {
+          delete bit->second->second;
+          spikeheap.erase(bit->second);
+        }
+      if (pbit->second != spikeheap.end())
+        {
+          delete pbit->second->second;
+          spikeheap.erase(pbit->second);
+        }
+      if (nbit->second != spikeheap.end())
+        {
+          delete nbit->second->second;
+          spikeheap.erase(nbit->second);
+        }
       beach.erase(nbit);
       beach.erase(bit);
 …
         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 =
+        pit = spikeheap.insert(std::make_pair(x, new BeachIt(beach.end())));
+        pit->second->it =
           beach.insert(std::make_pair(Part(ppv, prev, next), pit));
       } else {
 …
         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 =
+        nit = spikeheap.insert(std::make_pair(x, new BeachIt(beach.end())));
+        nit->second->it =
           beach.insert(std::make_pair(Part(prev, next, nnt), nit));
       } else {

Context Navigation

Changes in / [1362:43647f48e971:1363:a7d841273c68] in lemon

Legend:

Download in other formats: