Index: .hgignore =================================================================== --- .hgignore (revision 866) +++ .hgignore (revision 563) @@ -23,5 +23,4 @@ lemon/stamp-h2 doc/Doxyfile -doc/references.dox cmake/version.cmake .dirstamp Index: AUTHORS =================================================================== --- AUTHORS (revision 992) +++ AUTHORS (revision 951) @@ -1,3 +1,3 @@ -The main developers of release series 1.x are +The authors of the 1.x series are * Balazs Dezso @@ -6,9 +6,9 @@ * Akos Ladanyi -For more complete list of contributors, please visit the history of -the LEMON source code repository: http://lemon.cs.elte.hu/hg/lemon +For more details on the actual contribution, please visit the history +of the main LEMON source repository: http://lemon.cs.elte.hu/hg/lemon -Moreover, this version is heavily based on version 0.x of LEMON. Here -is the list of people who contributed to those versions. +Moreover, this version is heavily based on the 0.x series of +LEMON. Here is the list of people who contributed to those versions. * Mihaly Barasz Index: CMakeLists.txt =================================================================== --- CMakeLists.txt (revision 1000) +++ CMakeLists.txt (revision 975) @@ -13,45 +13,27 @@ ELSE() EXECUTE_PROCESS( - COMMAND - hg log -r. --template "{latesttag}" + COMMAND ${PYTHON_EXECUTABLE} ./scripts/chg-len.py WORKING_DIRECTORY ${PROJECT_SOURCE_DIR} - OUTPUT_VARIABLE HG_REVISION_TAG + OUTPUT_VARIABLE HG_REVISION_PATH ERROR_QUIET OUTPUT_STRIP_TRAILING_WHITESPACE ) EXECUTE_PROCESS( - COMMAND - hg log -r. --template "{latesttagdistance}" + COMMAND hg id -i WORKING_DIRECTORY ${PROJECT_SOURCE_DIR} - OUTPUT_VARIABLE HG_REVISION_DIST + OUTPUT_VARIABLE HG_REVISION ERROR_QUIET OUTPUT_STRIP_TRAILING_WHITESPACE ) - EXECUTE_PROCESS( - COMMAND - hg log -r. --template "{node|short}" - WORKING_DIRECTORY ${PROJECT_SOURCE_DIR} - OUTPUT_VARIABLE HG_REVISION_ID - ERROR_QUIET - OUTPUT_STRIP_TRAILING_WHITESPACE - ) - - IF(HG_REVISION_TAG STREQUAL "") + IF(HG_REVISION STREQUAL "") SET(HG_REVISION_ID "hg-tip") ELSE() - IF(HG_REVISION_TAG STREQUAL "null") - SET(HG_REVISION_TAG "trunk") - ELSEIF(HG_REVISION_TAG MATCHES "^r") - STRING(SUBSTRING ${HG_REVISION_TAG} 1 -1 HG_REVISION_TAG) - ENDIF() - IF(HG_REVISION_DIST STREQUAL "0") - SET(HG_REVISION ${HG_REVISION_TAG}) + IF(HG_REVISION_PATH STREQUAL "") + SET(HG_REVISION_ID ${HG_REVISION}) ELSE() - SET(HG_REVISION - "${HG_REVISION_TAG}+${HG_REVISION_DIST}-${HG_REVISION_ID}") + SET(HG_REVISION_ID ${HG_REVISION_PATH}.${HG_REVISION}) ENDIF() ENDIF() - - SET(LEMON_VERSION ${HG_REVISION} CACHE STRING "LEMON version string.") + SET(LEMON_VERSION ${HG_REVISION_ID} CACHE STRING "LEMON version string.") ENDIF() @@ -133,26 +115,4 @@ SET(LEMON_HAVE_LONG_LONG ${HAVE_LONG_LONG}) -INCLUDE(FindThreads) - -IF(NOT LEMON_THREADING) - IF(CMAKE_USE_PTHREADS_INIT) - SET(LEMON_THREADING "Pthread") - ELSEIF(CMAKE_USE_WIN32_THREADS_INIT) - SET(LEMON_THREADING "Win32") - ELSE() - SET(LEMON_THREADING "None") - ENDIF() -ENDIF() - -SET( LEMON_THREADING "${LEMON_THREADING}" CACHE STRING - "Choose the threading library, options are: Pthread Win32 None." - FORCE ) - -IF(LEMON_THREADING STREQUAL "Pthread") - SET(LEMON_USE_PTHREAD TRUE) -ELSEIF(LEMON_THREADING STREQUAL "Win32") - SET(LEMON_USE_WIN32_THREADS TRUE) -ENDIF() - ENABLE_TESTING() @@ -165,5 +125,4 @@ ADD_SUBDIRECTORY(lemon) IF(${CMAKE_SOURCE_DIR} STREQUAL ${PROJECT_SOURCE_DIR}) - ADD_SUBDIRECTORY(contrib) ADD_SUBDIRECTORY(demo) ADD_SUBDIRECTORY(tools) @@ -189,31 +148,4 @@ ENDIF() -CONFIGURE_FILE( - ${PROJECT_SOURCE_DIR}/cmake/version.cmake.in - ${PROJECT_BINARY_DIR}/cmake/version.cmake - @ONLY -) - -SET(ARCHIVE_BASE_NAME ${CMAKE_PROJECT_NAME}) -STRING(TOLOWER ${ARCHIVE_BASE_NAME} ARCHIVE_BASE_NAME) -SET(ARCHIVE_NAME ${ARCHIVE_BASE_NAME}-${PROJECT_VERSION}) -ADD_CUSTOM_TARGET(dist - COMMAND cmake -E remove_directory ${ARCHIVE_NAME} - COMMAND hg archive ${ARCHIVE_NAME} - COMMAND cmake -E copy cmake/version.cmake ${ARCHIVE_NAME}/cmake/version.cmake - COMMAND tar -czf ${ARCHIVE_BASE_NAME}-nodoc-${PROJECT_VERSION}.tar.gz ${ARCHIVE_NAME} - COMMAND zip -r ${ARCHIVE_BASE_NAME}-nodoc-${PROJECT_VERSION}.zip ${ARCHIVE_NAME} - COMMAND cmake -E copy_directory doc/html ${ARCHIVE_NAME}/doc/html - COMMAND tar -czf ${ARCHIVE_NAME}.tar.gz ${ARCHIVE_NAME} - COMMAND zip -r ${ARCHIVE_NAME}.zip ${ARCHIVE_NAME} - COMMAND cmake -E copy_directory doc/html ${ARCHIVE_BASE_NAME}-doc-${PROJECT_VERSION} - COMMAND tar -czf ${ARCHIVE_BASE_NAME}-doc-${PROJECT_VERSION}.tar.gz ${ARCHIVE_BASE_NAME}-doc-${PROJECT_VERSION} - COMMAND zip -r ${ARCHIVE_BASE_NAME}-doc-${PROJECT_VERSION}.zip ${ARCHIVE_BASE_NAME}-doc-${PROJECT_VERSION} - COMMAND cmake -E remove_directory ${ARCHIVE_NAME} - COMMAND cmake -E remove_directory ${ARCHIVE_BASE_NAME}-doc-${PROJECT_VERSION} - DEPENDS html - WORKING_DIRECTORY ${PROJECT_BINARY_DIR}) - -# CPACK config (Basically for NSIS) IF(${CMAKE_SOURCE_DIR} STREQUAL ${PROJECT_SOURCE_DIR}) SET(CPACK_PACKAGE_NAME ${PROJECT_NAME}) Index: INSTALL =================================================================== --- INSTALL (revision 992) +++ INSTALL (revision 568) @@ -2,120 +2,174 @@ ========================= -This file contains instructions for building and installing LEMON from -source on Linux. The process on Windows is similar. +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/). -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 - +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. In order to install LEMON from the extracted source tarball you have to issue the following commands: - 1. Step into the root of the source directory. + 1. `cd lemon-x.y.z' - $ cd lemon-x.y.z + This command changes to the directory which was created when you + extracted the sources. The x.y.z part is a version number. - 2. Create a build subdirectory and step into it. + 2. `./configure' - $ mkdir build - $ cd build + This command runs the configure shell script, which does some checks and + creates the makefiles. - 3. Perform system checks and create the makefiles. + 3. `make' - $ cmake .. + This command compiles the non-template part of LEMON into libemon.a + file. It also compiles the programs in the tools subdirectory by + default. - 4. Build LEMON. + 4. `make check' - $ make + 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. - This command compiles the non-template part of LEMON into - libemon.a file. It also compiles the programs in the 'tools' and - 'demo' subdirectories. - - 5. [Optional] Compile and run the self-tests. - - $ make check - - 5. [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. - - 6. [Optional] Install LEMON - - $ make install + 5. `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 - -DCMAKE_INSTALL_PREFIX=DIRECTORY flag to cmake in Step 3. - For example: - - $ cmake -DCMAKE_INSTALL_PREFIX=/home/username/lemon' + 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'. + + 6. `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. + Configure Options and Variables =============================== -In Step 3, you can customize the build process by passing options to CMAKE. +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]...' -$ cmake [OPTIONS] .. +Below you will find some useful variables and options (see `./configure --help' +for more): -You find a list of the most useful options below. +CXX='comp' --DCMAKE_INSTALL_PREFIX=PREFIX + 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 Set the installation prefix to PREFIX. By default it is /usr/local. --DCMAKE_BUILD_TYPE=[Release|Debug|Maintainer|...] +--enable-tools - This sets the compiler options. The choices are the following + Build the programs in the tools subdirectory (default). - '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. +--disable-tools - 'Debug': Optimization is turned off and debug info is added (-O0 - -ggdb with gcc). If is recommended during the development. + Do not build the programs in the tools subdirectory. - '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. +--with-glpk[=PREFIX] - 'RelWithDebInfo': Optimized build with debug info. + 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. - 'MinSizeRel': Size optimized build (-Os with gcc) +--with-glpk-includedir=DIR --DTEST_WITH_VALGRIND=YES + 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). - Using this, the test codes will be executed using valgrind. It is a - very effective way of identifying indexing problems and memory leaks. +--with-glpk-libdir=DIR --DCMAKE_CXX_COMPILER=path-to-compiler + 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). - Change the compiler to be used. +--without-glpk --DBUILD_SHARED_LIBS=TRUE + Disable GLPK support. - Build shared library instead of static one. Think twice if you - really want to use this option. +--with-cplex[=PREFIX] --DGLPK_ROOT_DIR=DIRECTORY --DCOIN_ROOT_DIR=DIRECTORY --DCPLEX_ROOT_DIR=DIRECTORY + 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. - Install root directory prefixes of optional third party libraries. +--with-cplex-includedir=DIR -Makefile Variables -================== + 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). -make VERBOSE=1 +--with-cplex-libdir=DIR - This results in a more verbose output by showing the full - compiler and linker commands. + 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). + +--without-cplex + + Disable CPLEX support. + +--with-soplex[=PREFIX] + + 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. + +--with-soplex-includedir=DIR + + 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). + +--with-soplex-libdir=DIR + + 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). + +--without-soplex + + Disable SoPlex support. + +--with-coin[=PREFIX] + + Enable support for COIN-OR solvers (CLP and CBC). You should + specify the prefix too. (by default, COIN-OR tools install + themselves to the source code directory). This command enables the + solvers that are actually found. + +--with-coin-includedir=DIR + + The directory where the COIN-OR header files are located. This is + only useful when the COIN-OR headers and libraries are not under + the same prefix (which is unlikely). + +--with-coin-libdir=DIR + + The directory where the COIN-OR libraries are located. This is only + useful when the COIN-OR headers and libraries are not under the + same prefix (which is unlikely). + +--without-coin + + Disable COIN-OR support. Index: LICENSE =================================================================== --- LICENSE (revision 992) +++ LICENSE (revision 553) @@ -2,5 +2,5 @@ copyright/license. -Copyright (C) 2003-2012 Egervary Jeno Kombinatorikus Optimalizalasi +Copyright (C) 2003-2009 Egervary Jeno Kombinatorikus Optimalizalasi Kutatocsoport (Egervary Combinatorial Optimization Research Group, EGRES). Index: Makefile.am =================================================================== --- Makefile.am (revision 752) +++ Makefile.am (revision 752) @@ -0,0 +1,79 @@ +ACLOCAL_AMFLAGS = -I m4 + +AM_CXXFLAGS = $(WARNINGCXXFLAGS) + +AM_CPPFLAGS = -I$(top_srcdir) -I$(top_builddir) +LDADD = $(top_builddir)/lemon/libemon.la + +EXTRA_DIST = \ + AUTHORS \ + LICENSE \ + m4/lx_check_cplex.m4 \ + m4/lx_check_glpk.m4 \ + m4/lx_check_soplex.m4 \ + m4/lx_check_coin.m4 \ + CMakeLists.txt \ + cmake/FindGhostscript.cmake \ + cmake/FindCPLEX.cmake \ + cmake/FindGLPK.cmake \ + cmake/FindCOIN.cmake \ + cmake/LEMONConfig.cmake.in \ + cmake/version.cmake.in \ + cmake/version.cmake \ + cmake/nsis/lemon.ico \ + cmake/nsis/uninstall.ico + +pkgconfigdir = $(libdir)/pkgconfig +lemondir = $(pkgincludedir) +bitsdir = $(lemondir)/bits +conceptdir = $(lemondir)/concepts +pkgconfig_DATA = +lib_LTLIBRARIES = +lemon_HEADERS = +bits_HEADERS = +concept_HEADERS = +noinst_HEADERS = +noinst_PROGRAMS = +bin_PROGRAMS = +check_PROGRAMS = +dist_bin_SCRIPTS = +TESTS = +XFAIL_TESTS = + +include lemon/Makefile.am +include test/Makefile.am +include doc/Makefile.am +include tools/Makefile.am + +DIST_SUBDIRS = demo + +demo: + $(MAKE) $(AM_MAKEFLAGS) -C demo + +MRPROPERFILES = \ + aclocal.m4 \ + config.h.in \ + config.h.in~ \ + configure \ + Makefile.in \ + build-aux/config.guess \ + build-aux/config.sub \ + build-aux/depcomp \ + build-aux/install-sh \ + build-aux/ltmain.sh \ + build-aux/missing \ + doc/doxygen.log + +mrproper: + $(MAKE) $(AM_MAKEFLAGS) maintainer-clean + -rm -f $(MRPROPERFILES) + +dist-bz2: dist + zcat $(PACKAGE)-$(VERSION).tar.gz | \ + bzip2 --best -c > $(PACKAGE)-$(VERSION).tar.bz2 + +distcheck-bz2: distcheck + zcat $(PACKAGE)-$(VERSION).tar.gz | \ + bzip2 --best -c > $(PACKAGE)-$(VERSION).tar.bz2 + +.PHONY: demo mrproper dist-bz2 distcheck-bz2 Index: NEWS =================================================================== --- NEWS (revision 881) +++ NEWS (revision 665) @@ -1,82 +1,2 @@ -2010-03-19 Version 1.2 released - - This is major feature release - - * New algorithms - * Bellman-Ford algorithm (#51) - * Minimum mean cycle algorithms (#179) - * Karp, Hartman-Orlin and Howard algorithms - * New minimum cost flow algorithms (#180) - * Cost Scaling algorithms - * Capacity Scaling algorithm - * Cycle-Canceling algorithms - * Planarity related algorithms (#62) - * Planarity checking algorithm - * Planar embedding algorithm - * Schnyder's planar drawing algorithm - * Coloring planar graphs with five or six colors - * Fractional matching algorithms (#314) - * New data structures - * StaticDigraph structure (#68) - * Several new priority queue structures (#50, #301) - * Fibonacci, Radix, Bucket, Pairing, Binomial - D-ary and fourary heaps (#301) - * Iterable map structures (#73) - * Other new tools and functionality - * Map utility functions (#320) - * Reserve functions are added to ListGraph and SmartGraph (#311) - * A resize() function is added to HypercubeGraph (#311) - * A count() function is added to CrossRefMap (#302) - * Support for multiple targets in Suurballe using fullInit() (#181) - * Traits class and named parameters for Suurballe (#323) - * Separate reset() and resetParams() functions in NetworkSimplex - to handle graph changes (#327) - * tolerance() functions are added to HaoOrlin (#306) - * Implementation improvements - * Improvements in weighted matching algorithms (#314) - * Jumpstart initialization - * ArcIt iteration is based on out-arc lists instead of in-arc lists - in ListDigraph (#311) - * Faster add row operation in CbcMip (#203) - * Better implementation for split() in ListDigraph (#311) - * ArgParser can also throw exception instead of exit(1) (#332) - * Miscellaneous - * A simple interactive bootstrap script - * Doc improvements (#62,#180,#299,#302,#303,#304,#307,#311,#331,#315, - #316,#319) - * BibTeX references in the doc (#184) - * Optionally use valgrind when running tests - * Also check ReferenceMapTag in concept checks (#312) - * dimacs-solver uses long long type by default. - * Several bugfixes (compared to release 1.1): - #295: Suppress MSVC warnings using pragmas - ----: Various CMAKE related improvements - * Remove duplications from doc/CMakeLists.txt - * Rename documentation install folder from 'docs' to 'html' - * Add tools/CMakeLists.txt to the tarball - * Generate and install LEMONConfig.cmake - * Change the label of the html project in Visual Studio - * Fix the check for the 'long long' type - * Put the version string into config.h - * Minor CMake improvements - * Set the version to 'hg-tip' if everything fails - #311: Add missing 'explicit' keywords - #302: Fix the implementation and doc of CrossRefMap - #308: Remove duplicate list_graph.h entry from source list - #307: Bugfix in Preflow and Circulation - #305: Bugfix and extension in the rename script - #312: Also check ReferenceMapTag in concept checks - #250: Bugfix in pathSource() and pathTarget() - #321: Use pathCopy(from,to) instead of copyPath(to,from) - #322: Distribure LEMONConfig.cmake.in - #330: Bug fix in map_extender.h - #336: Fix the date field comment of graphToEps() output - #323: Bug fix in Suurballe - #335: Fix clear() function in ExtendFindEnum - #337: Use void* as the LPX object pointer - #317: Fix (and improve) error message in mip_test.cc - Remove unnecessary OsiCbc dependency - #356: Allow multiple executions of weighted matching algorithms (#356) - 2009-05-13 Version 1.1 released @@ -153,5 +73,5 @@ ----: Add missing unistd.h include to time_measure.h #204: Compilation bug fixed in graph_to_eps.h with VS2005 - #214,#215: windows.h should never be included by LEMON headers + #214,#215: windows.h should never be included by lemon headers #230: Build systems check the availability of 'long long' type #229: Default implementation of Tolerance<> is used for integer types @@ -175,50 +95,50 @@ 2008-10-13 Version 1.0 released - This is the first stable release of LEMON. Compared to the 0.x - release series, it features a considerably smaller but more - matured set of tools. The API has also completely revised and - changed in several places. + This is the first stable release of LEMON. Compared to the 0.x + release series, it features a considerably smaller but more + matured set of tools. The API has also completely revised and + changed in several places. - * The major name changes compared to the 0.x series (see the + * The major name changes compared to the 0.x series (see the Migration Guide in the doc for more details) * Graph -> Digraph, UGraph -> Graph * Edge -> Arc, UEdge -> Edge - * source(UEdge)/target(UEdge) -> u(Edge)/v(Edge) - * Other improvements - * Better documentation - * Reviewed and cleaned up codebase - * CMake based build system (along with the autotools based one) - * Contents of the library (ported from 0.x) - * Algorithms - * breadth-first search (bfs.h) - * depth-first search (dfs.h) - * Dijkstra's algorithm (dijkstra.h) - * Kruskal's algorithm (kruskal.h) - * Data structures - * graph data structures (list_graph.h, smart_graph.h) - * path data structures (path.h) - * binary heap data structure (bin_heap.h) - * union-find data structures (unionfind.h) - * miscellaneous property maps (maps.h) - * two dimensional vector and bounding box (dim2.h) + * source(UEdge)/target(UEdge) -> u(Edge)/v(Edge) + * Other improvements + * Better documentation + * Reviewed and cleaned up codebase + * CMake based build system (along with the autotools based one) + * Contents of the library (ported from 0.x) + * Algorithms + * breadth-first search (bfs.h) + * depth-first search (dfs.h) + * Dijkstra's algorithm (dijkstra.h) + * Kruskal's algorithm (kruskal.h) + * Data structures + * graph data structures (list_graph.h, smart_graph.h) + * path data structures (path.h) + * binary heap data structure (bin_heap.h) + * union-find data structures (unionfind.h) + * miscellaneous property maps (maps.h) + * two dimensional vector and bounding box (dim2.h) * Concepts - * graph structure concepts (concepts/digraph.h, concepts/graph.h, + * graph structure concepts (concepts/digraph.h, concepts/graph.h, concepts/graph_components.h) - * concepts for other structures (concepts/heap.h, concepts/maps.h, - concepts/path.h) - * Tools - * Mersenne twister random number generator (random.h) - * tools for measuring cpu and wall clock time (time_measure.h) - * tools for counting steps and events (counter.h) - * tool for parsing command line arguments (arg_parser.h) - * tool for visualizing graphs (graph_to_eps.h) - * tools for reading and writing data in LEMON Graph Format + * concepts for other structures (concepts/heap.h, concepts/maps.h, + concepts/path.h) + * Tools + * Mersenne twister random number generator (random.h) + * tools for measuring cpu and wall clock time (time_measure.h) + * tools for counting steps and events (counter.h) + * tool for parsing command line arguments (arg_parser.h) + * tool for visualizing graphs (graph_to_eps.h) + * tools for reading and writing data in LEMON Graph Format (lgf_reader.h, lgf_writer.h) * tools to handle the anomalies of calculations with - floating point numbers (tolerance.h) + floating point numbers (tolerance.h) * tools to manage RGB colors (color.h) - * Infrastructure - * extended assertion handling (assert.h) - * exception classes and error handling (error.h) - * concept checking (concept_check.h) - * commonly used mathematical constants (math.h) + * Infrastructure + * extended assertion handling (assert.h) + * exception classes and error handling (error.h) + * concept checking (concept_check.h) + * commonly used mathematical constants (math.h) Index: README =================================================================== --- README (revision 848) +++ README (revision 658) @@ -18,8 +18,4 @@ Copying, distribution and modification conditions and terms. -NEWS - - News and version history. - INSTALL @@ -38,8 +34,4 @@ Some example programs to make you easier to get familiar with LEMON. -scripts/ - - Scripts that make it easier to develop LEMON. - test/ Index: cmake/version.cmake.in =================================================================== --- cmake/version.cmake.in (revision 983) +++ cmake/version.cmake.in (revision 678) @@ -1,1 +1,1 @@ -SET(LEMON_VERSION "@LEMON_VERSION@" CACHE STRING "LEMON version string.") +SET(LEMON_VERSION "@PACKAGE_VERSION@" CACHE STRING "LEMON version string.") Index: configure.ac =================================================================== --- configure.ac (revision 929) +++ configure.ac (revision 929) @@ -0,0 +1,140 @@ +dnl Process this file with autoconf to produce a configure script. + +dnl Version information. +m4_define([lemon_version_number], + [m4_normalize(esyscmd([echo ${LEMON_VERSION}]))]) +dnl m4_define([lemon_version_number], []) +m4_define([lemon_hg_path], [m4_normalize(esyscmd([./scripts/chg-len.py]))]) +m4_define([lemon_hg_revision], [m4_normalize(esyscmd([hg id -i 2> /dev/null]))]) +m4_define([lemon_version], [ifelse(lemon_version_number(), + [], + [ifelse(lemon_hg_revision(), + [], + [hg-tip], + [lemon_hg_path().lemon_hg_revision()])], + [lemon_version_number()])]) + +AC_PREREQ([2.59]) +AC_INIT([LEMON], [lemon_version()], [lemon-user@lemon.cs.elte.hu], [lemon]) +AC_CONFIG_AUX_DIR([build-aux]) +AC_CONFIG_MACRO_DIR([m4]) +AM_INIT_AUTOMAKE([-Wall -Werror foreign subdir-objects nostdinc]) +AC_CONFIG_SRCDIR([lemon/list_graph.h]) +AC_CONFIG_HEADERS([config.h lemon/config.h]) + +AC_DEFINE([LEMON_VERSION], [lemon_version()], [The version string]) + +dnl Do compilation tests using the C++ compiler. +AC_LANG([C++]) + +dnl Check the existence of long long type. +AC_CHECK_TYPE(long long, [long_long_found=yes], [long_long_found=no]) +if test x"$long_long_found" = x"yes"; then + AC_DEFINE([LEMON_HAVE_LONG_LONG], [1], [Define to 1 if you have long long.]) +fi + +dnl Checks for programs. +AC_PROG_CXX +AC_PROG_CXXCPP +AC_PROG_INSTALL +AC_DISABLE_SHARED +AC_PROG_LIBTOOL + +AC_CHECK_PROG([doxygen_found],[doxygen],[yes],[no]) +AC_CHECK_PROG([gs_found],[gs],[yes],[no]) + +dnl Detect Intel compiler. +AC_MSG_CHECKING([whether we are using the Intel C++ compiler]) +AC_COMPILE_IFELSE([#ifndef __INTEL_COMPILER +choke me +#endif], [ICC=[yes]], [ICC=[no]]) +if test x"$ICC" = x"yes"; then + AC_MSG_RESULT([yes]) +else + AC_MSG_RESULT([no]) +fi + +dnl Set custom compiler flags when using g++. +if test "$GXX" = yes -a "$ICC" = no; then + WARNINGCXXFLAGS="-Wall -W -Wall -W -Wunused -Wformat=2 -Wctor-dtor-privacy -Wnon-virtual-dtor -Wno-char-subscripts -Wwrite-strings -Wno-char-subscripts -Wreturn-type -Wcast-qual -Wcast-align -Wsign-promo -Woverloaded-virtual -ansi -fno-strict-aliasing -Wold-style-cast -Wno-unknown-pragmas" +fi +AC_SUBST([WARNINGCXXFLAGS]) + +dnl Checks for libraries. +LX_CHECK_GLPK +LX_CHECK_CPLEX +LX_CHECK_SOPLEX +LX_CHECK_COIN + +AM_CONDITIONAL([HAVE_LP], [test x"$lx_lp_found" = x"yes"]) +AM_CONDITIONAL([HAVE_MIP], [test x"$lx_mip_found" = x"yes"]) + +dnl Disable/enable building the binary tools. +AC_ARG_ENABLE([tools], +AS_HELP_STRING([--enable-tools], [build additional tools @<:@default@:>@]) +AS_HELP_STRING([--disable-tools], [do not build additional tools]), + [], [enable_tools=yes]) +AC_MSG_CHECKING([whether to build the additional tools]) +if test x"$enable_tools" != x"no"; then + AC_MSG_RESULT([yes]) +else + AC_MSG_RESULT([no]) +fi +AM_CONDITIONAL([WANT_TOOLS], [test x"$enable_tools" != x"no"]) + +dnl Checks for header files. +AC_CHECK_HEADERS(limits.h sys/time.h sys/times.h unistd.h) + +dnl Checks for typedefs, structures, and compiler characteristics. +AC_C_CONST +AC_C_INLINE +AC_TYPE_SIZE_T +AC_HEADER_TIME +AC_STRUCT_TM + +dnl Checks for library functions. +AC_HEADER_STDC +AC_CHECK_FUNCS(gettimeofday times ctime_r) + +dnl Add dependencies on files generated by configure. +AC_SUBST([CONFIG_STATUS_DEPENDENCIES], + ['$(top_srcdir)/doc/Doxyfile.in $(top_srcdir)/doc/mainpage.dox.in $(top_srcdir)/lemon/lemon.pc.in $(top_srcdir)/cmake/version.cmake.in']) + +AC_CONFIG_FILES([ +Makefile +demo/Makefile +cmake/version.cmake +doc/Doxyfile +doc/mainpage.dox +lemon/lemon.pc +]) + +AC_OUTPUT + +echo +echo '****************************** SUMMARY ******************************' +echo +echo Package version............... : $PACKAGE-$VERSION +echo +echo C++ compiler.................. : $CXX +echo C++ compiles flags............ : $WARNINGCXXFLAGS $CXXFLAGS +echo +echo Compiler supports long long... : $long_long_found +echo +echo GLPK support.................. : $lx_glpk_found +echo CPLEX support................. : $lx_cplex_found +echo SOPLEX support................ : $lx_soplex_found +echo CLP support................... : $lx_clp_found +echo CBC support................... : $lx_cbc_found +echo +echo Build additional tools........ : $enable_tools +echo +echo The packace will be installed in +echo -n ' ' +echo $prefix. +echo +echo '*********************************************************************' + +echo +echo Configure complete, now type \'make\' and then \'make install\'. +echo Index: ntrib/CMakeLists.txt =================================================================== --- contrib/CMakeLists.txt (revision 925) +++ (revision ) @@ -1,19 +1,0 @@ -INCLUDE_DIRECTORIES( - ${PROJECT_SOURCE_DIR} - ${PROJECT_BINARY_DIR} -) - -LINK_DIRECTORIES( - ${PROJECT_BINARY_DIR}/lemon -) - -# Uncomment (and adjust) the following two lines. 'myprog' is the name -# of the final executable ('.exe' will automatically be added to the -# name on Windows) and 'myprog-main.cc' is the source code it is -# compiled from. You can add more source files separated by -# whitespaces. Moreover, you can add multiple similar blocks if you -# want to build more than one executables. - -# ADD_EXECUTABLE(myprog myprog-main.cc) -# TARGET_LINK_LIBRARIES(myprog lemon) - Index: demo/Makefile.am =================================================================== --- demo/Makefile.am (revision 564) +++ demo/Makefile.am (revision 564) @@ -0,0 +1,17 @@ +AM_CXXFLAGS = $(WARNINGCXXFLAGS) + +AM_CPPFLAGS = -I$(top_srcdir) -I$(top_builddir) +LDADD = $(top_builddir)/lemon/libemon.la + +EXTRA_DIST = \ + CMakeLists.txt \ + digraph.lgf + +noinst_PROGRAMS = \ + arg_parser_demo \ + graph_to_eps_demo \ + lgf_demo + +arg_parser_demo_SOURCES = arg_parser_demo.cc +graph_to_eps_demo_SOURCES = graph_to_eps_demo.cc +lgf_demo_SOURCES = lgf_demo.cc Index: demo/arg_parser_demo.cc =================================================================== --- demo/arg_parser_demo.cc (revision 877) +++ demo/arg_parser_demo.cc (revision 440) @@ -3,5 +3,5 @@ * This file is a part of LEMON, a generic C++ optimization library. * - * Copyright (C) 2003-2010 + * Copyright (C) 2003-2009 * Egervary Jeno Kombinatorikus Optimalizalasi Kutatocsoport * (Egervary Research Group on Combinatorial Optimization, EGRES). @@ -66,16 +66,7 @@ .other("..."); - // Throw an exception when problems occurs. The default behavior is to - // exit(1) on these cases, but this makes Valgrind falsely warn - // about memory leaks. - ap.throwOnProblems(); - // Perform the parsing process // (in case of any error it terminates the program) - // The try {} construct is necessary only if the ap.trowOnProblems() - // setting is in use. - try { - ap.parse(); - } catch (ArgParserException &) { return 1; } + ap.parse(); // Check each option if it has been given and print its value Index: doc/CMakeLists.txt =================================================================== --- doc/CMakeLists.txt (revision 983) +++ doc/CMakeLists.txt (revision 929) @@ -18,14 +18,5 @@ ) -# Copy doc from source (if exists) -IF(EXISTS ${CMAKE_CURRENT_SOURCE_DIR}/html AND - NOT EXISTS ${CMAKE_CURRENT_BINARY_DIR}/html/index.html) - MESSAGE(STATUS "Copy doc from source tree") - EXECUTE_PROCESS( - COMMAND cmake -E copy_directory ${CMAKE_CURRENT_SOURCE_DIR}/html ${CMAKE_CURRENT_BINARY_DIR}/html - ) -ENDIF() - -IF(DOXYGEN_EXECUTABLE AND PYTHONINTERP_FOUND AND GHOSTSCRIPT_EXECUTABLE) +IF(DOXYGEN_EXECUTABLE AND GHOSTSCRIPT_EXECUTABLE) FILE(MAKE_DIRECTORY ${CMAKE_CURRENT_BINARY_DIR}/html/) SET(GHOSTSCRIPT_OPTIONS -dNOPAUSE -dBATCH -q -dEPSCrop -dTextAlphaBits=4 -dGraphicsAlphaBits=4 -sDEVICE=pngalpha) @@ -38,5 +29,4 @@ COMMAND ${GHOSTSCRIPT_EXECUTABLE} ${GHOSTSCRIPT_OPTIONS} -r18 -sOutputFile=gen-images/edge_biconnected_components.png ${CMAKE_CURRENT_SOURCE_DIR}/images/edge_biconnected_components.eps COMMAND ${GHOSTSCRIPT_EXECUTABLE} ${GHOSTSCRIPT_OPTIONS} -r18 -sOutputFile=gen-images/grid_graph.png ${CMAKE_CURRENT_SOURCE_DIR}/images/grid_graph.eps - COMMAND ${GHOSTSCRIPT_EXECUTABLE} ${GHOSTSCRIPT_OPTIONS} -r18 -sOutputFile=gen-images/matching.png ${CMAKE_CURRENT_SOURCE_DIR}/images/matching.eps COMMAND ${GHOSTSCRIPT_EXECUTABLE} ${GHOSTSCRIPT_OPTIONS} -r18 -sOutputFile=gen-images/node_biconnected_components.png ${CMAKE_CURRENT_SOURCE_DIR}/images/node_biconnected_components.eps COMMAND ${GHOSTSCRIPT_EXECUTABLE} ${GHOSTSCRIPT_OPTIONS} -r18 -sOutputFile=gen-images/nodeshape_0.png ${CMAKE_CURRENT_SOURCE_DIR}/images/nodeshape_0.eps @@ -45,8 +35,6 @@ COMMAND ${GHOSTSCRIPT_EXECUTABLE} ${GHOSTSCRIPT_OPTIONS} -r18 -sOutputFile=gen-images/nodeshape_3.png ${CMAKE_CURRENT_SOURCE_DIR}/images/nodeshape_3.eps COMMAND ${GHOSTSCRIPT_EXECUTABLE} ${GHOSTSCRIPT_OPTIONS} -r18 -sOutputFile=gen-images/nodeshape_4.png ${CMAKE_CURRENT_SOURCE_DIR}/images/nodeshape_4.eps - COMMAND ${GHOSTSCRIPT_EXECUTABLE} ${GHOSTSCRIPT_OPTIONS} -r18 -sOutputFile=gen-images/planar.png ${CMAKE_CURRENT_SOURCE_DIR}/images/planar.eps COMMAND ${GHOSTSCRIPT_EXECUTABLE} ${GHOSTSCRIPT_OPTIONS} -r18 -sOutputFile=gen-images/strongly_connected_components.png ${CMAKE_CURRENT_SOURCE_DIR}/images/strongly_connected_components.eps COMMAND ${CMAKE_COMMAND} -E remove_directory html - COMMAND ${PYTHON_EXECUTABLE} ${PROJECT_SOURCE_DIR}/scripts/bib2dox.py ${CMAKE_CURRENT_SOURCE_DIR}/references.bib >references.dox COMMAND ${DOXYGEN_EXECUTABLE} Doxyfile WORKING_DIRECTORY ${CMAKE_CURRENT_BINARY_DIR} Index: doc/Doxyfile.in =================================================================== --- doc/Doxyfile.in (revision 966) +++ doc/Doxyfile.in (revision 929) @@ -96,9 +96,7 @@ "@abs_top_srcdir@/lemon/concepts" \ "@abs_top_srcdir@/demo" \ - "@abs_top_srcdir@/contrib" \ "@abs_top_srcdir@/tools" \ "@abs_top_srcdir@/test/test_tools.h" \ - "@abs_top_builddir@/doc/mainpage.dox" \ - "@abs_top_builddir@/doc/references.dox" + "@abs_top_builddir@/doc/mainpage.dox" INPUT_ENCODING = UTF-8 FILE_PATTERNS = *.h \ Index: doc/Makefile.am =================================================================== --- doc/Makefile.am (revision 967) +++ doc/Makefile.am (revision 967) @@ -0,0 +1,110 @@ +EXTRA_DIST += \ + doc/Doxyfile.in \ + doc/DoxygenLayout.xml \ + doc/coding_style.dox \ + doc/dirs.dox \ + doc/groups.dox \ + doc/lgf.dox \ + doc/license.dox \ + doc/mainpage.dox \ + doc/migration.dox \ + doc/min_cost_flow.dox \ + doc/named-param.dox \ + doc/namespaces.dox \ + doc/template.h \ + doc/html \ + doc/CMakeLists.txt + +DOC_EPS_IMAGES18 = \ + grid_graph.eps \ + nodeshape_0.eps \ + nodeshape_1.eps \ + nodeshape_2.eps \ + nodeshape_3.eps \ + nodeshape_4.eps + +DOC_EPS_IMAGES27 = \ + bipartite_matching.eps \ + bipartite_partitions.eps \ + connected_components.eps \ + edge_biconnected_components.eps \ + node_biconnected_components.eps \ + strongly_connected_components.eps + +DOC_EPS_IMAGES = \ + $(DOC_EPS_IMAGES18) \ + $(DOC_EPS_IMAGES27) + +DOC_PNG_IMAGES = \ + $(DOC_EPS_IMAGES:%.eps=doc/gen-images/%.png) + +EXTRA_DIST += $(DOC_EPS_IMAGES:%=doc/images/%) + +doc/html: + $(MAKE) $(AM_MAKEFLAGS) html + +GS_COMMAND=gs -dNOPAUSE -dBATCH -q -dEPSCrop -dTextAlphaBits=4 -dGraphicsAlphaBits=4 + +$(DOC_EPS_IMAGES18:%.eps=doc/gen-images/%.png): doc/gen-images/%.png: doc/images/%.eps + -mkdir doc/gen-images + if test ${gs_found} = yes; then \ + $(GS_COMMAND) -sDEVICE=pngalpha -r18 -sOutputFile=$@ $<; \ + else \ + echo; \ + echo "Ghostscript not found."; \ + echo; \ + exit 1; \ + fi + +$(DOC_EPS_IMAGES27:%.eps=doc/gen-images/%.png): doc/gen-images/%.png: doc/images/%.eps + -mkdir doc/gen-images + if test ${gs_found} = yes; then \ + $(GS_COMMAND) -sDEVICE=pngalpha -r27 -sOutputFile=$@ $<; \ + else \ + echo; \ + echo "Ghostscript not found."; \ + echo; \ + exit 1; \ + fi + +html-local: $(DOC_PNG_IMAGES) + if test ${doxygen_found} = yes; then \ + cd doc; \ + doxygen Doxyfile; \ + cd ..; \ + else \ + echo; \ + echo "Doxygen not found."; \ + echo; \ + exit 1; \ + fi + +clean-local: + -rm -rf doc/html + -rm -f doc/doxygen.log + -rm -f $(DOC_PNG_IMAGES) + -rm -rf doc/gen-images + +update-external-tags: + wget -O doc/libstdc++.tag.tmp http://gcc.gnu.org/onlinedocs/libstdc++/latest-doxygen/libstdc++.tag && \ + mv doc/libstdc++.tag.tmp doc/libstdc++.tag || \ + rm doc/libstdc++.tag.tmp + +install-html-local: doc/html + @$(NORMAL_INSTALL) + $(mkinstalldirs) $(DESTDIR)$(htmldir)/html + for p in doc/html/*.{html,css,png,map,gif,tag} ; do \ + f="`echo $$p | sed -e 's|^.*/||'`"; \ + echo " $(INSTALL_DATA) $$p $(DESTDIR)$(htmldir)/html/$$f"; \ + $(INSTALL_DATA) $$p $(DESTDIR)$(htmldir)/html/$$f; \ + done + +uninstall-local: + @$(NORMAL_UNINSTALL) + for p in doc/html/*.{html,css,png,map,gif,tag} ; do \ + f="`echo $$p | sed -e 's|^.*/||'`"; \ + echo " rm -f $(DESTDIR)$(htmldir)/html/$$f"; \ + rm -f $(DESTDIR)$(htmldir)/html/$$f; \ + done + +.PHONY: update-external-tags Index: doc/coding_style.dox =================================================================== --- doc/coding_style.dox (revision 919) +++ doc/coding_style.dox (revision 440) @@ -99,8 +99,8 @@ \subsection pri-loc-var Private member variables -Private member variables should start with underscore. +Private member variables should start with underscore \code -_start_with_underscore +_start_with_underscores \endcode Index: doc/dirs.dox =================================================================== --- doc/dirs.dox (revision 925) +++ doc/dirs.dox (revision 440) @@ -32,17 +32,4 @@ documentation. */ - -/** -\dir contrib -\brief Directory for user contributed source codes. - -You can place your own C++ code using LEMON into this directory, which -will compile to an executable along with LEMON when you build the -library. This is probably the easiest way of compiling short to medium -codes, for this does require neither a LEMON installed system-wide nor -adding several paths to the compiler. - -Please have a look at contrib/CMakeLists.txt for -instruction on how to add your own files into the build process. */ /** Index: doc/groups.dox =================================================================== --- doc/groups.dox (revision 1003) +++ doc/groups.dox (revision 663) @@ -3,5 +3,5 @@ * This file is a part of LEMON, a generic C++ optimization library. * - * Copyright (C) 2003-2010 + * Copyright (C) 2003-2009 * Egervary Jeno Kombinatorikus Optimalizalasi Kutatocsoport * (Egervary Research Group on Combinatorial Optimization, EGRES). @@ -227,4 +227,12 @@ /** +@defgroup matrices Matrices +@ingroup datas +\brief Two dimensional data storages implemented in LEMON. + +This group contains two dimensional data storages implemented in LEMON. +*/ + +/** @defgroup paths Path Structures @ingroup datas @@ -239,26 +247,5 @@ any kind of path structure. -\sa \ref concepts::Path "Path concept" -*/ - -/** -@defgroup heaps Heap Structures -@ingroup datas -\brief %Heap structures implemented in LEMON. - -This group contains the heap structures implemented in LEMON. - -LEMON provides several heap classes. They are efficient implementations -of the abstract data type \e priority \e queue. They store items with -specified values called \e priorities in such a way that finding and -removing the item with minimum priority are efficient. -The basic operations are adding and erasing items, changing the priority -of an item, etc. - -Heaps are crucial in several algorithms, such as Dijkstra and Prim. -The heap implementations have the same interface, thus any of them can be -used easily in such algorithms. - -\sa \ref concepts::Heap "Heap concept" +\sa lemon::concepts::Path */ @@ -273,26 +260,4 @@ /** -@defgroup geomdat Geometric Data Structures -@ingroup auxdat -\brief Geometric data structures implemented in LEMON. - -This group contains geometric data structures implemented in LEMON. - - - \ref lemon::dim2::Point "dim2::Point" implements a two dimensional - vector with the usual operations. - - \ref lemon::dim2::Box "dim2::Box" can be used to determine the - rectangular bounding box of a set of \ref lemon::dim2::Point - "dim2::Point"'s. -*/ - -/** -@defgroup matrices Matrices -@ingroup auxdat -\brief Two dimensional data storages implemented in LEMON. - -This group contains two dimensional data storages implemented in LEMON. -*/ - -/** @defgroup algs Algorithms \brief This group contains the several algorithms @@ -309,6 +274,5 @@ This group contains the common graph search algorithms, namely -\e breadth-first \e search (BFS) and \e depth-first \e search (DFS) -\ref clrs01algorithms. +\e breadth-first \e search (BFS) and \e depth-first \e search (DFS). */ @@ -318,6 +282,5 @@ \brief Algorithms for finding shortest paths. -This group contains the algorithms for finding shortest paths in digraphs -\ref clrs01algorithms. +This group contains the algorithms for finding shortest paths in digraphs. - \ref Dijkstra algorithm for finding shortest paths from a source node @@ -336,13 +299,4 @@ /** -@defgroup spantree Minimum Spanning Tree Algorithms -@ingroup algs -\brief Algorithms for finding minimum cost spanning trees and arborescences. - -This group contains the algorithms for finding minimum cost spanning -trees and arborescences \ref clrs01algorithms. -*/ - -/** @defgroup max_flow Maximum Flow Algorithms @ingroup algs @@ -350,5 +304,5 @@ This group contains the algorithms for finding maximum flows and -feasible circulations \ref clrs01algorithms, \ref amo93networkflows. +feasible circulations. The \e maximum \e flow \e problem is to find a flow of maximum value between @@ -365,19 +319,15 @@ LEMON contains several algorithms for solving maximum flow problems: -- \ref EdmondsKarp Edmonds-Karp algorithm - \ref edmondskarp72theoretical. -- \ref Preflow Goldberg-Tarjan's preflow push-relabel algorithm - \ref goldberg88newapproach. -- \ref DinitzSleatorTarjan Dinitz's blocking flow algorithm with dynamic trees - \ref dinic70algorithm, \ref sleator83dynamic. -- \ref GoldbergTarjan !Preflow push-relabel algorithm with dynamic trees - \ref goldberg88newapproach, \ref sleator83dynamic. - -In most cases the \ref Preflow algorithm provides the +- \ref EdmondsKarp Edmonds-Karp algorithm. +- \ref Preflow Goldberg-Tarjan's preflow push-relabel algorithm. +- \ref DinitzSleatorTarjan Dinitz's blocking flow algorithm with dynamic trees. +- \ref GoldbergTarjan Preflow push-relabel algorithm with dynamic trees. + +In most cases the \ref Preflow "Preflow" algorithm provides the fastest method for computing a maximum flow. All implementations also provide functions to query the minimum cut, which is the dual problem of maximum flow. -\ref Circulation is a preflow push-relabel algorithm implemented directly +\ref Circulation is a preflow push-relabel algorithm implemented directly for finding feasible circulations, which is a somewhat different problem, but it is strongly related to maximum flow. @@ -392,33 +342,21 @@ This group contains the algorithms for finding minimum cost flows and -circulations \ref amo93networkflows. For more information about this -problem and its dual solution, see \ref min_cost_flow -"Minimum Cost Flow Problem". +circulations. For more information about this problem and its dual +solution see \ref min_cost_flow "Minimum Cost Flow Problem". LEMON contains several algorithms for this problem. - \ref NetworkSimplex Primal Network Simplex algorithm with various - pivot strategies \ref dantzig63linearprog, \ref kellyoneill91netsimplex. - - \ref CostScaling Cost Scaling algorithm based on push/augment and - relabel operations \ref goldberg90approximation, \ref goldberg97efficient, - \ref bunnagel98efficient. - - \ref CapacityScaling Capacity Scaling algorithm based on the successive - shortest path method \ref edmondskarp72theoretical. - - \ref CycleCanceling Cycle-Canceling algorithms, two of which are - strongly polynomial \ref klein67primal, \ref goldberg89cyclecanceling. - -In general, \ref NetworkSimplex and \ref CostScaling are the most efficient -implementations. -\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. + pivot strategies. + - \ref CostScaling Push-Relabel and Augment-Relabel algorithms based on + cost scaling. + - \ref CapacityScaling Successive Shortest %Path algorithm with optional + capacity scaling. + - \ref CancelAndTighten The Cancel and Tighten algorithm. + - \ref CycleCanceling Cycle-Canceling algorithms. + +In general NetworkSimplex is the most efficient implementation, +but in special cases other algorithms could be faster. For example, if the total supply and/or capacities are rather small, -\ref CapacityScaling is usually the fastest algorithm (without effective scaling). - -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). +CapacityScaling is usually the fastest algorithm (without effective scaling). */ @@ -438,5 +376,5 @@ \f[ \min_{X \subset V, X\not\in \{\emptyset, V\}} - \sum_{uv\in A: u\in X, v\not\in X}cap(uv) \f] + \sum_{uv\in A, u\in X, v\not\in X}cap(uv) \f] LEMON contains several algorithms related to minimum cut problems: @@ -454,37 +392,25 @@ /** -@defgroup min_mean_cycle Minimum Mean Cycle Algorithms -@ingroup algs -\brief Algorithms for finding minimum mean cycles. - -This group contains the algorithms for finding minimum mean cycles -\ref amo93networkflows, \ref karp78characterization. - -The \e minimum \e mean \e cycle \e problem is to find a directed cycle -of minimum mean length (cost) in a digraph. -The mean length of a cycle is the average length of its arcs, i.e. the -ratio between the total length of the cycle and the number of arcs on it. - -This problem has an important connection to \e conservative \e length -\e functions, too. A length function on the arcs of a digraph is called -conservative if and only if there is no directed cycle of negative total -length. For an arbitrary length function, the negative of the minimum -cycle mean is the smallest \f$\epsilon\f$ value so that increasing the -arc lengths uniformly by \f$\epsilon\f$ results in a conservative length -function. - -LEMON contains three algorithms for solving the minimum mean cycle problem: -- \ref KarpMmc Karp's original algorithm \ref karp78characterization. -- \ref HartmannOrlinMmc Hartmann-Orlin's algorithm, which is an improved - version of Karp's algorithm \ref hartmann93finding. -- \ref HowardMmc Howard's policy iteration algorithm - \ref dasdan98minmeancycle, \ref 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(ne) and use space O(n2+e), but the latter one is -typically faster due to the applied early termination scheme. +@defgroup graph_properties Connectivity and Other Graph Properties +@ingroup algs +\brief Algorithms for discovering the graph properties + +This group contains the algorithms for discovering the graph properties +like connectivity, bipartiteness, euler property, simplicity etc. + +\image html edge_biconnected_components.png +\image latex edge_biconnected_components.eps "bi-edge-connected components" width=\textwidth +*/ + +/** +@defgroup planar Planarity Embedding and Drawing +@ingroup algs +\brief Algorithms for planarity checking, embedding and drawing + +This group contains the algorithms for planarity checking, +embedding and drawing. + +\image html planar.png +\image latex planar.eps "Plane graph" width=\textwidth */ @@ -524,42 +450,29 @@ Edmond's blossom shrinking algorithm for calculating maximum weighted perfect matching in general graphs. -- \ref MaxFractionalMatching Push-relabel algorithm for calculating - maximum cardinality fractional matching in general graphs. -- \ref MaxWeightedFractionalMatching Augmenting path algorithm for calculating - maximum weighted fractional matching in general graphs. -- \ref MaxWeightedPerfectFractionalMatching - Augmenting path algorithm for calculating maximum weighted - perfect fractional matching in general graphs. - -\image html matching.png -\image latex matching.eps "Min Cost Perfect Matching" width=\textwidth -*/ - -/** -@defgroup graph_properties Connectivity and Other Graph Properties -@ingroup algs -\brief Algorithms for discovering the graph properties - -This group contains the algorithms for discovering the graph properties -like connectivity, bipartiteness, euler property, simplicity etc. - -\image html connected_components.png -\image latex connected_components.eps "Connected components" width=\textwidth -*/ - -/** -@defgroup planar Planar Embedding and Drawing -@ingroup algs -\brief Algorithms for planarity checking, embedding and drawing - -This group contains the algorithms for planarity checking, -embedding and drawing. - -\image html planar.png -\image latex planar.eps "Plane graph" width=\textwidth -*/ - -/** -@defgroup approx_algs Approximation Algorithms + +\image html bipartite_matching.png +\image latex bipartite_matching.eps "Bipartite Matching" width=\textwidth +*/ + +/** +@defgroup spantree Minimum Spanning Tree Algorithms +@ingroup algs +\brief Algorithms for finding minimum cost spanning trees and arborescences. + +This group contains the algorithms for finding minimum cost spanning +trees and arborescences. +*/ + +/** +@defgroup auxalg Auxiliary Algorithms +@ingroup algs +\brief Auxiliary algorithms implemented in LEMON. + +This group contains some algorithms implemented in LEMON +in order to make it easier to implement complex algorithms. +*/ + +/** +@defgroup approx Approximation Algorithms @ingroup algs \brief Approximation algorithms. @@ -567,17 +480,4 @@ This group contains the approximation and heuristic algorithms implemented in LEMON. - -Maximum Clique Problem - - \ref GrossoLocatelliPullanMc An efficient heuristic algorithm of - Grosso, Locatelli, and Pullan. -*/ - -/** -@defgroup auxalg Auxiliary Algorithms -@ingroup algs -\brief Auxiliary algorithms implemented in LEMON. - -This group contains some algorithms implemented in LEMON -in order to make it easier to implement complex algorithms. */ @@ -592,14 +492,11 @@ /** -@defgroup lp_group LP and MIP Solvers +@defgroup lp_group Lp and Mip Solvers @ingroup gen_opt_group -\brief LP and MIP solver interfaces for LEMON. - -This group contains LP and MIP solver interfaces for LEMON. -Various LP solvers could be used in the same manner with this -high-level interface. - -The currently supported solvers are \ref glpk, \ref clp, \ref cbc, -\ref cplex, \ref soplex. +\brief Lp and Mip solver interfaces for LEMON. + +This group contains Lp and Mip solver interfaces for LEMON. The +various LP solvers could be used in the same manner with this +interface. */ @@ -691,5 +588,5 @@ /** -@defgroup dimacs_group DIMACS Format +@defgroup dimacs_group DIMACS format @ingroup io_group \brief Read and write files in DIMACS format @@ -740,6 +637,6 @@ \brief Skeleton and concept checking classes for graph structures -This group contains the skeletons and concept checking classes of -graph structures. +This group contains the skeletons and concept checking classes of LEMON's +graph structures and helper classes used to implement these. */ @@ -753,4 +650,16 @@ /** +\anchor demoprograms + +@defgroup demos Demo Programs + +Some demo programs are listed here. Their full source codes can be found in +the \c demo subdirectory of the source tree. + +In order to compile them, use the make demo or the +make check commands. +*/ + +/** @defgroup tools Standalone Utility Applications @@ -761,15 +670,3 @@ */ -/** -\anchor demoprograms - -@defgroup demos Demo Programs - -Some demo programs are listed here. Their full source codes can be found in -the \c demo subdirectory of the source tree. - -In order to compile them, use the make demo or the -make check commands. -*/ - } Index: c/images/matching.eps =================================================================== --- doc/images/matching.eps (revision 865) +++ (revision ) @@ -1,130 +1,0 @@ -%!PS-Adobe-2.0 EPSF-2.0 -%%Creator: LEMON, graphToEps() -%%CreationDate: Sun Mar 14 09:08:34 2010 -%%BoundingBox: -353 -264 559 292 -%%EndComments -/lb { setlinewidth setrgbcolor newpath moveto - 4 2 roll 1 index 1 index curveto stroke } bind def -/l { setlinewidth setrgbcolor newpath moveto lineto stroke } bind def -/c { newpath dup 3 index add 2 index moveto 0 360 arc closepath } bind def -/sq { newpath 2 index 1 index add 2 index 2 index add moveto - 2 index 1 index sub 2 index 2 index add lineto - 2 index 1 index sub 2 index 2 index sub lineto - 2 index 1 index add 2 index 2 index sub lineto - closepath pop pop pop} bind def -/di { newpath 2 index 1 index add 2 index moveto - 2 index 2 index 2 index add lineto - 2 index 1 index sub 2 index lineto - 2 index 2 index 2 index sub lineto - closepath pop pop pop} bind def -/nc { 0 0 0 setrgbcolor 5 index 5 index 5 index c fill - setrgbcolor 1.1 div c fill - } bind def -/nsq { 0 0 0 setrgbcolor 5 index 5 index 5 index sq fill - setrgbcolor 1.1 div sq fill - } bind def -/ndi { 0 0 0 setrgbcolor 5 index 5 index 5 index di fill - setrgbcolor 1.1 div di fill - } bind def -/nfemale { 0 0 0 setrgbcolor 3 index 0.0909091 1.5 mul mul setlinewidth - newpath 5 index 5 index moveto 5 index 5 index 5 index 3.01 mul sub - lineto 5 index 4 index .7 mul sub 5 index 5 index 2.2 mul sub moveto - 5 index 4 index .7 mul add 5 index 5 index 2.2 mul sub lineto stroke - 5 index 5 index 5 index c fill - setrgbcolor 1.1 div c fill - } bind def -/nmale { - 0 0 0 setrgbcolor 3 index 0.0909091 1.5 mul mul setlinewidth - newpath 5 index 5 index moveto - 5 index 4 index 1 mul 1.5 mul add - 5 index 5 index 3 sqrt 1.5 mul mul add - 1 index 1 index lineto - 1 index 1 index 7 index sub moveto - 1 index 1 index lineto - exch 5 index 3 sqrt .5 mul mul sub exch 5 index .5 mul sub lineto - stroke - 5 index 5 index 5 index c fill - setrgbcolor 1.1 div c fill - } bind def -/arrl 1 def -/arrw 0.3 def -/lrl { 2 index mul exch 2 index mul exch rlineto pop} bind def -/arr { setrgbcolor /y1 exch def /x1 exch def /dy exch def /dx exch def - /w exch def /len exch def - newpath x1 dy w 2 div mul add y1 dx w 2 div mul sub moveto - len w sub arrl sub dx dy lrl - arrw dy dx neg lrl - dx arrl w add mul dy w 2 div arrw add mul sub - dy arrl w add mul dx w 2 div arrw add mul add rlineto - dx arrl w add mul neg dy w 2 div arrw add mul sub - dy arrl w add mul neg dx w 2 div arrw add mul add rlineto - arrw dy dx neg lrl - len w sub arrl sub neg dx dy lrl - closepath fill } bind def -/cshow { 2 index 2 index moveto dup stringwidth pop - neg 2 div fosi .35 mul neg rmoveto show pop pop} def - -gsave -%Arcs: -gsave -140.321 266.249 -327.729 150.06 0 0 0 4.99223 l -82.1207 -238.726 -245.288 -110.743 0 0 0 4.99223 l -336.635 -229.036 533.603 13.109 0 0 0 4.99223 l -53.8598 -45.8071 -245.288 -110.743 0 0 0 4.99223 l --75.5617 118.579 -327.729 150.06 0 0 0 4.99223 l --327.729 150.06 -245.288 -110.743 1 0 0 11.9813 l -533.603 13.109 218.184 -84.2955 0 0 0 4.99223 l -39.87 175.035 141.163 67.2575 0 0 0 4.99223 l -53.8598 -45.8071 -75.5617 118.579 0 0 0 4.99223 l --102.406 -141.267 82.1207 -238.726 0 0 0 4.99223 l -399.144 166.894 533.603 13.109 1 0 0 11.9813 l -39.87 175.035 140.321 266.249 1 0 0 11.9813 l -399.144 166.894 140.321 266.249 0 0 0 4.99223 l -399.144 166.894 141.163 67.2575 0 0 0 4.99223 l -53.8598 -45.8071 204.765 -173.77 0 0 0 4.99223 l -82.1207 -238.726 204.765 -173.77 0 0 0 4.99223 l -258.227 61.658 399.144 166.894 0 0 0 4.99223 l -53.8598 -45.8071 -102.406 -141.267 1 0 0 11.9813 l -175.073 -37.4477 141.163 67.2575 0 0 0 4.99223 l -258.227 61.658 380 0 0 0 0 4.99223 l -34.6739 40.8267 -75.5617 118.579 1 0 0 11.9813 l -380 0 533.603 13.109 0 0 0 4.99223 l -175.073 -37.4477 380 0 0 0 0 4.99223 l -218.184 -84.2955 204.765 -173.77 0 0 0 4.99223 l -53.8598 -45.8071 34.6739 40.8267 0 0 0 4.99223 l -167.905 -213.988 82.1207 -238.726 1 0 0 11.9813 l -336.635 -229.036 204.765 -173.77 1 0 0 11.9813 l -336.635 -229.036 167.905 -213.988 0 0 0 4.99223 l -329.08 -26.3098 218.184 -84.2955 0 0 0 4.99223 l -39.87 175.035 -75.5617 118.579 0 0 0 4.99223 l -53.8598 -45.8071 175.073 -37.4477 0 0 0 4.99223 l -34.6739 40.8267 141.163 67.2575 0 0 0 4.99223 l -258.227 61.658 141.163 67.2575 1 0 0 11.9813 l -175.073 -37.4477 218.184 -84.2955 1 0 0 11.9813 l -380 0 329.08 -26.3098 1 0 0 11.9813 l -grestore -%Nodes: -gsave --245.288 -110.743 14.9767 1 1 1 nc -204.765 -173.77 14.9767 1 1 1 nc --327.729 150.06 14.9767 1 1 1 nc --75.5617 118.579 14.9767 1 1 1 nc -218.184 -84.2955 14.9767 1 1 1 nc -140.321 266.249 14.9767 1 1 1 nc -141.163 67.2575 14.9767 1 1 1 nc -82.1207 -238.726 14.9767 1 1 1 nc -329.08 -26.3098 14.9767 1 1 1 nc --102.406 -141.267 14.9767 1 1 1 nc -533.603 13.109 14.9767 1 1 1 nc -167.905 -213.988 14.9767 1 1 1 nc -336.635 -229.036 14.9767 1 1 1 nc -380 0 14.9767 1 1 1 nc -399.144 166.894 14.9767 1 1 1 nc -34.6739 40.8267 14.9767 1 1 1 nc -39.87 175.035 14.9767 1 1 1 nc -175.073 -37.4477 14.9767 1 1 1 nc -53.8598 -45.8071 14.9767 1 1 1 nc -258.227 61.658 14.9767 1 1 1 nc -grestore -grestore -showpage Index: c/images/planar.eps =================================================================== --- doc/images/planar.eps (revision 827) +++ (revision ) @@ -1,181 +1,0 @@ -%!PS-Adobe-2.0 EPSF-2.0 -%%Creator: LEMON, graphToEps() -%%CreationDate: Fri Oct 19 18:32:32 2007 -%%BoundingBox: 0 0 596 842 -%%DocumentPaperSizes: a4 -%%EndComments -/lb { setlinewidth setrgbcolor newpath moveto - 4 2 roll 1 index 1 index curveto stroke } bind def -/l { setlinewidth setrgbcolor newpath moveto lineto stroke } bind def -/c { newpath dup 3 index add 2 index moveto 0 360 arc closepath } bind def -/sq { newpath 2 index 1 index add 2 index 2 index add moveto - 2 index 1 index sub 2 index 2 index add lineto - 2 index 1 index sub 2 index 2 index sub lineto - 2 index 1 index add 2 index 2 index sub lineto - closepath pop pop pop} bind def -/di { newpath 2 index 1 index add 2 index moveto - 2 index 2 index 2 index add lineto - 2 index 1 index sub 2 index lineto - 2 index 2 index 2 index sub lineto - closepath pop pop pop} bind def -/nc { 0 0 0 setrgbcolor 5 index 5 index 5 index c fill - setrgbcolor 1.1 div c fill - } bind def -/nsq { 0 0 0 setrgbcolor 5 index 5 index 5 index sq fill - setrgbcolor 1.1 div sq fill - } bind def -/ndi { 0 0 0 setrgbcolor 5 index 5 index 5 index di fill - setrgbcolor 1.1 div di fill - } bind def -/nfemale { 0 0 0 setrgbcolor 3 index 0.0909091 1.5 mul mul setlinewidth - newpath 5 index 5 index moveto 5 index 5 index 5 index 3.01 mul sub - lineto 5 index 4 index .7 mul sub 5 index 5 index 2.2 mul sub moveto - 5 index 4 index .7 mul add 5 index 5 index 2.2 mul sub lineto stroke - 5 index 5 index 5 index c fill - setrgbcolor 1.1 div c fill - } bind def -/nmale { - 0 0 0 setrgbcolor 3 index 0.0909091 1.5 mul mul setlinewidth - newpath 5 index 5 index moveto - 5 index 4 index 1 mul 1.5 mul add - 5 index 5 index 3 sqrt 1.5 mul mul add - 1 index 1 index lineto - 1 index 1 index 7 index sub moveto - 1 index 1 index lineto - exch 5 index 3 sqrt .5 mul mul sub exch 5 index .5 mul sub lineto - stroke - 5 index 5 index 5 index c fill - setrgbcolor 1.1 div c fill - } bind def -/arrl 1 def -/arrw 0.3 def -/lrl { 2 index mul exch 2 index mul exch rlineto pop} bind def -/arr { setrgbcolor /y1 exch def /x1 exch def /dy exch def /dx exch def - /w exch def /len exch def - newpath x1 dy w 2 div mul add y1 dx w 2 div mul sub moveto - len w sub arrl sub dx dy lrl - arrw dy dx neg lrl - dx arrl w add mul dy w 2 div arrw add mul sub - dy arrl w add mul dx w 2 div arrw add mul add rlineto - dx arrl w add mul neg dy w 2 div arrw add mul sub - dy arrl w add mul neg dx w 2 div arrw add mul add rlineto - arrw dy dx neg lrl - len w sub arrl sub neg dx dy lrl - closepath fill } bind def -/cshow { 2 index 2 index moveto dup stringwidth pop - neg 2 div fosi .35 mul neg rmoveto show pop pop} def - -gsave -15 138.307 translate -12.7843 dup scale -90 rotate -0.608112 -43.6081 translate -%Edges: -gsave -9 31 9.5 30.5 10 30 0 0 0 0.091217 lb -9 31 5.5 34.5 2 38 0 0 0 0.091217 lb -9 31 25.5 16 42 1 0 0 0 0.091217 lb -3 40 23 20.5 43 1 0 0 0 0.091217 lb -3 40 22.5 20.5 42 1 0 0 0 0.091217 lb -3 40 2.5 40.5 2 41 0 0 0 0.091217 lb -13 25 10.5 24.5 8 24 0 0 0 0.091217 lb -13 25 12 27 11 29 0 0 0 0.091217 lb -3 4 2.5 3 2 2 0 0 0 0.091217 lb -3 4 4.5 3 6 2 0 0 0 0.091217 lb -6 25 7 24.5 8 24 0 0 0 0.091217 lb -6 25 6 24.5 6 24 0 0 0 0.091217 lb -34 2 33.5 2 33 2 0 0 0 0.091217 lb -34 2 35 2 36 2 0 0 0 0.091217 lb -6 8 16 9 26 10 0 0 0 0.091217 lb -6 8 6 10.5 6 13 0 0 0 0.091217 lb -6 8 6 7.5 6 7 0 0 0 0.091217 lb -26 10 27.5 8.5 29 7 0 0 0 0.091217 lb -26 10 27.5 9 29 8 0 0 0 0.091217 lb -10 30 10.5 29.5 11 29 0 0 0 0.091217 lb -8 24 7 23.5 6 23 0 0 0 0.091217 lb -8 24 8 24.5 8 25 0 0 0 0.091217 lb -33 2 32.5 2 32 2 0 0 0 0.091217 lb -29 7 17.5 7 6 7 0 0 0 0.091217 lb -2 2 1.5 22 1 42 0 0 0 0.091217 lb -2 2 3.5 2 5 2 0 0 0 0.091217 lb -21 15 13.5 14.5 6 14 0 0 0 0.091217 lb -21 15 21 15.5 21 16 0 0 0 0.091217 lb -1 42 0.5 42.5 0 43 0 0 0 0.091217 lb -1 42 1.5 41.5 2 41 0 0 0 0.091217 lb -6 15 6 15.5 6 16 0 0 0 0.091217 lb -6 15 6 14.5 6 14 0 0 0 0.091217 lb -43 1 22 0.5 1 0 0 0 0 0.091217 lb -31 2 18.5 2 6 2 0 0 0 0.091217 lb -31 2 31.5 2 32 2 0 0 0 0.091217 lb -6 24 6 23.5 6 23 0 0 0 0.091217 lb -6 16 6 16.5 6 17 0 0 0 0.091217 lb -6 23 6 20 6 17 0 0 0 0.091217 lb -6 2 5.5 2 5 2 0 0 0 0.091217 lb -6 2 6 4.5 6 7 0 0 0 0.091217 lb -0 43 0.5 21.5 1 0 0 0 0 0.091217 lb -1 1 19.5 1.5 38 2 0 0 0 0.091217 lb -1 1 1 0.5 1 0 0 0 0 0.091217 lb -2 38 5.5 31.5 9 25 0 0 0 0.091217 lb -25 13 15.5 13 6 13 0 0 0 0.091217 lb -25 13 15.5 13.5 6 14 0 0 0 0.091217 lb -8 25 8.5 25 9 25 0 0 0 0.091217 lb -11 29 24.5 15.5 38 2 0 0 0 0.091217 lb -6 17 11.5 18 17 19 0 0 0 0.091217 lb -16 23 26.5 12.5 37 2 0 0 0 0.091217 lb -16 23 18.5 19.5 21 16 0 0 0 0.091217 lb -36 2 36.5 2 37 2 0 0 0 0.091217 lb -36 2 32.5 5 29 8 0 0 0 0.091217 lb -6 13 6 13.5 6 14 0 0 0 0.091217 lb -37 2 37.5 2 38 2 0 0 0 0.091217 lb -21 16 19 17.5 17 19 0 0 0 0.091217 lb -grestore -%Nodes: -gsave -29 8 0.304556 1 1 1 nc -2 41 0.304556 1 1 1 nc -6 7 0.304556 1 1 1 nc -5 2 0.304556 1 1 1 nc -17 19 0.304556 1 1 1 nc -21 16 0.304556 1 1 1 nc -1 0 0.304556 1 1 1 nc -9 25 0.304556 1 1 1 nc -6 14 0.304556 1 1 1 nc -42 1 0.304556 1 1 1 nc -38 2 0.304556 1 1 1 nc -37 2 0.304556 1 1 1 nc -6 13 0.304556 1 1 1 nc -36 2 0.304556 1 1 1 nc -16 23 0.304556 1 1 1 nc -6 17 0.304556 1 1 1 nc -11 29 0.304556 1 1 1 nc -8 25 0.304556 1 1 1 nc -32 2 0.304556 1 1 1 nc -25 13 0.304556 1 1 1 nc -2 38 0.304556 1 1 1 nc -1 1 0.304556 1 1 1 nc -0 43 0.304556 1 1 1 nc -6 2 0.304556 1 1 1 nc -6 23 0.304556 1 1 1 nc -6 16 0.304556 1 1 1 nc -6 24 0.304556 1 1 1 nc -31 2 0.304556 1 1 1 nc -43 1 0.304556 1 1 1 nc -6 15 0.304556 1 1 1 nc -1 42 0.304556 1 1 1 nc -21 15 0.304556 1 1 1 nc -2 2 0.304556 1 1 1 nc -29 7 0.304556 1 1 1 nc -33 2 0.304556 1 1 1 nc -8 24 0.304556 1 1 1 nc -10 30 0.304556 1 1 1 nc -26 10 0.304556 1 1 1 nc -6 8 0.304556 1 1 1 nc -34 2 0.304556 1 1 1 nc -6 25 0.304556 1 1 1 nc -3 4 0.304556 1 1 1 nc -13 25 0.304556 1 1 1 nc -3 40 0.304556 1 1 1 nc -9 31 0.304556 1 1 1 nc -grestore -grestore -showpage Index: doc/mainpage.dox.in =================================================================== --- doc/mainpage.dox.in (revision 930) +++ doc/mainpage.dox.in (revision 929) @@ -3,5 +3,5 @@ * This file is a part of LEMON, a generic C++ optimization library. * - * Copyright (C) 2003-2010 + * Copyright (C) 2003-2009 * Egervary Jeno Kombinatorikus Optimalizalasi Kutatocsoport * (Egervary Research Group on Combinatorial Optimization, EGRES). @@ -22,9 +22,12 @@ \section intro Introduction -LEMON stands for Library for Efficient Modeling -and Optimization in Networks. -It is a C++ template library providing efficient implementations of common -data structures and algorithms with focus on combinatorial optimization -tasks connected mainly with graphs and networks. +\subsection whatis What is LEMON + +LEMON stands for Library for Efficient Modeling +and Optimization in Networks. +It is a C++ template +library aimed at combinatorial optimization tasks which +often involve in working +with graphs. @@ -36,21 +39,8 @@ -The project is maintained by the -Egerváry Research Group on -Combinatorial Optimization \ref egres -at the Operations Research Department of the -Eötvös Loránd University, -Budapest, Hungary. -LEMON is also a member of the COIN-OR -initiative \ref coinor. - -\section howtoread How to Read the Documentation +\subsection howtoread How to read the documentation If you would like to get to know the library, see LEMON Tutorial. - -If you are interested in starting to use the library, see the Installation -Guide. If you know what you are looking for, then try to find it under the Index: doc/min_cost_flow.dox =================================================================== --- doc/min_cost_flow.dox (revision 1002) +++ doc/min_cost_flow.dox (revision 663) @@ -3,5 +3,5 @@ * This file is a part of LEMON, a generic C++ optimization library. * - * Copyright (C) 2003-2010 + * Copyright (C) 2003-2009 * Egervary Jeno Kombinatorikus Optimalizalasi Kutatocsoport * (Egervary Research Group on Combinatorial Optimization, EGRES). @@ -27,5 +27,5 @@ minimum total cost from a set of supply nodes to a set of demand nodes in a network with capacity constraints (lower and upper bounds) -and arc costs \ref amo93networkflows. +and arc costs. Formally, let \f$G=(V,A)\f$ be a digraph, \f$lower: A\rightarrow\mathbf{R}\f$, @@ -79,8 +79,8 @@ - if \f$cost^\pi(uv)<0\f$, then \f$f(uv)=upper(uv)\f$. - For all \f$u\in V\f$ nodes: - - \f$\pi(u)\leq 0\f$; + - \f$\pi(u)<=0\f$; - if \f$\sum_{uv\in A} f(uv) - \sum_{vu\in A} f(vu) \neq sup(u)\f$, then \f$\pi(u)=0\f$. - + Here \f$cost^\pi(uv)\f$ denotes the \e reduced \e cost of the arc \f$uv\in A\f$ with respect to the potential function \f$\pi\f$, i.e. @@ -102,5 +102,5 @@ \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 @@ -120,5 +120,5 @@ \f[ lower(uv) \leq f(uv) \leq upper(uv) \quad \forall uv\in A \f] -It means that the total demand must be less or equal to the +It means that the total demand must be less or equal to the total supply (i.e. \f$\sum_{u\in V} sup(u)\f$ must be zero or positive) and all the demands have to be satisfied, but there @@ -146,5 +146,5 @@ - if \f$cost^\pi(uv)<0\f$, then \f$f(uv)=upper(uv)\f$. - For all \f$u\in V\f$ nodes: - - \f$\pi(u)\geq 0\f$; + - \f$\pi(u)>=0\f$; - if \f$\sum_{uv\in A} f(uv) - \sum_{vu\in A} f(vu) \neq sup(u)\f$, then \f$\pi(u)=0\f$. Index: c/references.bib =================================================================== --- doc/references.bib (revision 1002) +++ (revision ) @@ -1,334 +1,0 @@ -%%%%% Defining LEMON %%%%% - -@misc{lemon, - key = {LEMON}, - title = {{LEMON} -- {L}ibrary for {E}fficient {M}odeling and - {O}ptimization in {N}etworks}, - howpublished = {\url{http://lemon.cs.elte.hu/}} -} - -@misc{egres, - key = {EGRES}, - title = {{EGRES} -- {E}gerv{\'a}ry {R}esearch {G}roup on - {C}ombinatorial {O}ptimization}, - url = {http://www.cs.elte.hu/egres/} -} - -@misc{coinor, - key = {COIN-OR}, - title = {{COIN-OR} -- {C}omputational {I}nfrastructure for - {O}perations {R}esearch}, - url = {http://www.coin-or.org/} -} - - -%%%%% Other libraries %%%%%% - -@misc{boost, - key = {Boost}, - title = {{B}oost {C++} {L}ibraries}, - url = {http://www.boost.org/} -} - -@book{bglbook, - author = {Jeremy G. Siek and Lee-Quan Lee and Andrew - Lumsdaine}, - title = {The Boost Graph Library: User Guide and Reference - Manual}, - publisher = {Addison-Wesley}, - year = 2002 -} - -@misc{leda, - key = {LEDA}, - title = {{LEDA} -- {L}ibrary of {E}fficient {D}ata {T}ypes and - {A}lgorithms}, - url = {http://www.algorithmic-solutions.com/} -} - -@book{ledabook, - author = {Kurt Mehlhorn and Stefan N{\"a}her}, - title = {{LEDA}: {A} platform for combinatorial and geometric - computing}, - isbn = {0-521-56329-1}, - publisher = {Cambridge University Press}, - address = {New York, NY, USA}, - year = 1999 -} - - -%%%%% Tools that LEMON depends on %%%%% - -@misc{cmake, - key = {CMake}, - title = {{CMake} -- {C}ross {P}latform {M}ake}, - url = {http://www.cmake.org/} -} - -@misc{doxygen, - key = {Doxygen}, - title = {{Doxygen} -- {S}ource code documentation generator - tool}, - url = {http://www.doxygen.org/} -} - - -%%%%% LP/MIP libraries %%%%% - -@misc{glpk, - key = {GLPK}, - title = {{GLPK} -- {GNU} {L}inear {P}rogramming {K}it}, - url = {http://www.gnu.org/software/glpk/} -} - -@misc{clp, - key = {Clp}, - title = {{Clp} -- {Coin-Or} {L}inear {P}rogramming}, - url = {http://projects.coin-or.org/Clp/} -} - -@misc{cbc, - key = {Cbc}, - title = {{Cbc} -- {Coin-Or} {B}ranch and {C}ut}, - url = {http://projects.coin-or.org/Cbc/} -} - -@misc{cplex, - key = {CPLEX}, - title = {{ILOG} {CPLEX}}, - url = {http://www.ilog.com/} -} - -@misc{soplex, - key = {SoPlex}, - title = {{SoPlex} -- {T}he {S}equential {O}bject-{O}riented - {S}implex}, - url = {http://soplex.zib.de/} -} - - -%%%%% General books %%%%% - -@book{amo93networkflows, - author = {Ravindra K. Ahuja and Thomas L. Magnanti and James - B. Orlin}, - title = {Network Flows: Theory, Algorithms, and Applications}, - publisher = {Prentice-Hall, Inc.}, - year = 1993, - month = feb, - isbn = {978-0136175490} -} - -@book{schrijver03combinatorial, - author = {Alexander Schrijver}, - title = {Combinatorial Optimization: Polyhedra and Efficiency}, - publisher = {Springer-Verlag}, - year = 2003, - isbn = {978-3540443896} -} - -@book{clrs01algorithms, - author = {Thomas H. Cormen and Charles E. Leiserson and Ronald - L. Rivest and Clifford Stein}, - title = {Introduction to Algorithms}, - publisher = {The MIT Press}, - year = 2001, - edition = {2nd} -} - -@book{stroustrup00cpp, - author = {Bjarne Stroustrup}, - title = {The C++ Programming Language}, - edition = {3rd}, - publisher = {Addison-Wesley Professional}, - isbn = 0201700735, - month = {February}, - year = 2000 -} - - -%%%%% Maximum flow algorithms %%%%% - -@article{edmondskarp72theoretical, - author = {Jack Edmonds and Richard M. Karp}, - title = {Theoretical improvements in algorithmic efficiency - for network flow problems}, - journal = {Journal of the ACM}, - year = 1972, - volume = 19, - number = 2, - pages = {248-264} -} - -@article{goldberg88newapproach, - author = {Andrew V. Goldberg and Robert E. Tarjan}, - title = {A new approach to the maximum flow problem}, - journal = {Journal of the ACM}, - year = 1988, - volume = 35, - number = 4, - pages = {921-940} -} - -@article{dinic70algorithm, - author = {E. A. Dinic}, - title = {Algorithm for solution of a problem of maximum flow - in a network with power estimation}, - journal = {Soviet Math. Doklady}, - year = 1970, - volume = 11, - pages = {1277-1280} -} - -@article{goldberg08partial, - author = {Andrew V. Goldberg}, - title = {The Partial Augment-Relabel Algorithm for the - Maximum Flow Problem}, - journal = {16th Annual European Symposium on Algorithms}, - year = 2008, - pages = {466-477} -} - -@article{sleator83dynamic, - author = {Daniel D. Sleator and Robert E. Tarjan}, - title = {A data structure for dynamic trees}, - journal = {Journal of Computer and System Sciences}, - year = 1983, - volume = 26, - number = 3, - pages = {362-391} -} - - -%%%%% Minimum mean cycle algorithms %%%%% - -@article{karp78characterization, - author = {Richard M. Karp}, - title = {A characterization of the minimum cycle mean in a - digraph}, - journal = {Discrete Math.}, - year = 1978, - volume = 23, - pages = {309-311} -} - -@article{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{dasdan98minmeancycle, - author = {Ali Dasdan and Rajesh K. Gupta}, - title = {Faster Maximum and Minimum Mean Cycle Alogrithms for - System Performance Analysis}, - journal = {IEEE Transactions on Computer-Aided Design of - Integrated Circuits and Systems}, - year = 1998, - volume = 17, - number = 10, - pages = {889-899} -} - -@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 %%%%% - -@article{klein67primal, - author = {Morton Klein}, - title = {A primal method for minimal cost flows with - applications to the assignment and transportation - problems}, - journal = {Management Science}, - year = 1967, - volume = 14, - pages = {205-220} -} - -@article{goldberg89cyclecanceling, - author = {Andrew V. Goldberg and Robert E. Tarjan}, - title = {Finding minimum-cost circulations by canceling - negative cycles}, - journal = {Journal of the ACM}, - year = 1989, - volume = 36, - number = 4, - pages = {873-886} -} - -@article{goldberg90approximation, - author = {Andrew V. Goldberg and Robert E. Tarjan}, - title = {Finding Minimum-Cost Circulations by Successive - Approximation}, - journal = {Mathematics of Operations Research}, - year = 1990, - volume = 15, - number = 3, - pages = {430-466} -} - -@article{goldberg97efficient, - author = {Andrew V. Goldberg}, - title = {An Efficient Implementation of a Scaling - Minimum-Cost Flow Algorithm}, - journal = {Journal of Algorithms}, - year = 1997, - volume = 22, - number = 1, - pages = {1-29} -} - -@article{bunnagel98efficient, - author = {Ursula B{\"u}nnagel and Bernhard Korte and Jens - Vygen}, - title = {Efficient implementation of the {G}oldberg-{T}arjan - minimum-cost flow algorithm}, - journal = {Optimization Methods and Software}, - year = 1998, - volume = 10, - pages = {157-174} -} - -@book{dantzig63linearprog, - author = {George B. Dantzig}, - title = {Linear Programming and Extensions}, - publisher = {Princeton University Press}, - year = 1963 -} - -@mastersthesis{kellyoneill91netsimplex, - author = {Damian J. Kelly and Garrett M. O'Neill}, - title = {The Minimum Cost Flow Problem and The Network - Simplex Method}, - school = {University College}, - address = {Dublin, Ireland}, - year = 1991, - month = sep -} - -%%%%% Other algorithms %%%%% - -@article{grosso08maxclique, - author = {Andrea Grosso and Marco Locatelli and Wayne Pullan}, - title = {Simple ingredients leading to very efficient - heuristics for the maximum clique problem}, - journal = {Journal of Heuristics}, - year = 2008, - volume = 14, - number = 6, - pages = {587--612} -} Index: lemon/CMakeLists.txt =================================================================== --- lemon/CMakeLists.txt (revision 981) +++ lemon/CMakeLists.txt (revision 968) @@ -5,10 +5,10 @@ CONFIGURE_FILE( - ${CMAKE_CURRENT_SOURCE_DIR}/config.h.in + ${CMAKE_CURRENT_SOURCE_DIR}/config.h.cmake ${CMAKE_CURRENT_BINARY_DIR}/config.h ) CONFIGURE_FILE( - ${CMAKE_CURRENT_SOURCE_DIR}/lemon.pc.in + ${CMAKE_CURRENT_SOURCE_DIR}/lemon.pc.cmake ${CMAKE_CURRENT_BINARY_DIR}/lemon.pc @ONLY Index: lemon/Makefile.am =================================================================== --- lemon/Makefile.am (revision 963) +++ lemon/Makefile.am (revision 963) @@ -0,0 +1,137 @@ +EXTRA_DIST += \ + lemon/lemon.pc.in \ + lemon/lemon.pc.cmake \ + lemon/CMakeLists.txt \ + lemon/config.h.cmake + +pkgconfig_DATA += lemon/lemon.pc + +lib_LTLIBRARIES += lemon/libemon.la + +lemon_libemon_la_SOURCES = \ + lemon/arg_parser.cc \ + lemon/base.cc \ + lemon/color.cc \ + lemon/lp_base.cc \ + lemon/lp_skeleton.cc \ + lemon/random.cc \ + lemon/bits/windows.cc + +nodist_lemon_HEADERS = lemon/config.h + +lemon_libemon_la_CXXFLAGS = \ + $(AM_CXXFLAGS) \ + $(GLPK_CFLAGS) \ + $(CPLEX_CFLAGS) \ + $(SOPLEX_CXXFLAGS) \ + $(CLP_CXXFLAGS) \ + $(CBC_CXXFLAGS) + +lemon_libemon_la_LDFLAGS = \ + $(GLPK_LIBS) \ + $(CPLEX_LIBS) \ + $(SOPLEX_LIBS) \ + $(CLP_LIBS) \ + $(CBC_LIBS) + +if HAVE_GLPK +lemon_libemon_la_SOURCES += lemon/glpk.cc +endif + +if HAVE_CPLEX +lemon_libemon_la_SOURCES += lemon/cplex.cc +endif + +if HAVE_SOPLEX +lemon_libemon_la_SOURCES += lemon/soplex.cc +endif + +if HAVE_CLP +lemon_libemon_la_SOURCES += lemon/clp.cc +endif + +if HAVE_CBC +lemon_libemon_la_SOURCES += lemon/cbc.cc +endif + +lemon_HEADERS += \ + lemon/adaptors.h \ + lemon/arg_parser.h \ + lemon/assert.h \ + lemon/bfs.h \ + lemon/bin_heap.h \ + lemon/bucket_heap.h \ + lemon/cbc.h \ + lemon/circulation.h \ + lemon/clp.h \ + lemon/color.h \ + lemon/concept_check.h \ + lemon/connectivity.h \ + lemon/counter.h \ + lemon/core.h \ + lemon/cplex.h \ + lemon/dfs.h \ + lemon/dijkstra.h \ + lemon/dim2.h \ + lemon/dimacs.h \ + lemon/edge_set.h \ + lemon/elevator.h \ + lemon/error.h \ + lemon/euler.h \ + lemon/fib_heap.h \ + lemon/full_graph.h \ + lemon/glpk.h \ + lemon/gomory_hu.h \ + lemon/graph_to_eps.h \ + lemon/grid_graph.h \ + lemon/hypercube_graph.h \ + lemon/kruskal.h \ + lemon/hao_orlin.h \ + lemon/lgf_reader.h \ + lemon/lgf_writer.h \ + lemon/list_graph.h \ + lemon/lp.h \ + lemon/lp_base.h \ + lemon/lp_skeleton.h \ + lemon/maps.h \ + lemon/matching.h \ + lemon/math.h \ + lemon/min_cost_arborescence.h \ + lemon/nauty_reader.h \ + lemon/network_simplex.h \ + lemon/path.h \ + lemon/preflow.h \ + lemon/radix_heap.h \ + lemon/radix_sort.h \ + lemon/random.h \ + lemon/smart_graph.h \ + lemon/soplex.h \ + lemon/suurballe.h \ + lemon/time_measure.h \ + lemon/tolerance.h \ + lemon/unionfind.h \ + lemon/bits/windows.h + +bits_HEADERS += \ + lemon/bits/alteration_notifier.h \ + lemon/bits/array_map.h \ + lemon/bits/bezier.h \ + lemon/bits/default_map.h \ + lemon/bits/edge_set_extender.h \ + lemon/bits/enable_if.h \ + lemon/bits/graph_adaptor_extender.h \ + lemon/bits/graph_extender.h \ + lemon/bits/map_extender.h \ + lemon/bits/path_dump.h \ + lemon/bits/solver_bits.h \ + lemon/bits/traits.h \ + lemon/bits/variant.h \ + lemon/bits/vector_map.h + +concept_HEADERS += \ + lemon/concepts/digraph.h \ + lemon/concepts/graph.h \ + lemon/concepts/graph_components.h \ + lemon/concepts/heap.h \ + lemon/concepts/maps.h \ + lemon/concepts/path.h Index: lemon/adaptors.h =================================================================== --- lemon/adaptors.h (revision 998) +++ lemon/adaptors.h (revision 997) @@ -3,5 +3,5 @@ * This file is a part of LEMON, a generic C++ optimization library. * - * Copyright (C) 2003-2010 + * Copyright (C) 2003-2009 * Egervary Jeno Kombinatorikus Optimalizalasi Kutatocsoport * (Egervary Research Group on Combinatorial Optimization, EGRES). @@ -361,7 +361,4 @@ /// parameter is set to be \c const. /// - /// This class provides item counting in the same time as the adapted - /// digraph structure. - /// /// \tparam DGR The type of the adapted digraph. /// It must conform to the \ref concepts::Digraph "Digraph" concept. @@ -422,5 +419,5 @@ Parent::initialize(digraph); _node_filter = &node_filter; - _arc_filter = &arc_filter; + _arc_filter = &arc_filter; } @@ -509,9 +506,9 @@ template - class NodeMap - : public SubMapExtender, - LEMON_SCOPE_FIX(DigraphAdaptorBase, NodeMap)> { + class NodeMap + : public SubMapExtender, + LEMON_SCOPE_FIX(DigraphAdaptorBase, NodeMap)> { typedef SubMapExtender, - LEMON_SCOPE_FIX(DigraphAdaptorBase, NodeMap)> Parent; + LEMON_SCOPE_FIX(DigraphAdaptorBase, NodeMap)> Parent; public: @@ -536,7 +533,7 @@ template - class ArcMap + class ArcMap : public SubMapExtender, - LEMON_SCOPE_FIX(DigraphAdaptorBase, ArcMap)> { + LEMON_SCOPE_FIX(DigraphAdaptorBase, ArcMap)> { typedef SubMapExtender, LEMON_SCOPE_FIX(DigraphAdaptorBase, ArcMap)> Parent; @@ -583,5 +580,5 @@ Parent::initialize(digraph); _node_filter = &node_filter; - _arc_filter = &arc_filter; + _arc_filter = &arc_filter; } @@ -652,8 +649,8 @@ template - class NodeMap + class NodeMap : public SubMapExtender, LEMON_SCOPE_FIX(DigraphAdaptorBase, NodeMap)> { - typedef SubMapExtender, + typedef SubMapExtender, LEMON_SCOPE_FIX(DigraphAdaptorBase, NodeMap)> Parent; @@ -679,5 +676,5 @@ template - class ArcMap + class ArcMap : public SubMapExtender, LEMON_SCOPE_FIX(DigraphAdaptorBase, ArcMap)> { @@ -722,6 +719,4 @@ /// by adding or removing nodes or arcs, unless the \c GR template /// parameter is set to be \c const. - /// - /// This class provides only linear time counting for nodes and arcs. /// /// \tparam DGR The type of the adapted digraph. @@ -1022,8 +1017,8 @@ template - class NodeMap + class NodeMap : public SubMapExtender, LEMON_SCOPE_FIX(GraphAdaptorBase, NodeMap)> { - typedef SubMapExtender, + typedef SubMapExtender, LEMON_SCOPE_FIX(GraphAdaptorBase, NodeMap)> Parent; @@ -1049,8 +1044,8 @@ template - class ArcMap + class ArcMap : public SubMapExtender, LEMON_SCOPE_FIX(GraphAdaptorBase, ArcMap)> { - typedef SubMapExtender, + typedef SubMapExtender, LEMON_SCOPE_FIX(GraphAdaptorBase, ArcMap)> Parent; @@ -1076,8 +1071,8 @@ template - class EdgeMap + class EdgeMap : public SubMapExtender, LEMON_SCOPE_FIX(GraphAdaptorBase, EdgeMap)> { - typedef SubMapExtender, + typedef SubMapExtender, LEMON_SCOPE_FIX(GraphAdaptorBase, EdgeMap)> Parent; @@ -1118,6 +1113,6 @@ NF* _node_filter; EF* _edge_filter; - SubGraphBase() - : Parent(), _node_filter(0), _edge_filter(0) { } + SubGraphBase() + : Parent(), _node_filter(0), _edge_filter(0) { } void initialize(GR& graph, NF& node_filter, EF& edge_filter) { @@ -1220,8 +1215,8 @@ template - class NodeMap + class NodeMap : public SubMapExtender, LEMON_SCOPE_FIX(GraphAdaptorBase, NodeMap)> { - typedef SubMapExtender, + typedef SubMapExtender, LEMON_SCOPE_FIX(GraphAdaptorBase, NodeMap)> Parent; @@ -1247,8 +1242,8 @@ template - class ArcMap + class ArcMap : public SubMapExtender, LEMON_SCOPE_FIX(GraphAdaptorBase, ArcMap)> { - typedef SubMapExtender, + typedef SubMapExtender, LEMON_SCOPE_FIX(GraphAdaptorBase, ArcMap)> Parent; @@ -1274,9 +1269,9 @@ template - class EdgeMap + class EdgeMap : public SubMapExtender, LEMON_SCOPE_FIX(GraphAdaptorBase, EdgeMap)> { - typedef SubMapExtender, - LEMON_SCOPE_FIX(GraphAdaptorBase, EdgeMap)> Parent; + typedef SubMapExtender, + LEMON_SCOPE_FIX(GraphAdaptorBase, EdgeMap)> Parent; public: @@ -1319,6 +1314,4 @@ /// by adding or removing nodes or edges, unless the \c GR template /// parameter is set to be \c const. - /// - /// This class provides only linear time counting for nodes, edges and arcs. /// /// \tparam GR The type of the adapted graph. @@ -1478,6 +1471,4 @@ /// by adding or removing nodes or arcs/edges, unless the \c GR template /// parameter is set to be \c const. - /// - /// This class provides only linear time item counting. /// /// \tparam GR The type of the adapted digraph or graph. @@ -1505,5 +1496,5 @@ #endif typedef DigraphAdaptorExtender< - SubDigraphBase >, + SubDigraphBase >, true> > Parent; @@ -1526,5 +1517,5 @@ /// Creates a subgraph for the given digraph or graph with the /// given node filter map. - FilterNodes(GR& graph, NF& node_filter) + FilterNodes(GR& graph, NF& node_filter) : Parent(), const_true_map() { @@ -1564,9 +1555,9 @@ typename enable_if >::type> : public GraphAdaptorExtender< - SubGraphBase >, + SubGraphBase >, true> > { typedef GraphAdaptorExtender< - SubGraphBase >, + SubGraphBase >, true> > Parent; @@ -1628,6 +1619,4 @@ /// by adding or removing nodes or arcs, unless the \c GR template /// parameter is set to be \c const. - /// - /// This class provides only linear time counting for nodes and arcs. /// /// \tparam DGR The type of the adapted digraph. @@ -1654,5 +1643,5 @@ #endif typedef DigraphAdaptorExtender< - SubDigraphBase >, + SubDigraphBase >, AF, false> > Parent; @@ -1740,6 +1729,4 @@ /// by adding or removing nodes or edges, unless the \c GR template /// parameter is set to be \c const. - /// - /// This class provides only linear time counting for nodes, edges and arcs. /// /// \tparam GR The type of the adapted graph. @@ -1762,9 +1749,9 @@ class FilterEdges : public GraphAdaptorExtender< - SubGraphBase >, + SubGraphBase >, EF, false> > { #endif typedef GraphAdaptorExtender< - SubGraphBase >, + SubGraphBase >, EF, false> > Parent; @@ -1791,5 +1778,5 @@ /// Creates a subgraph for the given graph with the given edge /// filter map. - FilterEdges(GR& graph, EF& edge_filter) + FilterEdges(GR& graph, EF& edge_filter) : Parent(), const_true_map() { Parent::initialize(graph, const_true_map, edge_filter); @@ -1859,5 +1846,5 @@ bool _forward; - Arc(const Edge& edge, bool forward) + Arc(const Edge& edge, bool forward) : _edge(edge), _forward(forward) {} @@ -2099,5 +2086,5 @@ ArcMapBase(const UndirectorBase& adaptor, const V& value) - : _forward(*adaptor._digraph, value), + : _forward(*adaptor._digraph, value), _backward(*adaptor._digraph, value) {} @@ -2217,5 +2204,5 @@ typedef typename ItemSetTraits::ItemNotifier EdgeNotifier; EdgeNotifier& notifier(Edge) const { return _digraph->notifier(Edge()); } - + typedef EdgeNotifier ArcNotifier; ArcNotifier& notifier(Arc) const { return _digraph->notifier(Edge()); } @@ -2245,7 +2232,4 @@ /// by adding or removing nodes or edges, unless the \c GR template /// parameter is set to be \c const. - /// - /// This class provides item counting in the same time as the adapted - /// digraph structure. /// /// \tparam DGR The type of the adapted digraph. @@ -2551,7 +2535,4 @@ /// by adding or removing nodes or arcs, unless the \c GR template /// parameter is set to be \c const. - /// - /// This class provides item counting in the same time as the adapted - /// graph structure. /// /// \tparam GR The type of the adapted graph. @@ -2698,6 +2679,4 @@ /// This class conforms to the \ref concepts::Digraph "Digraph" concept. /// - /// This class provides only linear time counting for nodes and arcs. - /// /// \tparam DGR The type of the adapted digraph. /// It must conform to the \ref concepts::Digraph "Digraph" concept. @@ -2729,5 +2708,5 @@ typename FM = CM, typename TL = Tolerance > - class ResidualDigraph + class ResidualDigraph : public SubDigraph< Undirector, @@ -2786,5 +2765,5 @@ ResidualDigraph(const DGR& digraph, const CM& capacity, FM& flow, const TL& tolerance = Tolerance()) - : Parent(), _capacity(&capacity), _flow(&flow), + : Parent(), _capacity(&capacity), _flow(&flow), _graph(digraph), _node_filter(), _forward_filter(capacity, flow, tolerance), @@ -2868,5 +2847,5 @@ /// Constructor - ResidualCapacity(const ResidualDigraph& adaptor) + ResidualCapacity(const ResidualDigraph& adaptor) : _adaptor(&adaptor) {} @@ -3347,7 +3326,4 @@ /// in the adaptor. /// - /// This class provides item counting in the same time as the adapted - /// digraph structure. - /// /// \tparam DGR The type of the adapted digraph. /// It must conform to the \ref concepts::Digraph "Digraph" concept. @@ -3448,5 +3424,5 @@ /// to get a node map of the split digraph. /// Its value type is inherited from the first node map type (\c IN). - /// \tparam IN The type of the node map for the in-nodes. + /// \tparam IN The type of the node map for the in-nodes. /// \tparam OUT The type of the node map for the out-nodes. template Index: lemon/arg_parser.cc =================================================================== --- lemon/arg_parser.cc (revision 877) +++ lemon/arg_parser.cc (revision 440) @@ -3,5 +3,5 @@ * This file is a part of LEMON, a generic C++ optimization library. * - * Copyright (C) 2003-2010 + * Copyright (C) 2003-2009 * Egervary Jeno Kombinatorikus Optimalizalasi Kutatocsoport * (Egervary Research Group on Combinatorial Optimization, EGRES). @@ -21,21 +21,12 @@ namespace lemon { - void ArgParser::_terminate(ArgParserException::Reason reason) const - { - if(_exit_on_problems) - exit(1); - else throw(ArgParserException(reason)); - } - - void ArgParser::_showHelp(void *p) { (static_cast(p))->showHelp(); - (static_cast(p))->_terminate(ArgParserException::HELP); + exit(1); } ArgParser::ArgParser(int argc, const char * const *argv) - :_argc(argc), _argv(argv), _command_name(argv[0]), - _exit_on_problems(true) { + :_argc(argc), _argv(argv), _command_name(argv[0]) { funcOption("-help","Print a short help message",_showHelp,this); synonym("help","-help"); @@ -352,5 +343,5 @@ i!=_others_help.end();++i) showHelp(i); for(Opts::const_iterator i=_opts.begin();i!=_opts.end();++i) showHelp(i); - _terminate(ArgParserException::HELP); + exit(1); } @@ -361,5 +352,5 @@ std::cerr << "\nType '" << _command_name << " --help' to obtain a short summary on the usage.\n\n"; - _terminate(ArgParserException::UNKNOWN_OPT); + exit(1); } @@ -424,5 +415,5 @@ std::cerr << "\nType '" << _command_name << " --help' to obtain a short summary on the usage.\n\n"; - _terminate(ArgParserException::INVALID_OPT); + exit(1); } } Index: lemon/arg_parser.h =================================================================== --- lemon/arg_parser.h (revision 879) +++ lemon/arg_parser.h (revision 440) @@ -3,5 +3,5 @@ * This file is a part of LEMON, a generic C++ optimization library. * - * Copyright (C) 2003-2010 + * Copyright (C) 2003-2009 * Egervary Jeno Kombinatorikus Optimalizalasi Kutatocsoport * (Egervary Research Group on Combinatorial Optimization, EGRES). @@ -34,49 +34,4 @@ namespace lemon { - - ///Exception used by ArgParser - - ///Exception used by ArgParser. - /// - class ArgParserException : public Exception { - public: - /// Reasons for failure - - /// Reasons for failure. - /// - enum Reason { - HELP, ///< --help option was given. - UNKNOWN_OPT, ///< Unknown option was given. - INVALID_OPT ///< Invalid combination of options. - }; - - private: - Reason _reason; - - public: - ///Constructor - ArgParserException(Reason r) throw() : _reason(r) {} - ///Virtual destructor - virtual ~ArgParserException() throw() {} - ///A short description of the exception - virtual const char* what() const throw() { - switch(_reason) - { - case HELP: - return "lemon::ArgParseException: ask for help"; - break; - case UNKNOWN_OPT: - return "lemon::ArgParseException: unknown option"; - break; - case INVALID_OPT: - return "lemon::ArgParseException: invalid combination of options"; - break; - } - return ""; - } - ///Return the reason for the failure - Reason reason() const {return _reason; } - }; - ///Command line arguments parser @@ -162,8 +117,4 @@ void (*func)(void *),void *data); - bool _exit_on_problems; - - void _terminate(ArgParserException::Reason reason) const; - public: @@ -430,9 +381,4 @@ const std::vector &files() const { return _file_args; } - ///Throw instead of exit in case of problems - void throwOnProblems() - { - _exit_on_problems=false; - } }; } Index: mon/bellman_ford.h =================================================================== --- lemon/bellman_ford.h (revision 880) +++ (revision ) @@ -1,1115 +1,0 @@ -/* -*- mode: C++; indent-tabs-mode: nil; -*- - * - * This file is a part of LEMON, a generic C++ optimization library. - * - * Copyright (C) 2003-2010 - * Egervary Jeno Kombinatorikus Optimalizalasi Kutatocsoport - * (Egervary Research Group on Combinatorial Optimization, EGRES). - * - * Permission to use, modify and distribute this software is granted - * provided that this copyright notice appears in all copies. For - * precise terms see the accompanying LICENSE file. - * - * This software is provided "AS IS" with no warranty of any kind, - * express or implied, and with no claim as to its suitability for any - * purpose. - * - */ - -#ifndef LEMON_BELLMAN_FORD_H -#define LEMON_BELLMAN_FORD_H - -/// \ingroup shortest_path -/// \file -/// \brief Bellman-Ford algorithm. - -#include -#include -#include -#include -#include -#include - -#include - -namespace lemon { - - /// \brief Default OperationTraits for the BellmanFord algorithm class. - /// - /// This operation traits class defines all computational operations - /// and constants that are used in the Bellman-Ford algorithm. - /// The default implementation is based on the \c numeric_limits class. - /// If the numeric type does not have infinity value, then the maximum - /// value is used as extremal infinity value. - template < - typename V, - bool has_inf = std::numeric_limits::has_infinity> - struct BellmanFordDefaultOperationTraits { - /// \e - typedef V Value; - /// \brief Gives back the zero value of the type. - static Value zero() { - return static_cast(0); - } - /// \brief Gives back the positive infinity value of the type. - static Value infinity() { - return std::numeric_limits::infinity(); - } - /// \brief Gives back the sum of the given two elements. - static Value plus(const Value& left, const Value& right) { - return left + right; - } - /// \brief Gives back \c true only if the first value is less than - /// the second. - static bool less(const Value& left, const Value& right) { - return left < right; - } - }; - - template - struct BellmanFordDefaultOperationTraits { - typedef V Value; - static Value zero() { - return static_cast(0); - } - static Value infinity() { - return std::numeric_limits::max(); - } - static Value plus(const Value& left, const Value& right) { - if (left == infinity() || right == infinity()) return infinity(); - return left + right; - } - static bool less(const Value& left, const Value& right) { - return left < right; - } - }; - - /// \brief Default traits class of BellmanFord class. - /// - /// Default traits class of BellmanFord class. - /// \param GR The type of the digraph. - /// \param LEN The type of the length map. - template - struct BellmanFordDefaultTraits { - /// The type of the digraph the algorithm runs on. - typedef GR Digraph; - - /// \brief The type of the map that stores the arc lengths. - /// - /// The type of the map that stores the arc lengths. - /// It must conform to the \ref concepts::ReadMap "ReadMap" concept. - typedef LEN LengthMap; - - /// The type of the arc lengths. - typedef typename LEN::Value Value; - - /// \brief Operation traits for Bellman-Ford algorithm. - /// - /// It defines the used operations and the infinity value for the - /// given \c Value type. - /// \see BellmanFordDefaultOperationTraits - typedef BellmanFordDefaultOperationTraits OperationTraits; - - /// \brief The type of the map that stores the last arcs of the - /// shortest paths. - /// - /// The type of the map that stores the last - /// arcs of the shortest paths. - /// It must conform to the \ref concepts::WriteMap "WriteMap" concept. - typedef typename GR::template NodeMap PredMap; - - /// \brief Instantiates a \c PredMap. - /// - /// This function instantiates a \ref PredMap. - /// \param g is the digraph to which we would like to define the - /// \ref PredMap. - static PredMap *createPredMap(const GR& g) { - return new PredMap(g); - } - - /// \brief The type of the map that stores the distances of the nodes. - /// - /// The type of the map that stores the distances of the nodes. - /// It must conform to the \ref concepts::WriteMap "WriteMap" concept. - typedef typename GR::template NodeMap DistMap; - - /// \brief Instantiates a \c DistMap. - /// - /// This function instantiates a \ref DistMap. - /// \param g is the digraph to which we would like to define the - /// \ref DistMap. - static DistMap *createDistMap(const GR& g) { - return new DistMap(g); - } - - }; - - /// \brief %BellmanFord algorithm class. - /// - /// \ingroup shortest_path - /// This class provides an efficient implementation of the Bellman-Ford - /// algorithm. The maximum time complexity of the algorithm is - /// O(ne). - /// - /// The Bellman-Ford algorithm solves the single-source shortest path - /// problem when the arcs can have negative lengths, but the digraph - /// should not contain directed cycles with negative total length. - /// If all arc costs are non-negative, consider to use the Dijkstra - /// algorithm instead, since it is more efficient. - /// - /// The arc lengths are passed to the algorithm using a - /// \ref concepts::ReadMap "ReadMap", so it is easy to change it to any - /// kind of length. The type of the length values is determined by the - /// \ref concepts::ReadMap::Value "Value" type of the length map. - /// - /// There is also a \ref bellmanFord() "function-type interface" for the - /// Bellman-Ford algorithm, which is convenient in the simplier cases and - /// it can be used easier. - /// - /// \tparam GR The type of the digraph the algorithm runs on. - /// The default type is \ref ListDigraph. - /// \tparam LEN A \ref concepts::ReadMap "readable" arc map that specifies - /// the lengths of the arcs. The default map type is - /// \ref concepts::Digraph::ArcMap "GR::ArcMap". - /// \tparam TR The traits class that defines various types used by the - /// algorithm. By default, it is \ref BellmanFordDefaultTraits - /// "BellmanFordDefaultTraits". - /// In most cases, this parameter should not be set directly, - /// consider to use the named template parameters instead. -#ifdef DOXYGEN - template -#else - template , - typename TR=BellmanFordDefaultTraits > -#endif - class BellmanFord { - public: - - ///The type of the underlying digraph. - typedef typename TR::Digraph Digraph; - - /// \brief The type of the arc lengths. - typedef typename TR::LengthMap::Value Value; - /// \brief The type of the map that stores the arc lengths. - typedef typename TR::LengthMap LengthMap; - /// \brief The type of the map that stores the last - /// arcs of the shortest paths. - typedef typename TR::PredMap PredMap; - /// \brief The type of the map that stores the distances of the nodes. - typedef typename TR::DistMap DistMap; - /// The type of the paths. - typedef PredMapPath Path; - ///\brief The \ref BellmanFordDefaultOperationTraits - /// "operation traits class" of the algorithm. - typedef typename TR::OperationTraits OperationTraits; - - ///The \ref BellmanFordDefaultTraits "traits class" of the algorithm. - typedef TR Traits; - - private: - - typedef typename Digraph::Node Node; - typedef typename Digraph::NodeIt NodeIt; - typedef typename Digraph::Arc Arc; - typedef typename Digraph::OutArcIt OutArcIt; - - // Pointer to the underlying digraph. - const Digraph *_gr; - // Pointer to the length map - const LengthMap *_length; - // Pointer to the map of predecessors arcs. - PredMap *_pred; - // Indicates if _pred is locally allocated (true) or not. - bool _local_pred; - // Pointer to the map of distances. - DistMap *_dist; - // Indicates if _dist is locally allocated (true) or not. - bool _local_dist; - - typedef typename Digraph::template NodeMap MaskMap; - MaskMap *_mask; - - std::vector _process; - - // Creates the maps if necessary. - void create_maps() { - if(!_pred) { - _local_pred = true; - _pred = Traits::createPredMap(*_gr); - } - if(!_dist) { - _local_dist = true; - _dist = Traits::createDistMap(*_gr); - } - if(!_mask) { - _mask = new MaskMap(*_gr); - } - } - - public : - - typedef BellmanFord Create; - - /// \name Named Template Parameters - - ///@{ - - template - struct SetPredMapTraits : public Traits { - typedef T PredMap; - static PredMap *createPredMap(const Digraph&) { - LEMON_ASSERT(false, "PredMap is not initialized"); - return 0; // ignore warnings - } - }; - - /// \brief \ref named-templ-param "Named parameter" for setting - /// \c PredMap type. - /// - /// \ref named-templ-param "Named parameter" for setting - /// \c PredMap type. - /// It must conform to the \ref concepts::WriteMap "WriteMap" concept. - template - struct SetPredMap - : public BellmanFord< Digraph, LengthMap, SetPredMapTraits > { - typedef BellmanFord< Digraph, LengthMap, SetPredMapTraits > Create; - }; - - template - struct SetDistMapTraits : public Traits { - typedef T DistMap; - static DistMap *createDistMap(const Digraph&) { - LEMON_ASSERT(false, "DistMap is not initialized"); - return 0; // ignore warnings - } - }; - - /// \brief \ref named-templ-param "Named parameter" for setting - /// \c DistMap type. - /// - /// \ref named-templ-param "Named parameter" for setting - /// \c DistMap type. - /// It must conform to the \ref concepts::WriteMap "WriteMap" concept. - template - struct SetDistMap - : public BellmanFord< Digraph, LengthMap, SetDistMapTraits > { - typedef BellmanFord< Digraph, LengthMap, SetDistMapTraits > Create; - }; - - template - struct SetOperationTraitsTraits : public Traits { - typedef T OperationTraits; - }; - - /// \brief \ref named-templ-param "Named parameter" for setting - /// \c OperationTraits type. - /// - /// \ref named-templ-param "Named parameter" for setting - /// \c OperationTraits type. - /// For more information, see \ref BellmanFordDefaultOperationTraits. - template - struct SetOperationTraits - : public BellmanFord< Digraph, LengthMap, SetOperationTraitsTraits > { - typedef BellmanFord< Digraph, LengthMap, SetOperationTraitsTraits > - Create; - }; - - ///@} - - protected: - - BellmanFord() {} - - public: - - /// \brief Constructor. - /// - /// Constructor. - /// \param g The digraph the algorithm runs on. - /// \param length The length map used by the algorithm. - BellmanFord(const Digraph& g, const LengthMap& length) : - _gr(&g), _length(&length), - _pred(0), _local_pred(false), - _dist(0), _local_dist(false), _mask(0) {} - - ///Destructor. - ~BellmanFord() { - if(_local_pred) delete _pred; - if(_local_dist) delete _dist; - if(_mask) delete _mask; - } - - /// \brief Sets the length map. - /// - /// Sets the length map. - /// \return (*this) - BellmanFord &lengthMap(const LengthMap &map) { - _length = ↦ - return *this; - } - - /// \brief Sets the map that stores the predecessor arcs. - /// - /// Sets the map that stores the predecessor arcs. - /// If you don't use this function before calling \ref run() - /// or \ref init(), an instance will be allocated automatically. - /// The destructor deallocates this automatically allocated map, - /// of course. - /// \return (*this) - BellmanFord &predMap(PredMap &map) { - if(_local_pred) { - delete _pred; - _local_pred=false; - } - _pred = ↦ - return *this; - } - - /// \brief Sets the map that stores the distances of the nodes. - /// - /// Sets the map that stores the distances of the nodes calculated - /// by the algorithm. - /// If you don't use this function before calling \ref run() - /// or \ref init(), an instance will be allocated automatically. - /// The destructor deallocates this automatically allocated map, - /// of course. - /// \return (*this) - BellmanFord &distMap(DistMap &map) { - if(_local_dist) { - delete _dist; - _local_dist=false; - } - _dist = ↦ - return *this; - } - - /// \name Execution Control - /// The simplest way to execute the Bellman-Ford algorithm is to use - /// one of the member functions called \ref run().\n - /// If you need better control on the execution, you have to call - /// \ref init() first, then you can add several source nodes - /// with \ref addSource(). Finally the actual path computation can be - /// performed with \ref start(), \ref checkedStart() or - /// \ref limitedStart(). - - ///@{ - - /// \brief Initializes the internal data structures. - /// - /// Initializes the internal data structures. The optional parameter - /// is the initial distance of each node. - void init(const Value value = OperationTraits::infinity()) { - create_maps(); - for (NodeIt it(*_gr); it != INVALID; ++it) { - _pred->set(it, INVALID); - _dist->set(it, value); - } - _process.clear(); - if (OperationTraits::less(value, OperationTraits::infinity())) { - for (NodeIt it(*_gr); it != INVALID; ++it) { - _process.push_back(it); - _mask->set(it, true); - } - } else { - for (NodeIt it(*_gr); it != INVALID; ++it) { - _mask->set(it, false); - } - } - } - - /// \brief Adds a new source node. - /// - /// This function adds a new source node. The optional second parameter - /// is the initial distance of the node. - void addSource(Node source, Value dst = OperationTraits::zero()) { - _dist->set(source, dst); - if (!(*_mask)[source]) { - _process.push_back(source); - _mask->set(source, true); - } - } - - /// \brief Executes one round from the Bellman-Ford algorithm. - /// - /// If the algoritm calculated the distances in the previous round - /// exactly for the paths of at most \c k arcs, then this function - /// will calculate the distances exactly for the paths of at most - /// k+1 arcs. Performing \c k iterations using this function - /// calculates the shortest path distances exactly for the paths - /// consisting of at most \c k arcs. - /// - /// \warning The paths with limited arc number cannot be retrieved - /// easily with \ref path() or \ref predArc() functions. If you also - /// need the shortest paths and not only the distances, you should - /// store the \ref predMap() "predecessor map" after each iteration - /// and build the path manually. - /// - /// \return \c true when the algorithm have not found more shorter - /// paths. - /// - /// \see ActiveIt - bool processNextRound() { - for (int i = 0; i < int(_process.size()); ++i) { - _mask->set(_process[i], false); - } - std::vector nextProcess; - std::vector values(_process.size()); - for (int i = 0; i < int(_process.size()); ++i) { - values[i] = (*_dist)[_process[i]]; - } - for (int i = 0; i < int(_process.size()); ++i) { - for (OutArcIt it(*_gr, _process[i]); it != INVALID; ++it) { - Node target = _gr->target(it); - Value relaxed = OperationTraits::plus(values[i], (*_length)[it]); - if (OperationTraits::less(relaxed, (*_dist)[target])) { - _pred->set(target, it); - _dist->set(target, relaxed); - if (!(*_mask)[target]) { - _mask->set(target, true); - nextProcess.push_back(target); - } - } - } - } - _process.swap(nextProcess); - return _process.empty(); - } - - /// \brief Executes one weak round from the Bellman-Ford algorithm. - /// - /// If the algorithm calculated the distances in the previous round - /// at least for the paths of at most \c k arcs, then this function - /// will calculate the distances at least for the paths of at most - /// k+1 arcs. - /// This function does not make it possible to calculate the shortest - /// path distances exactly for paths consisting of at most \c k arcs, - /// this is why it is called weak round. - /// - /// \return \c true when the algorithm have not found more shorter - /// paths. - /// - /// \see ActiveIt - bool processNextWeakRound() { - for (int i = 0; i < int(_process.size()); ++i) { - _mask->set(_process[i], false); - } - std::vector nextProcess; - for (int i = 0; i < int(_process.size()); ++i) { - for (OutArcIt it(*_gr, _process[i]); it != INVALID; ++it) { - Node target = _gr->target(it); - Value relaxed = - OperationTraits::plus((*_dist)[_process[i]], (*_length)[it]); - if (OperationTraits::less(relaxed, (*_dist)[target])) { - _pred->set(target, it); - _dist->set(target, relaxed); - if (!(*_mask)[target]) { - _mask->set(target, true); - nextProcess.push_back(target); - } - } - } - } - _process.swap(nextProcess); - return _process.empty(); - } - - /// \brief Executes the algorithm. - /// - /// Executes the algorithm. - /// - /// This method runs the Bellman-Ford algorithm from the root node(s) - /// in order to compute the shortest path to each node. - /// - /// The algorithm computes - /// - the shortest path tree (forest), - /// - the distance of each node from the root(s). - /// - /// \pre init() must be called and at least one root node should be - /// added with addSource() before using this function. - void start() { - int num = countNodes(*_gr) - 1; - for (int i = 0; i < num; ++i) { - if (processNextWeakRound()) break; - } - } - - /// \brief Executes the algorithm and checks the negative cycles. - /// - /// Executes the algorithm and checks the negative cycles. - /// - /// This method runs the Bellman-Ford algorithm from the root node(s) - /// in order to compute the shortest path to each node and also checks - /// if the digraph contains cycles with negative total length. - /// - /// The algorithm computes - /// - the shortest path tree (forest), - /// - the distance of each node from the root(s). - /// - /// \return \c false if there is a negative cycle in the digraph. - /// - /// \pre init() must be called and at least one root node should be - /// added with addSource() before using this function. - bool checkedStart() { - int num = countNodes(*_gr); - for (int i = 0; i < num; ++i) { - if (processNextWeakRound()) return true; - } - return _process.empty(); - } - - /// \brief Executes the algorithm with arc number limit. - /// - /// Executes the algorithm with arc number limit. - /// - /// This method runs the Bellman-Ford algorithm from the root node(s) - /// in order to compute the shortest path distance for each node - /// using only the paths consisting of at most \c num arcs. - /// - /// The algorithm computes - /// - the limited distance of each node from the root(s), - /// - the predecessor arc for each node. - /// - /// \warning The paths with limited arc number cannot be retrieved - /// easily with \ref path() or \ref predArc() functions. If you also - /// need the shortest paths and not only the distances, you should - /// store the \ref predMap() "predecessor map" after each iteration - /// and build the path manually. - /// - /// \pre init() must be called and at least one root node should be - /// added with addSource() before using this function. - void limitedStart(int num) { - for (int i = 0; i < num; ++i) { - if (processNextRound()) break; - } - } - - /// \brief Runs the algorithm from the given root node. - /// - /// This method runs the Bellman-Ford algorithm from the given root - /// node \c s in order to compute the shortest path to each node. - /// - /// The algorithm computes - /// - the shortest path tree (forest), - /// - the distance of each node from the root(s). - /// - /// \note bf.run(s) is just a shortcut of the following code. - /// \code - /// bf.init(); - /// bf.addSource(s); - /// bf.start(); - /// \endcode - void run(Node s) { - init(); - addSource(s); - start(); - } - - /// \brief Runs the algorithm from the given root node with arc - /// number limit. - /// - /// This method runs the Bellman-Ford algorithm from the given root - /// node \c s in order to compute the shortest path distance for each - /// node using only the paths consisting of at most \c num arcs. - /// - /// The algorithm computes - /// - the limited distance of each node from the root(s), - /// - the predecessor arc for each node. - /// - /// \warning The paths with limited arc number cannot be retrieved - /// easily with \ref path() or \ref predArc() functions. If you also - /// need the shortest paths and not only the distances, you should - /// store the \ref predMap() "predecessor map" after each iteration - /// and build the path manually. - /// - /// \note bf.run(s, num) is just a shortcut of the following code. - /// \code - /// bf.init(); - /// bf.addSource(s); - /// bf.limitedStart(num); - /// \endcode - void run(Node s, int num) { - init(); - addSource(s); - limitedStart(num); - } - - ///@} - - /// \brief LEMON iterator for getting the active nodes. - /// - /// This class provides a common style LEMON iterator that traverses - /// the active nodes of the Bellman-Ford algorithm after the last - /// phase. These nodes should be checked in the next phase to - /// find augmenting arcs outgoing from them. - class ActiveIt { - public: - - /// \brief Constructor. - /// - /// Constructor for getting the active nodes of the given BellmanFord - /// instance. - ActiveIt(const BellmanFord& algorithm) : _algorithm(&algorithm) - { - _index = _algorithm->_process.size() - 1; - } - - /// \brief Invalid constructor. - /// - /// Invalid constructor. - ActiveIt(Invalid) : _algorithm(0), _index(-1) {} - - /// \brief Conversion to \c Node. - /// - /// Conversion to \c Node. - operator Node() const { - return _index >= 0 ? _algorithm->_process[_index] : INVALID; - } - - /// \brief Increment operator. - /// - /// Increment operator. - ActiveIt& operator++() { - --_index; - return *this; - } - - bool operator==(const ActiveIt& it) const { - return static_cast(*this) == static_cast(it); - } - bool operator!=(const ActiveIt& it) const { - return static_cast(*this) != static_cast(it); - } - bool operator<(const ActiveIt& it) const { - return static_cast(*this) < static_cast(it); - } - - private: - const BellmanFord* _algorithm; - int _index; - }; - - /// \name Query Functions - /// The result of the Bellman-Ford algorithm can be obtained using these - /// functions.\n - /// Either \ref run() or \ref init() should be called before using them. - - ///@{ - - /// \brief The shortest path to the given node. - /// - /// Gives back the shortest path to the given node from the root(s). - /// - /// \warning \c t should be reached from the root(s). - /// - /// \pre Either \ref run() or \ref init() must be called before - /// using this function. - Path path(Node t) const - { - return Path(*_gr, *_pred, t); - } - - /// \brief The distance of the given node from the root(s). - /// - /// Returns the distance of the given node from the root(s). - /// - /// \warning If node \c v is not reached from the root(s), then - /// the return value of this function is undefined. - /// - /// \pre Either \ref run() or \ref init() must be called before - /// using this function. - Value dist(Node v) const { return (*_dist)[v]; } - - /// \brief Returns the 'previous arc' of the shortest path tree for - /// the given node. - /// - /// This function returns the 'previous arc' of the shortest path - /// tree for node \c v, i.e. it returns the last arc of a - /// shortest path from a root to \c v. It is \c INVALID if \c v - /// is not reached from the root(s) or if \c v is a root. - /// - /// The shortest path tree used here is equal to the shortest path - /// tree used in \ref predNode() and \ref predMap(). - /// - /// \pre Either \ref run() or \ref init() must be called before - /// using this function. - Arc predArc(Node v) const { return (*_pred)[v]; } - - /// \brief Returns the 'previous node' of the shortest path tree for - /// the given node. - /// - /// This function returns the 'previous node' of the shortest path - /// tree for node \c v, i.e. it returns the last but one node of - /// a shortest path from a root to \c v. It is \c INVALID if \c v - /// is not reached from the root(s) or if \c v is a root. - /// - /// The shortest path tree used here is equal to the shortest path - /// tree used in \ref predArc() and \ref predMap(). - /// - /// \pre Either \ref run() or \ref init() must be called before - /// using this function. - Node predNode(Node v) const { - return (*_pred)[v] == INVALID ? INVALID : _gr->source((*_pred)[v]); - } - - /// \brief Returns a const reference to the node map that stores the - /// distances of the nodes. - /// - /// Returns a const reference to the node map that stores the distances - /// of the nodes calculated by the algorithm. - /// - /// \pre Either \ref run() or \ref init() must be called before - /// using this function. - const DistMap &distMap() const { return *_dist;} - - /// \brief Returns a const reference to the node map that stores the - /// predecessor arcs. - /// - /// Returns a const reference to the node map that stores the predecessor - /// arcs, which form the shortest path tree (forest). - /// - /// \pre Either \ref run() or \ref init() must be called before - /// using this function. - const PredMap &predMap() const { return *_pred; } - - /// \brief Checks if a node is reached from the root(s). - /// - /// Returns \c true if \c v is reached from the root(s). - /// - /// \pre Either \ref run() or \ref init() must be called before - /// using this function. - bool reached(Node v) const { - return (*_dist)[v] != OperationTraits::infinity(); - } - - /// \brief Gives back a negative cycle. - /// - /// This function gives back a directed cycle with negative total - /// length if the algorithm has already found one. - /// Otherwise it gives back an empty path. - lemon::Path negativeCycle() const { - typename Digraph::template NodeMap state(*_gr, -1); - lemon::Path cycle; - for (int i = 0; i < int(_process.size()); ++i) { - if (state[_process[i]] != -1) continue; - for (Node v = _process[i]; (*_pred)[v] != INVALID; - v = _gr->source((*_pred)[v])) { - if (state[v] == i) { - cycle.addFront((*_pred)[v]); - for (Node u = _gr->source((*_pred)[v]); u != v; - u = _gr->source((*_pred)[u])) { - cycle.addFront((*_pred)[u]); - } - return cycle; - } - else if (state[v] >= 0) { - break; - } - state[v] = i; - } - } - return cycle; - } - - ///@} - }; - - /// \brief Default traits class of bellmanFord() function. - /// - /// Default traits class of bellmanFord() function. - /// \tparam GR The type of the digraph. - /// \tparam LEN The type of the length map. - template - struct BellmanFordWizardDefaultTraits { - /// The type of the digraph the algorithm runs on. - typedef GR Digraph; - - /// \brief The type of the map that stores the arc lengths. - /// - /// The type of the map that stores the arc lengths. - /// It must meet the \ref concepts::ReadMap "ReadMap" concept. - typedef LEN LengthMap; - - /// The type of the arc lengths. - typedef typename LEN::Value Value; - - /// \brief Operation traits for Bellman-Ford algorithm. - /// - /// It defines the used operations and the infinity value for the - /// given \c Value type. - /// \see BellmanFordDefaultOperationTraits - typedef BellmanFordDefaultOperationTraits OperationTraits; - - /// \brief The type of the map that stores the last - /// arcs of the shortest paths. - /// - /// The type of the map that stores the last arcs of the shortest paths. - /// It must conform to the \ref concepts::WriteMap "WriteMap" concept. - typedef typename GR::template NodeMap PredMap; - - /// \brief Instantiates a \c PredMap. - /// - /// This function instantiates a \ref PredMap. - /// \param g is the digraph to which we would like to define the - /// \ref PredMap. - static PredMap *createPredMap(const GR &g) { - return new PredMap(g); - } - - /// \brief The type of the map that stores the distances of the nodes. - /// - /// The type of the map that stores the distances of the nodes. - /// It must conform to the \ref concepts::WriteMap "WriteMap" concept. - typedef typename GR::template NodeMap DistMap; - - /// \brief Instantiates a \c DistMap. - /// - /// This function instantiates a \ref DistMap. - /// \param g is the digraph to which we would like to define the - /// \ref DistMap. - static DistMap *createDistMap(const GR &g) { - return new DistMap(g); - } - - ///The type of the shortest paths. - - ///The type of the shortest paths. - ///It must meet the \ref concepts::Path "Path" concept. - typedef lemon::Path Path; - }; - - /// \brief Default traits class used by BellmanFordWizard. - /// - /// Default traits class used by BellmanFordWizard. - /// \tparam GR The type of the digraph. - /// \tparam LEN The type of the length map. - template - class BellmanFordWizardBase - : public BellmanFordWizardDefaultTraits { - - typedef BellmanFordWizardDefaultTraits Base; - protected: - // Type of the nodes in the digraph. - typedef typename Base::Digraph::Node Node; - - // Pointer to the underlying digraph. - void *_graph; - // Pointer to the length map - void *_length; - // Pointer to the map of predecessors arcs. - void *_pred; - // Pointer to the map of distances. - void *_dist; - //Pointer to the shortest path to the target node. - void *_path; - //Pointer to the distance of the target node. - void *_di; - - public: - /// Constructor. - - /// This constructor does not require parameters, it initiates - /// all of the attributes to default values \c 0. - BellmanFordWizardBase() : - _graph(0), _length(0), _pred(0), _dist(0), _path(0), _di(0) {} - - /// Constructor. - - /// This constructor requires two parameters, - /// others are initiated to \c 0. - /// \param gr The digraph the algorithm runs on. - /// \param len The length map. - BellmanFordWizardBase(const GR& gr, - const LEN& len) : - _graph(reinterpret_cast(const_cast(&gr))), - _length(reinterpret_cast(const_cast(&len))), - _pred(0), _dist(0), _path(0), _di(0) {} - - }; - - /// \brief Auxiliary class for the function-type interface of the - /// \ref BellmanFord "Bellman-Ford" algorithm. - /// - /// This auxiliary class is created to implement the - /// \ref bellmanFord() "function-type interface" of the - /// \ref BellmanFord "Bellman-Ford" algorithm. - /// It does not have own \ref run() method, it uses the - /// functions and features of the plain \ref BellmanFord. - /// - /// This class should only be used through the \ref bellmanFord() - /// function, which makes it easier to use the algorithm. - /// - /// \tparam TR The traits class that defines various types used by the - /// algorithm. - template - class BellmanFordWizard : public TR { - typedef TR Base; - - typedef typename TR::Digraph Digraph; - - typedef typename Digraph::Node Node; - typedef typename Digraph::NodeIt NodeIt; - typedef typename Digraph::Arc Arc; - typedef typename Digraph::OutArcIt ArcIt; - - typedef typename TR::LengthMap LengthMap; - typedef typename LengthMap::Value Value; - typedef typename TR::PredMap PredMap; - typedef typename TR::DistMap DistMap; - typedef typename TR::Path Path; - - public: - /// Constructor. - BellmanFordWizard() : TR() {} - - /// \brief Constructor that requires parameters. - /// - /// Constructor that requires parameters. - /// These parameters will be the default values for the traits class. - /// \param gr The digraph the algorithm runs on. - /// \param len The length map. - BellmanFordWizard(const Digraph& gr, const LengthMap& len) - : TR(gr, len) {} - - /// \brief Copy constructor - BellmanFordWizard(const TR &b) : TR(b) {} - - ~BellmanFordWizard() {} - - /// \brief Runs the Bellman-Ford algorithm from the given source node. - /// - /// This method runs the Bellman-Ford algorithm from the given source - /// node in order to compute the shortest path to each node. - void run(Node s) { - BellmanFord - bf(*reinterpret_cast(Base::_graph), - *reinterpret_cast(Base::_length)); - if (Base::_pred) bf.predMap(*reinterpret_cast(Base::_pred)); - if (Base::_dist) bf.distMap(*reinterpret_cast(Base::_dist)); - bf.run(s); - } - - /// \brief Runs the Bellman-Ford algorithm to find the shortest path - /// between \c s and \c t. - /// - /// This method runs the Bellman-Ford algorithm from node \c s - /// in order to compute the shortest path to node \c t. - /// Actually, it computes the shortest path to each node, but using - /// this function you can retrieve the distance and the shortest path - /// for a single target node easier. - /// - /// \return \c true if \c t is reachable form \c s. - bool run(Node s, Node t) { - BellmanFord - bf(*reinterpret_cast(Base::_graph), - *reinterpret_cast(Base::_length)); - if (Base::_pred) bf.predMap(*reinterpret_cast(Base::_pred)); - if (Base::_dist) bf.distMap(*reinterpret_cast(Base::_dist)); - bf.run(s); - if (Base::_path) *reinterpret_cast(Base::_path) = bf.path(t); - if (Base::_di) *reinterpret_cast(Base::_di) = bf.dist(t); - return bf.reached(t); - } - - template - struct SetPredMapBase : public Base { - typedef T PredMap; - static PredMap *createPredMap(const Digraph &) { return 0; }; - SetPredMapBase(const TR &b) : TR(b) {} - }; - - /// \brief \ref named-templ-param "Named parameter" for setting - /// the predecessor map. - /// - /// \ref named-templ-param "Named parameter" for setting - /// the map that stores the predecessor arcs of the nodes. - template - BellmanFordWizard > predMap(const T &t) { - Base::_pred=reinterpret_cast(const_cast(&t)); - return BellmanFordWizard >(*this); - } - - template - struct SetDistMapBase : public Base { - typedef T DistMap; - static DistMap *createDistMap(const Digraph &) { return 0; }; - SetDistMapBase(const TR &b) : TR(b) {} - }; - - /// \brief \ref named-templ-param "Named parameter" for setting - /// the distance map. - /// - /// \ref named-templ-param "Named parameter" for setting - /// the map that stores the distances of the nodes calculated - /// by the algorithm. - template - BellmanFordWizard > distMap(const T &t) { - Base::_dist=reinterpret_cast(const_cast(&t)); - return BellmanFordWizard >(*this); - } - - template - struct SetPathBase : public Base { - typedef T Path; - SetPathBase(const TR &b) : TR(b) {} - }; - - /// \brief \ref named-func-param "Named parameter" for getting - /// the shortest path to the target node. - /// - /// \ref named-func-param "Named parameter" for getting - /// the shortest path to the target node. - template - BellmanFordWizard > path(const T &t) - { - Base::_path=reinterpret_cast(const_cast(&t)); - return BellmanFordWizard >(*this); - } - - /// \brief \ref named-func-param "Named parameter" for getting - /// the distance of the target node. - /// - /// \ref named-func-param "Named parameter" for getting - /// the distance of the target node. - BellmanFordWizard dist(const Value &d) - { - Base::_di=reinterpret_cast(const_cast(&d)); - return *this; - } - - }; - - /// \brief Function type interface for the \ref BellmanFord "Bellman-Ford" - /// algorithm. - /// - /// \ingroup shortest_path - /// Function type interface for the \ref BellmanFord "Bellman-Ford" - /// algorithm. - /// - /// This function also has several \ref named-templ-func-param - /// "named parameters", they are declared as the members of class - /// \ref BellmanFordWizard. - /// The following examples show how to use these parameters. - /// \code - /// // Compute shortest path from node s to each node - /// bellmanFord(g,length).predMap(preds).distMap(dists).run(s); - /// - /// // Compute shortest path from s to t - /// bool reached = bellmanFord(g,length).path(p).dist(d).run(s,t); - /// \endcode - /// \warning Don't forget to put the \ref BellmanFordWizard::run() "run()" - /// to the end of the parameter list. - /// \sa BellmanFordWizard - /// \sa BellmanFord - template - BellmanFordWizard > - bellmanFord(const GR& digraph, - const LEN& length) - { - return BellmanFordWizard >(digraph, length); - } - -} //END OF NAMESPACE LEMON - -#endif - Index: lemon/bfs.h =================================================================== --- lemon/bfs.h (revision 976) +++ lemon/bfs.h (revision 975) @@ -3,5 +3,5 @@ * This file is a part of LEMON, a generic C++ optimization library. * - * Copyright (C) 2003-2010 + * Copyright (C) 2003-2009 * Egervary Jeno Kombinatorikus Optimalizalasi Kutatocsoport * (Egervary Research Group on Combinatorial Optimization, EGRES). @@ -48,5 +48,5 @@ ///The type of the map that stores the predecessor ///arcs of the shortest paths. - ///It must conform to the \ref concepts::WriteMap "WriteMap" concept. + ///It must meet the \ref concepts::WriteMap "WriteMap" concept. typedef typename Digraph::template NodeMap PredMap; ///Instantiates a \c PredMap. @@ -63,6 +63,5 @@ ///The type of the map that indicates which nodes are processed. - ///It must conform to the \ref concepts::WriteMap "WriteMap" concept. - ///By default, it is a NullMap. + ///It must meet the \ref concepts::WriteMap "WriteMap" concept. typedef NullMap ProcessedMap; ///Instantiates a \c ProcessedMap. @@ -83,6 +82,5 @@ ///The type of the map that indicates which nodes are reached. - ///It must conform to - ///the \ref concepts::ReadWriteMap "ReadWriteMap" concept. + ///It must meet the \ref concepts::ReadWriteMap "ReadWriteMap" concept. typedef typename Digraph::template NodeMap ReachedMap; ///Instantiates a \c ReachedMap. @@ -99,5 +97,5 @@ ///The type of the map that stores the distances of the nodes. - ///It must conform to the \ref concepts::WriteMap "WriteMap" concept. + ///It must meet the \ref concepts::WriteMap "WriteMap" concept. typedef typename Digraph::template NodeMap DistMap; ///Instantiates a \c DistMap. @@ -123,9 +121,4 @@ ///\tparam GR The type of the digraph the algorithm runs on. ///The default type is \ref ListDigraph. - ///\tparam TR The traits class that defines various types used by the - ///algorithm. By default, it is \ref BfsDefaultTraits - ///"BfsDefaultTraits". - ///In most cases, this parameter should not be set directly, - ///consider to use the named template parameters instead. #ifdef DOXYGEN template struct SetPredMap : public Bfs< Digraph, SetPredMapTraits > { @@ -253,5 +246,5 @@ ///\ref named-templ-param "Named parameter" for setting ///\c DistMap type. - ///It must conform to the \ref concepts::WriteMap "WriteMap" concept. + ///It must meet the \ref concepts::WriteMap "WriteMap" concept. template struct SetDistMap : public Bfs< Digraph, SetDistMapTraits > { @@ -273,6 +266,5 @@ ///\ref named-templ-param "Named parameter" for setting ///\c ReachedMap type. - ///It must conform to - ///the \ref concepts::ReadWriteMap "ReadWriteMap" concept. + ///It must meet the \ref concepts::ReadWriteMap "ReadWriteMap" concept. template struct SetReachedMap : public Bfs< Digraph, SetReachedMapTraits > { @@ -294,5 +286,5 @@ ///\ref named-templ-param "Named parameter" for setting ///\c ProcessedMap type. - ///It must conform to the \ref concepts::WriteMap "WriteMap" concept. + ///It must meet the \ref concepts::WriteMap "WriteMap" concept. template struct SetProcessedMap : public Bfs< Digraph, SetProcessedMapTraits > { @@ -422,6 +414,6 @@ ///The simplest way to execute the BFS algorithm is to use one of the ///member functions called \ref run(Node) "run()".\n - ///If you need better control on the execution, you have to call - ///\ref init() first, then you can add several source nodes with + ///If you need more control on the execution, first you have to call + ///\ref init(), then you can add several source nodes with ///\ref addSource(). Finally the actual path computation can be ///performed with one of the \ref start() functions. @@ -709,6 +701,10 @@ ///Runs the algorithm to visit all nodes in the digraph. - ///This method runs the %BFS algorithm in order to visit all nodes - ///in the digraph. + ///This method runs the %BFS algorithm in order to + ///compute the shortest path to each node. + /// + ///The algorithm computes + ///- the shortest path tree (forest), + ///- the distance of each node from the root(s). /// ///\note b.run(s) is just a shortcut of the following code. @@ -742,7 +738,7 @@ ///@{ - ///The shortest path to the given node. - - ///Returns the shortest path to the given node from the root(s). + ///The shortest path to a node. + + ///Returns the shortest path to a node. /// ///\warning \c t should be reached from the root(s). @@ -752,7 +748,7 @@ Path path(Node t) const { return Path(*G, *_pred, t); } - ///The distance of the given node from the root(s). - - ///Returns the distance of the given node from the root(s). + ///The distance of a node from the root(s). + + ///Returns the distance of a node from the root(s). /// ///\warning If node \c v is not reached from the root(s), then @@ -763,7 +759,6 @@ int dist(Node v) const { return (*_dist)[v]; } - ///\brief Returns the 'previous arc' of the shortest path tree for - ///the given node. - /// + ///Returns the 'previous arc' of the shortest path tree for a node. + ///This function returns the 'previous arc' of the shortest path ///tree for the node \c v, i.e. it returns the last arc of a @@ -772,5 +767,5 @@ /// ///The shortest path tree used here is equal to the shortest path - ///tree used in \ref predNode() and \ref predMap(). + ///tree used in \ref predNode(). /// ///\pre Either \ref run(Node) "run()" or \ref init() @@ -778,14 +773,13 @@ Arc predArc(Node v) const { return (*_pred)[v];} - ///\brief Returns the 'previous node' of the shortest path tree for - ///the given node. - /// + ///Returns the 'previous node' of the shortest path tree for a node. + ///This function returns the 'previous node' of the shortest path ///tree for the node \c v, i.e. it returns the last but one node - ///of a shortest path from a root to \c v. It is \c INVALID + ///from a shortest path from a root to \c v. It is \c INVALID ///if \c v is not reached from the root(s) or if \c v is a root. /// ///The shortest path tree used here is equal to the shortest path - ///tree used in \ref predArc() and \ref predMap(). + ///tree used in \ref predArc(). /// ///\pre Either \ref run(Node) "run()" or \ref init() @@ -808,5 +802,5 @@ /// ///Returns a const reference to the node map that stores the predecessor - ///arcs, which form the shortest path tree (forest). + ///arcs, which form the shortest path tree. /// ///\pre Either \ref run(Node) "run()" or \ref init() @@ -814,5 +808,5 @@ const PredMap &predMap() const { return *_pred;} - ///Checks if the given node is reached from the root(s). + ///Checks if a node is reached from the root(s). ///Returns \c true if \c v is reached from the root(s). @@ -840,5 +834,5 @@ ///The type of the map that stores the predecessor ///arcs of the shortest paths. - ///It must conform to the \ref concepts::WriteMap "WriteMap" concept. + ///It must meet the \ref concepts::WriteMap "WriteMap" concept. typedef typename Digraph::template NodeMap PredMap; ///Instantiates a PredMap. @@ -855,6 +849,6 @@ ///The type of the map that indicates which nodes are processed. - ///It must conform to the \ref concepts::WriteMap "WriteMap" concept. - ///By default, it is a NullMap. + ///It must meet the \ref concepts::WriteMap "WriteMap" concept. + ///By default it is a NullMap. typedef NullMap ProcessedMap; ///Instantiates a ProcessedMap. @@ -875,6 +869,5 @@ ///The type of the map that indicates which nodes are reached. - ///It must conform to - ///the \ref concepts::ReadWriteMap "ReadWriteMap" concept. + ///It must meet the \ref concepts::ReadWriteMap "ReadWriteMap" concept. typedef typename Digraph::template NodeMap ReachedMap; ///Instantiates a ReachedMap. @@ -891,5 +884,5 @@ ///The type of the map that stores the distances of the nodes. - ///It must conform to the \ref concepts::WriteMap "WriteMap" concept. + ///It must meet the \ref concepts::WriteMap "WriteMap" concept. typedef typename Digraph::template NodeMap DistMap; ///Instantiates a DistMap. @@ -906,5 +899,5 @@ ///The type of the shortest paths. - ///It must conform to the \ref concepts::Path "Path" concept. + ///It must meet the \ref concepts::Path "Path" concept. typedef lemon::Path Path; }; @@ -912,6 +905,10 @@ /// Default traits class used by BfsWizard - /// Default traits class used by BfsWizard. - /// \tparam GR The type of the digraph. + /// To make it easier to use Bfs algorithm + /// we have created a wizard class. + /// This \ref BfsWizard class needs default traits, + /// as well as the \ref Bfs class. + /// The \ref BfsWizardBase is a class to be the default traits of the + /// \ref BfsWizard class. template class BfsWizardBase : public BfsWizardDefaultTraits @@ -941,5 +938,5 @@ /// Constructor. - /// This constructor does not require parameters, it initiates + /// This constructor does not require parameters, therefore it initiates /// all of the attributes to \c 0. BfsWizardBase() : _g(0), _reached(0), _processed(0), _pred(0), @@ -966,7 +963,4 @@ /// This class should only be used through the \ref bfs() function, /// which makes it easier to use the algorithm. - /// - /// \tparam TR The traits class that defines various types used by the - /// algorithm. template class BfsWizard : public TR @@ -974,4 +968,5 @@ typedef TR Base; + ///The type of the digraph the algorithm runs on. typedef typename TR::Digraph Digraph; @@ -981,8 +976,14 @@ typedef typename Digraph::OutArcIt OutArcIt; + ///\brief The type of the map that stores the predecessor + ///arcs of the shortest paths. typedef typename TR::PredMap PredMap; + ///\brief The type of the map that stores the distances of the nodes. typedef typename TR::DistMap DistMap; + ///\brief The type of the map that indicates which nodes are reached. typedef typename TR::ReachedMap ReachedMap; + ///\brief The type of the map that indicates which nodes are processed. typedef typename TR::ProcessedMap ProcessedMap; + ///The type of the shortest paths typedef typename TR::Path Path; @@ -1054,6 +1055,6 @@ ///Runs BFS algorithm to visit all nodes in the digraph. - ///This method runs BFS algorithm in order to visit all nodes - ///in the digraph. + ///This method runs BFS algorithm in order to compute + ///the shortest path to each node. void run() { @@ -1067,10 +1068,9 @@ SetPredMapBase(const TR &b) : TR(b) {} }; - - ///\brief \ref named-templ-param "Named parameter" for setting - ///the predecessor map. - /// - ///\ref named-templ-param "Named parameter" function for setting - ///the map that stores the predecessor arcs of the nodes. + ///\brief \ref named-func-param "Named parameter" + ///for setting PredMap object. + /// + ///\ref named-func-param "Named parameter" + ///for setting PredMap object. template BfsWizard > predMap(const T &t) @@ -1086,10 +1086,9 @@ SetReachedMapBase(const TR &b) : TR(b) {} }; - - ///\brief \ref named-templ-param "Named parameter" for setting - ///the reached map. - /// - ///\ref named-templ-param "Named parameter" function for setting - ///the map that indicates which nodes are reached. + ///\brief \ref named-func-param "Named parameter" + ///for setting ReachedMap object. + /// + /// \ref named-func-param "Named parameter" + ///for setting ReachedMap object. template BfsWizard > reachedMap(const T &t) @@ -1105,11 +1104,9 @@ SetDistMapBase(const TR &b) : TR(b) {} }; - - ///\brief \ref named-templ-param "Named parameter" for setting - ///the distance map. - /// - ///\ref named-templ-param "Named parameter" function for setting - ///the map that stores the distances of the nodes calculated - ///by the algorithm. + ///\brief \ref named-func-param "Named parameter" + ///for setting DistMap object. + /// + /// \ref named-func-param "Named parameter" + ///for setting DistMap object. template BfsWizard > distMap(const T &t) @@ -1125,10 +1122,9 @@ SetProcessedMapBase(const TR &b) : TR(b) {} }; - - ///\brief \ref named-func-param "Named parameter" for setting - ///the processed map. - /// - ///\ref named-templ-param "Named parameter" function for setting - ///the map that indicates which nodes are processed. + ///\brief \ref named-func-param "Named parameter" + ///for setting ProcessedMap object. + /// + /// \ref named-func-param "Named parameter" + ///for setting ProcessedMap object. template BfsWizard > processedMap(const T &t) @@ -1270,6 +1266,5 @@ /// /// The type of the map that indicates which nodes are reached. - /// It must conform to - ///the \ref concepts::ReadWriteMap "ReadWriteMap" concept. + /// It must meet the \ref concepts::ReadWriteMap "ReadWriteMap" concept. typedef typename Digraph::template NodeMap ReachedMap; @@ -1309,9 +1304,9 @@ /// does not observe the BFS events. If you want to observe the BFS /// events, you should implement your own visitor class. - /// \tparam TR The traits class that defines various types used by the - /// algorithm. By default, it is \ref BfsVisitDefaultTraits - /// "BfsVisitDefaultTraits". - /// In most cases, this parameter should not be set directly, - /// consider to use the named template parameters instead. + /// \tparam TR Traits class to set various data types used by the + /// algorithm. The default traits class is + /// \ref BfsVisitDefaultTraits "BfsVisitDefaultTraits". + /// See \ref BfsVisitDefaultTraits for the documentation of + /// a BFS visit traits class. #ifdef DOXYGEN template @@ -1432,6 +1427,6 @@ /// The simplest way to execute the BFS algorithm is to use one of the /// member functions called \ref run(Node) "run()".\n - /// If you need better control on the execution, you have to call - /// \ref init() first, then you can add several source nodes with + /// If you need more control on the execution, first you have to call + /// \ref init(), then you can add several source nodes with /// \ref addSource(). Finally the actual path computation can be /// performed with one of the \ref start() functions. @@ -1705,6 +1700,10 @@ /// \brief Runs the algorithm to visit all nodes in the digraph. /// - /// This method runs the %BFS algorithm in order to visit all nodes - /// in the digraph. + /// This method runs the %BFS algorithm in order to + /// compute the shortest path to each node. + /// + /// The algorithm computes + /// - the shortest path tree (forest), + /// - the distance of each node from the root(s). /// /// \note b.run(s) is just a shortcut of the following code. @@ -1738,5 +1737,5 @@ ///@{ - /// \brief Checks if the given node is reached from the root(s). + /// \brief Checks if a node is reached from the root(s). /// /// Returns \c true if \c v is reached from the root(s). Index: lemon/bin_heap.h =================================================================== --- lemon/bin_heap.h (revision 711) +++ lemon/bin_heap.h (revision 683) @@ -20,7 +20,7 @@ #define LEMON_BIN_HEAP_H -///\ingroup heaps +///\ingroup auxdat ///\file -///\brief Binary heap implementation. +///\brief Binary Heap implementation. #include @@ -30,39 +30,43 @@ namespace lemon { - /// \ingroup heaps - /// - /// \brief Binary heap data structure. - /// - /// This class implements the \e binary \e heap data structure. - /// It fully conforms to the \ref concepts::Heap "heap concept". - /// - /// \tparam PR Type of the priorities of the items. - /// \tparam IM A read-writable item map with \c int values, used - /// internally to handle the cross references. - /// \tparam CMP A functor class for comparing the priorities. - /// The default is \c std::less. -#ifdef DOXYGEN - template -#else + ///\ingroup auxdat + /// + ///\brief A Binary Heap implementation. + /// + ///This class implements the \e binary \e heap data structure. + /// + ///A \e heap is a data structure for storing items with specified values + ///called \e priorities in such a way that finding the item with minimum + ///priority is efficient. \c CMP specifies the ordering of the priorities. + ///In a heap one can change the priority of an item, add or erase an + ///item, etc. + /// + ///\tparam PR Type of the priority of the items. + ///\tparam IM A read and writable item map with int values, used internally + ///to handle the cross references. + ///\tparam CMP A functor class for the ordering of the priorities. + ///The default is \c std::less. + /// + ///\sa FibHeap + ///\sa Dijkstra template > -#endif class BinHeap { + public: - - /// Type of the item-int map. + ///\e typedef IM ItemIntMap; - /// Type of the priorities. + ///\e typedef PR Prio; - /// Type of the items stored in the heap. + ///\e typedef typename ItemIntMap::Key Item; - /// Type of the item-priority pairs. + ///\e typedef std::pair Pair; - /// Functor type for comparing the priorities. + ///\e typedef CMP Compare; - /// \brief Type to represent the states of the items. - /// - /// Each item has a state associated to it. It can be "in heap", - /// "pre-heap" or "post-heap". The latter two are indifferent from the + /// \brief Type to represent the items states. + /// + /// Each Item element have a state associated to it. It may be "in heap", + /// "pre heap" or "post heap". The latter two are indifferent from the /// heap's point of view, but may be useful to the user. /// @@ -81,41 +85,40 @@ public: - - /// \brief Constructor. - /// - /// Constructor. - /// \param map A map that assigns \c int values to the items. - /// It is used internally to handle the cross references. - /// The assigned value must be \c PRE_HEAP (-1) for each item. + /// \brief The constructor. + /// + /// The constructor. + /// \param map should be given to the constructor, since it is used + /// internally to handle the cross references. The value of the map + /// must be \c PRE_HEAP (-1) for every item. explicit BinHeap(ItemIntMap &map) : _iim(map) {} - /// \brief Constructor. - /// - /// Constructor. - /// \param map A map that assigns \c int values to the items. - /// It is used internally to handle the cross references. - /// The assigned value must be \c PRE_HEAP (-1) for each item. - /// \param comp The function object used for comparing the priorities. + /// \brief The constructor. + /// + /// The constructor. + /// \param map should be given to the constructor, since it is used + /// internally to handle the cross references. The value of the map + /// should be PRE_HEAP (-1) for each element. + /// + /// \param comp The comparator function object. BinHeap(ItemIntMap &map, const Compare &comp) : _iim(map), _comp(comp) {} - /// \brief The number of items stored in the heap. - /// - /// This function returns the number of items stored in the heap. + /// The number of items stored in the heap. + /// + /// \brief Returns the number of items stored in the heap. int size() const { return _data.size(); } - /// \brief Check if the heap is empty. - /// - /// This function returns \c true if the heap is empty. + /// \brief Checks if the heap stores no items. + /// + /// Returns \c true if and only if the heap stores no items. bool empty() const { return _data.empty(); } - /// \brief Make the heap empty. - /// - /// This functon makes the heap empty. - /// It does not change the cross reference map. If you want to reuse - /// a heap that is not surely empty, you should first clear it and - /// then you should set the cross reference map to \c PRE_HEAP - /// for each item. + /// \brief Make empty this heap. + /// + /// Make empty this heap. It does not change the cross reference map. + /// If you want to reuse what is not surely empty you should first clear + /// the heap and after that you should set the cross reference map for + /// each item to \c PRE_HEAP. void clear() { _data.clear(); @@ -125,10 +128,10 @@ static int parent(int i) { return (i-1)/2; } - static int secondChild(int i) { return 2*i+2; } + static int second_child(int i) { return 2*i+2; } bool less(const Pair &p1, const Pair &p2) const { return _comp(p1.second, p2.second); } - int bubbleUp(int hole, Pair p) { + int bubble_up(int hole, Pair p) { int par = parent(hole); while( hole>0 && less(p,_data[par]) ) { @@ -141,6 +144,6 @@ } - int bubbleDown(int hole, Pair p, int length) { - int child = secondChild(hole); + int bubble_down(int hole, Pair p, int length) { + int child = second_child(hole); while(child < length) { if( less(_data[child-1], _data[child]) ) { @@ -151,5 +154,5 @@ move(_data[child], hole); hole = child; - child = secondChild(hole); + child = second_child(hole); } child--; @@ -169,45 +172,42 @@ public: - /// \brief Insert a pair of item and priority into the heap. /// - /// This function inserts \c p.first to the heap with priority - /// \c p.second. + /// Adds \c p.first to the heap with priority \c p.second. /// \param p The pair to insert. - /// \pre \c p.first must not be stored in the heap. void push(const Pair &p) { int n = _data.size(); _data.resize(n+1); - bubbleUp(n, p); - } - - /// \brief Insert an item into the heap with the given priority. - /// - /// This function inserts the given item into the heap with the - /// given priority. + bubble_up(n, p); + } + + /// \brief Insert an item into the heap with the given heap. + /// + /// Adds \c i to the heap with priority \c p. /// \param i The item to insert. /// \param p The priority of the item. - /// \pre \e i must not be stored in the heap. void push(const Item &i, const Prio &p) { push(Pair(i,p)); } - /// \brief Return the item having minimum priority. - /// - /// This function returns the item having minimum priority. - /// \pre The heap must be non-empty. + /// \brief Returns the item with minimum priority relative to \c Compare. + /// + /// This method returns the item with minimum priority relative to \c + /// Compare. + /// \pre The heap must be nonempty. Item top() const { return _data[0].first; } - /// \brief The minimum priority. - /// - /// This function returns the minimum priority. - /// \pre The heap must be non-empty. + /// \brief Returns the minimum priority relative to \c Compare. + /// + /// It returns the minimum priority relative to \c Compare. + /// \pre The heap must be nonempty. Prio prio() const { return _data[0].second; } - /// \brief Remove the item having minimum priority. - /// - /// This function removes the item having minimum priority. + /// \brief Deletes the item with minimum priority relative to \c Compare. + /// + /// This method deletes the item with minimum priority relative to \c + /// Compare from the heap. /// \pre The heap must be non-empty. void pop() { @@ -215,15 +215,14 @@ _iim.set(_data[0].first, POST_HEAP); if (n > 0) { - bubbleDown(0, _data[n], n); + bubble_down(0, _data[n], n); } _data.pop_back(); } - /// \brief Remove the given item from the heap. - /// - /// This function removes the given item from the heap if it is - /// already stored. - /// \param i The item to delete. - /// \pre \e i must be in the heap. + /// \brief Deletes \c i from the heap. + /// + /// This method deletes item \c i from the heap. + /// \param i The item to erase. + /// \pre The item should be in the heap. void erase(const Item &i) { int h = _iim[i]; @@ -231,6 +230,6 @@ _iim.set(_data[h].first, POST_HEAP); if( h < n ) { - if ( bubbleUp(h, _data[n]) == h) { - bubbleDown(h, _data[n], n); + if ( bubble_up(h, _data[n]) == h) { + bubble_down(h, _data[n], n); } } @@ -238,9 +237,10 @@ } - /// \brief The priority of the given item. - /// - /// This function returns the priority of the given item. - /// \param i The item. - /// \pre \e i must be in the heap. + + /// \brief Returns the priority of \c i. + /// + /// This function returns the priority of item \c i. + /// \param i The item. + /// \pre \c i must be in the heap. Prio operator[](const Item &i) const { int idx = _iim[i]; @@ -248,10 +248,9 @@ } - /// \brief Set the priority of an item or insert it, if it is - /// not stored in the heap. - /// - /// This method sets the priority of the given item if it is - /// already stored in the heap. Otherwise it inserts the given - /// item into the heap with the given priority. + /// \brief \c i gets to the heap with priority \c p independently + /// if \c i was already there. + /// + /// This method calls \ref push(\c i, \c p) if \c i is not stored + /// in the heap and sets the priority of \c i to \c p otherwise. /// \param i The item. /// \param p The priority. @@ -262,40 +261,42 @@ } else if( _comp(p, _data[idx].second) ) { - bubbleUp(idx, Pair(i,p)); + bubble_up(idx, Pair(i,p)); } else { - bubbleDown(idx, Pair(i,p), _data.size()); - } - } - - /// \brief Decrease the priority of an item to the given value. - /// - /// This function decreases the priority of an item to the given value. + bubble_down(idx, Pair(i,p), _data.size()); + } + } + + /// \brief Decreases the priority of \c i to \c p. + /// + /// This method decreases the priority of item \c i to \c p. /// \param i The item. /// \param p The priority. - /// \pre \e i must be stored in the heap with priority at least \e p. + /// \pre \c i must be stored in the heap with priority at least \c + /// p relative to \c Compare. void decrease(const Item &i, const Prio &p) { int idx = _iim[i]; - bubbleUp(idx, Pair(i,p)); - } - - /// \brief Increase the priority of an item to the given value. - /// - /// This function increases the priority of an item to the given value. + bubble_up(idx, Pair(i,p)); + } + + /// \brief Increases the priority of \c i to \c p. + /// + /// This method sets the priority of item \c i to \c p. /// \param i The item. /// \param p The priority. - /// \pre \e i must be stored in the heap with priority at most \e p. + /// \pre \c i must be stored in the heap with priority at most \c + /// p relative to \c Compare. void increase(const Item &i, const Prio &p) { int idx = _iim[i]; - bubbleDown(idx, Pair(i,p), _data.size()); - } - - /// \brief Return the state of an item. - /// - /// This method returns \c PRE_HEAP if the given item has never - /// been in the heap, \c IN_HEAP if it is in the heap at the moment, - /// and \c POST_HEAP otherwise. - /// In the latter case it is possible that the item will get back - /// to the heap again. + bubble_down(idx, Pair(i,p), _data.size()); + } + + /// \brief Returns if \c item is in, has already been in, or has + /// never been in the heap. + /// + /// This method returns PRE_HEAP if \c item has never been in the + /// heap, IN_HEAP if it is in the heap at the moment, and POST_HEAP + /// otherwise. In the latter case it is possible that \c item will + /// get back to the heap again. /// \param i The item. State state(const Item &i) const { @@ -306,9 +307,9 @@ } - /// \brief Set the state of an item in the heap. - /// - /// This function sets the state of the given item in the heap. - /// It can be used to manually clear the heap when it is important - /// to achive better time complexity. + /// \brief Sets the state of the \c item in the heap. + /// + /// Sets the state of the \c item in the heap. It can be used to + /// manually clear the heap when it is important to achive the + /// better time complexity. /// \param i The item. /// \param st The state. It should not be \c IN_HEAP. @@ -327,11 +328,10 @@ } - /// \brief Replace an item in the heap. - /// - /// This function replaces item \c i with item \c j. - /// Item \c i must be in the heap, while \c j must be out of the heap. - /// After calling this method, item \c i will be out of the - /// heap and \c j will be in the heap with the same prioriority - /// as item \c i had before. + /// \brief Replaces an item in the heap. + /// + /// The \c i item is replaced with \c j item. The \c i item should + /// be in the heap, while the \c j should be out of the heap. The + /// \c i item will out of the heap and \c j will be in the heap + /// with the same prioriority as prevoiusly the \c i item. void replace(const Item& i, const Item& j) { int idx = _iim[i]; Index: mon/binomial_heap.h =================================================================== --- lemon/binomial_heap.h (revision 877) +++ (revision ) @@ -1,445 +1,0 @@ -/* -*- mode: C++; indent-tabs-mode: nil; -*- - * - * This file is a part of LEMON, a generic C++ optimization library. - * - * Copyright (C) 2003-2010 - * Egervary Jeno Kombinatorikus Optimalizalasi Kutatocsoport - * (Egervary Research Group on Combinatorial Optimization, EGRES). - * - * Permission to use, modify and distribute this software is granted - * provided that this copyright notice appears in all copies. For - * precise terms see the accompanying LICENSE file. - * - * This software is provided "AS IS" with no warranty of any kind, - * express or implied, and with no claim as to its suitability for any - * purpose. - * - */ - -#ifndef LEMON_BINOMIAL_HEAP_H -#define LEMON_BINOMIAL_HEAP_H - -///\file -///\ingroup heaps -///\brief Binomial Heap implementation. - -#include -#include -#include -#include -#include - -namespace lemon { - - /// \ingroup heaps - /// - ///\brief Binomial heap data structure. - /// - /// This class implements the \e binomial \e heap data structure. - /// It fully conforms to the \ref concepts::Heap "heap concept". - /// - /// The methods \ref increase() and \ref erase() are not efficient - /// in a binomial heap. In case of many calls of these operations, - /// it is better to use other heap structure, e.g. \ref BinHeap - /// "binary heap". - /// - /// \tparam PR Type of the priorities of the items. - /// \tparam IM A read-writable item map with \c int values, used - /// internally to handle the cross references. - /// \tparam CMP A functor class for comparing the priorities. - /// The default is \c std::less. -#ifdef DOXYGEN - template -#else - template > -#endif - class BinomialHeap { - public: - /// Type of the item-int map. - typedef IM ItemIntMap; - /// Type of the priorities. - typedef PR Prio; - /// Type of the items stored in the heap. - typedef typename ItemIntMap::Key Item; - /// Functor type for comparing the priorities. - typedef CMP Compare; - - /// \brief Type to represent the states of the items. - /// - /// Each item has a state associated to it. It can be "in heap", - /// "pre-heap" or "post-heap". The latter two are indifferent from the - /// heap's point of view, but may be useful to the user. - /// - /// The item-int map must be initialized in such way that it assigns - /// \c PRE_HEAP (-1) to any element to be put in the heap. - enum State { - IN_HEAP = 0, ///< = 0. - PRE_HEAP = -1, ///< = -1. - POST_HEAP = -2 ///< = -2. - }; - - private: - class Store; - - std::vector _data; - int _min, _head; - ItemIntMap &_iim; - Compare _comp; - int _num_items; - - public: - /// \brief Constructor. - /// - /// Constructor. - /// \param map A map that assigns \c int values to the items. - /// It is used internally to handle the cross references. - /// The assigned value must be \c PRE_HEAP (-1) for each item. - explicit BinomialHeap(ItemIntMap &map) - : _min(0), _head(-1), _iim(map), _num_items(0) {} - - /// \brief Constructor. - /// - /// Constructor. - /// \param map A map that assigns \c int values to the items. - /// It is used internally to handle the cross references. - /// The assigned value must be \c PRE_HEAP (-1) for each item. - /// \param comp The function object used for comparing the priorities. - BinomialHeap(ItemIntMap &map, const Compare &comp) - : _min(0), _head(-1), _iim(map), _comp(comp), _num_items(0) {} - - /// \brief The number of items stored in the heap. - /// - /// This function returns the number of items stored in the heap. - int size() const { return _num_items; } - - /// \brief Check if the heap is empty. - /// - /// This function returns \c true if the heap is empty. - bool empty() const { return _num_items==0; } - - /// \brief Make the heap empty. - /// - /// This functon makes the heap empty. - /// It does not change the cross reference map. If you want to reuse - /// a heap that is not surely empty, you should first clear it and - /// then you should set the cross reference map to \c PRE_HEAP - /// for each item. - void clear() { - _data.clear(); _min=0; _num_items=0; _head=-1; - } - - /// \brief Set the priority of an item or insert it, if it is - /// not stored in the heap. - /// - /// This method sets the priority of the given item if it is - /// already stored in the heap. Otherwise it inserts the given - /// item into the heap with the given priority. - /// \param item The item. - /// \param value The priority. - void set (const Item& item, const Prio& value) { - int i=_iim[item]; - if ( i >= 0 && _data[i].in ) { - if ( _comp(value, _data[i].prio) ) decrease(item, value); - if ( _comp(_data[i].prio, value) ) increase(item, value); - } else push(item, value); - } - - /// \brief Insert an item into the heap with the given priority. - /// - /// This function inserts the given item into the heap with the - /// given priority. - /// \param item The item to insert. - /// \param value The priority of the item. - /// \pre \e item must not be stored in the heap. - void push (const Item& item, const Prio& value) { - int i=_iim[item]; - if ( i<0 ) { - int s=_data.size(); - _iim.set( item,s ); - Store st; - st.name=item; - st.prio=value; - _data.push_back(st); - i=s; - } - else { - _data[i].parent=_data[i].right_neighbor=_data[i].child=-1; - _data[i].degree=0; - _data[i].in=true; - _data[i].prio=value; - } - - if( 0==_num_items ) { - _head=i; - _min=i; - } else { - merge(i); - if( _comp(_data[i].prio, _data[_min].prio) ) _min=i; - } - ++_num_items; - } - - /// \brief Return the item having minimum priority. - /// - /// This function returns the item having minimum priority. - /// \pre The heap must be non-empty. - Item top() const { return _data[_min].name; } - - /// \brief The minimum priority. - /// - /// This function returns the minimum priority. - /// \pre The heap must be non-empty. - Prio prio() const { return _data[_min].prio; } - - /// \brief The priority of the given item. - /// - /// This function returns the priority of the given item. - /// \param item The item. - /// \pre \e item must be in the heap. - const Prio& operator[](const Item& item) const { - return _data[_iim[item]].prio; - } - - /// \brief Remove the item having minimum priority. - /// - /// This function removes the item having minimum priority. - /// \pre The heap must be non-empty. - void pop() { - _data[_min].in=false; - - int head_child=-1; - if ( _data[_min].child!=-1 ) { - int child=_data[_min].child; - int neighb; - while( child!=-1 ) { - neighb=_data[child].right_neighbor; - _data[child].parent=-1; - _data[child].right_neighbor=head_child; - head_child=child; - child=neighb; - } - } - - if ( _data[_head].right_neighbor==-1 ) { - // there was only one root - _head=head_child; - } - else { - // there were more roots - if( _head!=_min ) { unlace(_min); } - else { _head=_data[_head].right_neighbor; } - merge(head_child); - } - _min=findMin(); - --_num_items; - } - - /// \brief Remove the given item from the heap. - /// - /// This function removes the given item from the heap if it is - /// already stored. - /// \param item The item to delete. - /// \pre \e item must be in the heap. - void erase (const Item& item) { - int i=_iim[item]; - if ( i >= 0 && _data[i].in ) { - decrease( item, _data[_min].prio-1 ); - pop(); - } - } - - /// \brief Decrease the priority of an item to the given value. - /// - /// This function decreases the priority of an item to the given value. - /// \param item The item. - /// \param value The priority. - /// \pre \e item must be stored in the heap with priority at least \e value. - void decrease (Item item, const Prio& value) { - int i=_iim[item]; - int p=_data[i].parent; - _data[i].prio=value; - - while( p!=-1 && _comp(value, _data[p].prio) ) { - _data[i].name=_data[p].name; - _data[i].prio=_data[p].prio; - _data[p].name=item; - _data[p].prio=value; - _iim[_data[i].name]=i; - i=p; - p=_data[p].parent; - } - _iim[item]=i; - if ( _comp(value, _data[_min].prio) ) _min=i; - } - - /// \brief Increase the priority of an item to the given value. - /// - /// This function increases the priority of an item to the given value. - /// \param item The item. - /// \param value The priority. - /// \pre \e item must be stored in the heap with priority at most \e value. - void increase (Item item, const Prio& value) { - erase(item); - push(item, value); - } - - /// \brief Return the state of an item. - /// - /// This method returns \c PRE_HEAP if the given item has never - /// been in the heap, \c IN_HEAP if it is in the heap at the moment, - /// and \c POST_HEAP otherwise. - /// In the latter case it is possible that the item will get back - /// to the heap again. - /// \param item The item. - State state(const Item &item) const { - int i=_iim[item]; - if( i>=0 ) { - if ( _data[i].in ) i=0; - else i=-2; - } - return State(i); - } - - /// \brief Set the state of an item in the heap. - /// - /// This function sets the state of the given item in the heap. - /// It can be used to manually clear the heap when it is important - /// to achive better time complexity. - /// \param i The item. - /// \param st The state. It should not be \c IN_HEAP. - void state(const Item& i, State st) { - switch (st) { - case POST_HEAP: - case PRE_HEAP: - if (state(i) == IN_HEAP) { - erase(i); - } - _iim[i] = st; - break; - case IN_HEAP: - break; - } - } - - private: - - // Find the minimum of the roots - int findMin() { - if( _head!=-1 ) { - int min_loc=_head, min_val=_data[_head].prio; - for( int x=_data[_head].right_neighbor; x!=-1; - x=_data[x].right_neighbor ) { - if( _comp( _data[x].prio,min_val ) ) { - min_val=_data[x].prio; - min_loc=x; - } - } - return min_loc; - } - else return -1; - } - - // Merge the heap with another heap starting at the given position - void merge(int a) { - if( _head==-1 || a==-1 ) return; - if( _data[a].right_neighbor==-1 && - _data[a].degree<=_data[_head].degree ) { - _data[a].right_neighbor=_head; - _head=a; - } else { - interleave(a); - } - if( _data[_head].right_neighbor==-1 ) return; - - int x=_head; - int x_prev=-1, x_next=_data[x].right_neighbor; - while( x_next!=-1 ) { - if( _data[x].degree!=_data[x_next].degree || - ( _data[x_next].right_neighbor!=-1 && - _data[_data[x_next].right_neighbor].degree==_data[x].degree ) ) { - x_prev=x; - x=x_next; - } - else { - if( _comp(_data[x_next].prio,_data[x].prio) ) { - if( x_prev==-1 ) { - _head=x_next; - } else { - _data[x_prev].right_neighbor=x_next; - } - fuse(x,x_next); - x=x_next; - } - else { - _data[x].right_neighbor=_data[x_next].right_neighbor; - fuse(x_next,x); - } - } - x_next=_data[x].right_neighbor; - } - } - - // Interleave the elements of the given list into the list of the roots - void interleave(int a) { - int p=_head, q=a; - int curr=_data.size(); - _data.push_back(Store()); - - while( p!=-1 || q!=-1 ) { - if( q==-1 || ( p!=-1 && _data[p].degree<_data[q].degree ) ) { - _data[curr].right_neighbor=p; - curr=p; - p=_data[p].right_neighbor; - } - else { - _data[curr].right_neighbor=q; - curr=q; - q=_data[q].right_neighbor; - } - } - - _head=_data.back().right_neighbor; - _data.pop_back(); - } - - // Lace node a under node b - void fuse(int a, int b) { - _data[a].parent=b; - _data[a].right_neighbor=_data[b].child; - _data[b].child=a; - - ++_data[b].degree; - } - - // Unlace node a (if it has siblings) - void unlace(int a) { - int neighb=_data[a].right_neighbor; - int other=_head; - - while( _data[other].right_neighbor!=a ) - other=_data[other].right_neighbor; - _data[other].right_neighbor=neighb; - } - - private: - - class Store { - friend class BinomialHeap; - - Item name; - int parent; - int right_neighbor; - int child; - int degree; - bool in; - Prio prio; - - Store() : parent(-1), right_neighbor(-1), child(-1), degree(0), - in(true) {} - }; - }; - -} //namespace lemon - -#endif //LEMON_BINOMIAL_HEAP_H - Index: lemon/bits/alteration_notifier.h =================================================================== --- lemon/bits/alteration_notifier.h (revision 979) +++ lemon/bits/alteration_notifier.h (revision 440) @@ -24,5 +24,4 @@ #include -#include //\ingroup graphbits @@ -253,5 +252,5 @@ typedef std::list Observers; Observers _observers; - lemon::bits::Lock _lock; + public: @@ -334,16 +333,12 @@ void attach(ObserverBase& observer) { - _lock.lock(); observer._index = _observers.insert(_observers.begin(), &observer); observer._notifier = this; - _lock.unlock(); } void detach(ObserverBase& observer) { - _lock.lock(); _observers.erase(observer._index); observer._index = _observers.end(); observer._notifier = 0; - _lock.unlock(); } Index: lemon/bits/array_map.h =================================================================== --- lemon/bits/array_map.h (revision 877) +++ lemon/bits/array_map.h (revision 617) @@ -3,5 +3,5 @@ * This file is a part of LEMON, a generic C++ optimization library. * - * Copyright (C) 2003-2010 + * Copyright (C) 2003-2009 * Egervary Jeno Kombinatorikus Optimalizalasi Kutatocsoport * (Egervary Research Group on Combinatorial Optimization, EGRES). @@ -71,5 +71,5 @@ private: - + // The MapBase of the Map which imlements the core regisitry function. typedef typename Notifier::ObserverBase Parent; Index: lemon/bits/default_map.h =================================================================== --- lemon/bits/default_map.h (revision 877) +++ lemon/bits/default_map.h (revision 627) @@ -3,5 +3,5 @@ * This file is a part of LEMON, a generic C++ optimization library. * - * Copyright (C) 2003-2010 + * Copyright (C) 2003-2009 * Egervary Jeno Kombinatorikus Optimalizalasi Kutatocsoport * (Egervary Research Group on Combinatorial Optimization, EGRES). @@ -158,5 +158,5 @@ public: typedef DefaultMap<_Graph, _Item, _Value> Map; - + typedef typename Parent::GraphType GraphType; typedef typename Parent::Value Value; Index: lemon/bits/edge_set_extender.h =================================================================== --- lemon/bits/edge_set_extender.h (revision 1000) +++ lemon/bits/edge_set_extender.h (revision 997) @@ -1,7 +1,7 @@ -/* -*- mode: C++; indent-tabs-mode: nil; -*- +/* -*- C++ -*- * - * This file is a part of LEMON, a generic C++ optimization library. + * This file is a part of LEMON, a generic C++ optimization library * - * Copyright (C) 2003-2010 + * Copyright (C) 2003-2008 * Egervary Jeno Kombinatorikus Optimalizalasi Kutatocsoport * (Egervary Research Group on Combinatorial Optimization, EGRES). @@ -64,9 +64,9 @@ Node oppositeNode(const Node &n, const Arc &e) const { if (n == Parent::source(e)) - return Parent::target(e); + return Parent::target(e); else if(n==Parent::target(e)) - return Parent::source(e); + return Parent::source(e); else - return INVALID; + return INVALID; } @@ -92,5 +92,5 @@ // Iterable extensions - class NodeIt : public Node { + class NodeIt : public Node { const Digraph* digraph; public: @@ -101,19 +101,19 @@ explicit NodeIt(const Digraph& _graph) : digraph(&_graph) { - _graph.first(static_cast(*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(*this)); + } + + NodeIt(const Digraph& _graph, const Node& node) + : Node(node), digraph(&_graph) {} + + NodeIt& operator++() { + digraph->next(*this); + return *this; + } + + }; + + + class ArcIt : public Arc { const Digraph* digraph; public: @@ -124,19 +124,19 @@ explicit ArcIt(const Digraph& _graph) : digraph(&_graph) { - _graph.first(static_cast(*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(*this)); + } + + ArcIt(const Digraph& _graph, const Arc& e) : + Arc(e), digraph(&_graph) { } + + ArcIt& operator++() { + digraph->next(*this); + return *this; + } + + }; + + + class OutArcIt : public Arc { const Digraph* digraph; public: @@ -146,21 +146,21 @@ OutArcIt(Invalid i) : Arc(i) { } - OutArcIt(const Digraph& _graph, const Node& node) - : digraph(&_graph) { - _graph.firstOut(*this, node); - } - - OutArcIt(const Digraph& _graph, const Arc& arc) - : Arc(arc), digraph(&_graph) {} - - OutArcIt& operator++() { - digraph->nextOut(*this); - return *this; - } - - }; - - - class InArcIt : public Arc { + OutArcIt(const Digraph& _graph, const Node& node) + : digraph(&_graph) { + _graph.firstOut(*this, node); + } + + OutArcIt(const Digraph& _graph, const Arc& arc) + : Arc(arc), digraph(&_graph) {} + + OutArcIt& operator++() { + digraph->nextOut(*this); + return *this; + } + + }; + + + class InArcIt : public Arc { const Digraph* digraph; public: @@ -170,15 +170,15 @@ InArcIt(Invalid i) : Arc(i) { } - InArcIt(const Digraph& _graph, const Node& node) - : digraph(&_graph) { - _graph.firstIn(*this, node); - } - - InArcIt(const Digraph& _graph, const Arc& arc) : - Arc(arc), digraph(&_graph) {} - - InArcIt& operator++() { - digraph->nextIn(*this); - return *this; + InArcIt(const Digraph& _graph, const Node& node) + : digraph(&_graph) { + _graph.firstIn(*this, node); + } + + InArcIt(const Digraph& _graph, const Arc& arc) : + Arc(arc), digraph(&_graph) {} + + InArcIt& operator++() { + digraph->nextIn(*this); + return *this; } @@ -216,18 +216,18 @@ // Mappable extension - + template - class ArcMap + class ArcMap : public MapExtender > { typedef MapExtender > 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=(cmap); + return operator=(cmap); } @@ -235,5 +235,5 @@ ArcMap& operator=(const CMap& cmap) { Parent::operator=(cmap); - return *this; + return *this; } @@ -248,5 +248,5 @@ return arc; } - + void clear() { notifier(Arc()).clear(); @@ -313,9 +313,9 @@ Node oppositeNode(const Node &n, const Edge &e) const { if( n == Parent::u(e)) - return Parent::v(e); + return Parent::v(e); else if( n == Parent::v(e)) - return Parent::u(e); + return Parent::u(e); else - return INVALID; + return INVALID; } @@ -341,5 +341,5 @@ using Parent::notifier; - + ArcNotifier& notifier(Arc) const { return arc_notifier; @@ -351,5 +351,5 @@ - class NodeIt : public Node { + class NodeIt : public Node { const Graph* graph; public: @@ -360,19 +360,19 @@ explicit NodeIt(const Graph& _graph) : graph(&_graph) { - _graph.first(static_cast(*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(*this)); + } + + NodeIt(const Graph& _graph, const Node& node) + : Node(node), graph(&_graph) {} + + NodeIt& operator++() { + graph->next(*this); + return *this; + } + + }; + + + class ArcIt : public Arc { const Graph* graph; public: @@ -383,19 +383,19 @@ explicit ArcIt(const Graph& _graph) : graph(&_graph) { - _graph.first(static_cast(*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(*this)); + } + + ArcIt(const Graph& _graph, const Arc& e) : + Arc(e), graph(&_graph) { } + + ArcIt& operator++() { + graph->next(*this); + return *this; + } + + }; + + + class OutArcIt : public Arc { const Graph* graph; public: @@ -405,21 +405,21 @@ OutArcIt(Invalid i) : Arc(i) { } - OutArcIt(const Graph& _graph, const Node& node) - : graph(&_graph) { - _graph.firstOut(*this, node); - } - - OutArcIt(const Graph& _graph, const Arc& arc) - : Arc(arc), graph(&_graph) {} - - OutArcIt& operator++() { - graph->nextOut(*this); - return *this; - } - - }; - - - class InArcIt : public Arc { + OutArcIt(const Graph& _graph, const Node& node) + : graph(&_graph) { + _graph.firstOut(*this, node); + } + + OutArcIt(const Graph& _graph, const Arc& arc) + : Arc(arc), graph(&_graph) {} + + OutArcIt& operator++() { + graph->nextOut(*this); + return *this; + } + + }; + + + class InArcIt : public Arc { const Graph* graph; public: @@ -429,21 +429,21 @@ InArcIt(Invalid i) : Arc(i) { } - InArcIt(const Graph& _graph, const Node& node) - : graph(&_graph) { - _graph.firstIn(*this, node); - } - - InArcIt(const Graph& _graph, const Arc& arc) : - Arc(arc), graph(&_graph) {} - - InArcIt& operator++() { - graph->nextIn(*this); - return *this; - } - - }; - - - class EdgeIt : public Parent::Edge { + InArcIt(const Graph& _graph, const Node& node) + : graph(&_graph) { + _graph.firstIn(*this, node); + } + + InArcIt(const Graph& _graph, const Arc& arc) : + Arc(arc), graph(&_graph) {} + + InArcIt& operator++() { + graph->nextIn(*this); + return *this; + } + + }; + + + class EdgeIt : public Parent::Edge { const Graph* graph; public: @@ -454,13 +454,13 @@ explicit EdgeIt(const Graph& _graph) : graph(&_graph) { - _graph.first(static_cast(*this)); - } - - EdgeIt(const Graph& _graph, const Edge& e) : - Edge(e), graph(&_graph) { } - - EdgeIt& operator++() { - graph->next(*this); - return *this; + _graph.first(static_cast(*this)); + } + + EdgeIt(const Graph& _graph, const Edge& e) : + Edge(e), graph(&_graph) { } + + EdgeIt& operator++() { + graph->next(*this); + return *this; } @@ -478,15 +478,15 @@ IncEdgeIt(const Graph& _graph, const Node &n) : graph(&_graph) { - _graph.firstInc(*this, direction, n); + _graph.firstInc(*this, direction, n); } IncEdgeIt(const Graph& _graph, const Edge &ue, const Node &n) - : graph(&_graph), Edge(ue) { - direction = (_graph.source(ue) == n); + : graph(&_graph), Edge(ue) { + direction = (_graph.source(ue) == n); } IncEdgeIt& operator++() { - graph->nextInc(*this, direction); - return *this; + graph->nextInc(*this, direction); + return *this; } }; @@ -535,16 +535,16 @@ template - class ArcMap + class ArcMap : public MapExtender > { typedef MapExtender > 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=(cmap); + return operator=(cmap); } @@ -552,5 +552,5 @@ ArcMap& operator=(const CMap& cmap) { Parent::operator=(cmap); - return *this; + return *this; } @@ -559,17 +559,17 @@ template - class EdgeMap + class EdgeMap : public MapExtender > { typedef MapExtender > 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=(cmap); + return operator=(cmap); } @@ -577,5 +577,5 @@ EdgeMap& operator=(const CMap& cmap) { Parent::operator=(cmap); - return *this; + return *this; } @@ -594,5 +594,5 @@ return edge; } - + void clear() { notifier(Arc()).clear(); @@ -620,5 +620,5 @@ arc_notifier.clear(); } - + }; Index: lemon/bits/graph_extender.h =================================================================== --- lemon/bits/graph_extender.h (revision 998) +++ lemon/bits/graph_extender.h (revision 997) @@ -57,9 +57,9 @@ } - static Node fromId(int id, Node) { + Node fromId(int id, Node) const { return Parent::nodeFromId(id); } - static Arc fromId(int id, Arc) { + Arc fromId(int id, Arc) const { return Parent::arcFromId(id); } @@ -356,13 +356,13 @@ } - static Node fromId(int id, Node) { + Node fromId(int id, Node) const { return Parent::nodeFromId(id); } - static Arc fromId(int id, Arc) { + Arc fromId(int id, Arc) const { return Parent::arcFromId(id); } - static Edge fromId(int id, Edge) { + Edge fromId(int id, Edge) const { return Parent::edgeFromId(id); } Index: mon/bits/lock.h =================================================================== --- lemon/bits/lock.h (revision 979) +++ (revision ) @@ -1,65 +1,0 @@ -/* -*- mode: C++; indent-tabs-mode: nil; -*- - * - * This file is a part of LEMON, a generic C++ optimization library. - * - * Copyright (C) 2003-2012 - * Egervary Jeno Kombinatorikus Optimalizalasi Kutatocsoport - * (Egervary Research Group on Combinatorial Optimization, EGRES). - * - * Permission to use, modify and distribute this software is granted - * provided that this copyright notice appears in all copies. For - * precise terms see the accompanying LICENSE file. - * - * This software is provided "AS IS" with no warranty of any kind, - * express or implied, and with no claim as to its suitability for any - * purpose. - * - */ - -#ifndef LEMON_BITS_LOCK_H -#define LEMON_BITS_LOCK_H - -#include -#if defined(LEMON_USE_PTHREAD) -#include -#elif defined(LEMON_USE_WIN32_THREADS) -#include -#endif - -namespace lemon { - namespace bits { - -#if defined(LEMON_USE_PTHREAD) - class Lock { - public: - Lock() { - pthread_mutex_init(&_lock, 0); - } - ~Lock() { - pthread_mutex_destroy(&_lock); - } - void lock() { - pthread_mutex_lock(&_lock); - } - void unlock() { - pthread_mutex_unlock(&_lock); - } - - private: - pthread_mutex_t _lock; - }; -#elif defined(LEMON_USE_WIN32_THREADS) - class Lock : public WinLock {}; -#else - class Lock { - public: - Lock() {} - ~Lock() {} - void lock() {} - void unlock() {} - }; -#endif - } -} - -#endif Index: lemon/bits/solver_bits.h =================================================================== --- lemon/bits/solver_bits.h (revision 989) +++ lemon/bits/solver_bits.h (revision 988) @@ -3,5 +3,5 @@ * This file is a part of LEMON, a generic C++ optimization library. * - * Copyright (C) 2003-2010 + * Copyright (C) 2003-2008 * Egervary Jeno Kombinatorikus Optimalizalasi Kutatocsoport * (Egervary Research Group on Combinatorial Optimization, EGRES). Index: lemon/bits/windows.cc =================================================================== --- lemon/bits/windows.cc (revision 1001) +++ lemon/bits/windows.cc (revision 940) @@ -3,5 +3,5 @@ * This file is a part of LEMON, a generic C++ optimization library. * - * Copyright (C) 2003-2010 + * Copyright (C) 2003-2009 * Egervary Jeno Kombinatorikus Optimalizalasi Kutatocsoport * (Egervary Research Group on Combinatorial Optimization, EGRES). @@ -99,5 +99,5 @@ GetSystemTime(&time); char buf1[11], buf2[9], buf3[5]; - if (GetDateFormat(MY_LOCALE, 0, &time, + if (GetDateFormat(MY_LOCALE, 0, &time, ("ddd MMM dd"), buf1, 11) && GetTimeFormat(MY_LOCALE, 0, &time, @@ -131,36 +131,4 @@ #endif } - - WinLock::WinLock() { -#ifdef 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 WIN32 - CRITICAL_SECTION *lock = static_cast(_repr); - DeleteCriticalSection(lock); - delete lock; -#endif - } - - void WinLock::lock() { -#ifdef WIN32 - CRITICAL_SECTION *lock = static_cast(_repr); - EnterCriticalSection(lock); -#endif - } - - void WinLock::unlock() { -#ifdef WIN32 - CRITICAL_SECTION *lock = static_cast(_repr); - LeaveCriticalSection(lock); -#endif - } } } Index: lemon/bits/windows.h =================================================================== --- lemon/bits/windows.h (revision 979) +++ lemon/bits/windows.h (revision 529) @@ -29,14 +29,4 @@ std::string getWinFormattedDate(); int getWinRndSeed(); - - class WinLock { - public: - WinLock(); - ~WinLock(); - void lock(); - void unlock(); - private: - void *_repr; - }; } } Index: lemon/bucket_heap.h =================================================================== --- lemon/bucket_heap.h (revision 877) +++ lemon/bucket_heap.h (revision 683) @@ -3,5 +3,5 @@ * This file is a part of LEMON, a generic C++ optimization library. * - * Copyright (C) 2003-2010 + * Copyright (C) 2003-2009 * Egervary Jeno Kombinatorikus Optimalizalasi Kutatocsoport * (Egervary Research Group on Combinatorial Optimization, EGRES). @@ -20,7 +20,7 @@ #define LEMON_BUCKET_HEAP_H -///\ingroup heaps +///\ingroup auxdat ///\file -///\brief Bucket heap implementation. +///\brief Bucket Heap implementation. #include @@ -54,39 +54,33 @@ } - /// \ingroup heaps - /// - /// \brief Bucket heap data structure. - /// - /// This class implements the \e bucket \e heap data structure. - /// It practically conforms to the \ref concepts::Heap "heap concept", - /// but it has some limitations. - /// - /// The bucket heap is a very simple structure. It can store only - /// \c int priorities and it maintains a list of items for each priority - /// in the range [0..C). So it should only be used when the - /// priorities are small. It is not intended to use as a Dijkstra heap. - /// - /// \tparam IM A read-writable item map with \c int values, used - /// internally to handle the cross references. - /// \tparam MIN Indicate if the heap is a \e min-heap or a \e max-heap. - /// The default is \e min-heap. If this parameter is set to \c false, - /// then the comparison is reversed, so the top(), prio() and pop() - /// functions deal with the item having maximum priority instead of the - /// minimum. - /// - /// \sa SimpleBucketHeap + /// \ingroup auxdat + /// + /// \brief A Bucket Heap implementation. + /// + /// This class implements the \e bucket \e heap data structure. A \e heap + /// is a data structure for storing items with specified values called \e + /// priorities in such a way that finding the item with minimum priority is + /// efficient. The bucket heap is very simple implementation, it can store + /// only integer priorities and it stores for each priority in the + /// \f$ [0..C) \f$ range a list of items. So it should be used only when + /// the priorities are small. It is not intended to use as dijkstra heap. + /// + /// \param IM A read and write Item int map, used internally + /// to handle the cross references. + /// \param MIN If the given parameter is false then instead of the + /// minimum value the maximum can be retrivied with the top() and + /// prio() member functions. template class BucketHeap { public: - - /// Type of the item-int map. + /// \e + typedef typename IM::Key Item; + /// \e + typedef int Prio; + /// \e + typedef std::pair Pair; + /// \e typedef IM ItemIntMap; - /// Type of the priorities. - typedef int Prio; - /// Type of the items stored in the heap. - typedef typename ItemIntMap::Key Item; - /// Type of the item-priority pairs. - typedef std::pair Pair; private: @@ -96,8 +90,8 @@ public: - /// \brief Type to represent the states of the items. - /// - /// Each item has a state associated to it. It can be "in heap", - /// "pre-heap" or "post-heap". The latter two are indifferent from the + /// \brief Type to represent the items states. + /// + /// Each Item element have a state associated to it. It may be "in heap", + /// "pre heap" or "post heap". The latter two are indifferent from the /// heap's point of view, but may be useful to the user. /// @@ -111,30 +105,28 @@ public: - - /// \brief Constructor. - /// - /// Constructor. - /// \param map A map that assigns \c int values to the items. - /// It is used internally to handle the cross references. - /// The assigned value must be \c PRE_HEAP (-1) for each item. + /// \brief The constructor. + /// + /// The constructor. + /// \param map should be given to the constructor, since it is used + /// internally to handle the cross references. The value of the map + /// should be PRE_HEAP (-1) for each element. explicit BucketHeap(ItemIntMap &map) : _iim(map), _minimum(0) {} - /// \brief The number of items stored in the heap. - /// - /// This function returns the number of items stored in the heap. + /// The number of items stored in the heap. + /// + /// \brief Returns the number of items stored in the heap. int size() const { return _data.size(); } - /// \brief Check if the heap is empty. - /// - /// This function returns \c true if the heap is empty. + /// \brief Checks if the heap stores no items. + /// + /// Returns \c true if and only if the heap stores no items. bool empty() const { return _data.empty(); } - /// \brief Make the heap empty. - /// - /// This functon makes the heap empty. - /// It does not change the cross reference map. If you want to reuse - /// a heap that is not surely empty, you should first clear it and - /// then you should set the cross reference map to \c PRE_HEAP - /// for each item. + /// \brief Make empty this heap. + /// + /// Make empty this heap. It does not change the cross reference + /// map. If you want to reuse a heap what is not surely empty you + /// should first clear the heap and after that you should set the + /// cross reference map for each item to \c PRE_HEAP. void clear() { _data.clear(); _first.clear(); _minimum = 0; @@ -143,5 +135,5 @@ private: - void relocateLast(int idx) { + void relocate_last(int idx) { if (idx + 1 < int(_data.size())) { _data[idx] = _data.back(); @@ -183,11 +175,8 @@ public: - /// \brief Insert a pair of item and priority into the heap. /// - /// This function inserts \c p.first to the heap with priority - /// \c p.second. + /// Adds \c p.first to the heap with priority \c p.second. /// \param p The pair to insert. - /// \pre \c p.first must not be stored in the heap. void push(const Pair& p) { push(p.first, p.second); @@ -196,9 +185,7 @@ /// \brief Insert an item into the heap with the given priority. /// - /// This function inserts the given item into the heap with the - /// given priority. + /// Adds \c i to the heap with priority \c p. /// \param i The item to insert. /// \param p The priority of the item. - /// \pre \e i must not be stored in the heap. void push(const Item &i, const Prio &p) { int idx = _data.size(); @@ -211,8 +198,8 @@ } - /// \brief Return the item having minimum priority. - /// - /// This function returns the item having minimum priority. - /// \pre The heap must be non-empty. + /// \brief Returns the item with minimum priority. + /// + /// This method returns the item with minimum priority. + /// \pre The heap must be nonempty. Item top() const { while (_first[_minimum] == -1) { @@ -222,8 +209,8 @@ } - /// \brief The minimum priority. - /// - /// This function returns the minimum priority. - /// \pre The heap must be non-empty. + /// \brief Returns the minimum priority. + /// + /// It returns the minimum priority. + /// \pre The heap must be nonempty. Prio prio() const { while (_first[_minimum] == -1) { @@ -233,7 +220,7 @@ } - /// \brief Remove the item having minimum priority. - /// - /// This function removes the item having minimum priority. + /// \brief Deletes the item with minimum priority. + /// + /// This method deletes the item with minimum priority from the heap. /// \pre The heap must be non-empty. void pop() { @@ -244,25 +231,25 @@ _iim[_data[idx].item] = -2; unlace(idx); - relocateLast(idx); - } - - /// \brief Remove the given item from the heap. - /// - /// This function removes the given item from the heap if it is - /// already stored. - /// \param i The item to delete. - /// \pre \e i must be in the heap. + relocate_last(idx); + } + + /// \brief Deletes \c i from the heap. + /// + /// This method deletes item \c i from the heap, if \c i was + /// already stored in the heap. + /// \param i The item to erase. void erase(const Item &i) { int idx = _iim[i]; _iim[_data[idx].item] = -2; unlace(idx); - relocateLast(idx); - } - - /// \brief The priority of the given item. - /// - /// This function returns the priority of the given item. - /// \param i The item. - /// \pre \e i must be in the heap. + relocate_last(idx); + } + + + /// \brief Returns the priority of \c i. + /// + /// This function returns the priority of item \c i. + /// \pre \c i must be in the heap. + /// \param i The item. Prio operator[](const Item &i) const { int idx = _iim[i]; @@ -270,10 +257,9 @@ } - /// \brief Set the priority of an item or insert it, if it is - /// not stored in the heap. - /// - /// This method sets the priority of the given item if it is - /// already stored in the heap. Otherwise it inserts the given - /// item into the heap with the given priority. + /// \brief \c i gets to the heap with priority \c p independently + /// if \c i was already there. + /// + /// This method calls \ref push(\c i, \c p) if \c i is not stored + /// in the heap and sets the priority of \c i to \c p otherwise. /// \param i The item. /// \param p The priority. @@ -289,10 +275,11 @@ } - /// \brief Decrease the priority of an item to the given value. - /// - /// This function decreases the priority of an item to the given value. + /// \brief Decreases the priority of \c i to \c p. + /// + /// This method decreases the priority of item \c i to \c p. + /// \pre \c i must be stored in the heap with priority at least \c + /// p relative to \c Compare. /// \param i The item. /// \param p The priority. - /// \pre \e i must be stored in the heap with priority at least \e p. void decrease(const Item &i, const Prio &p) { int idx = _iim[i]; @@ -305,10 +292,11 @@ } - /// \brief Increase the priority of an item to the given value. - /// - /// This function increases the priority of an item to the given value. + /// \brief Increases the priority of \c i to \c p. + /// + /// This method sets the priority of item \c i to \c p. + /// \pre \c i must be stored in the heap with priority at most \c + /// p relative to \c Compare. /// \param i The item. /// \param p The priority. - /// \pre \e i must be stored in the heap with priority at most \e p. void increase(const Item &i, const Prio &p) { int idx = _iim[i]; @@ -318,11 +306,11 @@ } - /// \brief Return the state of an item. - /// - /// This method returns \c PRE_HEAP if the given item has never - /// been in the heap, \c IN_HEAP if it is in the heap at the moment, - /// and \c POST_HEAP otherwise. - /// In the latter case it is possible that the item will get back - /// to the heap again. + /// \brief Returns if \c item is in, has already been in, or has + /// never been in the heap. + /// + /// This method returns PRE_HEAP if \c item has never been in the + /// heap, IN_HEAP if it is in the heap at the moment, and POST_HEAP + /// otherwise. In the latter case it is possible that \c item will + /// get back to the heap again. /// \param i The item. State state(const Item &i) const { @@ -332,9 +320,9 @@ } - /// \brief Set the state of an item in the heap. - /// - /// This function sets the state of the given item in the heap. - /// It can be used to manually clear the heap when it is important - /// to achive better time complexity. + /// \brief Sets the state of the \c item in the heap. + /// + /// Sets the state of the \c item in the heap. It can be used to + /// manually clear the heap when it is important to achive the + /// better time complexity. /// \param i The item. /// \param st The state. It should not be \c IN_HEAP. @@ -372,27 +360,21 @@ }; // class BucketHeap - /// \ingroup heaps - /// - /// \brief Simplified bucket heap data structure. + /// \ingroup auxdat + /// + /// \brief A Simplified Bucket Heap implementation. /// /// This class implements a simplified \e bucket \e heap data - /// structure. It does not provide some functionality, but it is - /// faster and simpler than BucketHeap. The main difference is - /// that BucketHeap stores a doubly-linked list for each key while - /// this class stores only simply-linked lists. It supports erasing - /// only for the item having minimum priority and it does not support - /// key increasing and decreasing. - /// - /// Note that this implementation does not conform to the - /// \ref concepts::Heap "heap concept" due to the lack of some - /// functionality. - /// - /// \tparam IM A read-writable item map with \c int values, used - /// internally to handle the cross references. - /// \tparam MIN Indicate if the heap is a \e min-heap or a \e max-heap. - /// The default is \e min-heap. If this parameter is set to \c false, - /// then the comparison is reversed, so the top(), prio() and pop() - /// functions deal with the item having maximum priority instead of the - /// minimum. + /// structure. It does not provide some functionality but it faster + /// and simplier data structure than the BucketHeap. The main + /// difference is that the BucketHeap stores for every key a double + /// linked list while this class stores just simple lists. In the + /// other way it does not support erasing each elements just the + /// minimal and it does not supports key increasing, decreasing. + /// + /// \param IM A read and write Item int map, used internally + /// to handle the cross references. + /// \param MIN If the given parameter is false then instead of the + /// minimum value the maximum can be retrivied with the top() and + /// prio() member functions. /// /// \sa BucketHeap @@ -401,13 +383,8 @@ public: - - /// Type of the item-int map. + typedef typename IM::Key Item; + typedef int Prio; + typedef std::pair Pair; typedef IM ItemIntMap; - /// Type of the priorities. - typedef int Prio; - /// Type of the items stored in the heap. - typedef typename ItemIntMap::Key Item; - /// Type of the item-priority pairs. - typedef std::pair Pair; private: @@ -417,8 +394,8 @@ public: - /// \brief Type to represent the states of the items. - /// - /// Each item has a state associated to it. It can be "in heap", - /// "pre-heap" or "post-heap". The latter two are indifferent from the + /// \brief Type to represent the items states. + /// + /// Each Item element have a state associated to it. It may be "in heap", + /// "pre heap" or "post heap". The latter two are indifferent from the /// heap's point of view, but may be useful to the user. /// @@ -433,30 +410,29 @@ public: - /// \brief Constructor. - /// - /// Constructor. - /// \param map A map that assigns \c int values to the items. - /// It is used internally to handle the cross references. - /// The assigned value must be \c PRE_HEAP (-1) for each item. + /// \brief The constructor. + /// + /// The constructor. + /// \param map should be given to the constructor, since it is used + /// internally to handle the cross references. The value of the map + /// should be PRE_HEAP (-1) for each element. explicit SimpleBucketHeap(ItemIntMap &map) : _iim(map), _free(-1), _num(0), _minimum(0) {} - /// \brief The number of items stored in the heap. - /// - /// This function returns the number of items stored in the heap. + /// \brief Returns the number of items stored in the heap. + /// + /// The number of items stored in the heap. int size() const { return _num; } - /// \brief Check if the heap is empty. - /// - /// This function returns \c true if the heap is empty. + /// \brief Checks if the heap stores no items. + /// + /// Returns \c true if and only if the heap stores no items. bool empty() const { return _num == 0; } - /// \brief Make the heap empty. - /// - /// This functon makes the heap empty. - /// It does not change the cross reference map. If you want to reuse - /// a heap that is not surely empty, you should first clear it and - /// then you should set the cross reference map to \c PRE_HEAP - /// for each item. + /// \brief Make empty this heap. + /// + /// Make empty this heap. It does not change the cross reference + /// map. If you want to reuse a heap what is not surely empty you + /// should first clear the heap and after that you should set the + /// cross reference map for each item to \c PRE_HEAP. void clear() { _data.clear(); _first.clear(); _free = -1; _num = 0; _minimum = 0; @@ -465,8 +441,6 @@ /// \brief Insert a pair of item and priority into the heap. /// - /// This function inserts \c p.first to the heap with priority - /// \c p.second. + /// Adds \c p.first to the heap with priority \c p.second. /// \param p The pair to insert. - /// \pre \c p.first must not be stored in the heap. void push(const Pair& p) { push(p.first, p.second); @@ -475,9 +449,7 @@ /// \brief Insert an item into the heap with the given priority. /// - /// This function inserts the given item into the heap with the - /// given priority. + /// Adds \c i to the heap with priority \c p. /// \param i The item to insert. /// \param p The priority of the item. - /// \pre \e i must not be stored in the heap. void push(const Item &i, const Prio &p) { int idx; @@ -500,8 +472,8 @@ } - /// \brief Return the item having minimum priority. - /// - /// This function returns the item having minimum priority. - /// \pre The heap must be non-empty. + /// \brief Returns the item with minimum priority. + /// + /// This method returns the item with minimum priority. + /// \pre The heap must be nonempty. Item top() const { while (_first[_minimum] == -1) { @@ -511,8 +483,8 @@ } - /// \brief The minimum priority. - /// - /// This function returns the minimum priority. - /// \pre The heap must be non-empty. + /// \brief Returns the minimum priority. + /// + /// It returns the minimum priority. + /// \pre The heap must be nonempty. Prio prio() const { while (_first[_minimum] == -1) { @@ -522,7 +494,7 @@ } - /// \brief Remove the item having minimum priority. - /// - /// This function removes the item having minimum priority. + /// \brief Deletes the item with minimum priority. + /// + /// This method deletes the item with minimum priority from the heap. /// \pre The heap must be non-empty. void pop() { @@ -538,13 +510,14 @@ } - /// \brief The priority of the given item. - /// - /// This function returns the priority of the given item. - /// \param i The item. - /// \pre \e i must be in the heap. - /// \warning This operator is not a constant time function because - /// it scans the whole data structure to find the proper value. + /// \brief Returns the priority of \c i. + /// + /// This function returns the priority of item \c i. + /// \warning This operator is not a constant time function + /// because it scans the whole data structure to find the proper + /// value. + /// \pre \c i must be in the heap. + /// \param i The item. Prio operator[](const Item &i) const { - for (int k = 0; k < int(_first.size()); ++k) { + for (int k = 0; k < _first.size(); ++k) { int idx = _first[k]; while (idx != -1) { @@ -558,11 +531,11 @@ } - /// \brief Return the state of an item. - /// - /// This method returns \c PRE_HEAP if the given item has never - /// been in the heap, \c IN_HEAP if it is in the heap at the moment, - /// and \c POST_HEAP otherwise. - /// In the latter case it is possible that the item will get back - /// to the heap again. + /// \brief Returns if \c item is in, has already been in, or has + /// never been in the heap. + /// + /// This method returns PRE_HEAP if \c item has never been in the + /// heap, IN_HEAP if it is in the heap at the moment, and POST_HEAP + /// otherwise. In the latter case it is possible that \c item will + /// get back to the heap again. /// \param i The item. State state(const Item &i) const { Index: mon/capacity_scaling.h =================================================================== --- lemon/capacity_scaling.h (revision 1004) +++ (revision ) @@ -1,998 +1,0 @@ -/* -*- mode: C++; indent-tabs-mode: nil; -*- - * - * This file is a part of LEMON, a generic C++ optimization library. - * - * Copyright (C) 2003-2010 - * Egervary Jeno Kombinatorikus Optimalizalasi Kutatocsoport - * (Egervary Research Group on Combinatorial Optimization, EGRES). - * - * Permission to use, modify and distribute this software is granted - * provided that this copyright notice appears in all copies. For - * precise terms see the accompanying LICENSE file. - * - * This software is provided "AS IS" with no warranty of any kind, - * express or implied, and with no claim as to its suitability for any - * purpose. - * - */ - -#ifndef LEMON_CAPACITY_SCALING_H -#define LEMON_CAPACITY_SCALING_H - -/// \ingroup min_cost_flow_algs -/// -/// \file -/// \brief Capacity Scaling algorithm for finding a minimum cost flow. - -#include -#include -#include -#include - -namespace lemon { - - /// \brief Default traits class of CapacityScaling algorithm. - /// - /// Default traits class of CapacityScaling algorithm. - /// \tparam GR Digraph type. - /// \tparam V The number type used for flow amounts, capacity bounds - /// and supply values. By default it is \c int. - /// \tparam C The number type used for costs and potentials. - /// By default it is the same as \c V. - template - struct CapacityScalingDefaultTraits - { - /// The type of the digraph - typedef GR Digraph; - /// The type of the flow amounts, capacity bounds and supply values - typedef V Value; - /// The type of the arc costs - typedef C Cost; - - /// \brief The type of the heap used for internal Dijkstra computations. - /// - /// The type of the heap used for internal Dijkstra computations. - /// It must conform to the \ref lemon::concepts::Heap "Heap" concept, - /// its priority type must be \c Cost and its cross reference type - /// must be \ref RangeMap "RangeMap". - typedef BinHeap > Heap; - }; - - /// \addtogroup min_cost_flow_algs - /// @{ - - /// \brief Implementation of the Capacity Scaling algorithm for - /// finding a \ref min_cost_flow "minimum cost flow". - /// - /// \ref CapacityScaling implements the capacity scaling version - /// of the successive shortest path algorithm for finding a - /// \ref min_cost_flow "minimum cost flow" \ref amo93networkflows, - /// \ref edmondskarp72theoretical. It is an efficient dual - /// solution method. - /// - /// 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) - /// can be given using separate functions, and the algorithm can be - /// executed using the \ref run() function. If some parameters are not - /// specified, then default values will be used. - /// - /// \tparam GR The digraph type the algorithm runs on. - /// \tparam V The number type used for flow amounts, capacity bounds - /// and supply values in the algorithm. By default, it is \c int. - /// \tparam C The number type used for costs and potentials in the - /// algorithm. By default, it is the same as \c V. - /// \tparam TR The traits class that defines various types used by the - /// algorithm. By default, it is \ref CapacityScalingDefaultTraits - /// "CapacityScalingDefaultTraits". - /// In most cases, this parameter should not be set directly, - /// consider to use the named template parameters instead. - /// - /// \warning Both \c V and \c C must be signed number types. - /// \warning Capacity bounds and supply values must be integer, but - /// arc costs can be arbitrary real numbers. - /// \warning This algorithm does not support negative costs for - /// arcs having infinite upper bound. -#ifdef DOXYGEN - template -#else - template < typename GR, typename V = int, typename C = V, - typename TR = CapacityScalingDefaultTraits > -#endif - class CapacityScaling - { - public: - - /// The type of the digraph - typedef typename TR::Digraph Digraph; - /// The type of the flow amounts, capacity bounds and supply values - typedef typename TR::Value Value; - /// The type of the arc costs - typedef typename TR::Cost Cost; - - /// The type of the heap used for internal Dijkstra computations - typedef typename TR::Heap Heap; - - /// The \ref CapacityScalingDefaultTraits "traits class" of the algorithm - typedef TR Traits; - - public: - - /// \brief Problem type constants for the \c run() function. - /// - /// Enum type containing the problem type constants that can be - /// returned by the \ref run() function of the algorithm. - enum ProblemType { - /// The problem has no feasible solution (flow). - INFEASIBLE, - /// The problem has optimal solution (i.e. it is feasible and - /// bounded), and the algorithm has found optimal flow and node - /// potentials (primal and dual solutions). - OPTIMAL, - /// The digraph contains an arc of negative cost and infinite - /// upper bound. It means that the objective function is unbounded - /// on that arc, however, note that it could actually be bounded - /// over the feasible flows, but this algroithm cannot handle - /// these cases. - UNBOUNDED - }; - - private: - - TEMPLATE_DIGRAPH_TYPEDEFS(GR); - - typedef std::vector IntVector; - typedef std::vector ValueVector; - typedef std::vector CostVector; - typedef std::vector BoolVector; - // Note: vector is used instead of vector for efficiency reasons - - private: - - // Data related to the underlying digraph - const GR &_graph; - int _node_num; - int _arc_num; - int _res_arc_num; - int _root; - - // Parameters of the problem - bool _have_lower; - Value _sum_supply; - - // Data structures for storing the digraph - IntNodeMap _node_id; - IntArcMap _arc_idf; - IntArcMap _arc_idb; - IntVector _first_out; - BoolVector _forward; - IntVector _source; - IntVector _target; - IntVector _reverse; - - // Node and arc data - ValueVector _lower; - ValueVector _upper; - CostVector _cost; - ValueVector _supply; - - ValueVector _res_cap; - CostVector _pi; - ValueVector _excess; - IntVector _excess_nodes; - IntVector _deficit_nodes; - - Value _delta; - int _factor; - IntVector _pred; - - public: - - /// \brief Constant for infinite upper bounds (capacities). - /// - /// Constant for infinite upper bounds (capacities). - /// It is \c std::numeric_limits::infinity() if available, - /// \c std::numeric_limits::max() otherwise. - const Value INF; - - private: - - // Special implementation of the Dijkstra algorithm for finding - // shortest paths in the residual network of the digraph with - // respect to the reduced arc costs and modifying the node - // potentials according to the found distance labels. - class ResidualDijkstra - { - private: - - int _node_num; - bool _geq; - const IntVector &_first_out; - const IntVector &_target; - const CostVector &_cost; - const ValueVector &_res_cap; - const ValueVector &_excess; - CostVector &_pi; - IntVector &_pred; - - IntVector _proc_nodes; - CostVector _dist; - - public: - - ResidualDijkstra(CapacityScaling& cs) : - _node_num(cs._node_num), _geq(cs._sum_supply < 0), - _first_out(cs._first_out), _target(cs._target), _cost(cs._cost), - _res_cap(cs._res_cap), _excess(cs._excess), _pi(cs._pi), - _pred(cs._pred), _dist(cs._node_num) - {} - - int run(int s, Value delta = 1) { - RangeMap heap_cross_ref(_node_num, Heap::PRE_HEAP); - Heap heap(heap_cross_ref); - heap.push(s, 0); - _pred[s] = -1; - _proc_nodes.clear(); - - // Process nodes - while (!heap.empty() && _excess[heap.top()] > -delta) { - int u = heap.top(), v; - Cost d = heap.prio() + _pi[u], dn; - _dist[u] = heap.prio(); - _proc_nodes.push_back(u); - heap.pop(); - - // Traverse outgoing residual arcs - int last_out = _geq ? _first_out[u+1] : _first_out[u+1] - 1; - for (int a = _first_out[u]; a != last_out; ++a) { - if (_res_cap[a] < delta) continue; - v = _target[a]; - switch (heap.state(v)) { - case Heap::PRE_HEAP: - heap.push(v, d + _cost[a] - _pi[v]); - _pred[v] = a; - break; - case Heap::IN_HEAP: - dn = d + _cost[a] - _pi[v]; - if (dn < heap[v]) { - heap.decrease(v, dn); - _pred[v] = a; - } - break; - case Heap::POST_HEAP: - break; - } - } - } - if (heap.empty()) return -1; - - // Update potentials of processed nodes - int t = heap.top(); - Cost dt = heap.prio(); - for (int i = 0; i < int(_proc_nodes.size()); ++i) { - _pi[_proc_nodes[i]] += _dist[_proc_nodes[i]] - dt; - } - - return t; - } - - }; //class ResidualDijkstra - - public: - - /// \name Named Template Parameters - /// @{ - - template - struct SetHeapTraits : public Traits { - typedef T Heap; - }; - - /// \brief \ref named-templ-param "Named parameter" for setting - /// \c Heap type. - /// - /// \ref named-templ-param "Named parameter" for setting \c Heap - /// type, which is used for internal Dijkstra computations. - /// It must conform to the \ref lemon::concepts::Heap "Heap" concept, - /// its priority type must be \c Cost and its cross reference type - /// must be \ref RangeMap "RangeMap". - template - struct SetHeap - : public CapacityScaling > { - typedef CapacityScaling > Create; - }; - - /// @} - - protected: - - CapacityScaling() {} - - public: - - /// \brief Constructor. - /// - /// The constructor of the class. - /// - /// \param graph The digraph the algorithm runs on. - CapacityScaling(const GR& graph) : - _graph(graph), _node_id(graph), _arc_idf(graph), _arc_idb(graph), - INF(std::numeric_limits::has_infinity ? - std::numeric_limits::infinity() : - std::numeric_limits::max()) - { - // Check the number types - LEMON_ASSERT(std::numeric_limits::is_signed, - "The flow type of CapacityScaling must be signed"); - LEMON_ASSERT(std::numeric_limits::is_signed, - "The cost type of CapacityScaling must be signed"); - - // Reset data structures - reset(); - } - - /// \name Parameters - /// The parameters of the algorithm can be specified using these - /// functions. - - /// @{ - - /// \brief Set the lower bounds on the arcs. - /// - /// This function sets the lower bounds on the arcs. - /// If it is not used before calling \ref run(), the lower bounds - /// will be set to zero on all arcs. - /// - /// \param map An arc map storing the lower bounds. - /// Its \c Value type must be convertible to the \c Value type - /// of the algorithm. - /// - /// \return (*this) - template - 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 (*this) - template - 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 (*this) - template - 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 (*this) - template - 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 (*this) - 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 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 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 (*this) - /// - /// \see reset(), run() - CapacityScaling& resetParams() { - for (int i = 0; i != _node_num; ++i) { - _supply[i] = 0; - } - for (int j = 0; j != _res_arc_num; ++j) { - _lower[j] = 0; - _upper[j] = INF; - _cost[j] = _forward[j] ? 1 : -1; - } - _have_lower = false; - return *this; - } - - /// \brief Reset the internal data structures and all the parameters - /// that have been given before. - /// - /// This function resets the internal data structures and all the - /// paramaters that have been given before using functions \ref lowerMap(), - /// \ref upperMap(), \ref costMap(), \ref supplyMap(), \ref stSupply(). - /// - /// It is useful for multiple \ref run() calls. Basically, all the given - /// parameters are kept for the next \ref run() call, unless - /// \ref resetParams() or \ref reset() is used. - /// If the underlying digraph was also modified after the construction - /// of the class or the last \ref reset() call, then the \ref reset() - /// function must be used, otherwise \ref resetParams() is sufficient. - /// - /// See \ref resetParams() for examples. - /// - /// \return (*this) - /// - /// \see resetParams(), run() - CapacityScaling& reset() { - // Resize vectors - _node_num = countNodes(_graph); - _arc_num = countArcs(_graph); - _res_arc_num = 2 * (_arc_num + _node_num); - _root = _node_num; - ++_node_num; - - _first_out.resize(_node_num + 1); - _forward.resize(_res_arc_num); - _source.resize(_res_arc_num); - _target.resize(_res_arc_num); - _reverse.resize(_res_arc_num); - - _lower.resize(_res_arc_num); - _upper.resize(_res_arc_num); - _cost.resize(_res_arc_num); - _supply.resize(_node_num); - - _res_cap.resize(_res_arc_num); - _pi.resize(_node_num); - _excess.resize(_node_num); - _pred.resize(_node_num); - - // Copy the graph - int i = 0, j = 0, k = 2 * _arc_num + _node_num - 1; - for (NodeIt n(_graph); n != INVALID; ++n, ++i) { - _node_id[n] = i; - } - i = 0; - for (NodeIt n(_graph); n != INVALID; ++n, ++i) { - _first_out[i] = j; - for (OutArcIt a(_graph, n); a != INVALID; ++a, ++j) { - _arc_idf[a] = j; - _forward[j] = true; - _source[j] = i; - _target[j] = _node_id[_graph.runningNode(a)]; - } - for (InArcIt a(_graph, n); a != INVALID; ++a, ++j) { - _arc_idb[a] = j; - _forward[j] = false; - _source[j] = i; - _target[j] = _node_id[_graph.runningNode(a)]; - } - _forward[j] = false; - _source[j] = i; - _target[j] = _root; - _reverse[j] = k; - _forward[k] = true; - _source[k] = _root; - _target[k] = i; - _reverse[k] = j; - ++j; ++k; - } - _first_out[i] = j; - _first_out[_node_num] = k; - for (ArcIt a(_graph); a != INVALID; ++a) { - int fi = _arc_idf[a]; - int bi = _arc_idb[a]; - _reverse[fi] = bi; - _reverse[bi] = fi; - } - - // Reset parameters - resetParams(); - return *this; - } - - /// @} - - /// \name Query Functions - /// The results of the algorithm can be obtained using these - /// functions.\n - /// The \ref run() function must be called before using them. - - /// @{ - - /// \brief Return the total cost of the found flow. - /// - /// This function returns the total cost of the found flow. - /// Its complexity is O(e). - /// - /// \note The return type of the function can be specified as a - /// template parameter. For example, - /// \code - /// cs.totalCost(); - /// \endcode - /// It is useful if the total cost cannot be stored in the \c Cost - /// type of the algorithm, which is the default return type of the - /// function. - /// - /// \pre \ref run() must be called before using this function. - template - Number totalCost() const { - Number c = 0; - for (ArcIt a(_graph); a != INVALID; ++a) { - int i = _arc_idb[a]; - c += static_cast(_res_cap[i]) * - (-static_cast(_cost[i])); - } - return c; - } - -#ifndef DOXYGEN - Cost totalCost() const { - return totalCost(); - } -#endif - - /// \brief Return the flow on the given arc. - /// - /// This function returns the flow on the given arc. - /// - /// \pre \ref run() must be called before using this function. - Value flow(const Arc& a) const { - return _res_cap[_arc_idb[a]]; - } - - /// \brief Copy the flow values (the primal solution) into the - /// given map. - /// - /// This function copies the flow value on each arc into the given - /// map. The \c Value type of the algorithm must be convertible to - /// the \c Value type of the map. - /// - /// \pre \ref run() must be called before using this function. - template - void flowMap(FlowMap &map) const { - for (ArcIt a(_graph); a != INVALID; ++a) { - map.set(a, _res_cap[_arc_idb[a]]); - } - } - - /// \brief Return the potential (dual value) of the given node. - /// - /// This function returns the potential (dual value) of the - /// given node. - /// - /// \pre \ref run() must be called before using this function. - Cost potential(const Node& n) const { - return _pi[_node_id[n]]; - } - - /// \brief Copy the potential values (the dual solution) into the - /// given map. - /// - /// This function copies the potential (dual value) of each node - /// into the given map. - /// The \c Cost type of the algorithm must be convertible to the - /// \c Value type of the map. - /// - /// \pre \ref run() must be called before using this function. - template - void potentialMap(PotentialMap &map) const { - for (NodeIt n(_graph); n != INVALID; ++n) { - map.set(n, _pi[_node_id[n]]); - } - } - - /// @} - - private: - - // Initialize the algorithm - ProblemType init() { - if (_node_num <= 1) return INFEASIBLE; - - // Check the sum of supply values - _sum_supply = 0; - for (int i = 0; i != _root; ++i) { - _sum_supply += _supply[i]; - } - if (_sum_supply > 0) return INFEASIBLE; - - // Initialize vectors - for (int i = 0; i != _root; ++i) { - _pi[i] = 0; - _excess[i] = _supply[i]; - } - - // Remove non-zero lower bounds - const Value MAX = std::numeric_limits::max(); - int last_out; - if (_have_lower) { - for (int i = 0; i != _root; ++i) { - last_out = _first_out[i+1]; - for (int j = _first_out[i]; j != last_out; ++j) { - if (_forward[j]) { - Value c = _lower[j]; - if (c >= 0) { - _res_cap[j] = _upper[j] < MAX ? _upper[j] - c : INF; - } else { - _res_cap[j] = _upper[j] < MAX + c ? _upper[j] - c : INF; - } - _excess[i] -= c; - _excess[_target[j]] += c; - } else { - _res_cap[j] = 0; - } - } - } - } else { - for (int j = 0; j != _res_arc_num; ++j) { - _res_cap[j] = _forward[j] ? _upper[j] : 0; - } - } - - // Handle negative costs - for (int i = 0; i != _root; ++i) { - last_out = _first_out[i+1] - 1; - for (int j = _first_out[i]; j != last_out; ++j) { - Value rc = _res_cap[j]; - if (_cost[j] < 0 && rc > 0) { - if (rc >= MAX) return UNBOUNDED; - _excess[i] -= rc; - _excess[_target[j]] += rc; - _res_cap[j] = 0; - _res_cap[_reverse[j]] += rc; - } - } - } - - // Handle GEQ supply type - if (_sum_supply < 0) { - _pi[_root] = 0; - _excess[_root] = -_sum_supply; - for (int a = _first_out[_root]; a != _res_arc_num; ++a) { - int ra = _reverse[a]; - _res_cap[a] = -_sum_supply + 1; - _res_cap[ra] = 0; - _cost[a] = 0; - _cost[ra] = 0; - } - } else { - _pi[_root] = 0; - _excess[_root] = 0; - for (int a = _first_out[_root]; a != _res_arc_num; ++a) { - int ra = _reverse[a]; - _res_cap[a] = 1; - _res_cap[ra] = 0; - _cost[a] = 0; - _cost[ra] = 0; - } - } - - // Initialize delta value - if (_factor > 1) { - // With scaling - Value max_sup = 0, max_dem = 0, max_cap = 0; - for (int i = 0; i != _root; ++i) { - Value ex = _excess[i]; - if ( ex > max_sup) max_sup = ex; - if (-ex > max_dem) max_dem = -ex; - int last_out = _first_out[i+1] - 1; - for (int j = _first_out[i]; j != last_out; ++j) { - if (_res_cap[j] > max_cap) max_cap = _res_cap[j]; - } - } - max_sup = std::min(std::min(max_sup, max_dem), max_cap); - for (_delta = 1; 2 * _delta <= max_sup; _delta *= 2) ; - } else { - // Without scaling - _delta = 1; - } - - return OPTIMAL; - } - - ProblemType start() { - // Execute the algorithm - ProblemType pt; - if (_delta > 1) - pt = startWithScaling(); - else - pt = startWithoutScaling(); - - // Handle non-zero lower bounds - if (_have_lower) { - int limit = _first_out[_root]; - for (int j = 0; j != limit; ++j) { - if (!_forward[j]) _res_cap[j] += _lower[j]; - } - } - - // Shift potentials if necessary - Cost pr = _pi[_root]; - if (_sum_supply < 0 || pr > 0) { - for (int i = 0; i != _node_num; ++i) { - _pi[i] -= pr; - } - } - - return pt; - } - - // Execute the capacity scaling algorithm - ProblemType startWithScaling() { - // Perform capacity scaling phases - int s, t; - ResidualDijkstra _dijkstra(*this); - while (true) { - // Saturate all arcs not satisfying the optimality condition - int last_out; - for (int u = 0; u != _node_num; ++u) { - last_out = _sum_supply < 0 ? - _first_out[u+1] : _first_out[u+1] - 1; - for (int a = _first_out[u]; a != last_out; ++a) { - int v = _target[a]; - Cost c = _cost[a] + _pi[u] - _pi[v]; - Value rc = _res_cap[a]; - if (c < 0 && rc >= _delta) { - _excess[u] -= rc; - _excess[v] += rc; - _res_cap[a] = 0; - _res_cap[_reverse[a]] += rc; - } - } - } - - // Find excess nodes and deficit nodes - _excess_nodes.clear(); - _deficit_nodes.clear(); - for (int u = 0; u != _node_num; ++u) { - Value ex = _excess[u]; - if (ex >= _delta) _excess_nodes.push_back(u); - if (ex <= -_delta) _deficit_nodes.push_back(u); - } - int next_node = 0, next_def_node = 0; - - // Find augmenting shortest paths - while (next_node < int(_excess_nodes.size())) { - // Check deficit nodes - if (_delta > 1) { - bool delta_deficit = false; - for ( ; next_def_node < int(_deficit_nodes.size()); - ++next_def_node ) { - if (_excess[_deficit_nodes[next_def_node]] <= -_delta) { - delta_deficit = true; - break; - } - } - if (!delta_deficit) break; - } - - // Run Dijkstra in the residual network - s = _excess_nodes[next_node]; - if ((t = _dijkstra.run(s, _delta)) == -1) { - if (_delta > 1) { - ++next_node; - continue; - } - return INFEASIBLE; - } - - // Augment along a shortest path from s to t - Value d = std::min(_excess[s], -_excess[t]); - int u = t; - int a; - if (d > _delta) { - while ((a = _pred[u]) != -1) { - if (_res_cap[a] < d) d = _res_cap[a]; - u = _source[a]; - } - } - u = t; - while ((a = _pred[u]) != -1) { - _res_cap[a] -= d; - _res_cap[_reverse[a]] += d; - u = _source[a]; - } - _excess[s] -= d; - _excess[t] += d; - - if (_excess[s] < _delta) ++next_node; - } - - if (_delta == 1) break; - _delta = _delta <= _factor ? 1 : _delta / _factor; - } - - return OPTIMAL; - } - - // Execute the successive shortest path algorithm - ProblemType startWithoutScaling() { - // Find excess nodes - _excess_nodes.clear(); - for (int i = 0; i != _node_num; ++i) { - if (_excess[i] > 0) _excess_nodes.push_back(i); - } - if (_excess_nodes.size() == 0) return OPTIMAL; - int next_node = 0; - - // Find shortest paths - int s, t; - ResidualDijkstra _dijkstra(*this); - while ( _excess[_excess_nodes[next_node]] > 0 || - ++next_node < int(_excess_nodes.size()) ) - { - // Run Dijkstra in the residual network - s = _excess_nodes[next_node]; - if ((t = _dijkstra.run(s)) == -1) return INFEASIBLE; - - // Augment along a shortest path from s to t - Value d = std::min(_excess[s], -_excess[t]); - int u = t; - int a; - if (d > 1) { - while ((a = _pred[u]) != -1) { - if (_res_cap[a] < d) d = _res_cap[a]; - u = _source[a]; - } - } - u = t; - while ((a = _pred[u]) != -1) { - _res_cap[a] -= d; - _res_cap[_reverse[a]] += d; - u = _source[a]; - } - _excess[s] -= d; - _excess[t] += d; - } - - return OPTIMAL; - } - - }; //class CapacityScaling - - ///@} - -} //namespace lemon - -#endif //LEMON_CAPACITY_SCALING_H Index: lemon/cbc.cc =================================================================== --- lemon/cbc.cc (revision 1000) +++ lemon/cbc.cc (revision 988) @@ -90,16 +90,4 @@ } - int CbcMip::_addRow(Value l, ExprIterator b, ExprIterator e, Value u) { - std::vector indexes; - std::vector values; - - for(ExprIterator it = b; it != e; ++it) { - indexes.push_back(it->first); - values.push_back(it->second); - } - - _prob->addRow(values.size(), &indexes.front(), &values.front(), l, u); - return _prob->numberRows() - 1; - } void CbcMip::_eraseCol(int i) { Index: lemon/cbc.h =================================================================== --- lemon/cbc.h (revision 877) +++ lemon/cbc.h (revision 576) @@ -3,5 +3,5 @@ * This file is a part of LEMON, a generic C++ optimization library. * - * Copyright (C) 2003-2010 + * Copyright (C) 2003-2009 * Egervary Jeno Kombinatorikus Optimalizalasi Kutatocsoport * (Egervary Research Group on Combinatorial Optimization, EGRES). @@ -63,5 +63,4 @@ virtual int _addCol(); virtual int _addRow(); - virtual int _addRow(Value l, ExprIterator b, ExprIterator e, Value u); virtual void _eraseCol(int i); @@ -122,5 +121,5 @@ int _message_level; - + }; Index: lemon/circulation.h =================================================================== --- lemon/circulation.h (revision 998) +++ lemon/circulation.h (revision 997) @@ -3,5 +3,5 @@ * This file is a part of LEMON, a generic C++ optimization library. * - * Copyright (C) 2003-2010 + * Copyright (C) 2003-2009 * Egervary Jeno Kombinatorikus Optimalizalasi Kutatocsoport * (Egervary Research Group on Combinatorial Optimization, EGRES). @@ -60,6 +60,6 @@ /// \brief The type of supply map. /// - /// The type of the map that stores the signed supply values of the - /// nodes. + /// The type of the map that stores the signed supply values of the + /// nodes. /// It must conform to the \ref concepts::ReadMap "ReadMap" concept. typedef SM SupplyMap; @@ -73,9 +73,5 @@ /// It must conform to the \ref concepts::ReadWriteMap "ReadWriteMap" /// concept. -#ifdef DOXYGEN - typedef GR::ArcMap FlowMap; -#else typedef typename Digraph::template ArcMap FlowMap; -#endif /// \brief Instantiates a FlowMap. @@ -92,10 +88,7 @@ /// The elevator type used by the algorithm. /// - /// \sa Elevator, LinkedElevator -#ifdef DOXYGEN - typedef lemon::Elevator Elevator; -#else + /// \sa Elevator + /// \sa LinkedElevator typedef lemon::Elevator Elevator; -#endif /// \brief Instantiates an Elevator. @@ -142,5 +135,5 @@ \geq sup(u) \quad \forall u\in V, \f] \f[ lower(uv) \leq f(uv) \leq upper(uv) \quad \forall uv\in A. \f] - + The sum of the supply values, i.e. \f$\sum_{u\in V} sup(u)\f$ must be zero or negative in order to have a feasible solution (since the sum @@ -152,5 +145,5 @@ constraints have to be satisfied with equality, i.e. all demands have to be satisfied and all supplies have to be used. - + If you need the opposite inequalities in the supply/demand constraints (i.e. the total demand is less than the total supply and all the demands @@ -174,9 +167,4 @@ \tparam SM The type of the supply map. The default map type is \ref concepts::Digraph::NodeMap "GR::NodeMap". - \tparam TR The traits class that defines various types used by the - algorithm. By default, it is \ref CirculationDefaultTraits - "CirculationDefaultTraits". - In most cases, this parameter should not be set directly, - consider to use the named template parameters instead. */ #ifdef DOXYGEN @@ -312,5 +300,5 @@ /// able to automatically created by the algorithm (i.e. the /// digraph and the maximum level should be passed to it). - /// However, an external elevator object could also be passed to the + /// However an external elevator object could also be passed to the /// algorithm with the \ref elevator(Elevator&) "elevator()" function /// before calling \ref run() or \ref init(). @@ -338,5 +326,5 @@ /// \param graph The digraph the algorithm runs on. /// \param lower The lower bounds for the flow values on the arcs. - /// \param upper The upper bounds (capacities) for the flow values + /// \param upper The upper bounds (capacities) for the flow values /// on the arcs. /// \param supply The signed supply values of the nodes. @@ -463,8 +451,7 @@ } - /// \brief Sets the tolerance used by the algorithm. - /// - /// Sets the tolerance object used by the algorithm. - /// \return (*this) + /// \brief Sets the tolerance used by algorithm. + /// + /// Sets the tolerance used by algorithm. Circulation& tolerance(const Tolerance& tolerance) { _tol = tolerance; @@ -474,6 +461,5 @@ /// \brief Returns a const reference to the tolerance. /// - /// Returns a const reference to the tolerance object used by - /// the algorithm. + /// Returns a const reference to the tolerance. const Tolerance& tolerance() const { return _tol; @@ -482,6 +468,6 @@ /// \name Execution Control /// The simplest way to execute the algorithm is to call \ref run().\n - /// If you need better control on the initial solution or the execution, - /// you have to call one of the \ref init() functions first, then + /// If you need more control on the initial solution or the execution, + /// first you have to call one of the \ref init() functions, then /// the \ref start() function. Index: lemon/clp.cc =================================================================== --- lemon/clp.cc (revision 989) +++ lemon/clp.cc (revision 988) @@ -3,5 +3,5 @@ * This file is a part of LEMON, a generic C++ optimization library. * - * Copyright (C) 2003-2010 + * Copyright (C) 2003-2008 * Egervary Jeno Kombinatorikus Optimalizalasi Kutatocsoport * (Egervary Research Group on Combinatorial Optimization, EGRES). @@ -76,17 +76,4 @@ int ClpLp::_addRow() { _prob->addRow(0, 0, 0, -COIN_DBL_MAX, COIN_DBL_MAX); - return _prob->numberRows() - 1; - } - - int ClpLp::_addRow(Value l, ExprIterator b, ExprIterator e, Value u) { - std::vector indexes; - std::vector values; - - for(ExprIterator it = b; it != e; ++it) { - indexes.push_back(it->first); - values.push_back(it->second); - } - - _prob->addRow(values.size(), &indexes.front(), &values.front(), l, u); return _prob->numberRows() - 1; } Index: lemon/clp.h =================================================================== --- lemon/clp.h (revision 877) +++ lemon/clp.h (revision 576) @@ -3,5 +3,5 @@ * This file is a part of LEMON, a generic C++ optimization library. * - * Copyright (C) 2003-2010 + * Copyright (C) 2003-2008 * Egervary Jeno Kombinatorikus Optimalizalasi Kutatocsoport * (Egervary Research Group on Combinatorial Optimization, EGRES). @@ -76,5 +76,4 @@ virtual int _addCol(); virtual int _addRow(); - virtual int _addRow(Value l, ExprIterator b, ExprIterator e, Value u); virtual void _eraseCol(int i); @@ -139,5 +138,5 @@ virtual void _messageLevel(MessageLevel); - + public: Index: lemon/concepts/digraph.h =================================================================== --- lemon/concepts/digraph.h (revision 877) +++ lemon/concepts/digraph.h (revision 580) @@ -3,5 +3,5 @@ * This file is a part of LEMON, a generic C++ optimization library. * - * Copyright (C) 2003-2010 + * Copyright (C) 2003-2009 * Egervary Jeno Kombinatorikus Optimalizalasi Kutatocsoport * (Egervary Research Group on Combinatorial Optimization, EGRES). @@ -36,38 +36,44 @@ /// \brief Class describing the concept of directed graphs. /// - /// This class describes the common interface of all directed - /// graphs (digraphs). + /// This class describes the \ref concept "concept" of the + /// immutable directed digraphs. /// - /// Like all concept classes, it only provides an interface - /// without any sensible implementation. So any general algorithm for - /// directed graphs should compile with this class, but it will not - /// run properly, of course. - /// An actual digraph implementation like \ref ListDigraph or - /// \ref SmartDigraph may have additional functionality. + /// Note that actual digraph implementation like @ref ListDigraph or + /// @ref SmartDigraph may have several additional functionality. /// - /// \sa Graph + /// \sa concept class Digraph { private: - /// Diraphs are \e not copy constructible. Use DigraphCopy instead. - Digraph(const Digraph &) {} - /// \brief Assignment of a digraph to another one is \e not allowed. - /// Use DigraphCopy instead. + ///Digraphs are \e not copy constructible. Use DigraphCopy() instead. + + ///Digraphs are \e not copy constructible. Use DigraphCopy() instead. + /// + Digraph(const Digraph &) {}; + ///\brief Assignment of \ref Digraph "Digraph"s to another ones are + ///\e not allowed. Use DigraphCopy() instead. + + ///Assignment of \ref Digraph "Digraph"s to another ones are + ///\e not allowed. Use DigraphCopy() instead. + void operator=(const Digraph &) {} - public: - /// Default constructor. + ///\e + + /// Defalult constructor. + + /// Defalult constructor. + /// Digraph() { } - - /// The node type of the digraph + /// Class for identifying a node of the digraph /// This class identifies a node of the digraph. It also serves /// as a base class of the node iterators, - /// thus they convert to this type. + /// thus they will convert to this type. class Node { public: /// Default constructor - /// Default constructor. - /// \warning It sets the object to an undefined value. + /// @warning The default constructor sets the iterator + /// to an undefined value. Node() { } /// Copy constructor. @@ -77,37 +83,38 @@ Node(const Node&) { } - /// %Invalid constructor \& conversion. - - /// Initializes the object to be invalid. + /// Invalid constructor \& conversion. + + /// This constructor initializes the iterator to be invalid. /// \sa Invalid for more details. Node(Invalid) { } /// Equality operator - /// Equality operator. - /// /// Two iterators are equal if and only if they point to the - /// same object or both are \c INVALID. + /// same object or both are invalid. bool operator==(Node) const { return true; } /// Inequality operator - /// Inequality operator. + /// \sa operator==(Node n) + /// bool operator!=(Node) const { return true; } /// Artificial ordering operator. - /// Artificial ordering operator. - /// - /// \note This operator only has to define some strict ordering of - /// the nodes; this order has nothing to do with the iteration - /// ordering of the nodes. + /// To allow the use of digraph descriptors as key type in std::map or + /// similar associative container we require this. + /// + /// \note This operator only have to define some strict ordering of + /// the items; this order has nothing to do with the iteration + /// ordering of the items. bool operator<(Node) const { return false; } - }; - - /// Iterator class for the nodes. - - /// This iterator goes through each node of the digraph. - /// Its usage is quite simple, for example, you can count the number - /// of nodes in a digraph \c g of type \c %Digraph like this: + + }; + + /// This iterator goes through each node. + + /// This iterator goes through each node. + /// Its usage is quite simple, for example you can count the number + /// of nodes in digraph \c g of type \c Digraph like this: ///\code /// int count=0; @@ -118,6 +125,6 @@ /// Default constructor - /// Default constructor. - /// \warning It sets the iterator to an undefined value. + /// @warning The default constructor sets the iterator + /// to an undefined value. NodeIt() { } /// Copy constructor. @@ -126,18 +133,20 @@ /// NodeIt(const NodeIt& n) : Node(n) { } - /// %Invalid constructor \& conversion. - - /// Initializes the iterator to be invalid. + /// Invalid constructor \& conversion. + + /// Initialize the iterator to be invalid. /// \sa Invalid for more details. NodeIt(Invalid) { } /// Sets the iterator to the first node. - /// Sets the iterator to the first node of the given digraph. - /// - explicit NodeIt(const Digraph&) { } - /// Sets the iterator to the given node. - - /// Sets the iterator to the given node of the given digraph. - /// + /// Sets the iterator to the first node of \c g. + /// + NodeIt(const Digraph&) { } + /// Node -> NodeIt conversion. + + /// Sets the iterator to the node of \c the digraph pointed by + /// the trivial iterator. + /// This feature necessitates that each time we + /// iterate the arc-set, the iteration order is the same. NodeIt(const Digraph&, const Node&) { } /// Next node. @@ -149,5 +158,5 @@ - /// The arc type of the digraph + /// Class for identifying an arc of the digraph /// This class identifies an arc of the digraph. It also serves @@ -158,6 +167,6 @@ /// Default constructor - /// Default constructor. - /// \warning It sets the object to an undefined value. + /// @warning The default constructor sets the iterator + /// to an undefined value. Arc() { } /// Copy constructor. @@ -166,48 +175,49 @@ /// Arc(const Arc&) { } - /// %Invalid constructor \& conversion. - - /// Initializes the object to be invalid. - /// \sa Invalid for more details. + /// Initialize the iterator to be invalid. + + /// Initialize the iterator to be invalid. + /// Arc(Invalid) { } /// Equality operator - /// Equality operator. - /// /// Two iterators are equal if and only if they point to the - /// same object or both are \c INVALID. + /// same object or both are invalid. bool operator==(Arc) const { return true; } /// Inequality operator - /// Inequality operator. + /// \sa operator==(Arc n) + /// bool operator!=(Arc) const { return true; } /// Artificial ordering operator. - /// Artificial ordering operator. - /// - /// \note This operator only has to define some strict ordering of - /// the arcs; this order has nothing to do with the iteration - /// ordering of the arcs. + /// To allow the use of digraph descriptors as key type in std::map or + /// similar associative container we require this. + /// + /// \note This operator only have to define some strict ordering of + /// the items; this order has nothing to do with the iteration + /// ordering of the items. bool operator<(Arc) const { return false; } }; - /// Iterator class for the outgoing arcs of a node. + /// This iterator goes trough the outgoing arcs of a node. /// This iterator goes trough the \e outgoing arcs of a certain node /// of a digraph. - /// Its usage is quite simple, for example, you can count the number + /// Its usage is quite simple, for example you can count the number /// of outgoing arcs of a node \c n - /// in a digraph \c g of type \c %Digraph as follows. + /// in digraph \c g of type \c Digraph as follows. ///\code /// int count=0; - /// for (Digraph::OutArcIt a(g, n); a!=INVALID; ++a) ++count; + /// for (Digraph::OutArcIt e(g, n); e!=INVALID; ++e) ++count; ///\endcode + class OutArcIt : public Arc { public: /// Default constructor - /// Default constructor. - /// \warning It sets the iterator to an undefined value. + /// @warning The default constructor sets the iterator + /// to an undefined value. OutArcIt() { } /// Copy constructor. @@ -216,20 +226,21 @@ /// OutArcIt(const OutArcIt& e) : Arc(e) { } - /// %Invalid constructor \& conversion. - - /// Initializes the iterator to be invalid. - /// \sa Invalid for more details. + /// Initialize the iterator to be invalid. + + /// Initialize the iterator to be invalid. + /// OutArcIt(Invalid) { } - /// Sets the iterator to the first outgoing arc. - - /// Sets the iterator to the first outgoing arc of the given node. - /// + /// This constructor sets the iterator to the first outgoing arc. + + /// This constructor sets the iterator to the first outgoing arc of + /// the node. OutArcIt(const Digraph&, const Node&) { } - /// Sets the iterator to the given arc. - - /// Sets the iterator to the given arc of the given digraph. - /// + /// Arc -> OutArcIt conversion + + /// Sets the iterator to the value of the trivial iterator. + /// This feature necessitates that each time we + /// iterate the arc-set, the iteration order is the same. OutArcIt(const Digraph&, const Arc&) { } - /// Next outgoing arc + ///Next outgoing arc /// Assign the iterator to the next @@ -238,21 +249,22 @@ }; - /// Iterator class for the incoming arcs of a node. + /// This iterator goes trough the incoming arcs of a node. /// This iterator goes trough the \e incoming arcs of a certain node /// of a digraph. - /// Its usage is quite simple, for example, you can count the number - /// of incoming arcs of a node \c n - /// in a digraph \c g of type \c %Digraph as follows. + /// Its usage is quite simple, for example you can count the number + /// of outgoing arcs of a node \c n + /// in digraph \c g of type \c Digraph as follows. ///\code /// int count=0; - /// for(Digraph::InArcIt a(g, n); a!=INVALID; ++a) ++count; + /// for(Digraph::InArcIt e(g, n); e!=INVALID; ++e) ++count; ///\endcode + class InArcIt : public Arc { public: /// Default constructor - /// Default constructor. - /// \warning It sets the iterator to an undefined value. + /// @warning The default constructor sets the iterator + /// to an undefined value. InArcIt() { } /// Copy constructor. @@ -261,34 +273,34 @@ /// InArcIt(const InArcIt& e) : Arc(e) { } - /// %Invalid constructor \& conversion. - - /// Initializes the iterator to be invalid. - /// \sa Invalid for more details. + /// Initialize the iterator to be invalid. + + /// Initialize the iterator to be invalid. + /// InArcIt(Invalid) { } - /// Sets the iterator to the first incoming arc. - - /// Sets the iterator to the first incoming arc of the given node. - /// + /// This constructor sets the iterator to first incoming arc. + + /// This constructor set the iterator to the first incoming arc of + /// the node. InArcIt(const Digraph&, const Node&) { } - /// Sets the iterator to the given arc. - - /// Sets the iterator to the given arc of the given digraph. - /// + /// Arc -> InArcIt conversion + + /// Sets the iterator to the value of the trivial iterator \c e. + /// This feature necessitates that each time we + /// iterate the arc-set, the iteration order is the same. InArcIt(const Digraph&, const Arc&) { } /// Next incoming arc - /// Assign the iterator to the next - /// incoming arc of the corresponding node. + /// Assign the iterator to the next inarc of the corresponding node. + /// InArcIt& operator++() { return *this; } }; - - /// Iterator class for the arcs. - - /// This iterator goes through each arc of the digraph. - /// Its usage is quite simple, for example, you can count the number - /// of arcs in a digraph \c g of type \c %Digraph as follows: + /// This iterator goes through each arc. + + /// This iterator goes through each arc of a digraph. + /// Its usage is quite simple, for example you can count the number + /// of arcs in a digraph \c g of type \c Digraph as follows: ///\code /// int count=0; - /// for(Digraph::ArcIt a(g); a!=INVALID; ++a) ++count; + /// for(Digraph::ArcIt e(g); e!=INVALID; ++e) ++count; ///\endcode class ArcIt : public Arc { @@ -296,6 +308,6 @@ /// Default constructor - /// Default constructor. - /// \warning It sets the iterator to an undefined value. + /// @warning The default constructor sets the iterator + /// to an undefined value. ArcIt() { } /// Copy constructor. @@ -304,66 +316,56 @@ /// ArcIt(const ArcIt& e) : Arc(e) { } - /// %Invalid constructor \& conversion. - - /// Initializes the iterator to be invalid. - /// \sa Invalid for more details. + /// Initialize the iterator to be invalid. + + /// Initialize the iterator to be invalid. + /// ArcIt(Invalid) { } - /// Sets the iterator to the first arc. - - /// Sets the iterator to the first arc of the given digraph. - /// - explicit ArcIt(const Digraph& g) { ignore_unused_variable_warning(g); } - /// Sets the iterator to the given arc. - - /// Sets the iterator to the given arc of the given digraph. - /// + /// This constructor sets the iterator to the first arc. + + /// This constructor sets the iterator to the first arc of \c g. + ///@param g the digraph + ArcIt(const Digraph& g) { ignore_unused_variable_warning(g); } + /// Arc -> ArcIt conversion + + /// Sets the iterator to the value of the trivial iterator \c e. + /// This feature necessitates that each time we + /// iterate the arc-set, the iteration order is the same. ArcIt(const Digraph&, const Arc&) { } - /// Next arc + ///Next arc /// Assign the iterator to the next arc. - /// ArcIt& operator++() { return *this; } }; - - /// \brief The source node of the arc. - /// - /// Returns the source node of the given arc. + ///Gives back the target node of an arc. + + ///Gives back the target node of an arc. + /// + Node target(Arc) const { return INVALID; } + ///Gives back the source node of an arc. + + ///Gives back the source node of an arc. + /// Node source(Arc) const { return INVALID; } - /// \brief The target node of the arc. - /// - /// Returns the target node of the given arc. - Node target(Arc) const { return INVALID; } - - /// \brief The ID of the node. - /// - /// Returns the ID of the given node. + /// \brief Returns the ID of the node. int id(Node) const { return -1; } - /// \brief The ID of the arc. - /// - /// Returns the ID of the given arc. + /// \brief Returns the ID of the arc. int id(Arc) const { return -1; } - /// \brief The node with the given ID. - /// - /// Returns the node with the given ID. - /// \pre The argument should be a valid node ID in the digraph. + /// \brief Returns the node with the given ID. + /// + /// \pre The argument should be a valid node ID in the graph. Node nodeFromId(int) const { return INVALID; } - /// \brief The arc with the given ID. - /// - /// Returns the arc with the given ID. - /// \pre The argument should be a valid arc ID in the digraph. + /// \brief Returns the arc with the given ID. + /// + /// \pre The argument should be a valid arc ID in the graph. Arc arcFromId(int) const { return INVALID; } - /// \brief An upper bound on the node IDs. - /// - /// Returns an upper bound on the node IDs. + /// \brief Returns an upper bound on the node IDs. int maxNodeId() const { return -1; } - /// \brief An upper bound on the arc IDs. - /// - /// Returns an upper bound on the arc IDs. + /// \brief Returns an upper bound on the arc IDs. int maxArcId() const { return -1; } @@ -391,49 +393,48 @@ int maxId(Arc) const { return -1; } - /// \brief The opposite node on the arc. - /// - /// Returns the opposite node on the given arc. - Node oppositeNode(Node, Arc) const { return INVALID; } - /// \brief The base node of the iterator. /// - /// Returns the base node of the given outgoing arc iterator - /// (i.e. the source node of the corresponding arc). - Node baseNode(OutArcIt) const { return INVALID; } + /// Gives back the base node of the iterator. + /// It is always the target of the pointed arc. + Node baseNode(const InArcIt&) const { return INVALID; } /// \brief The running node of the iterator. /// - /// Returns the running node of the given outgoing arc iterator - /// (i.e. the target node of the corresponding arc). - Node runningNode(OutArcIt) const { return INVALID; } + /// Gives back the running node of the iterator. + /// It is always the source of the pointed arc. + Node runningNode(const InArcIt&) const { return INVALID; } /// \brief The base node of the iterator. /// - /// Returns the base node of the given incomming arc iterator - /// (i.e. the target node of the corresponding arc). - Node baseNode(InArcIt) const { return INVALID; } + /// Gives back the base node of the iterator. + /// It is always the source of the pointed arc. + Node baseNode(const OutArcIt&) const { return INVALID; } /// \brief The running node of the iterator. /// - /// Returns the running node of the given incomming arc iterator - /// (i.e. the source node of the corresponding arc). - Node runningNode(InArcIt) const { return INVALID; } - - /// \brief Standard graph map type for the nodes. - /// - /// Standard graph map type for the nodes. - /// It conforms to the ReferenceMap concept. + /// Gives back the running node of the iterator. + /// It is always the target of the pointed arc. + Node runningNode(const OutArcIt&) const { return INVALID; } + + /// \brief The opposite node on the given arc. + /// + /// Gives back the opposite node on the given arc. + Node oppositeNode(const Node&, const Arc&) const { return INVALID; } + + /// \brief Reference map of the nodes to type \c T. + /// + /// Reference map of the nodes to type \c T. template class NodeMap : public ReferenceMap { public: - /// Constructor - explicit NodeMap(const Digraph&) { } - /// Constructor with given initial value + ///\e + NodeMap(const Digraph&) { } + ///\e NodeMap(const Digraph&, T) { } private: ///Copy constructor - NodeMap(const NodeMap& nm) : + NodeMap(const NodeMap& nm) : ReferenceMap(nm) { } ///Assignment operator @@ -445,17 +446,15 @@ }; - /// \brief Standard graph map type for the arcs. - /// - /// Standard graph map type for the arcs. - /// It conforms to the ReferenceMap concept. + /// \brief Reference map of the arcs to type \c T. + /// + /// Reference map of the arcs to type \c T. template class ArcMap : public ReferenceMap { public: - /// Constructor - explicit ArcMap(const Digraph&) { } - /// Constructor with given initial value + ///\e + ArcMap(const Digraph&) { } + ///\e ArcMap(const Digraph&, T) { } - private: ///Copy constructor Index: lemon/concepts/graph.h =================================================================== --- lemon/concepts/graph.h (revision 877) +++ lemon/concepts/graph.h (revision 657) @@ -3,5 +3,5 @@ * This file is a part of LEMON, a generic C++ optimization library. * - * Copyright (C) 2003-2010 + * Copyright (C) 2003-2009 * Egervary Jeno Kombinatorikus Optimalizalasi Kutatocsoport * (Egervary Research Group on Combinatorial Optimization, EGRES). @@ -19,5 +19,5 @@ ///\ingroup graph_concepts ///\file -///\brief The concept of undirected graphs. +///\brief The concept of Undirected Graphs. #ifndef LEMON_CONCEPTS_GRAPH_H @@ -25,6 +25,4 @@ #include -#include -#include #include @@ -34,72 +32,61 @@ /// \ingroup graph_concepts /// - /// \brief Class describing the concept of undirected graphs. + /// \brief Class describing the concept of Undirected Graphs. /// - /// This class describes the common interface of all undirected - /// graphs. + /// This class describes the common interface of all Undirected + /// Graphs. /// - /// Like all concept classes, it only provides an interface - /// without any sensible implementation. So any general algorithm for - /// undirected graphs should compile with this class, but it will not + /// As all concept describing classes it provides only interface + /// without any sensible implementation. So any algorithm for + /// undirected graph should compile with this class, but it will not /// run properly, of course. - /// An actual graph implementation like \ref ListGraph or - /// \ref SmartGraph may have additional functionality. /// - /// The undirected graphs also fulfill the concept of \ref Digraph - /// "directed graphs", since each edge can also be regarded as two - /// oppositely directed arcs. - /// Undirected graphs provide an Edge type for the undirected edges and - /// an Arc type for the directed arcs. The Arc type is convertible to - /// Edge or inherited from it, i.e. the corresponding edge can be - /// obtained from an arc. - /// EdgeIt and EdgeMap classes can be used for the edges, while ArcIt - /// and ArcMap classes can be used for the arcs (just like in digraphs). - /// Both InArcIt and OutArcIt iterates on the same edges but with - /// opposite direction. IncEdgeIt also iterates on the same edges - /// as OutArcIt and InArcIt, but it is not convertible to Arc, - /// only to Edge. + /// The LEMON undirected graphs also fulfill the concept of + /// directed graphs (\ref lemon::concepts::Digraph "Digraph + /// Concept"). Each edges can be seen as two opposite + /// directed arc and consequently the undirected graph can be + /// seen as the direceted graph of these directed arcs. The + /// Graph has the Edge inner class for the edges and + /// the Arc type for the directed arcs. The Arc type is + /// convertible to Edge or inherited from it so from a directed + /// arc we can get the represented edge. /// - /// In LEMON, each undirected edge has an inherent orientation. - /// Thus it can defined if an arc is forward or backward oriented in - /// an undirected graph with respect to this default oriantation of - /// the represented edge. - /// With the direction() and direct() functions the direction - /// of an arc can be obtained and set, respectively. + /// In the sense of the LEMON each edge has a default + /// direction (it should be in every computer implementation, + /// because the order of edge's nodes defines an + /// orientation). With the default orientation we can define that + /// the directed arc is forward or backward directed. With the \c + /// direction() and \c direct() function we can get the direction + /// of the directed arc and we can direct an edge. /// - /// Only nodes and edges can be added to or removed from an undirected - /// graph and the corresponding arcs are added or removed automatically. - /// - /// \sa Digraph + /// The EdgeIt is an iterator for the edges. We can use + /// the EdgeMap to map values for the edges. The InArcIt and + /// OutArcIt iterates on the same edges but with opposite + /// direction. The IncEdgeIt iterates also on the same edges + /// as the OutArcIt and InArcIt but it is not convertible to Arc just + /// to Edge. class Graph { - private: - /// Graphs are \e not copy constructible. Use DigraphCopy instead. - Graph(const Graph&) {} - /// \brief Assignment of a graph to another one is \e not allowed. - /// Use DigraphCopy instead. - void operator=(const Graph&) {} - public: - /// Default constructor. - Graph() {} - - /// \brief Undirected graphs should be tagged with \c UndirectedTag. - /// - /// Undirected graphs should be tagged with \c UndirectedTag. - /// - /// This tag helps the \c enable_if technics to make compile time + /// \brief The undirected graph should be tagged by the + /// UndirectedTag. + /// + /// The undirected graph should be tagged by the UndirectedTag. This + /// tag helps the enable_if technics to make compile time /// specializations for undirected graphs. typedef True UndirectedTag; - /// The node type of the graph - - /// This class identifies a node of the graph. It also serves - /// as a base class of the node iterators, - /// thus they convert to this type. + /// \brief The base type of node iterators, + /// or in other words, the trivial node iterator. + /// + /// This is the base type of each node iterator, + /// thus each kind of node iterator converts to this. + /// More precisely each kind of node iterator should be inherited + /// from the trivial node iterator. class Node { public: /// Default constructor - /// Default constructor. - /// \warning It sets the object to an undefined value. + /// @warning The default constructor sets the iterator + /// to an undefined value. Node() { } /// Copy constructor. @@ -109,27 +96,27 @@ Node(const Node&) { } - /// %Invalid constructor \& conversion. - - /// Initializes the object to be invalid. + /// Invalid constructor \& conversion. + + /// This constructor initializes the iterator to be invalid. /// \sa Invalid for more details. Node(Invalid) { } /// Equality operator - /// Equality operator. - /// /// Two iterators are equal if and only if they point to the - /// same object or both are \c INVALID. + /// same object or both are invalid. bool operator==(Node) const { return true; } /// Inequality operator - /// Inequality operator. + /// \sa operator==(Node n) + /// bool operator!=(Node) const { return true; } /// Artificial ordering operator. - /// Artificial ordering operator. - /// - /// \note This operator only has to define some strict ordering of + /// To allow the use of graph descriptors as key type in std::map or + /// similar associative container we require this. + /// + /// \note This operator only have to define some strict ordering of /// the items; this order has nothing to do with the iteration /// ordering of the items. @@ -138,9 +125,9 @@ }; - /// Iterator class for the nodes. - - /// This iterator goes through each node of the graph. - /// Its usage is quite simple, for example, you can count the number - /// of nodes in a graph \c g of type \c %Graph like this: + /// This iterator goes through each node. + + /// This iterator goes through each node. + /// Its usage is quite simple, for example you can count the number + /// of nodes in graph \c g of type \c Graph like this: ///\code /// int count=0; @@ -151,6 +138,6 @@ /// Default constructor - /// Default constructor. - /// \warning It sets the iterator to an undefined value. + /// @warning The default constructor sets the iterator + /// to an undefined value. NodeIt() { } /// Copy constructor. @@ -159,18 +146,20 @@ /// NodeIt(const NodeIt& n) : Node(n) { } - /// %Invalid constructor \& conversion. - - /// Initializes the iterator to be invalid. + /// Invalid constructor \& conversion. + + /// Initialize the iterator to be invalid. /// \sa Invalid for more details. NodeIt(Invalid) { } /// Sets the iterator to the first node. - /// Sets the iterator to the first node of the given digraph. - /// - explicit NodeIt(const Graph&) { } - /// Sets the iterator to the given node. - - /// Sets the iterator to the given node of the given digraph. - /// + /// Sets the iterator to the first node of \c g. + /// + NodeIt(const Graph&) { } + /// Node -> NodeIt conversion. + + /// Sets the iterator to the node of \c the graph pointed by + /// the trivial iterator. + /// This feature necessitates that each time we + /// iterate the arc-set, the iteration order is the same. NodeIt(const Graph&, const Node&) { } /// Next node. @@ -182,15 +171,14 @@ - /// The edge type of the graph - - /// This class identifies an edge of the graph. It also serves - /// as a base class of the edge iterators, - /// thus they will convert to this type. + /// The base type of the edge iterators. + + /// The base type of the edge iterators. + /// class Edge { public: /// Default constructor - /// Default constructor. - /// \warning It sets the object to an undefined value. + /// @warning The default constructor sets the iterator + /// to an undefined value. Edge() { } /// Copy constructor. @@ -199,36 +187,36 @@ /// Edge(const Edge&) { } - /// %Invalid constructor \& conversion. - - /// Initializes the object to be invalid. - /// \sa Invalid for more details. + /// Initialize the iterator to be invalid. + + /// Initialize the iterator to be invalid. + /// Edge(Invalid) { } /// Equality operator - /// Equality operator. - /// /// Two iterators are equal if and only if they point to the - /// same object or both are \c INVALID. + /// same object or both are invalid. bool operator==(Edge) const { return true; } /// Inequality operator - /// Inequality operator. + /// \sa operator==(Edge n) + /// bool operator!=(Edge) const { return true; } /// Artificial ordering operator. - /// Artificial ordering operator. - /// - /// \note This operator only has to define some strict ordering of - /// the edges; this order has nothing to do with the iteration - /// ordering of the edges. + /// To allow the use of graph descriptors as key type in std::map or + /// similar associative container we require this. + /// + /// \note This operator only have to define some strict ordering of + /// the items; this order has nothing to do with the iteration + /// ordering of the items. bool operator<(Edge) const { return false; } }; - /// Iterator class for the edges. - - /// This iterator goes through each edge of the graph. - /// Its usage is quite simple, for example, you can count the number - /// of edges in a graph \c g of type \c %Graph as follows: + /// This iterator goes through each edge. + + /// This iterator goes through each edge of a graph. + /// Its usage is quite simple, for example you can count the number + /// of edges in a graph \c g of type \c Graph as follows: ///\code /// int count=0; @@ -239,6 +227,6 @@ /// Default constructor - /// Default constructor. - /// \warning It sets the iterator to an undefined value. + /// @warning The default constructor sets the iterator + /// to an undefined value. EdgeIt() { } /// Copy constructor. @@ -247,33 +235,36 @@ /// EdgeIt(const EdgeIt& e) : Edge(e) { } - /// %Invalid constructor \& conversion. - - /// Initializes the iterator to be invalid. - /// \sa Invalid for more details. + /// Initialize the iterator to be invalid. + + /// Initialize the iterator to be invalid. + /// EdgeIt(Invalid) { } - /// Sets the iterator to the first edge. - - /// Sets the iterator to the first edge of the given graph. - /// - explicit EdgeIt(const Graph&) { } - /// Sets the iterator to the given edge. - - /// Sets the iterator to the given edge of the given graph. - /// + /// This constructor sets the iterator to the first edge. + + /// This constructor sets the iterator to the first edge. + EdgeIt(const Graph&) { } + /// Edge -> EdgeIt conversion + + /// Sets the iterator to the value of the trivial iterator. + /// This feature necessitates that each time we + /// iterate the edge-set, the iteration order is the + /// same. EdgeIt(const Graph&, const Edge&) { } /// Next edge /// Assign the iterator to the next edge. - /// EdgeIt& operator++() { return *this; } }; - /// Iterator class for the incident edges of a node. - - /// This iterator goes trough the incident undirected edges - /// of a certain node of a graph. - /// Its usage is quite simple, for example, you can compute the - /// degree (i.e. the number of incident edges) of a node \c n - /// in a graph \c g of type \c %Graph as follows. + /// \brief This iterator goes trough the incident undirected + /// arcs of a node. + /// + /// This iterator goes trough the incident edges + /// of a certain node of a graph. You should assume that the + /// loop arcs will be iterated twice. + /// + /// Its usage is quite simple, for example you can compute the + /// degree (i.e. count the number of incident arcs of a node \c n + /// in graph \c g of type \c Graph as follows. /// ///\code @@ -281,12 +272,10 @@ /// for(Graph::IncEdgeIt e(g, n); e!=INVALID; ++e) ++count; ///\endcode - /// - /// \warning Loop edges will be iterated twice. class IncEdgeIt : public Edge { public: /// Default constructor - /// Default constructor. - /// \warning It sets the iterator to an undefined value. + /// @warning The default constructor sets the iterator + /// to an undefined value. IncEdgeIt() { } /// Copy constructor. @@ -295,37 +284,38 @@ /// IncEdgeIt(const IncEdgeIt& e) : Edge(e) { } - /// %Invalid constructor \& conversion. - - /// Initializes the iterator to be invalid. - /// \sa Invalid for more details. + /// Initialize the iterator to be invalid. + + /// Initialize the iterator to be invalid. + /// IncEdgeIt(Invalid) { } - /// Sets the iterator to the first incident edge. - - /// Sets the iterator to the first incident edge of the given node. - /// + /// This constructor sets the iterator to first incident arc. + + /// This constructor set the iterator to the first incident arc of + /// the node. IncEdgeIt(const Graph&, const Node&) { } - /// Sets the iterator to the given edge. - - /// Sets the iterator to the given edge of the given graph. - /// + /// Edge -> IncEdgeIt conversion + + /// Sets the iterator to the value of the trivial iterator \c e. + /// This feature necessitates that each time we + /// iterate the arc-set, the iteration order is the same. IncEdgeIt(const Graph&, const Edge&) { } - /// Next incident edge - - /// Assign the iterator to the next incident edge + /// Next incident arc + + /// Assign the iterator to the next incident arc /// of the corresponding node. IncEdgeIt& operator++() { return *this; } }; - /// The arc type of the graph - - /// This class identifies a directed arc of the graph. It also serves - /// as a base class of the arc iterators, - /// thus they will convert to this type. + /// The directed arc type. + + /// The directed arc type. It can be converted to the + /// edge or it should be inherited from the undirected + /// edge. class Arc { public: /// Default constructor - /// Default constructor. - /// \warning It sets the object to an undefined value. + /// @warning The default constructor sets the iterator + /// to an undefined value. Arc() { } /// Copy constructor. @@ -334,45 +324,41 @@ /// Arc(const Arc&) { } - /// %Invalid constructor \& conversion. - - /// Initializes the object to be invalid. - /// \sa Invalid for more details. + /// Initialize the iterator to be invalid. + + /// Initialize the iterator to be invalid. + /// Arc(Invalid) { } /// Equality operator - /// Equality operator. - /// /// Two iterators are equal if and only if they point to the - /// same object or both are \c INVALID. + /// same object or both are invalid. bool operator==(Arc) const { return true; } /// Inequality operator - /// Inequality operator. + /// \sa operator==(Arc n) + /// bool operator!=(Arc) const { return true; } /// Artificial ordering operator. - /// Artificial ordering operator. - /// - /// \note This operator only has to define some strict ordering of - /// the arcs; this order has nothing to do with the iteration - /// ordering of the arcs. + /// To allow the use of graph descriptors as key type in std::map or + /// similar associative container we require this. + /// + /// \note This operator only have to define some strict ordering of + /// the items; this order has nothing to do with the iteration + /// ordering of the items. bool operator<(Arc) const { return false; } - /// Converison to \c Edge - - /// Converison to \c Edge. - /// + /// Converison to Edge operator Edge() const { return Edge(); } }; - - /// Iterator class for the arcs. - - /// This iterator goes through each directed arc of the graph. - /// Its usage is quite simple, for example, you can count the number - /// of arcs in a graph \c g of type \c %Graph as follows: + /// This iterator goes through each directed arc. + + /// This iterator goes through each arc of a graph. + /// Its usage is quite simple, for example you can count the number + /// of arcs in a graph \c g of type \c Graph as follows: ///\code /// int count=0; - /// for(Graph::ArcIt a(g); a!=INVALID; ++a) ++count; + /// for(Graph::ArcIt e(g); e!=INVALID; ++e) ++count; ///\endcode class ArcIt : public Arc { @@ -380,6 +366,6 @@ /// Default constructor - /// Default constructor. - /// \warning It sets the iterator to an undefined value. + /// @warning The default constructor sets the iterator + /// to an undefined value. ArcIt() { } /// Copy constructor. @@ -388,43 +374,44 @@ /// ArcIt(const ArcIt& e) : Arc(e) { } - /// %Invalid constructor \& conversion. - - /// Initializes the iterator to be invalid. - /// \sa Invalid for more details. + /// Initialize the iterator to be invalid. + + /// Initialize the iterator to be invalid. + /// ArcIt(Invalid) { } - /// Sets the iterator to the first arc. - - /// Sets the iterator to the first arc of the given graph. - /// - explicit ArcIt(const Graph &g) { ignore_unused_variable_warning(g); } - /// Sets the iterator to the given arc. - - /// Sets the iterator to the given arc of the given graph. - /// + /// This constructor sets the iterator to the first arc. + + /// This constructor sets the iterator to the first arc of \c g. + ///@param g the graph + ArcIt(const Graph &g) { ignore_unused_variable_warning(g); } + /// Arc -> ArcIt conversion + + /// Sets the iterator to the value of the trivial iterator \c e. + /// This feature necessitates that each time we + /// iterate the arc-set, the iteration order is the same. ArcIt(const Graph&, const Arc&) { } - /// Next arc + ///Next arc /// Assign the iterator to the next arc. - /// ArcIt& operator++() { return *this; } }; - /// Iterator class for the outgoing arcs of a node. - - /// This iterator goes trough the \e outgoing directed arcs of a - /// certain node of a graph. - /// Its usage is quite simple, for example, you can count the number + /// This iterator goes trough the outgoing directed arcs of a node. + + /// This iterator goes trough the \e outgoing arcs of a certain node + /// of a graph. + /// Its usage is quite simple, for example you can count the number /// of outgoing arcs of a node \c n - /// in a graph \c g of type \c %Graph as follows. + /// in graph \c g of type \c Graph as follows. ///\code /// int count=0; - /// for (Digraph::OutArcIt a(g, n); a!=INVALID; ++a) ++count; + /// for (Graph::OutArcIt e(g, n); e!=INVALID; ++e) ++count; ///\endcode + class OutArcIt : public Arc { public: /// Default constructor - /// Default constructor. - /// \warning It sets the iterator to an undefined value. + /// @warning The default constructor sets the iterator + /// to an undefined value. OutArcIt() { } /// Copy constructor. @@ -433,23 +420,26 @@ /// OutArcIt(const OutArcIt& e) : Arc(e) { } - /// %Invalid constructor \& conversion. - - /// Initializes the iterator to be invalid. - /// \sa Invalid for more details. + /// Initialize the iterator to be invalid. + + /// Initialize the iterator to be invalid. + /// OutArcIt(Invalid) { } - /// Sets the iterator to the first outgoing arc. - - /// Sets the iterator to the first outgoing arc of the given node. - /// + /// This constructor sets the iterator to the first outgoing arc. + + /// This constructor sets the iterator to the first outgoing arc of + /// the node. + ///@param n the node + ///@param g the graph OutArcIt(const Graph& n, const Node& g) { ignore_unused_variable_warning(n); ignore_unused_variable_warning(g); } - /// Sets the iterator to the given arc. - - /// Sets the iterator to the given arc of the given graph. - /// + /// Arc -> OutArcIt conversion + + /// Sets the iterator to the value of the trivial iterator. + /// This feature necessitates that each time we + /// iterate the arc-set, the iteration order is the same. OutArcIt(const Graph&, const Arc&) { } - /// Next outgoing arc + ///Next outgoing arc /// Assign the iterator to the next @@ -458,21 +448,22 @@ }; - /// Iterator class for the incoming arcs of a node. - - /// This iterator goes trough the \e incoming directed arcs of a - /// certain node of a graph. - /// Its usage is quite simple, for example, you can count the number - /// of incoming arcs of a node \c n - /// in a graph \c g of type \c %Graph as follows. + /// This iterator goes trough the incoming directed arcs of a node. + + /// This iterator goes trough the \e incoming arcs of a certain node + /// of a graph. + /// Its usage is quite simple, for example you can count the number + /// of outgoing arcs of a node \c n + /// in graph \c g of type \c Graph as follows. ///\code /// int count=0; - /// for (Digraph::InArcIt a(g, n); a!=INVALID; ++a) ++count; + /// for(Graph::InArcIt e(g, n); e!=INVALID; ++e) ++count; ///\endcode + class InArcIt : public Arc { public: /// Default constructor - /// Default constructor. - /// \warning It sets the iterator to an undefined value. + /// @warning The default constructor sets the iterator + /// to an undefined value. InArcIt() { } /// Copy constructor. @@ -481,33 +472,35 @@ /// InArcIt(const InArcIt& e) : Arc(e) { } - /// %Invalid constructor \& conversion. - - /// Initializes the iterator to be invalid. - /// \sa Invalid for more details. + /// Initialize the iterator to be invalid. + + /// Initialize the iterator to be invalid. + /// InArcIt(Invalid) { } - /// Sets the iterator to the first incoming arc. - - /// Sets the iterator to the first incoming arc of the given node. - /// + /// This constructor sets the iterator to first incoming arc. + + /// This constructor set the iterator to the first incoming arc of + /// the node. + ///@param n the node + ///@param g the graph InArcIt(const Graph& g, const Node& n) { ignore_unused_variable_warning(n); ignore_unused_variable_warning(g); } - /// Sets the iterator to the given arc. - - /// Sets the iterator to the given arc of the given graph. - /// + /// Arc -> InArcIt conversion + + /// Sets the iterator to the value of the trivial iterator \c e. + /// This feature necessitates that each time we + /// iterate the arc-set, the iteration order is the same. InArcIt(const Graph&, const Arc&) { } /// Next incoming arc - /// Assign the iterator to the next - /// incoming arc of the corresponding node. + /// Assign the iterator to the next inarc of the corresponding node. + /// InArcIt& operator++() { return *this; } }; - /// \brief Standard graph map type for the nodes. - /// - /// Standard graph map type for the nodes. - /// It conforms to the ReferenceMap concept. + /// \brief Reference map of the nodes to type \c T. + /// + /// Reference map of the nodes to type \c T. template class NodeMap : public ReferenceMap @@ -515,7 +508,7 @@ public: - /// Constructor - explicit NodeMap(const Graph&) { } - /// Constructor with given initial value + ///\e + NodeMap(const Graph&) { } + ///\e NodeMap(const Graph&, T) { } @@ -532,8 +525,7 @@ }; - /// \brief Standard graph map type for the arcs. - /// - /// Standard graph map type for the arcs. - /// It conforms to the ReferenceMap concept. + /// \brief Reference map of the arcs to type \c T. + /// + /// Reference map of the arcs to type \c T. template class ArcMap : public ReferenceMap @@ -541,9 +533,8 @@ public: - /// Constructor - explicit ArcMap(const Graph&) { } - /// Constructor with given initial value + ///\e + ArcMap(const Graph&) { } + ///\e ArcMap(const Graph&, T) { } - private: ///Copy constructor @@ -558,8 +549,7 @@ }; - /// \brief Standard graph map type for the edges. - /// - /// Standard graph map type for the edges. - /// It conforms to the ReferenceMap concept. + /// Reference map of the edges to type \c T. + + /// Reference map of the edges to type \c T. template class EdgeMap : public ReferenceMap @@ -567,9 +557,8 @@ public: - /// Constructor - explicit EdgeMap(const Graph&) { } - /// Constructor with given initial value + ///\e + EdgeMap(const Graph&) { } + ///\e EdgeMap(const Graph&, T) { } - private: ///Copy constructor @@ -584,121 +573,104 @@ }; - /// \brief The first node of the edge. - /// - /// Returns the first node of the given edge. - /// - /// Edges don't have source and target nodes, however, methods - /// u() and v() are used to query the two end-nodes of an edge. - /// The orientation of an edge that arises this way is called - /// the inherent direction, it is used to define the default - /// direction for the corresponding arcs. + /// \brief Direct the given edge. + /// + /// Direct the given edge. The returned arc source + /// will be the given node. + Arc direct(const Edge&, const Node&) const { + return INVALID; + } + + /// \brief Direct the given edge. + /// + /// Direct the given edge. The returned arc + /// represents the given edge and the direction comes + /// from the bool parameter. The source of the edge and + /// the directed arc is the same when the given bool is true. + Arc direct(const Edge&, bool) const { + return INVALID; + } + + /// \brief Returns true if the arc has default orientation. + /// + /// Returns whether the given directed arc is same orientation as + /// the corresponding edge's default orientation. + bool direction(Arc) const { return true; } + + /// \brief Returns the opposite directed arc. + /// + /// Returns the opposite directed arc. + Arc oppositeArc(Arc) const { return INVALID; } + + /// \brief Opposite node on an arc + /// + /// \return The opposite of the given node on the given edge. + Node oppositeNode(Node, Edge) const { return INVALID; } + + /// \brief First node of the edge. + /// + /// \return The first node of the given edge. + /// + /// Naturally edges don't have direction and thus + /// don't have source and target node. However we use \c u() and \c v() + /// methods to query the two nodes of the arc. The direction of the + /// arc which arises this way is called the inherent direction of the + /// edge, and is used to define the "default" direction + /// of the directed versions of the arcs. /// \sa v() /// \sa direction() Node u(Edge) const { return INVALID; } - /// \brief The second node of the edge. - /// - /// Returns the second node of the given edge. - /// - /// Edges don't have source and target nodes, however, methods - /// u() and v() are used to query the two end-nodes of an edge. - /// The orientation of an edge that arises this way is called - /// the inherent direction, it is used to define the default - /// direction for the corresponding arcs. + /// \brief Second node of the edge. + /// + /// \return The second node of the given edge. + /// + /// Naturally edges don't have direction and thus + /// don't have source and target node. However we use \c u() and \c v() + /// methods to query the two nodes of the arc. The direction of the + /// arc which arises this way is called the inherent direction of the + /// edge, and is used to define the "default" direction + /// of the directed versions of the arcs. /// \sa u() /// \sa direction() Node v(Edge) const { return INVALID; } - /// \brief The source node of the arc. - /// - /// Returns the source node of the given arc. + /// \brief Source node of the directed arc. Node source(Arc) const { return INVALID; } - /// \brief The target node of the arc. - /// - /// Returns the target node of the given arc. + /// \brief Target node of the directed arc. Node target(Arc) const { return INVALID; } - /// \brief The ID of the node. - /// - /// Returns the ID of the given node. + /// \brief Returns the id of the node. int id(Node) const { return -1; } - /// \brief The ID of the edge. - /// - /// Returns the ID of the given edge. + /// \brief Returns the id of the edge. int id(Edge) const { return -1; } - /// \brief The ID of the arc. - /// - /// Returns the ID of the given arc. + /// \brief Returns the id of the arc. int id(Arc) const { return -1; } - /// \brief The node with the given ID. - /// - /// Returns the node with the given ID. - /// \pre The argument should be a valid node ID in the graph. + /// \brief Returns the node with the given id. + /// + /// \pre The argument should be a valid node id in the graph. Node nodeFromId(int) const { return INVALID; } - /// \brief The edge with the given ID. - /// - /// Returns the edge with the given ID. - /// \pre The argument should be a valid edge ID in the graph. + /// \brief Returns the edge with the given id. + /// + /// \pre The argument should be a valid edge id in the graph. Edge edgeFromId(int) const { return INVALID; } - /// \brief The arc with the given ID. - /// - /// Returns the arc with the given ID. - /// \pre The argument should be a valid arc ID in the graph. + /// \brief Returns the arc with the given id. + /// + /// \pre The argument should be a valid arc id in the graph. Arc arcFromId(int) const { return INVALID; } - /// \brief An upper bound on the node IDs. - /// - /// Returns an upper bound on the node IDs. + /// \brief Returns an upper bound on the node IDs. int maxNodeId() const { return -1; } - /// \brief An upper bound on the edge IDs. - /// - /// Returns an upper bound on the edge IDs. + /// \brief Returns an upper bound on the edge IDs. int maxEdgeId() const { return -1; } - /// \brief An upper bound on the arc IDs. - /// - /// Returns an upper bound on the arc IDs. + /// \brief Returns an upper bound on the arc IDs. int maxArcId() const { return -1; } - - /// \brief The direction of the arc. - /// - /// Returns \c true if the direction of the given arc is the same as - /// the inherent orientation of the represented edge. - bool direction(Arc) const { return true; } - - /// \brief Direct the edge. - /// - /// Direct the given edge. The returned arc - /// represents the given edge and its direction comes - /// from the bool parameter. If it is \c true, then the direction - /// of the arc is the same as the inherent orientation of the edge. - Arc direct(Edge, bool) const { - return INVALID; - } - - /// \brief Direct the edge. - /// - /// Direct the given edge. The returned arc represents the given - /// edge and its source node is the given node. - Arc direct(Edge, Node) const { - return INVALID; - } - - /// \brief The oppositely directed arc. - /// - /// Returns the oppositely directed arc representing the same edge. - Arc oppositeArc(Arc) const { return INVALID; } - - /// \brief The opposite node on the edge. - /// - /// Returns the opposite node on the given edge. - Node oppositeNode(Node, Edge) const { return INVALID; } void first(Node&) const {} @@ -734,37 +706,45 @@ int maxId(Arc) const { return -1; } - /// \brief The base node of the iterator. - /// - /// Returns the base node of the given incident edge iterator. - Node baseNode(IncEdgeIt) const { return INVALID; } - - /// \brief The running node of the iterator. - /// - /// Returns the running node of the given incident edge iterator. - Node runningNode(IncEdgeIt) const { return INVALID; } - - /// \brief The base node of the iterator. - /// - /// Returns the base node of the given outgoing arc iterator - /// (i.e. the source node of the corresponding arc). - Node baseNode(OutArcIt) const { return INVALID; } - - /// \brief The running node of the iterator. - /// - /// Returns the running node of the given outgoing arc iterator - /// (i.e. the target node of the corresponding arc). - Node runningNode(OutArcIt) const { return INVALID; } - - /// \brief The base node of the iterator. - /// - /// Returns the base node of the given incomming arc iterator - /// (i.e. the target node of the corresponding arc). - Node baseNode(InArcIt) const { return INVALID; } - - /// \brief The running node of the iterator. - /// - /// Returns the running node of the given incomming arc iterator - /// (i.e. the source node of the corresponding arc). - Node runningNode(InArcIt) const { return INVALID; } + /// \brief Base node of the iterator + /// + /// Returns the base node (the source in this case) of the iterator + Node baseNode(OutArcIt e) const { + return source(e); + } + /// \brief Running node of the iterator + /// + /// Returns the running node (the target in this case) of the + /// iterator + Node runningNode(OutArcIt e) const { + return target(e); + } + + /// \brief Base node of the iterator + /// + /// Returns the base node (the target in this case) of the iterator + Node baseNode(InArcIt e) const { + return target(e); + } + /// \brief Running node of the iterator + /// + /// Returns the running node (the source in this case) of the + /// iterator + Node runningNode(InArcIt e) const { + return source(e); + } + + /// \brief Base node of the iterator + /// + /// Returns the base node of the iterator + Node baseNode(IncEdgeIt) const { + return INVALID; + } + + /// \brief Running node of the iterator + /// + /// Returns the running node of the iterator + Node runningNode(IncEdgeIt) const { + return INVALID; + } template Index: lemon/concepts/graph_components.h =================================================================== --- lemon/concepts/graph_components.h (revision 1000) +++ lemon/concepts/graph_components.h (revision 1007) @@ -3,5 +3,5 @@ * This file is a part of LEMON, a generic C++ optimization library. * - * Copyright (C) 2003-2010 + * Copyright (C) 2003-2009 * Egervary Jeno Kombinatorikus Optimalizalasi Kutatocsoport * (Egervary Research Group on Combinatorial Optimization, EGRES). @@ -19,5 +19,5 @@ ///\ingroup graph_concepts ///\file -///\brief The concepts of graph components. +///\brief The concept of graph components. #ifndef LEMON_CONCEPTS_GRAPH_COMPONENTS_H @@ -39,5 +39,5 @@ /// \note This class is a template class so that we can use it to /// create graph skeleton classes. The reason for this is that \c Node - /// and \c Arc (or \c Edge) types should \e not derive from the same + /// and \c Arc (or \c Edge) types should \e not derive from the same /// base class. For \c Node you should instantiate it with character /// \c 'n', for \c Arc with \c 'a' and for \c Edge with \c 'e'. @@ -90,8 +90,8 @@ /// /// This operator defines an ordering of the items. - /// It makes possible to use graph item types as key types in + /// It makes possible to use graph item types as key types in /// associative containers (e.g. \c std::map). /// - /// \note This operator only has to define some strict ordering of + /// \note This operator only have to define some strict ordering of /// the items; this order has nothing to do with the iteration /// ordering of the items. @@ -109,4 +109,6 @@ bool b; + ignore_unused_variable_warning(b); + b = (ia == ib) && (ia != ib); b = (ia == INVALID) && (ib != INVALID); @@ -124,5 +126,5 @@ /// This class describes the base interface of directed graph types. /// All digraph %concepts have to conform to this class. - /// It just provides types for nodes and arcs and functions + /// It just provides types for nodes and arcs and functions /// to get the source and the target nodes of arcs. class BaseDigraphComponent { @@ -432,5 +434,5 @@ /// \brief Concept class for \c NodeIt, \c ArcIt and \c EdgeIt types. /// - /// This class describes the concept of \c NodeIt, \c ArcIt and + /// This class describes the concept of \c NodeIt, \c ArcIt and /// \c EdgeIt subtypes of digraph and graph types. template @@ -472,5 +474,5 @@ /// next item. GraphItemIt& operator++() { return *this; } - + /// \brief Equality operator /// @@ -510,13 +512,13 @@ }; - /// \brief Concept class for \c InArcIt, \c OutArcIt and + /// \brief Concept class for \c InArcIt, \c OutArcIt and /// \c IncEdgeIt types. /// - /// This class describes the concept of \c InArcIt, \c OutArcIt + /// This class describes the concept of \c InArcIt, \c OutArcIt /// and \c IncEdgeIt subtypes of digraph and graph types. /// /// \note Since these iterator classes do not inherit from the same /// base class, there is an additional template parameter (selector) - /// \c sel. For \c InArcIt you should instantiate it with character + /// \c sel. For \c InArcIt you should instantiate it with character /// \c 'i', for \c OutArcIt with \c 'o' and for \c IncEdgeIt with \c 'e'. template #include @@ -36,25 +36,19 @@ /// \brief The heap concept. /// - /// This concept class describes the main interface of heaps. - /// The various \ref heaps "heap structures" are efficient - /// implementations of the abstract data type \e priority \e queue. - /// They store items with specified values called \e priorities - /// in such a way that finding and removing the item with minimum - /// priority are efficient. The basic operations are adding and - /// erasing items, changing the priority of an item, etc. + /// Concept class describing the main interface of heaps. A \e heap + /// is a data structure for storing items with specified values called + /// \e priorities in such a way that finding the item with minimum + /// priority is efficient. In a heap one can change the priority of an + /// item, add or erase an item, etc. /// - /// Heaps are crucial in several algorithms, such as Dijkstra and Prim. - /// Any class that conforms to this concept can be used easily in such - /// algorithms. - /// - /// \tparam PR Type of the priorities of the items. - /// \tparam IM A read-writable item map with \c int values, used + /// \tparam PR Type of the priority of the items. + /// \tparam IM A read and writable item map with int values, used /// internally to handle the cross references. - /// \tparam CMP A functor class for comparing the priorities. + /// \tparam Comp A functor class for the ordering of the priorities. /// The default is \c std::less. #ifdef DOXYGEN - template + template > #else - template > + template #endif class Heap { @@ -71,6 +65,7 @@ /// /// Each item has a state associated to it. It can be "in heap", - /// "pre-heap" or "post-heap". The latter two are indifferent from the - /// heap's point of view, but may be useful to the user. + /// "pre heap" or "post heap". The later two are indifferent + /// from the point of view of the heap, but may be useful for + /// the user. /// /// The item-int map must be initialized in such way that it assigns @@ -78,148 +73,99 @@ enum State { IN_HEAP = 0, ///< = 0. The "in heap" state constant. - PRE_HEAP = -1, ///< = -1. The "pre-heap" state constant. - POST_HEAP = -2 ///< = -2. The "post-heap" state constant. + PRE_HEAP = -1, ///< = -1. The "pre heap" state constant. + POST_HEAP = -2 ///< = -2. The "post heap" state constant. }; - /// \brief Constructor. - /// - /// Constructor. + /// \brief The constructor. + /// + /// The constructor. /// \param map A map that assigns \c int values to keys of type /// \c Item. It is used internally by the heap implementations to /// handle the cross references. The assigned value must be - /// \c PRE_HEAP (-1) for each item. -#ifdef DOXYGEN + /// \c PRE_HEAP (-1) for every item. explicit Heap(ItemIntMap &map) {} -#else - explicit Heap(ItemIntMap&) {} -#endif - - /// \brief Constructor. - /// - /// Constructor. - /// \param map A map that assigns \c int values to keys of type - /// \c Item. It is used internally by the heap implementations to - /// handle the cross references. The assigned value must be - /// \c PRE_HEAP (-1) for each item. - /// \param comp The function object used for comparing the priorities. -#ifdef DOXYGEN - explicit Heap(ItemIntMap &map, const CMP &comp) {} -#else - explicit Heap(ItemIntMap&, const CMP&) {} -#endif /// \brief The number of items stored in the heap. /// - /// This function returns the number of items stored in the heap. + /// Returns the number of items stored in the heap. int size() const { return 0; } - /// \brief Check if the heap is empty. - /// - /// This function returns \c true if the heap is empty. + /// \brief Checks if the heap is empty. + /// + /// Returns \c true if the heap is empty. bool empty() const { return false; } - /// \brief Make the heap empty. - /// - /// This functon makes the heap empty. - /// It does not change the cross reference map. If you want to reuse - /// a heap that is not surely empty, you should first clear it and - /// then you should set the cross reference map to \c PRE_HEAP - /// for each item. - void clear() {} - - /// \brief Insert an item into the heap with the given priority. - /// - /// This function inserts the given item into the heap with the - /// given priority. + /// \brief Makes the heap empty. + /// + /// Makes the heap empty. + void clear(); + + /// \brief Inserts an item into the heap with the given priority. + /// + /// Inserts the given item into the heap with the given priority. /// \param i The item to insert. /// \param p The priority of the item. - /// \pre \e i must not be stored in the heap. -#ifdef DOXYGEN void push(const Item &i, const Prio &p) {} -#else - void push(const Item&, const Prio&) {} -#endif - - /// \brief Return the item having minimum priority. - /// - /// This function returns the item having minimum priority. + + /// \brief Returns the item having minimum priority. + /// + /// Returns the item having minimum priority. /// \pre The heap must be non-empty. - Item top() const { return Item(); } + Item top() const {} /// \brief The minimum priority. /// - /// This function returns the minimum priority. + /// Returns the minimum priority. /// \pre The heap must be non-empty. - Prio prio() const { return Prio(); } - - /// \brief Remove the item having minimum priority. - /// - /// This function removes the item having minimum priority. + Prio prio() const {} + + /// \brief Removes the item having minimum priority. + /// + /// Removes the item having minimum priority. /// \pre The heap must be non-empty. void pop() {} - /// \brief Remove the given item from the heap. - /// - /// This function removes the given item from the heap if it is - /// already stored. + /// \brief Removes an item from the heap. + /// + /// Removes the given item from the heap if it is already stored. /// \param i The item to delete. - /// \pre \e i must be in the heap. -#ifdef DOXYGEN void erase(const Item &i) {} -#else - void erase(const Item&) {} -#endif - - /// \brief The priority of the given item. - /// - /// This function returns the priority of the given item. - /// \param i The item. - /// \pre \e i must be in the heap. -#ifdef DOXYGEN + + /// \brief The priority of an item. + /// + /// Returns the priority of the given item. + /// \param i The item. + /// \pre \c i must be in the heap. Prio operator[](const Item &i) const {} -#else - Prio operator[](const Item&) const { return Prio(); } -#endif - - /// \brief Set the priority of an item or insert it, if it is + + /// \brief Sets the priority of an item or inserts it, if it is /// not stored in the heap. /// /// This method sets the priority of the given item if it is - /// already stored in the heap. Otherwise it inserts the given - /// item into the heap with the given priority. + /// already stored in the heap. + /// Otherwise it inserts the given item with the given priority. /// /// \param i The item. /// \param p The priority. -#ifdef DOXYGEN void set(const Item &i, const Prio &p) {} -#else - void set(const Item&, const Prio&) {} -#endif - - /// \brief Decrease the priority of an item to the given value. - /// - /// This function decreases the priority of an item to the given value. + + /// \brief Decreases the priority of an item to the given value. + /// + /// Decreases the priority of an item to the given value. /// \param i The item. /// \param p The priority. - /// \pre \e i must be stored in the heap with priority at least \e p. -#ifdef DOXYGEN + /// \pre \c i must be stored in the heap with priority at least \c p. void decrease(const Item &i, const Prio &p) {} -#else - void decrease(const Item&, const Prio&) {} -#endif - - /// \brief Increase the priority of an item to the given value. - /// - /// This function increases the priority of an item to the given value. + + /// \brief Increases the priority of an item to the given value. + /// + /// Increases the priority of an item to the given value. /// \param i The item. /// \param p The priority. - /// \pre \e i must be stored in the heap with priority at most \e p. -#ifdef DOXYGEN + /// \pre \c i must be stored in the heap with priority at most \c p. void increase(const Item &i, const Prio &p) {} -#else - void increase(const Item&, const Prio&) {} -#endif - - /// \brief Return the state of an item. + + /// \brief Returns if an item is in, has already been in, or has + /// never been in the heap. /// /// This method returns \c PRE_HEAP if the given item has never @@ -229,22 +175,14 @@ /// to the heap again. /// \param i The item. -#ifdef DOXYGEN State state(const Item &i) const {} -#else - State state(const Item&) const { return PRE_HEAP; } -#endif - - /// \brief Set the state of an item in the heap. - /// - /// This function sets the state of the given item in the heap. - /// It can be used to manually clear the heap when it is important - /// to achive better time complexity. + + /// \brief Sets the state of an item in the heap. + /// + /// Sets the state of the given item in the heap. It can be used + /// to manually clear the heap when it is important to achive the + /// better time complexity. /// \param i The item. /// \param st The state. It should not be \c IN_HEAP. -#ifdef DOXYGEN void state(const Item& i, State st) {} -#else - void state(const Item&, State) {} -#endif Index: lemon/concepts/path.h =================================================================== --- lemon/concepts/path.h (revision 976) +++ lemon/concepts/path.h (revision 975) @@ -19,5 +19,5 @@ ///\ingroup concept ///\file -///\brief The concept of paths +///\brief Classes for representing paths in digraphs. /// @@ -39,20 +39,11 @@ /// A skeleton structure for representing directed paths in a /// digraph. - /// In a sense, a path can be treated as a list of arcs. - /// LEMON path types just store this list. As a consequence, they cannot - /// enumerate the nodes on the path directly and a zero length path - /// cannot store its source node. - /// - /// The arcs of a path should be stored in the order of their directions, - /// i.e. the target node of each arc should be the same as the source - /// node of the next arc. This consistency could be checked using - /// \ref checkPath(). - /// The source and target nodes of a (consistent) path can be obtained - /// using \ref pathSource() and \ref pathTarget(). - /// - /// A path can be constructed from another path of any type using the - /// copy constructor or the assignment operator. - /// /// \tparam GR The digraph type in which the path is. + /// + /// In a sense, the path can be treated as a list of arcs. The + /// lemon path type stores just this list. As a consequence it + /// cannot enumerate the nodes in the path and the zero length + /// paths cannot store the source. + /// template class Path { @@ -69,9 +60,9 @@ Path() {} - /// \brief Template copy constructor + /// \brief Template constructor template Path(const CPath& cpath) {} - /// \brief Template assigment operator + /// \brief Template assigment template Path& operator=(const CPath& cpath) { @@ -80,5 +71,5 @@ } - /// Length of the path, i.e. the number of arcs on the path. + /// Length of the path ie. the number of arcs in the path. int length() const { return 0;} @@ -89,7 +80,7 @@ void clear() {} - /// \brief LEMON style iterator for enumerating the arcs of a path. + /// \brief LEMON style iterator for path arcs /// - /// LEMON style iterator class for enumerating the arcs of a path. + /// This class is used to iterate on the arcs of the paths. class ArcIt { public: @@ -98,8 +89,8 @@ /// Invalid constructor ArcIt(Invalid) {} - /// Sets the iterator to the first arc of the given path + /// Constructor for first arc ArcIt(const Path &) {} - /// Conversion to \c Arc + /// Conversion to Arc operator Arc() const { return INVALID; } @@ -204,16 +195,22 @@ /// /// A skeleton structure for path dumpers. The path dumpers are - /// the generalization of the paths, they can enumerate the arcs - /// of the path either in forward or in backward order. - /// These classes are typically not used directly, they are rather - /// used to be assigned to a real path type. + /// the generalization of the paths. The path dumpers can + /// enumerate the arcs of the path wheter in forward or in + /// backward order. In most time these classes are not used + /// directly rather it used to assign a dumped class to a real + /// path type. /// /// The main purpose of this concept is that the shortest path - /// algorithms can enumerate the arcs easily in reverse order. - /// In LEMON, such algorithms give back a (reverse) path dumper that - /// can be assigned to a real path. The dumpers can be implemented as + /// algorithms can enumerate easily the arcs in reverse order. + /// If we would like to give back a real path from these + /// algorithms then we should create a temporarly path object. In + /// LEMON such algorithms gives back a path dumper what can + /// assigned to a real path and the dumpers can be implemented as /// an adaptor class to the predecessor map. /// /// \tparam GR The digraph type in which the path is. + /// + /// The paths can be constructed from any path type by a + /// template constructor or a template assignment operator. template class PathDumper { @@ -225,5 +222,5 @@ typedef typename Digraph::Arc Arc; - /// Length of the path, i.e. the number of arcs on the path. + /// Length of the path ie. the number of arcs in the path. int length() const { return 0;} @@ -233,12 +230,13 @@ /// \brief Forward or reverse dumping /// - /// If this tag is defined to be \c True, then reverse dumping - /// is provided in the path dumper. In this case, \c RevArcIt - /// iterator should be implemented instead of \c ArcIt iterator. + /// If the RevPathTag is defined and true then reverse dumping + /// is provided in the path dumper. In this case instead of the + /// ArcIt the RevArcIt iterator should be implemented in the + /// dumper. typedef False RevPathTag; - /// \brief LEMON style iterator for enumerating the arcs of a path. + /// \brief LEMON style iterator for path arcs /// - /// LEMON style iterator class for enumerating the arcs of a path. + /// This class is used to iterate on the arcs of the paths. class ArcIt { public: @@ -247,8 +245,8 @@ /// Invalid constructor ArcIt(Invalid) {} - /// Sets the iterator to the first arc of the given path + /// Constructor for first arc ArcIt(const PathDumper&) {} - /// Conversion to \c Arc + /// Conversion to Arc operator Arc() const { return INVALID; } @@ -265,9 +263,8 @@ }; - /// \brief LEMON style iterator for enumerating the arcs of a path - /// in reverse direction. + /// \brief LEMON style iterator for path arcs /// - /// LEMON style iterator class for enumerating the arcs of a path - /// in reverse direction. + /// This class is used to iterate on the arcs of the paths in + /// reverse direction. class RevArcIt { public: @@ -276,8 +273,8 @@ /// Invalid constructor RevArcIt(Invalid) {} - /// Sets the iterator to the last arc of the given path + /// Constructor for first arc RevArcIt(const PathDumper &) {} - /// Conversion to \c Arc + /// Conversion to Arc operator Arc() const { return INVALID; } Index: lemon/config.h.cmake =================================================================== --- lemon/config.h.cmake (revision 678) +++ lemon/config.h.cmake (revision 678) @@ -0,0 +1,8 @@ +#define LEMON_VERSION "@PROJECT_VERSION@" +#cmakedefine LEMON_HAVE_LONG_LONG 1 +#cmakedefine LEMON_HAVE_LP 1 +#cmakedefine LEMON_HAVE_MIP 1 +#cmakedefine LEMON_HAVE_GLPK 1 +#cmakedefine LEMON_HAVE_CPLEX 1 +#cmakedefine LEMON_HAVE_CLP 1 +#cmakedefine LEMON_HAVE_CBC 1 Index: lemon/config.h.in =================================================================== --- lemon/config.h.in (revision 981) +++ lemon/config.h.in (revision 678) @@ -1,10 +1,26 @@ -#define LEMON_VERSION "@PROJECT_VERSION@" -#cmakedefine LEMON_HAVE_LONG_LONG 1 -#cmakedefine LEMON_HAVE_LP 1 -#cmakedefine LEMON_HAVE_MIP 1 -#cmakedefine LEMON_HAVE_GLPK 1 -#cmakedefine LEMON_HAVE_CPLEX 1 -#cmakedefine LEMON_HAVE_CLP 1 -#cmakedefine LEMON_HAVE_CBC 1 -#cmakedefine LEMON_USE_PTHREAD 1 -#cmakedefine LEMON_USE_WIN32_THREADS 1 +/* The version string */ +#undef LEMON_VERSION + +/* Define to 1 if you have long long */ +#undef LEMON_HAVE_LONG_LONG + +/* Define to 1 if you have any LP solver. */ +#undef LEMON_HAVE_LP + +/* Define to 1 if you have any MIP solver. */ +#undef LEMON_HAVE_MIP + +/* Define to 1 if you have CPLEX. */ +#undef LEMON_HAVE_CPLEX + +/* Define to 1 if you have GLPK. */ +#undef LEMON_HAVE_GLPK + +/* Define to 1 if you have SOPLEX */ +#undef LEMON_HAVE_SOPLEX + +/* Define to 1 if you have CLP */ +#undef LEMON_HAVE_CLP + +/* Define to 1 if you have CBC */ +#undef LEMON_HAVE_CBC Index: lemon/connectivity.h =================================================================== --- lemon/connectivity.h (revision 877) +++ lemon/connectivity.h (revision 648) @@ -3,5 +3,5 @@ * This file is a part of LEMON, a generic C++ optimization library. * - * Copyright (C) 2003-2010 + * Copyright (C) 2003-2009 * Egervary Jeno Kombinatorikus Optimalizalasi Kutatocsoport * (Egervary Research Group on Combinatorial Optimization, EGRES). @@ -259,5 +259,5 @@ /// \return \c true if the digraph is strongly connected. /// \note By definition, the empty digraph is strongly connected. - /// + /// /// \see countStronglyConnectedComponents(), stronglyConnectedComponents() /// \see connected() @@ -311,5 +311,5 @@ /// \ingroup graph_properties /// - /// \brief Count the number of strongly connected components of a + /// \brief Count the number of strongly connected components of a /// directed graph /// @@ -745,5 +745,5 @@ /// \brief Check whether an undirected graph is bi-node-connected. /// - /// This function checks whether the given undirected graph is + /// This function checks whether the given undirected graph is /// bi-node-connected, i.e. any two edges are on same circle. /// @@ -759,5 +759,5 @@ /// \ingroup graph_properties /// - /// \brief Count the number of bi-node-connected components of an + /// \brief Count the number of bi-node-connected components of an /// undirected graph. /// @@ -813,5 +813,5 @@ /// \retval compMap A writable edge map. The values will be set from 0 /// to the number of the bi-node-connected components minus one. Each - /// value of the map will be set exactly once, and the values of a + /// value of the map will be set exactly once, and the values of a /// certain component will be set continuously. /// \return The number of bi-node-connected components. @@ -859,5 +859,5 @@ /// /// \param graph The undirected graph. - /// \retval cutMap A writable node map. The values will be set to + /// \retval cutMap A writable node map. The values will be set to /// \c true for the nodes that separate two or more components /// (exactly once for each cut node), and will not be changed for @@ -1086,5 +1086,5 @@ /// \brief Check whether an undirected graph is bi-edge-connected. /// - /// This function checks whether the given undirected graph is + /// This function checks whether the given undirected graph is /// bi-edge-connected, i.e. any two nodes are connected with at least /// two edge-disjoint paths. @@ -1193,5 +1193,5 @@ /// /// This function finds the bi-edge-connected cut edges in the given - /// undirected graph. + /// undirected graph. /// /// The bi-edge-connected components are the classes of an equivalence @@ -1350,5 +1350,5 @@ /// \param digraph The digraph. /// \retval order A readable and writable node map. The values will be - /// set from 0 to the number of the nodes in the digraph minus one. + /// set from 0 to the number of the nodes in the digraph minus one. /// Each value of the map will be set exactly once, and the values will /// be set descending order. Index: lemon/core.h =================================================================== --- lemon/core.h (revision 1000) +++ lemon/core.h (revision 993) @@ -3,5 +3,5 @@ * This file is a part of LEMON, a generic C++ optimization library. * - * Copyright (C) 2003-2010 + * Copyright (C) 2003-2009 * Egervary Jeno Kombinatorikus Optimalizalasi Kutatocsoport * (Egervary Research Group on Combinatorial Optimization, EGRES). @@ -447,23 +447,4 @@ } - - /// \brief Check whether a graph is undirected. - /// - /// This function returns \c true if the given graph is undirected. -#ifdef DOXYGEN - template - bool undirected(const GR& g) { return false; } -#else - template - typename enable_if, bool>::type - undirected(const GR&) { - return true; - } - template - typename disable_if, bool>::type - undirected(const GR&) { - return false; - } -#endif /// \brief Class to copy a digraph. @@ -1261,6 +1242,5 @@ protected: - class AutoNodeMap : public ItemSetTraits::template Map::Type - { + class AutoNodeMap : public ItemSetTraits::template Map::Type { typedef typename ItemSetTraits::template Map::Type Parent; @@ -1301,5 +1281,5 @@ }; - protected: + protected: const Digraph &_g; Index: mon/cost_scaling.h =================================================================== --- lemon/cost_scaling.h (revision 1003) +++ (revision ) @@ -1,1590 +1,0 @@ -/* -*- mode: C++; indent-tabs-mode: nil; -*- - * - * This file is a part of LEMON, a generic C++ optimization library. - * - * Copyright (C) 2003-2010 - * Egervary Jeno Kombinatorikus Optimalizalasi Kutatocsoport - * (Egervary Research Group on Combinatorial Optimization, EGRES). - * - * Permission to use, modify and distribute this software is granted - * provided that this copyright notice appears in all copies. For - * precise terms see the accompanying LICENSE file. - * - * This software is provided "AS IS" with no warranty of any kind, - * express or implied, and with no claim as to its suitability for any - * purpose. - * - */ - -#ifndef LEMON_COST_SCALING_H -#define LEMON_COST_SCALING_H - -/// \ingroup min_cost_flow_algs -/// \file -/// \brief Cost scaling algorithm for finding a minimum cost flow. - -#include -#include -#include - -#include -#include -#include -#include -#include -#include - -namespace lemon { - - /// \brief Default traits class of CostScaling algorithm. - /// - /// Default traits class of CostScaling algorithm. - /// \tparam GR Digraph type. - /// \tparam V The number type used for flow amounts, capacity bounds - /// and supply values. By default it is \c int. - /// \tparam C The number type used for costs and potentials. - /// By default it is the same as \c V. -#ifdef DOXYGEN - template -#else - template < typename GR, typename V = int, typename C = V, - bool integer = std::numeric_limits::is_integer > -#endif - struct CostScalingDefaultTraits - { - /// The type of the digraph - typedef GR Digraph; - /// The type of the flow amounts, capacity bounds and supply values - typedef V Value; - /// The type of the arc costs - typedef C Cost; - - /// \brief The large cost type used for internal computations - /// - /// The large cost type used for internal computations. - /// It is \c long \c long if the \c Cost type is integer, - /// otherwise it is \c double. - /// \c Cost must be convertible to \c LargeCost. - typedef double LargeCost; - }; - - // Default traits class for integer cost types - template - struct CostScalingDefaultTraits - { - typedef GR Digraph; - typedef V Value; - typedef C Cost; -#ifdef LEMON_HAVE_LONG_LONG - typedef long long LargeCost; -#else - typedef long LargeCost; -#endif - }; - - - /// \addtogroup min_cost_flow_algs - /// @{ - - /// \brief Implementation of the Cost Scaling algorithm for - /// finding a \ref min_cost_flow "minimum cost flow". - /// - /// \ref CostScaling implements a cost scaling algorithm that performs - /// push/augment and relabel operations for finding a \ref min_cost_flow - /// "minimum cost flow" \ref amo93networkflows, \ref goldberg90approximation, - /// \ref goldberg97efficient, \ref bunnagel98efficient. - /// It is a highly efficient primal-dual solution method, which - /// can be viewed as the generalization of the \ref Preflow - /// "preflow push-relabel" algorithm for the maximum flow problem. - /// - /// In general, \ref NetworkSimplex and \ref CostScaling are the fastest - /// implementations available in LEMON for 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) - /// can be given using separate functions, and the algorithm can be - /// executed using the \ref run() function. If some parameters are not - /// specified, then default values will be used. - /// - /// \tparam GR The digraph type the algorithm runs on. - /// \tparam V The number type used for flow amounts, capacity bounds - /// and supply values in the algorithm. By default, it is \c int. - /// \tparam C The number type used for costs and potentials in the - /// algorithm. By default, it is the same as \c V. - /// \tparam TR The traits class that defines various types used by the - /// algorithm. By default, it is \ref CostScalingDefaultTraits - /// "CostScalingDefaultTraits". - /// In most cases, this parameter should not be set directly, - /// consider to use the named template parameters instead. - /// - /// \warning Both \c V and \c C must be signed number types. - /// \warning All input data (capacities, supply values, and costs) must - /// be integer. - /// \warning This algorithm does not support negative costs for - /// arcs having infinite upper bound. - /// - /// \note %CostScaling provides three different internal methods, - /// from which the most efficient one is used by default. - /// For more information, see \ref Method. -#ifdef DOXYGEN - template -#else - template < typename GR, typename V = int, typename C = V, - typename TR = CostScalingDefaultTraits > -#endif - class CostScaling - { - public: - - /// The type of the digraph - typedef typename TR::Digraph Digraph; - /// The type of the flow amounts, capacity bounds and supply values - typedef typename TR::Value Value; - /// The type of the arc costs - typedef typename TR::Cost Cost; - - /// \brief The large cost type - /// - /// The large cost type used for internal computations. - /// By default, it is \c long \c long if the \c Cost type is integer, - /// otherwise it is \c double. - typedef typename TR::LargeCost LargeCost; - - /// The \ref CostScalingDefaultTraits "traits class" of the algorithm - typedef TR Traits; - - public: - - /// \brief Problem type constants for the \c run() function. - /// - /// Enum type containing the problem type constants that can be - /// returned by the \ref run() function of the algorithm. - enum ProblemType { - /// The problem has no feasible solution (flow). - INFEASIBLE, - /// The problem has optimal solution (i.e. it is feasible and - /// bounded), and the algorithm has found optimal flow and node - /// potentials (primal and dual solutions). - OPTIMAL, - /// The digraph contains an arc of negative cost and infinite - /// upper bound. It means that the objective function is unbounded - /// on that arc, however, note that it could actually be bounded - /// over the feasible flows, but this algroithm cannot handle - /// these cases. - UNBOUNDED - }; - - /// \brief Constants for selecting the internal method. - /// - /// Enum type containing constants for selecting the internal method - /// for the \ref run() function. - /// - /// \ref CostScaling provides three internal methods that differ mainly - /// in their base operations, which are used in conjunction with the - /// relabel operation. - /// By default, the so called \ref PARTIAL_AUGMENT - /// "Partial Augment-Relabel" method is used, which turned out to be - /// the most efficient and the most robust on various test inputs. - /// However, the other methods can be selected using the \ref run() - /// function with the proper parameter. - enum Method { - /// Local push operations are used, i.e. flow is moved only on one - /// admissible arc at once. - PUSH, - /// Augment operations are used, i.e. flow is moved on admissible - /// paths from a node with excess to a node with deficit. - AUGMENT, - /// Partial augment operations are used, i.e. flow is moved on - /// admissible paths started from a node with excess, but the - /// lengths of these paths are limited. This method can be viewed - /// as a combined version of the previous two operations. - PARTIAL_AUGMENT - }; - - private: - - TEMPLATE_DIGRAPH_TYPEDEFS(GR); - - typedef std::vector IntVector; - typedef std::vector ValueVector; - typedef std::vector CostVector; - typedef std::vector LargeCostVector; - typedef std::vector BoolVector; - // Note: vector is used instead of vector for efficiency reasons - - private: - - template - class StaticVectorMap { - public: - typedef KT Key; - typedef VT Value; - - StaticVectorMap(std::vector& v) : _v(v) {} - - const Value& operator[](const Key& key) const { - return _v[StaticDigraph::id(key)]; - } - - Value& operator[](const Key& key) { - return _v[StaticDigraph::id(key)]; - } - - void set(const Key& key, const Value& val) { - _v[StaticDigraph::id(key)] = val; - } - - private: - std::vector& _v; - }; - - typedef StaticVectorMap LargeCostArcMap; - - private: - - // Data related to the underlying digraph - const GR &_graph; - int _node_num; - int _arc_num; - int _res_node_num; - int _res_arc_num; - int _root; - - // Parameters of the problem - bool _have_lower; - Value _sum_supply; - int _sup_node_num; - - // Data structures for storing the digraph - IntNodeMap _node_id; - IntArcMap _arc_idf; - IntArcMap _arc_idb; - IntVector _first_out; - BoolVector _forward; - IntVector _source; - IntVector _target; - IntVector _reverse; - - // Node and arc data - ValueVector _lower; - ValueVector _upper; - CostVector _scost; - ValueVector _supply; - - ValueVector _res_cap; - LargeCostVector _cost; - LargeCostVector _pi; - ValueVector _excess; - IntVector _next_out; - std::deque _active_nodes; - - // Data for scaling - LargeCost _epsilon; - int _alpha; - - IntVector _buckets; - IntVector _bucket_next; - IntVector _bucket_prev; - IntVector _rank; - int _max_rank; - - public: - - /// \brief Constant for infinite upper bounds (capacities). - /// - /// Constant for infinite upper bounds (capacities). - /// It is \c std::numeric_limits::infinity() if available, - /// \c std::numeric_limits::max() otherwise. - const Value INF; - - public: - - /// \name Named Template Parameters - /// @{ - - template - struct SetLargeCostTraits : public Traits { - typedef T LargeCost; - }; - - /// \brief \ref named-templ-param "Named parameter" for setting - /// \c LargeCost type. - /// - /// \ref named-templ-param "Named parameter" for setting \c LargeCost - /// type, which is used for internal computations in the algorithm. - /// \c Cost must be convertible to \c LargeCost. - template - struct SetLargeCost - : public CostScaling > { - typedef CostScaling > Create; - }; - - /// @} - - protected: - - CostScaling() {} - - public: - - /// \brief Constructor. - /// - /// The constructor of the class. - /// - /// \param graph The digraph the algorithm runs on. - CostScaling(const GR& graph) : - _graph(graph), _node_id(graph), _arc_idf(graph), _arc_idb(graph), - INF(std::numeric_limits::has_infinity ? - std::numeric_limits::infinity() : - std::numeric_limits::max()) - { - // Check the number types - LEMON_ASSERT(std::numeric_limits::is_signed, - "The flow type of CostScaling must be signed"); - LEMON_ASSERT(std::numeric_limits::is_signed, - "The cost type of CostScaling must be signed"); - - // Reset data structures - reset(); - } - - /// \name Parameters - /// The parameters of the algorithm can be specified using these - /// functions. - - /// @{ - - /// \brief Set the lower bounds on the arcs. - /// - /// This function sets the lower bounds on the arcs. - /// If it is not used before calling \ref run(), the lower bounds - /// will be set to zero on all arcs. - /// - /// \param map An arc map storing the lower bounds. - /// Its \c Value type must be convertible to the \c Value type - /// of the algorithm. - /// - /// \return (*this) - template - 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 (*this) - template - 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 (*this) - template - 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 (*this) - template - 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 (*this) - 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 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 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 (*this) - /// - /// \see reset(), run() - CostScaling& resetParams() { - for (int i = 0; i != _res_node_num; ++i) { - _supply[i] = 0; - } - int limit = _first_out[_root]; - for (int j = 0; j != limit; ++j) { - _lower[j] = 0; - _upper[j] = INF; - _scost[j] = _forward[j] ? 1 : -1; - } - for (int j = limit; j != _res_arc_num; ++j) { - _lower[j] = 0; - _upper[j] = INF; - _scost[j] = 0; - _scost[_reverse[j]] = 0; - } - _have_lower = false; - return *this; - } - - /// \brief Reset the internal data structures and all the parameters - /// that have been given before. - /// - /// This function resets the internal data structures and all the - /// paramaters that have been given before using functions \ref lowerMap(), - /// \ref upperMap(), \ref costMap(), \ref supplyMap(), \ref stSupply(). - /// - /// It is useful for multiple \ref run() calls. By default, all the given - /// parameters are kept for the next \ref run() call, unless - /// \ref resetParams() or \ref reset() is used. - /// If the underlying digraph was also modified after the construction - /// of the class or the last \ref reset() call, then the \ref reset() - /// function must be used, otherwise \ref resetParams() is sufficient. - /// - /// See \ref resetParams() for examples. - /// - /// \return (*this) - /// - /// \see resetParams(), run() - CostScaling& reset() { - // Resize vectors - _node_num = countNodes(_graph); - _arc_num = countArcs(_graph); - _res_node_num = _node_num + 1; - _res_arc_num = 2 * (_arc_num + _node_num); - _root = _node_num; - - _first_out.resize(_res_node_num + 1); - _forward.resize(_res_arc_num); - _source.resize(_res_arc_num); - _target.resize(_res_arc_num); - _reverse.resize(_res_arc_num); - - _lower.resize(_res_arc_num); - _upper.resize(_res_arc_num); - _scost.resize(_res_arc_num); - _supply.resize(_res_node_num); - - _res_cap.resize(_res_arc_num); - _cost.resize(_res_arc_num); - _pi.resize(_res_node_num); - _excess.resize(_res_node_num); - _next_out.resize(_res_node_num); - - // Copy the graph - int i = 0, j = 0, k = 2 * _arc_num + _node_num; - for (NodeIt n(_graph); n != INVALID; ++n, ++i) { - _node_id[n] = i; - } - i = 0; - for (NodeIt n(_graph); n != INVALID; ++n, ++i) { - _first_out[i] = j; - for (OutArcIt a(_graph, n); a != INVALID; ++a, ++j) { - _arc_idf[a] = j; - _forward[j] = true; - _source[j] = i; - _target[j] = _node_id[_graph.runningNode(a)]; - } - for (InArcIt a(_graph, n); a != INVALID; ++a, ++j) { - _arc_idb[a] = j; - _forward[j] = false; - _source[j] = i; - _target[j] = _node_id[_graph.runningNode(a)]; - } - _forward[j] = false; - _source[j] = i; - _target[j] = _root; - _reverse[j] = k; - _forward[k] = true; - _source[k] = _root; - _target[k] = i; - _reverse[k] = j; - ++j; ++k; - } - _first_out[i] = j; - _first_out[_res_node_num] = k; - for (ArcIt a(_graph); a != INVALID; ++a) { - int fi = _arc_idf[a]; - int bi = _arc_idb[a]; - _reverse[fi] = bi; - _reverse[bi] = fi; - } - - // Reset parameters - resetParams(); - return *this; - } - - /// @} - - /// \name Query Functions - /// The results of the algorithm can be obtained using these - /// functions.\n - /// The \ref run() function must be called before using them. - - /// @{ - - /// \brief Return the total cost of the found flow. - /// - /// This function returns the total cost of the found flow. - /// Its complexity is O(e). - /// - /// \note The return type of the function can be specified as a - /// template parameter. For example, - /// \code - /// cs.totalCost(); - /// \endcode - /// It is useful if the total cost cannot be stored in the \c Cost - /// type of the algorithm, which is the default return type of the - /// function. - /// - /// \pre \ref run() must be called before using this function. - template - Number totalCost() const { - Number c = 0; - for (ArcIt a(_graph); a != INVALID; ++a) { - int i = _arc_idb[a]; - c += static_cast(_res_cap[i]) * - (-static_cast(_scost[i])); - } - return c; - } - -#ifndef DOXYGEN - Cost totalCost() const { - return totalCost(); - } -#endif - - /// \brief Return the flow on the given arc. - /// - /// This function returns the flow on the given arc. - /// - /// \pre \ref run() must be called before using this function. - Value flow(const Arc& a) const { - return _res_cap[_arc_idb[a]]; - } - - /// \brief Copy the flow values (the primal solution) into the - /// given map. - /// - /// This function copies the flow value on each arc into the given - /// map. The \c Value type of the algorithm must be convertible to - /// the \c Value type of the map. - /// - /// \pre \ref run() must be called before using this function. - template - void flowMap(FlowMap &map) const { - for (ArcIt a(_graph); a != INVALID; ++a) { - map.set(a, _res_cap[_arc_idb[a]]); - } - } - - /// \brief Return the potential (dual value) of the given node. - /// - /// This function returns the potential (dual value) of the - /// given node. - /// - /// \pre \ref run() must be called before using this function. - Cost potential(const Node& n) const { - return static_cast(_pi[_node_id[n]]); - } - - /// \brief Copy the potential values (the dual solution) into the - /// given map. - /// - /// This function copies the potential (dual value) of each node - /// into the given map. - /// The \c Cost type of the algorithm must be convertible to the - /// \c Value type of the map. - /// - /// \pre \ref run() must be called before using this function. - template - void potentialMap(PotentialMap &map) const { - for (NodeIt n(_graph); n != INVALID; ++n) { - map.set(n, static_cast(_pi[_node_id[n]])); - } - } - - /// @} - - private: - - // Initialize the algorithm - ProblemType init() { - if (_res_node_num <= 1) return INFEASIBLE; - - // Check the sum of supply values - _sum_supply = 0; - for (int i = 0; i != _root; ++i) { - _sum_supply += _supply[i]; - } - if (_sum_supply > 0) return INFEASIBLE; - - - // Initialize vectors - for (int i = 0; i != _res_node_num; ++i) { - _pi[i] = 0; - _excess[i] = _supply[i]; - } - - // Remove infinite upper bounds and check negative arcs - const Value MAX = std::numeric_limits::max(); - int last_out; - if (_have_lower) { - for (int i = 0; i != _root; ++i) { - last_out = _first_out[i+1]; - for (int j = _first_out[i]; j != last_out; ++j) { - if (_forward[j]) { - Value c = _scost[j] < 0 ? _upper[j] : _lower[j]; - if (c >= MAX) return UNBOUNDED; - _excess[i] -= c; - _excess[_target[j]] += c; - } - } - } - } else { - for (int i = 0; i != _root; ++i) { - last_out = _first_out[i+1]; - for (int j = _first_out[i]; j != last_out; ++j) { - if (_forward[j] && _scost[j] < 0) { - Value c = _upper[j]; - if (c >= MAX) return UNBOUNDED; - _excess[i] -= c; - _excess[_target[j]] += c; - } - } - } - } - Value ex, max_cap = 0; - for (int i = 0; i != _res_node_num; ++i) { - ex = _excess[i]; - _excess[i] = 0; - if (ex < 0) max_cap -= ex; - } - for (int j = 0; j != _res_arc_num; ++j) { - if (_upper[j] >= MAX) _upper[j] = max_cap; - } - - // Initialize the large cost vector and the epsilon parameter - _epsilon = 0; - LargeCost lc; - for (int i = 0; i != _root; ++i) { - last_out = _first_out[i+1]; - for (int j = _first_out[i]; j != last_out; ++j) { - lc = static_cast(_scost[j]) * _res_node_num * _alpha; - _cost[j] = lc; - if (lc > _epsilon) _epsilon = lc; - } - } - _epsilon /= _alpha; - - // Initialize maps for Circulation and remove non-zero lower bounds - ConstMap low(0); - typedef typename Digraph::template ArcMap ValueArcMap; - typedef typename Digraph::template NodeMap ValueNodeMap; - ValueArcMap cap(_graph), flow(_graph); - ValueNodeMap sup(_graph); - for (NodeIt n(_graph); n != INVALID; ++n) { - sup[n] = _supply[_node_id[n]]; - } - if (_have_lower) { - for (ArcIt a(_graph); a != INVALID; ++a) { - int j = _arc_idf[a]; - Value c = _lower[j]; - cap[a] = _upper[j] - c; - sup[_graph.source(a)] -= c; - sup[_graph.target(a)] += c; - } - } else { - for (ArcIt a(_graph); a != INVALID; ++a) { - cap[a] = _upper[_arc_idf[a]]; - } - } - - _sup_node_num = 0; - for (NodeIt n(_graph); n != INVALID; ++n) { - if (sup[n] > 0) ++_sup_node_num; - } - - // Find a feasible flow using Circulation - Circulation, ValueArcMap, ValueNodeMap> - circ(_graph, low, cap, sup); - if (!circ.flowMap(flow).run()) return INFEASIBLE; - - // Set residual capacities and handle GEQ supply type - if (_sum_supply < 0) { - for (ArcIt a(_graph); a != INVALID; ++a) { - Value fa = flow[a]; - _res_cap[_arc_idf[a]] = cap[a] - fa; - _res_cap[_arc_idb[a]] = fa; - sup[_graph.source(a)] -= fa; - sup[_graph.target(a)] += fa; - } - for (NodeIt n(_graph); n != INVALID; ++n) { - _excess[_node_id[n]] = sup[n]; - } - for (int a = _first_out[_root]; a != _res_arc_num; ++a) { - int u = _target[a]; - int ra = _reverse[a]; - _res_cap[a] = -_sum_supply + 1; - _res_cap[ra] = -_excess[u]; - _cost[a] = 0; - _cost[ra] = 0; - _excess[u] = 0; - } - } else { - for (ArcIt a(_graph); a != INVALID; ++a) { - Value fa = flow[a]; - _res_cap[_arc_idf[a]] = cap[a] - fa; - _res_cap[_arc_idb[a]] = fa; - } - for (int a = _first_out[_root]; a != _res_arc_num; ++a) { - int ra = _reverse[a]; - _res_cap[a] = 0; - _res_cap[ra] = 0; - _cost[a] = 0; - _cost[ra] = 0; - } - } - - // Initialize data structures for buckets - _max_rank = _alpha * _res_node_num; - _buckets.resize(_max_rank); - _bucket_next.resize(_res_node_num + 1); - _bucket_prev.resize(_res_node_num + 1); - _rank.resize(_res_node_num + 1); - - return OPTIMAL; - } - - // Execute the algorithm and transform the results - void start(Method method) { - const int MAX_PARTIAL_PATH_LENGTH = 4; - - switch (method) { - case PUSH: - startPush(); - break; - case AUGMENT: - startAugment(_res_node_num - 1); - break; - case PARTIAL_AUGMENT: - startAugment(MAX_PARTIAL_PATH_LENGTH); - break; - } - - // Compute node potentials (dual solution) - for (int i = 0; i != _res_node_num; ++i) { - _pi[i] = static_cast(_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 IntPair; - StaticDigraph sgr; - std::vector arc_vec; - std::vector 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::Create - bf(sgr, cost_map); - bf.init(0); - bf.start(); - - for (int i = 0; i != _res_node_num; ++i) { - _pi[i] += bf.dist(sgr.node(i)); - } - } - - // Shift potentials to meet the requirements of the GEQ type - // optimality conditions - LargeCost max_pot = _pi[_root]; - for (int i = 0; i != _res_node_num; ++i) { - if (_pi[i] > max_pot) max_pot = _pi[i]; - } - if (max_pot != 0) { - for (int i = 0; i != _res_node_num; ++i) { - _pi[i] -= max_pot; - } - } - - // Handle non-zero lower bounds - if (_have_lower) { - int limit = _first_out[_root]; - for (int j = 0; j != limit; ++j) { - if (!_forward[j]) _res_cap[j] += _lower[j]; - } - } - } - - // Initialize a cost scaling phase - void initPhase() { - // Saturate arcs not satisfying the optimality condition - for (int u = 0; u != _res_node_num; ++u) { - int last_out = _first_out[u+1]; - LargeCost pi_u = _pi[u]; - for (int a = _first_out[u]; a != last_out; ++a) { - Value delta = _res_cap[a]; - if (delta > 0) { - int v = _target[a]; - if (_cost[a] + pi_u - _pi[v] < 0) { - _excess[u] -= delta; - _excess[v] += delta; - _res_cap[a] = 0; - _res_cap[_reverse[a]] += delta; - } - } - } - } - - // Find active nodes (i.e. nodes with positive excess) - for (int u = 0; u != _res_node_num; ++u) { - if (_excess[u] > 0) _active_nodes.push_back(u); - } - - // Initialize the next arcs - for (int u = 0; u != _res_node_num; ++u) { - _next_out[u] = _first_out[u]; - } - } - - // Price (potential) refinement heuristic - bool priceRefinement() { - - // Stack for stroing the topological order - IntVector stack(_res_node_num); - int stack_top; - - // Perform phases - while (topologicalSort(stack, stack_top)) { - - // Compute node ranks in the acyclic admissible network and - // store the nodes in buckets - for (int i = 0; i != _res_node_num; ++i) { - _rank[i] = 0; - } - const int bucket_end = _root + 1; - for (int r = 0; r != _max_rank; ++r) { - _buckets[r] = bucket_end; - } - int top_rank = 0; - for ( ; stack_top >= 0; --stack_top) { - int u = stack[stack_top], v; - int rank_u = _rank[u]; - - LargeCost rc, pi_u = _pi[u]; - int last_out = _first_out[u+1]; - for (int a = _first_out[u]; a != last_out; ++a) { - if (_res_cap[a] > 0) { - v = _target[a]; - rc = _cost[a] + pi_u - _pi[v]; - if (rc < 0) { - LargeCost nrc = static_cast((-rc - 0.5) / _epsilon); - if (nrc < LargeCost(_max_rank)) { - int new_rank_v = rank_u + static_cast(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(nrc); - } - } - - // Change the rank of node v - if (new_rank_v > old_rank_v) { - _rank[v] = new_rank_v; - - // Remove v from its old bucket - if (old_rank_v > 0) { - if (_buckets[old_rank_v] == v) { - _buckets[old_rank_v] = _bucket_next[v]; - } else { - int pv = _bucket_prev[v], nv = _bucket_next[v]; - _bucket_next[pv] = nv; - _bucket_prev[nv] = pv; - } - } - - // Insert v into its new bucket - int nv = _buckets[new_rank_v]; - _bucket_next[v] = nv; - _bucket_prev[nv] = v; - _buckets[new_rank_v] = v; - } - } - } - } - - // Refine potential of node u - _pi[u] -= rank * _epsilon; - } - } - - } - - return false; - } - - // Find and cancel cycles in the admissible network and - // determine topological order using DFS - bool topologicalSort(IntVector &stack, int &stack_top) { - const int MAX_CYCLE_CANCEL = 1; - - BoolVector reached(_res_node_num, false); - BoolVector processed(_res_node_num, false); - IntVector pred(_res_node_num); - for (int i = 0; i != _res_node_num; ++i) { - _next_out[i] = _first_out[i]; - } - stack_top = -1; - - int cycle_cnt = 0; - for (int start = 0; start != _res_node_num; ++start) { - if (reached[start]) continue; - - // Start DFS search from this start node - pred[start] = -1; - int tip = start, v; - while (true) { - // Check the outgoing arcs of the current tip node - reached[tip] = true; - LargeCost pi_tip = _pi[tip]; - int a, last_out = _first_out[tip+1]; - for (a = _next_out[tip]; a != last_out; ++a) { - if (_res_cap[a] > 0) { - v = _target[a]; - if (_cost[a] + pi_tip - _pi[v] < 0) { - if (!reached[v]) { - // A new node is reached - reached[v] = true; - pred[v] = tip; - _next_out[tip] = a; - tip = v; - a = _next_out[tip]; - last_out = _first_out[tip+1]; - break; - } - else if (!processed[v]) { - // A cycle is found - ++cycle_cnt; - _next_out[tip] = a; - - // Find the minimum residual capacity along the cycle - Value d, delta = _res_cap[a]; - int u, delta_node = tip; - for (u = tip; u != v; ) { - u = pred[u]; - d = _res_cap[_next_out[u]]; - if (d <= delta) { - delta = d; - delta_node = u; - } - } - - // Augment along the cycle - _res_cap[a] -= delta; - _res_cap[_reverse[a]] += delta; - for (u = tip; u != v; ) { - u = pred[u]; - int ca = _next_out[u]; - _res_cap[ca] -= delta; - _res_cap[_reverse[ca]] += delta; - } - - // Check the maximum number of cycle canceling - if (cycle_cnt >= MAX_CYCLE_CANCEL) { - return false; - } - - // Roll back search to delta_node - if (delta_node != tip) { - for (u = tip; u != delta_node; u = pred[u]) { - reached[u] = false; - } - tip = delta_node; - a = _next_out[tip] + 1; - last_out = _first_out[tip+1]; - break; - } - } - } - } - } - - // Step back to the previous node - if (a == last_out) { - processed[tip] = true; - stack[++stack_top] = tip; - tip = pred[tip]; - if (tip < 0) { - // Finish DFS from the current start node - break; - } - ++_next_out[tip]; - } - } - - } - - return (cycle_cnt == 0); - } - - // Global potential update heuristic - void globalUpdate() { - const int bucket_end = _root + 1; - - // Initialize buckets - for (int r = 0; r != _max_rank; ++r) { - _buckets[r] = bucket_end; - } - Value total_excess = 0; - int b0 = bucket_end; - for (int i = 0; i != _res_node_num; ++i) { - if (_excess[i] < 0) { - _rank[i] = 0; - _bucket_next[i] = b0; - _bucket_prev[b0] = i; - b0 = i; - } else { - total_excess += _excess[i]; - _rank[i] = _max_rank; - } - } - if (total_excess == 0) return; - _buckets[0] = b0; - - // Search the buckets - int r = 0; - for ( ; r != _max_rank; ++r) { - while (_buckets[r] != bucket_end) { - // Remove the first node from the current bucket - int u = _buckets[r]; - _buckets[r] = _bucket_next[u]; - - // Search the incomming arcs of u - LargeCost pi_u = _pi[u]; - int last_out = _first_out[u+1]; - for (int a = _first_out[u]; a != last_out; ++a) { - int ra = _reverse[a]; - if (_res_cap[ra] > 0) { - int v = _source[ra]; - int old_rank_v = _rank[v]; - if (r < old_rank_v) { - // Compute the new rank of v - LargeCost nrc = (_cost[ra] + _pi[v] - pi_u) / _epsilon; - int new_rank_v = old_rank_v; - if (nrc < LargeCost(_max_rank)) { - new_rank_v = r + 1 + static_cast(nrc); - } - - // Change the rank of v - if (new_rank_v < old_rank_v) { - _rank[v] = new_rank_v; - _next_out[v] = _first_out[v]; - - // Remove v from its old bucket - if (old_rank_v < _max_rank) { - if (_buckets[old_rank_v] == v) { - _buckets[old_rank_v] = _bucket_next[v]; - } else { - int pv = _bucket_prev[v], nv = _bucket_next[v]; - _bucket_next[pv] = nv; - _bucket_prev[nv] = pv; - } - } - - // Insert v into its new bucket - int nv = _buckets[new_rank_v]; - _bucket_next[v] = nv; - _bucket_prev[nv] = v; - _buckets[new_rank_v] = v; - } - } - } - } - - // Finish search if there are no more active nodes - if (_excess[u] > 0) { - total_excess -= _excess[u]; - if (total_excess <= 0) break; - } - } - if (total_excess <= 0) break; - } - - // Relabel nodes - for (int u = 0; u != _res_node_num; ++u) { - int k = std::min(_rank[u], r); - if (k > 0) { - _pi[u] -= _epsilon * k; - _next_out[u] = _first_out[u]; - } - } - } - - /// Execute the algorithm performing augment and relabel operations - void startAugment(int max_length) { - // Paramters for heuristics - const int PRICE_REFINEMENT_LIMIT = 2; - const double GLOBAL_UPDATE_FACTOR = 1.0; - const int global_update_skip = static_cast(GLOBAL_UPDATE_FACTOR * - (_res_node_num + _sup_node_num * _sup_node_num)); - int next_global_update_limit = global_update_skip; - - // Perform cost scaling phases - IntVector path; - BoolVector path_arc(_res_arc_num, false); - int relabel_cnt = 0; - int eps_phase_cnt = 0; - for ( ; _epsilon >= 1; _epsilon = _epsilon < _alpha && _epsilon > 1 ? - 1 : _epsilon / _alpha ) - { - ++eps_phase_cnt; - - // Price refinement heuristic - if (eps_phase_cnt >= PRICE_REFINEMENT_LIMIT) { - if (priceRefinement()) continue; - } - - // Initialize current phase - initPhase(); - - // Perform partial augment and relabel operations - while (true) { - // Select an active node (FIFO selection) - while (_active_nodes.size() > 0 && - _excess[_active_nodes.front()] <= 0) { - _active_nodes.pop_front(); - } - if (_active_nodes.size() == 0) break; - int start = _active_nodes.front(); - - // Find an augmenting path from the start node - int tip = start; - while (int(path.size()) < max_length && _excess[tip] >= 0) { - int u; - LargeCost rc, min_red_cost = std::numeric_limits::max(); - LargeCost pi_tip = _pi[tip]; - int last_out = _first_out[tip+1]; - for (int a = _next_out[tip]; a != last_out; ++a) { - if (_res_cap[a] > 0) { - u = _target[a]; - rc = _cost[a] + pi_tip - _pi[u]; - if (rc < 0) { - path.push_back(a); - _next_out[tip] = a; - if (path_arc[a]) { - goto augment; // a cycle is found, stop path search - } - tip = u; - path_arc[a] = true; - goto next_step; - } - else if (rc < min_red_cost) { - min_red_cost = rc; - } - } - } - - // Relabel tip node - if (tip != start) { - int ra = _reverse[path.back()]; - min_red_cost = - std::min(min_red_cost, _cost[ra] + pi_tip - _pi[_target[ra]]); - } - last_out = _next_out[tip]; - for (int a = _first_out[tip]; a != last_out; ++a) { - if (_res_cap[a] > 0) { - rc = _cost[a] + pi_tip - _pi[_target[a]]; - if (rc < min_red_cost) { - min_red_cost = rc; - } - } - } - _pi[tip] -= min_red_cost + _epsilon; - _next_out[tip] = _first_out[tip]; - ++relabel_cnt; - - // Step back - if (tip != start) { - int pa = path.back(); - path_arc[pa] = false; - tip = _source[pa]; - path.pop_back(); - } - - next_step: ; - } - - // Augment along the found path (as much flow as possible) - augment: - Value delta; - int pa, u, v = start; - for (int i = 0; i != int(path.size()); ++i) { - pa = path[i]; - u = v; - v = _target[pa]; - path_arc[pa] = false; - delta = std::min(_res_cap[pa], _excess[u]); - _res_cap[pa] -= delta; - _res_cap[_reverse[pa]] += delta; - _excess[u] -= delta; - _excess[v] += delta; - if (_excess[v] > 0 && _excess[v] <= delta) { - _active_nodes.push_back(v); - } - } - path.clear(); - - // Global update heuristic - if (relabel_cnt >= next_global_update_limit) { - globalUpdate(); - next_global_update_limit += global_update_skip; - } - } - - } - - } - - /// Execute the algorithm performing push and relabel operations - void startPush() { - // Paramters for heuristics - const int PRICE_REFINEMENT_LIMIT = 2; - const double GLOBAL_UPDATE_FACTOR = 2.0; - - const int global_update_skip = static_cast(GLOBAL_UPDATE_FACTOR * - (_res_node_num + _sup_node_num * _sup_node_num)); - int next_global_update_limit = global_update_skip; - - // Perform cost scaling phases - BoolVector hyper(_res_node_num, false); - LargeCostVector hyper_cost(_res_node_num); - int relabel_cnt = 0; - int eps_phase_cnt = 0; - for ( ; _epsilon >= 1; _epsilon = _epsilon < _alpha && _epsilon > 1 ? - 1 : _epsilon / _alpha ) - { - ++eps_phase_cnt; - - // Price refinement heuristic - if (eps_phase_cnt >= PRICE_REFINEMENT_LIMIT) { - if (priceRefinement()) continue; - } - - // Initialize current phase - initPhase(); - - // Perform push and relabel operations - while (_active_nodes.size() > 0) { - LargeCost min_red_cost, rc, pi_n; - Value delta; - int n, t, a, last_out = _res_arc_num; - - next_node: - // Select an active node (FIFO selection) - n = _active_nodes.front(); - last_out = _first_out[n+1]; - pi_n = _pi[n]; - - // Perform push operations if there are admissible arcs - if (_excess[n] > 0) { - for (a = _next_out[n]; a != last_out; ++a) { - if (_res_cap[a] > 0 && - _cost[a] + pi_n - _pi[_target[a]] < 0) { - delta = std::min(_res_cap[a], _excess[n]); - t = _target[a]; - - // Push-look-ahead heuristic - Value ahead = -_excess[t]; - int last_out_t = _first_out[t+1]; - LargeCost pi_t = _pi[t]; - for (int ta = _next_out[t]; ta != last_out_t; ++ta) { - if (_res_cap[ta] > 0 && - _cost[ta] + pi_t - _pi[_target[ta]] < 0) - ahead += _res_cap[ta]; - if (ahead >= delta) break; - } - if (ahead < 0) ahead = 0; - - // Push flow along the arc - if (ahead < delta && !hyper[t]) { - _res_cap[a] -= ahead; - _res_cap[_reverse[a]] += ahead; - _excess[n] -= ahead; - _excess[t] += ahead; - _active_nodes.push_front(t); - hyper[t] = true; - hyper_cost[t] = _cost[a] + pi_n - pi_t; - _next_out[n] = a; - goto next_node; - } else { - _res_cap[a] -= delta; - _res_cap[_reverse[a]] += delta; - _excess[n] -= delta; - _excess[t] += delta; - if (_excess[t] > 0 && _excess[t] <= delta) - _active_nodes.push_back(t); - } - - if (_excess[n] == 0) { - _next_out[n] = a; - goto remove_nodes; - } - } - } - _next_out[n] = a; - } - - // Relabel the node if it is still active (or hyper) - if (_excess[n] > 0 || hyper[n]) { - min_red_cost = hyper[n] ? -hyper_cost[n] : - std::numeric_limits::max(); - for (int a = _first_out[n]; a != last_out; ++a) { - if (_res_cap[a] > 0) { - rc = _cost[a] + pi_n - _pi[_target[a]]; - if (rc < min_red_cost) { - min_red_cost = rc; - } - } - } - _pi[n] -= min_red_cost + _epsilon; - _next_out[n] = _first_out[n]; - hyper[n] = false; - ++relabel_cnt; - } - - // Remove nodes that are not active nor hyper - remove_nodes: - while ( _active_nodes.size() > 0 && - _excess[_active_nodes.front()] <= 0 && - !hyper[_active_nodes.front()] ) { - _active_nodes.pop_front(); - } - - // Global update heuristic - if (relabel_cnt >= next_global_update_limit) { - globalUpdate(); - for (int u = 0; u != _res_node_num; ++u) - hyper[u] = false; - next_global_update_limit += global_update_skip; - } - } - } - } - - }; //class CostScaling - - ///@} - -} //namespace lemon - -#endif //LEMON_COST_SCALING_H Index: lemon/counter.h =================================================================== --- lemon/counter.h (revision 786) +++ lemon/counter.h (revision 440) @@ -213,5 +213,5 @@ /// 'Do nothing' version of Counter. - /// This class can be used in the same way as \ref Counter, but it + /// This class can be used in the same way as \ref Counter however it /// does not count at all and does not print report on destruction. /// Index: lemon/cplex.cc =================================================================== --- lemon/cplex.cc (revision 989) +++ lemon/cplex.cc (revision 988) @@ -3,5 +3,5 @@ * This file is a part of LEMON, a generic C++ optimization library. * - * Copyright (C) 2003-2010 + * Copyright (C) 2003-2009 * Egervary Jeno Kombinatorikus Optimalizalasi Kutatocsoport * (Egervary Research Group on Combinatorial Optimization, EGRES). @@ -112,37 +112,4 @@ } - int CplexBase::_addRow(Value lb, ExprIterator b, - ExprIterator e, Value ub) { - int i = CPXgetnumrows(cplexEnv(), _prob); - if (lb == -INF) { - const char s = 'L'; - CPXnewrows(cplexEnv(), _prob, 1, &ub, &s, 0, 0); - } else if (ub == INF) { - const char s = 'G'; - CPXnewrows(cplexEnv(), _prob, 1, &lb, &s, 0, 0); - } else if (lb == ub){ - const char s = 'E'; - CPXnewrows(cplexEnv(), _prob, 1, &lb, &s, 0, 0); - } else { - const char s = 'R'; - double len = ub - lb; - CPXnewrows(cplexEnv(), _prob, 1, &lb, &s, &len, 0); - } - - std::vector indices; - std::vector rowlist; - std::vector values; - - for(ExprIterator it=b; it!=e; ++it) { - indices.push_back(it->first); - values.push_back(it->second); - rowlist.push_back(i); - } - - CPXchgcoeflist(cplexEnv(), _prob, values.size(), - &rowlist.front(), &indices.front(), &values.front()); - - return i; - } void CplexBase::_eraseCol(int i) { @@ -488,5 +455,5 @@ void CplexBase::_applyMessageLevel() { - CPXsetintparam(cplexEnv(), CPX_PARAM_SCRIND, + CPXsetintparam(cplexEnv(), CPX_PARAM_SCRIND, _message_enabled ? CPX_ON : CPX_OFF); } Index: lemon/cplex.h =================================================================== --- lemon/cplex.h (revision 746) +++ lemon/cplex.h (revision 576) @@ -94,5 +94,4 @@ virtual int _addCol(); virtual int _addRow(); - virtual int _addRow(Value l, ExprIterator b, ExprIterator e, Value u); virtual void _eraseCol(int i); Index: mon/cycle_canceling.h =================================================================== --- lemon/cycle_canceling.h (revision 1003) +++ (revision ) @@ -1,1175 +1,0 @@ -/* -*- mode: C++; indent-tabs-mode: nil; -*- - * - * This file is a part of LEMON, a generic C++ optimization library. - * - * Copyright (C) 2003-2010 - * Egervary Jeno Kombinatorikus Optimalizalasi Kutatocsoport - * (Egervary Research Group on Combinatorial Optimization, EGRES). - * - * Permission to use, modify and distribute this software is granted - * provided that this copyright notice appears in all copies. For - * precise terms see the accompanying LICENSE file. - * - * This software is provided "AS IS" with no warranty of any kind, - * express or implied, and with no claim as to its suitability for any - * purpose. - * - */ - -#ifndef LEMON_CYCLE_CANCELING_H -#define LEMON_CYCLE_CANCELING_H - -/// \ingroup min_cost_flow_algs -/// \file -/// \brief Cycle-canceling algorithms for finding a minimum cost flow. - -#include -#include - -#include -#include -#include -#include -#include -#include -#include -#include -#include - -namespace lemon { - - /// \addtogroup min_cost_flow_algs - /// @{ - - /// \brief Implementation of cycle-canceling algorithms for - /// finding a \ref min_cost_flow "minimum cost flow". - /// - /// \ref CycleCanceling implements three different cycle-canceling - /// algorithms for finding a \ref min_cost_flow "minimum cost flow" - /// \ref amo93networkflows, \ref klein67primal, - /// \ref goldberg89cyclecanceling. - /// The most efficent one is the \ref CANCEL_AND_TIGHTEN - /// "Cancel-and-Tighten" algorithm, thus it is the default method. - /// It runs in strongly polynomial time, 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) - /// can be given using separate functions, and the algorithm can be - /// executed using the \ref run() function. If some parameters are not - /// specified, then default values will be used. - /// - /// \tparam GR The digraph type the algorithm runs on. - /// \tparam V The number type used for flow amounts, capacity bounds - /// and supply values in the algorithm. By default, it is \c int. - /// \tparam C The number type used for costs and potentials in the - /// algorithm. By default, it is the same as \c V. - /// - /// \warning Both \c V and \c C must be signed number types. - /// \warning All input data (capacities, supply values, and costs) must - /// be integer. - /// \warning This algorithm does not support negative costs for - /// arcs having infinite upper bound. - /// - /// \note For more information about the three available methods, - /// see \ref Method. -#ifdef DOXYGEN - template -#else - template -#endif - class CycleCanceling - { - public: - - /// The type of the digraph - typedef GR Digraph; - /// The type of the flow amounts, capacity bounds and supply values - typedef V Value; - /// The type of the arc costs - typedef C Cost; - - public: - - /// \brief Problem type constants for the \c run() function. - /// - /// Enum type containing the problem type constants that can be - /// returned by the \ref run() function of the algorithm. - enum ProblemType { - /// The problem has no feasible solution (flow). - INFEASIBLE, - /// The problem has optimal solution (i.e. it is feasible and - /// bounded), and the algorithm has found optimal flow and node - /// potentials (primal and dual solutions). - OPTIMAL, - /// The digraph contains an arc of negative cost and infinite - /// upper bound. It means that the objective function is unbounded - /// on that arc, however, note that it could actually be bounded - /// over the feasible flows, but this algroithm cannot handle - /// these cases. - UNBOUNDED - }; - - /// \brief Constants for selecting the used method. - /// - /// Enum type containing constants for selecting the used method - /// for the \ref run() function. - /// - /// \ref CycleCanceling provides three different cycle-canceling - /// methods. By default, \ref CANCEL_AND_TIGHTEN "Cancel-and-Tighten" - /// is used, which is by far the most efficient and the most robust. - /// However, the other methods can be selected using the \ref run() - /// function with the proper parameter. - enum Method { - /// A simple cycle-canceling method, which uses the - /// \ref BellmanFord "Bellman-Ford" algorithm 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 - /// \ref min_mean_cycle "minimum mean cycle" in each iteration. - /// Its running time complexity is O(n2e3log(n)). - MINIMUM_MEAN_CYCLE_CANCELING, - /// The "Cancel-and-Tighten" algorithm, which can be viewed as an - /// improved version of the previous method - /// \ref goldberg89cyclecanceling. - /// It is faster both in theory and in practice, its running time - /// complexity is O(n2e2log(n)). - CANCEL_AND_TIGHTEN - }; - - private: - - TEMPLATE_DIGRAPH_TYPEDEFS(GR); - - typedef std::vector IntVector; - typedef std::vector DoubleVector; - typedef std::vector ValueVector; - typedef std::vector CostVector; - typedef std::vector BoolVector; - // Note: vector is used instead of vector for efficiency reasons - - private: - - template - class StaticVectorMap { - public: - typedef KT Key; - typedef VT Value; - - StaticVectorMap(std::vector& v) : _v(v) {} - - const Value& operator[](const Key& key) const { - return _v[StaticDigraph::id(key)]; - } - - Value& operator[](const Key& key) { - return _v[StaticDigraph::id(key)]; - } - - void set(const Key& key, const Value& val) { - _v[StaticDigraph::id(key)] = val; - } - - private: - std::vector& _v; - }; - - typedef StaticVectorMap CostNodeMap; - typedef StaticVectorMap CostArcMap; - - private: - - - // Data related to the underlying digraph - const GR &_graph; - int _node_num; - int _arc_num; - int _res_node_num; - int _res_arc_num; - int _root; - - // Parameters of the problem - bool _have_lower; - Value _sum_supply; - - // Data structures for storing the digraph - IntNodeMap _node_id; - IntArcMap _arc_idf; - IntArcMap _arc_idb; - IntVector _first_out; - BoolVector _forward; - IntVector _source; - IntVector _target; - IntVector _reverse; - - // Node and arc data - ValueVector _lower; - ValueVector _upper; - CostVector _cost; - ValueVector _supply; - - ValueVector _res_cap; - CostVector _pi; - - // Data for a StaticDigraph structure - typedef std::pair IntPair; - StaticDigraph _sgr; - std::vector _arc_vec; - std::vector _cost_vec; - IntVector _id_vec; - CostArcMap _cost_map; - CostNodeMap _pi_map; - - public: - - /// \brief Constant for infinite upper bounds (capacities). - /// - /// Constant for infinite upper bounds (capacities). - /// It is \c std::numeric_limits::infinity() if available, - /// \c std::numeric_limits::max() otherwise. - const Value INF; - - public: - - /// \brief Constructor. - /// - /// The constructor of the class. - /// - /// \param graph The digraph the algorithm runs on. - CycleCanceling(const GR& graph) : - _graph(graph), _node_id(graph), _arc_idf(graph), _arc_idb(graph), - _cost_map(_cost_vec), _pi_map(_pi), - INF(std::numeric_limits::has_infinity ? - std::numeric_limits::infinity() : - std::numeric_limits::max()) - { - // Check the number types - LEMON_ASSERT(std::numeric_limits::is_signed, - "The flow type of CycleCanceling must be signed"); - LEMON_ASSERT(std::numeric_limits::is_signed, - "The cost type of CycleCanceling must be signed"); - - // Reset data structures - reset(); - } - - /// \name Parameters - /// The parameters of the algorithm can be specified using these - /// functions. - - /// @{ - - /// \brief Set the lower bounds on the arcs. - /// - /// This function sets the lower bounds on the arcs. - /// If it is not used before calling \ref run(), the lower bounds - /// will be set to zero on all arcs. - /// - /// \param map An arc map storing the lower bounds. - /// Its \c Value type must be convertible to the \c Value type - /// of the algorithm. - /// - /// \return (*this) - template - 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 (*this) - template - 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 (*this) - template - 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 (*this) - template - 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 (*this) - 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 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 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 (*this) - /// - /// \see reset(), run() - CycleCanceling& resetParams() { - for (int i = 0; i != _res_node_num; ++i) { - _supply[i] = 0; - } - int limit = _first_out[_root]; - for (int j = 0; j != limit; ++j) { - _lower[j] = 0; - _upper[j] = INF; - _cost[j] = _forward[j] ? 1 : -1; - } - for (int j = limit; j != _res_arc_num; ++j) { - _lower[j] = 0; - _upper[j] = INF; - _cost[j] = 0; - _cost[_reverse[j]] = 0; - } - _have_lower = false; - return *this; - } - - /// \brief Reset the internal data structures and all the parameters - /// that have been given before. - /// - /// This function resets the internal data structures and all the - /// paramaters that have been given before using functions \ref lowerMap(), - /// \ref upperMap(), \ref costMap(), \ref supplyMap(), \ref stSupply(). - /// - /// It is useful for multiple \ref run() calls. Basically, all the given - /// parameters are kept for the next \ref run() call, unless - /// \ref resetParams() or \ref reset() is used. - /// If the underlying digraph was also modified after the construction - /// of the class or the last \ref reset() call, then the \ref reset() - /// function must be used, otherwise \ref resetParams() is sufficient. - /// - /// See \ref resetParams() for examples. - /// - /// \return (*this) - /// - /// \see resetParams(), run() - CycleCanceling& reset() { - // Resize vectors - _node_num = countNodes(_graph); - _arc_num = countArcs(_graph); - _res_node_num = _node_num + 1; - _res_arc_num = 2 * (_arc_num + _node_num); - _root = _node_num; - - _first_out.resize(_res_node_num + 1); - _forward.resize(_res_arc_num); - _source.resize(_res_arc_num); - _target.resize(_res_arc_num); - _reverse.resize(_res_arc_num); - - _lower.resize(_res_arc_num); - _upper.resize(_res_arc_num); - _cost.resize(_res_arc_num); - _supply.resize(_res_node_num); - - _res_cap.resize(_res_arc_num); - _pi.resize(_res_node_num); - - _arc_vec.reserve(_res_arc_num); - _cost_vec.reserve(_res_arc_num); - _id_vec.reserve(_res_arc_num); - - // Copy the graph - int i = 0, j = 0, k = 2 * _arc_num + _node_num; - for (NodeIt n(_graph); n != INVALID; ++n, ++i) { - _node_id[n] = i; - } - i = 0; - for (NodeIt n(_graph); n != INVALID; ++n, ++i) { - _first_out[i] = j; - for (OutArcIt a(_graph, n); a != INVALID; ++a, ++j) { - _arc_idf[a] = j; - _forward[j] = true; - _source[j] = i; - _target[j] = _node_id[_graph.runningNode(a)]; - } - for (InArcIt a(_graph, n); a != INVALID; ++a, ++j) { - _arc_idb[a] = j; - _forward[j] = false; - _source[j] = i; - _target[j] = _node_id[_graph.runningNode(a)]; - } - _forward[j] = false; - _source[j] = i; - _target[j] = _root; - _reverse[j] = k; - _forward[k] = true; - _source[k] = _root; - _target[k] = i; - _reverse[k] = j; - ++j; ++k; - } - _first_out[i] = j; - _first_out[_res_node_num] = k; - for (ArcIt a(_graph); a != INVALID; ++a) { - int fi = _arc_idf[a]; - int bi = _arc_idb[a]; - _reverse[fi] = bi; - _reverse[bi] = fi; - } - - // Reset parameters - resetParams(); - return *this; - } - - /// @} - - /// \name Query Functions - /// The results of the algorithm can be obtained using these - /// functions.\n - /// The \ref run() function must be called before using them. - - /// @{ - - /// \brief Return the total cost of the found flow. - /// - /// This function returns the total cost of the found flow. - /// Its complexity is O(e). - /// - /// \note The return type of the function can be specified as a - /// template parameter. For example, - /// \code - /// cc.totalCost(); - /// \endcode - /// It is useful if the total cost cannot be stored in the \c Cost - /// type of the algorithm, which is the default return type of the - /// function. - /// - /// \pre \ref run() must be called before using this function. - template - Number totalCost() const { - Number c = 0; - for (ArcIt a(_graph); a != INVALID; ++a) { - int i = _arc_idb[a]; - c += static_cast(_res_cap[i]) * - (-static_cast(_cost[i])); - } - return c; - } - -#ifndef DOXYGEN - Cost totalCost() const { - return totalCost(); - } -#endif - - /// \brief Return the flow on the given arc. - /// - /// This function returns the flow on the given arc. - /// - /// \pre \ref run() must be called before using this function. - Value flow(const Arc& a) const { - return _res_cap[_arc_idb[a]]; - } - - /// \brief Copy the flow values (the primal solution) into the - /// given map. - /// - /// This function copies the flow value on each arc into the given - /// map. The \c Value type of the algorithm must be convertible to - /// the \c Value type of the map. - /// - /// \pre \ref run() must be called before using this function. - template - void flowMap(FlowMap &map) const { - for (ArcIt a(_graph); a != INVALID; ++a) { - map.set(a, _res_cap[_arc_idb[a]]); - } - } - - /// \brief Return the potential (dual value) of the given node. - /// - /// This function returns the potential (dual value) of the - /// given node. - /// - /// \pre \ref run() must be called before using this function. - Cost potential(const Node& n) const { - return static_cast(_pi[_node_id[n]]); - } - - /// \brief Copy the potential values (the dual solution) into the - /// given map. - /// - /// This function copies the potential (dual value) of each node - /// into the given map. - /// The \c Cost type of the algorithm must be convertible to the - /// \c Value type of the map. - /// - /// \pre \ref run() must be called before using this function. - template - void potentialMap(PotentialMap &map) const { - for (NodeIt n(_graph); n != INVALID; ++n) { - map.set(n, static_cast(_pi[_node_id[n]])); - } - } - - /// @} - - private: - - // Initialize the algorithm - ProblemType init() { - if (_res_node_num <= 1) return INFEASIBLE; - - // Check the sum of supply values - _sum_supply = 0; - for (int i = 0; i != _root; ++i) { - _sum_supply += _supply[i]; - } - if (_sum_supply > 0) return INFEASIBLE; - - - // Initialize vectors - for (int i = 0; i != _res_node_num; ++i) { - _pi[i] = 0; - } - ValueVector excess(_supply); - - // Remove infinite upper bounds and check negative arcs - const Value MAX = std::numeric_limits::max(); - int last_out; - if (_have_lower) { - for (int i = 0; i != _root; ++i) { - last_out = _first_out[i+1]; - for (int j = _first_out[i]; j != last_out; ++j) { - if (_forward[j]) { - Value c = _cost[j] < 0 ? _upper[j] : _lower[j]; - if (c >= MAX) return UNBOUNDED; - excess[i] -= c; - excess[_target[j]] += c; - } - } - } - } else { - for (int i = 0; i != _root; ++i) { - last_out = _first_out[i+1]; - for (int j = _first_out[i]; j != last_out; ++j) { - if (_forward[j] && _cost[j] < 0) { - Value c = _upper[j]; - if (c >= MAX) return UNBOUNDED; - excess[i] -= c; - excess[_target[j]] += c; - } - } - } - } - Value ex, max_cap = 0; - for (int i = 0; i != _res_node_num; ++i) { - ex = excess[i]; - if (ex < 0) max_cap -= ex; - } - for (int j = 0; j != _res_arc_num; ++j) { - if (_upper[j] >= MAX) _upper[j] = max_cap; - } - - // Initialize maps for Circulation and remove non-zero lower bounds - ConstMap low(0); - typedef typename Digraph::template ArcMap ValueArcMap; - typedef typename Digraph::template NodeMap ValueNodeMap; - ValueArcMap cap(_graph), flow(_graph); - ValueNodeMap sup(_graph); - for (NodeIt n(_graph); n != INVALID; ++n) { - sup[n] = _supply[_node_id[n]]; - } - if (_have_lower) { - for (ArcIt a(_graph); a != INVALID; ++a) { - int j = _arc_idf[a]; - Value c = _lower[j]; - cap[a] = _upper[j] - c; - sup[_graph.source(a)] -= c; - sup[_graph.target(a)] += c; - } - } else { - for (ArcIt a(_graph); a != INVALID; ++a) { - cap[a] = _upper[_arc_idf[a]]; - } - } - - // Find a feasible flow using Circulation - Circulation, ValueArcMap, ValueNodeMap> - circ(_graph, low, cap, sup); - if (!circ.flowMap(flow).run()) return INFEASIBLE; - - // Set residual capacities and handle GEQ supply type - if (_sum_supply < 0) { - for (ArcIt a(_graph); a != INVALID; ++a) { - Value fa = flow[a]; - _res_cap[_arc_idf[a]] = cap[a] - fa; - _res_cap[_arc_idb[a]] = fa; - sup[_graph.source(a)] -= fa; - sup[_graph.target(a)] += fa; - } - for (NodeIt n(_graph); n != INVALID; ++n) { - excess[_node_id[n]] = sup[n]; - } - for (int a = _first_out[_root]; a != _res_arc_num; ++a) { - int u = _target[a]; - int ra = _reverse[a]; - _res_cap[a] = -_sum_supply + 1; - _res_cap[ra] = -excess[u]; - _cost[a] = 0; - _cost[ra] = 0; - } - } else { - for (ArcIt a(_graph); a != INVALID; ++a) { - Value fa = flow[a]; - _res_cap[_arc_idf[a]] = cap[a] - fa; - _res_cap[_arc_idb[a]] = fa; - } - for (int a = _first_out[_root]; a != _res_arc_num; ++a) { - int ra = _reverse[a]; - _res_cap[a] = 1; - _res_cap[ra] = 0; - _cost[a] = 0; - _cost[ra] = 0; - } - } - - return OPTIMAL; - } - - // Build a StaticDigraph structure containing the current - // residual network - void buildResidualNetwork() { - _arc_vec.clear(); - _cost_vec.clear(); - _id_vec.clear(); - for (int j = 0; j != _res_arc_num; ++j) { - if (_res_cap[j] > 0) { - _arc_vec.push_back(IntPair(_source[j], _target[j])); - _cost_vec.push_back(_cost[j]); - _id_vec.push_back(j); - } - } - _sgr.build(_res_node_num, _arc_vec.begin(), _arc_vec.end()); - } - - // Execute the algorithm and transform the results - void start(Method method) { - // Execute the algorithm - switch (method) { - case SIMPLE_CYCLE_CANCELING: - startSimpleCycleCanceling(); - break; - case MINIMUM_MEAN_CYCLE_CANCELING: - startMinMeanCycleCanceling(); - break; - case CANCEL_AND_TIGHTEN: - startCancelAndTighten(); - break; - } - - // Compute node potentials - if (method != SIMPLE_CYCLE_CANCELING) { - buildResidualNetwork(); - typename BellmanFord - ::template SetDistMap::Create bf(_sgr, _cost_map); - bf.distMap(_pi_map); - bf.init(0); - bf.start(); - } - - // Handle non-zero lower bounds - if (_have_lower) { - int limit = _first_out[_root]; - for (int j = 0; j != limit; ++j) { - if (!_forward[j]) _res_cap[j] += _lower[j]; - } - } - } - - // Execute the "Simple Cycle Canceling" method - void startSimpleCycleCanceling() { - // Constants for computing the iteration limits - const int BF_FIRST_LIMIT = 2; - const double BF_LIMIT_FACTOR = 1.5; - - typedef StaticVectorMap FilterMap; - typedef FilterArcs ResDigraph; - typedef StaticVectorMap PredMap; - typedef typename BellmanFord - ::template SetDistMap - ::template SetPredMap::Create BF; - - // Build the residual network - _arc_vec.clear(); - _cost_vec.clear(); - for (int j = 0; j != _res_arc_num; ++j) { - _arc_vec.push_back(IntPair(_source[j], _target[j])); - _cost_vec.push_back(_cost[j]); - } - _sgr.build(_res_node_num, _arc_vec.begin(), _arc_vec.end()); - - FilterMap filter_map(_res_cap); - ResDigraph rgr(_sgr, filter_map); - std::vector cycle; - std::vector pred(_res_arc_num); - PredMap pred_map(pred); - BF bf(rgr, _cost_map); - bf.distMap(_pi_map).predMap(pred_map); - - int length_bound = BF_FIRST_LIMIT; - bool optimal = false; - while (!optimal) { - bf.init(0); - int iter_num = 0; - bool cycle_found = false; - while (!cycle_found) { - // Perform some iterations of the Bellman-Ford algorithm - int curr_iter_num = iter_num + length_bound <= _node_num ? - length_bound : _node_num - iter_num; - iter_num += curr_iter_num; - int real_iter_num = curr_iter_num; - for (int i = 0; i < curr_iter_num; ++i) { - if (bf.processNextWeakRound()) { - real_iter_num = i; - break; - } - } - if (real_iter_num < curr_iter_num) { - // Optimal flow is found - optimal = true; - break; - } else { - // Search for node disjoint negative cycles - std::vector state(_res_node_num, 0); - int id = 0; - for (int u = 0; u != _res_node_num; ++u) { - if (state[u] != 0) continue; - ++id; - int v = u; - for (; v != -1 && state[v] == 0; v = pred[v] == INVALID ? - -1 : rgr.id(rgr.source(pred[v]))) { - state[v] = id; - } - if (v != -1 && state[v] == id) { - // A negative cycle is found - cycle_found = true; - cycle.clear(); - StaticDigraph::Arc a = pred[v]; - Value d, delta = _res_cap[rgr.id(a)]; - cycle.push_back(rgr.id(a)); - while (rgr.id(rgr.source(a)) != v) { - a = pred_map[rgr.source(a)]; - d = _res_cap[rgr.id(a)]; - if (d < delta) delta = d; - cycle.push_back(rgr.id(a)); - } - - // Augment along the cycle - for (int i = 0; i < int(cycle.size()); ++i) { - int j = cycle[i]; - _res_cap[j] -= delta; - _res_cap[_reverse[j]] += delta; - } - } - } - } - - // Increase iteration limit if no cycle is found - if (!cycle_found) { - length_bound = static_cast(length_bound * BF_LIMIT_FACTOR); - } - } - } - } - - // Execute the "Minimum Mean Cycle Canceling" method - void startMinMeanCycleCanceling() { - typedef SimplePath SPath; - typedef typename SPath::ArcIt SPathArcIt; - typedef typename HowardMmc - ::template SetPath::Create MMC; - - SPath cycle; - MMC mmc(_sgr, _cost_map); - mmc.cycle(cycle); - buildResidualNetwork(); - while (mmc.findCycleMean() && mmc.cycleCost() < 0) { - // Find the cycle - mmc.findCycle(); - - // Compute delta value - Value delta = INF; - for (SPathArcIt a(cycle); a != INVALID; ++a) { - Value d = _res_cap[_id_vec[_sgr.id(a)]]; - if (d < delta) delta = d; - } - - // Augment along the cycle - for (SPathArcIt a(cycle); a != INVALID; ++a) { - int j = _id_vec[_sgr.id(a)]; - _res_cap[j] -= delta; - _res_cap[_reverse[j]] += delta; - } - - // Rebuild the residual network - buildResidualNetwork(); - } - } - - // Execute the "Cancel-and-Tighten" method - void startCancelAndTighten() { - // Constants for the min mean cycle computations - const double LIMIT_FACTOR = 1.0; - const int MIN_LIMIT = 5; - - // Contruct auxiliary data vectors - DoubleVector pi(_res_node_num, 0.0); - IntVector level(_res_node_num); - BoolVector reached(_res_node_num); - BoolVector processed(_res_node_num); - IntVector pred_node(_res_node_num); - IntVector pred_arc(_res_node_num); - std::vector stack(_res_node_num); - std::vector proc_vector(_res_node_num); - - // Initialize epsilon - double epsilon = 0; - for (int a = 0; a != _res_arc_num; ++a) { - if (_res_cap[a] > 0 && -_cost[a] > epsilon) - epsilon = -_cost[a]; - } - - // Start phases - Tolerance tol; - tol.epsilon(1e-6); - int limit = int(LIMIT_FACTOR * std::sqrt(double(_res_node_num))); - if (limit < MIN_LIMIT) limit = MIN_LIMIT; - int iter = limit; - while (epsilon * _res_node_num >= 1) { - // Find and cancel cycles in the admissible network using DFS - for (int u = 0; u != _res_node_num; ++u) { - reached[u] = false; - processed[u] = false; - } - int stack_head = -1; - int proc_head = -1; - for (int start = 0; start != _res_node_num; ++start) { - if (reached[start]) continue; - - // New start node - reached[start] = true; - pred_arc[start] = -1; - pred_node[start] = -1; - - // Find the first admissible outgoing arc - double p = pi[start]; - int a = _first_out[start]; - int last_out = _first_out[start+1]; - for (; a != last_out && (_res_cap[a] == 0 || - !tol.negative(_cost[a] + p - pi[_target[a]])); ++a) ; - if (a == last_out) { - processed[start] = true; - proc_vector[++proc_head] = start; - continue; - } - stack[++stack_head] = a; - - while (stack_head >= 0) { - int sa = stack[stack_head]; - int u = _source[sa]; - int v = _target[sa]; - - if (!reached[v]) { - // A new node is reached - reached[v] = true; - pred_node[v] = u; - pred_arc[v] = sa; - p = pi[v]; - a = _first_out[v]; - last_out = _first_out[v+1]; - for (; a != last_out && (_res_cap[a] == 0 || - !tol.negative(_cost[a] + p - pi[_target[a]])); ++a) ; - stack[++stack_head] = a == last_out ? -1 : a; - } else { - if (!processed[v]) { - // A cycle is found - int n, w = u; - Value d, delta = _res_cap[sa]; - for (n = u; n != v; n = pred_node[n]) { - d = _res_cap[pred_arc[n]]; - if (d <= delta) { - delta = d; - w = pred_node[n]; - } - } - - // Augment along the cycle - _res_cap[sa] -= delta; - _res_cap[_reverse[sa]] += delta; - for (n = u; n != v; n = pred_node[n]) { - int pa = pred_arc[n]; - _res_cap[pa] -= delta; - _res_cap[_reverse[pa]] += delta; - } - for (n = u; stack_head > 0 && n != w; n = pred_node[n]) { - --stack_head; - reached[n] = false; - } - u = w; - } - v = u; - - // Find the next admissible outgoing arc - p = pi[v]; - a = stack[stack_head] + 1; - last_out = _first_out[v+1]; - for (; a != last_out && (_res_cap[a] == 0 || - !tol.negative(_cost[a] + p - pi[_target[a]])); ++a) ; - stack[stack_head] = a == last_out ? -1 : a; - } - - while (stack_head >= 0 && stack[stack_head] == -1) { - processed[v] = true; - proc_vector[++proc_head] = v; - if (--stack_head >= 0) { - // Find the next admissible outgoing arc - v = _source[stack[stack_head]]; - p = pi[v]; - a = stack[stack_head] + 1; - last_out = _first_out[v+1]; - for (; a != last_out && (_res_cap[a] == 0 || - !tol.negative(_cost[a] + p - pi[_target[a]])); ++a) ; - stack[stack_head] = a == last_out ? -1 : a; - } - } - } - } - - // Tighten potentials and epsilon - if (--iter > 0) { - for (int u = 0; u != _res_node_num; ++u) { - level[u] = 0; - } - for (int i = proc_head; i > 0; --i) { - int u = proc_vector[i]; - double p = pi[u]; - int l = level[u] + 1; - int last_out = _first_out[u+1]; - for (int a = _first_out[u]; a != last_out; ++a) { - int v = _target[a]; - if (_res_cap[a] > 0 && tol.negative(_cost[a] + p - pi[v]) && - l > level[v]) level[v] = l; - } - } - - // Modify potentials - double q = std::numeric_limits::max(); - for (int u = 0; u != _res_node_num; ++u) { - int lu = level[u]; - double p, pu = pi[u]; - int last_out = _first_out[u+1]; - for (int a = _first_out[u]; a != last_out; ++a) { - if (_res_cap[a] == 0) continue; - int v = _target[a]; - int ld = lu - level[v]; - if (ld > 0) { - p = (_cost[a] + pu - pi[v] + epsilon) / (ld + 1); - if (p < q) q = p; - } - } - } - for (int u = 0; u != _res_node_num; ++u) { - pi[u] -= q * level[u]; - } - - // Modify epsilon - epsilon = 0; - for (int u = 0; u != _res_node_num; ++u) { - double curr, pu = pi[u]; - int last_out = _first_out[u+1]; - for (int a = _first_out[u]; a != last_out; ++a) { - if (_res_cap[a] == 0) continue; - curr = _cost[a] + pu - pi[_target[a]]; - if (-curr > epsilon) epsilon = -curr; - } - } - } else { - typedef HowardMmc MMC; - typedef typename BellmanFord - ::template SetDistMap::Create BF; - - // Set epsilon to the minimum cycle mean - buildResidualNetwork(); - MMC mmc(_sgr, _cost_map); - mmc.findCycleMean(); - epsilon = -mmc.cycleMean(); - Cost cycle_cost = mmc.cycleCost(); - int cycle_size = mmc.cycleSize(); - - // Compute feasible potentials for the current epsilon - for (int i = 0; i != int(_cost_vec.size()); ++i) { - _cost_vec[i] = cycle_size * _cost_vec[i] - cycle_cost; - } - BF bf(_sgr, _cost_map); - bf.distMap(_pi_map); - bf.init(0); - bf.start(); - for (int u = 0; u != _res_node_num; ++u) { - pi[u] = static_cast(_pi[u]) / cycle_size; - } - - iter = limit; - } - } - } - - }; //class CycleCanceling - - ///@} - -} //namespace lemon - -#endif //LEMON_CYCLE_CANCELING_H Index: lemon/dfs.h =================================================================== --- lemon/dfs.h (revision 1000) +++ lemon/dfs.h (revision 975) @@ -3,5 +3,5 @@ * This file is a part of LEMON, a generic C++ optimization library. * - * Copyright (C) 2003-2010 + * Copyright (C) 2003-2009 * Egervary Jeno Kombinatorikus Optimalizalasi Kutatocsoport * (Egervary Research Group on Combinatorial Optimization, EGRES). @@ -48,5 +48,5 @@ ///The type of the map that stores the predecessor ///arcs of the %DFS paths. - ///It must conform to the \ref concepts::WriteMap "WriteMap" concept. + ///It must meet the \ref concepts::WriteMap "WriteMap" concept. typedef typename Digraph::template NodeMap PredMap; ///Instantiates a \c PredMap. @@ -63,6 +63,5 @@ ///The type of the map that indicates which nodes are processed. - ///It must conform to the \ref concepts::WriteMap "WriteMap" concept. - ///By default, it is a NullMap. + ///It must meet the \ref concepts::WriteMap "WriteMap" concept. typedef NullMap ProcessedMap; ///Instantiates a \c ProcessedMap. @@ -83,6 +82,5 @@ ///The type of the map that indicates which nodes are reached. - ///It must conform to - ///the \ref concepts::ReadWriteMap "ReadWriteMap" concept. + ///It must meet the \ref concepts::ReadWriteMap "ReadWriteMap" concept. typedef typename Digraph::template NodeMap ReachedMap; ///Instantiates a \c ReachedMap. @@ -99,5 +97,5 @@ ///The type of the map that stores the distances of the nodes. - ///It must conform to the \ref concepts::WriteMap "WriteMap" concept. + ///It must meet the \ref concepts::WriteMap "WriteMap" concept. typedef typename Digraph::template NodeMap DistMap; ///Instantiates a \c DistMap. @@ -123,9 +121,4 @@ ///\tparam GR The type of the digraph the algorithm runs on. ///The default type is \ref ListDigraph. - ///\tparam TR The traits class that defines various types used by the - ///algorithm. By default, it is \ref DfsDefaultTraits - ///"DfsDefaultTraits". - ///In most cases, this parameter should not be set directly, - ///consider to use the named template parameters instead. #ifdef DOXYGEN template struct SetPredMap : public Dfs > { @@ -252,5 +245,5 @@ ///\ref named-templ-param "Named parameter" for setting ///\c DistMap type. - ///It must conform to the \ref concepts::WriteMap "WriteMap" concept. + ///It must meet the \ref concepts::WriteMap "WriteMap" concept. template struct SetDistMap : public Dfs< Digraph, SetDistMapTraits > { @@ -272,6 +265,5 @@ ///\ref named-templ-param "Named parameter" for setting ///\c ReachedMap type. - ///It must conform to - ///the \ref concepts::ReadWriteMap "ReadWriteMap" concept. + ///It must meet the \ref concepts::ReadWriteMap "ReadWriteMap" concept. template struct SetReachedMap : public Dfs< Digraph, SetReachedMapTraits > { @@ -293,5 +285,5 @@ ///\ref named-templ-param "Named parameter" for setting ///\c ProcessedMap type. - ///It must conform to the \ref concepts::WriteMap "WriteMap" concept. + ///It must meet the \ref concepts::WriteMap "WriteMap" concept. template struct SetProcessedMap : public Dfs< Digraph, SetProcessedMapTraits > { @@ -420,6 +412,6 @@ ///The simplest way to execute the DFS algorithm is to use one of the ///member functions called \ref run(Node) "run()".\n - ///If you need better control on the execution, you have to call - ///\ref init() first, then you can add a source node with \ref addSource() + ///If you need more control on the execution, first you have to call + ///\ref init(), then you can add a source node with \ref addSource() ///and perform the actual computation with \ref start(). ///This procedure can be repeated if there are nodes that have not @@ -641,6 +633,10 @@ ///Runs the algorithm to visit all nodes in the digraph. - ///This method runs the %DFS algorithm in order to visit all nodes - ///in the digraph. + ///This method runs the %DFS algorithm in order to compute the + ///%DFS path to each node. + /// + ///The algorithm computes + ///- the %DFS tree (forest), + ///- the distance of each node from the root(s) in the %DFS tree. /// ///\note d.run() is just a shortcut of the following code. @@ -674,7 +670,7 @@ ///@{ - ///The DFS path to the given node. - - ///Returns the DFS path to the given node from the root(s). + ///The DFS path to a node. + + ///Returns the DFS path to a node. /// ///\warning \c t should be reached from the root(s). @@ -684,7 +680,7 @@ Path path(Node t) const { return Path(*G, *_pred, t); } - ///The distance of the given node from the root(s). - - ///Returns the distance of the given node from the root(s). + ///The distance of a node from the root(s). + + ///Returns the distance of a node from the root(s). /// ///\warning If node \c v is not reached from the root(s), then @@ -695,5 +691,5 @@ int dist(Node v) const { return (*_dist)[v]; } - ///Returns the 'previous arc' of the %DFS tree for the given node. + ///Returns the 'previous arc' of the %DFS tree for a node. ///This function returns the 'previous arc' of the %DFS tree for the @@ -703,5 +699,5 @@ /// ///The %DFS tree used here is equal to the %DFS tree used in - ///\ref predNode() and \ref predMap(). + ///\ref predNode(). /// ///\pre Either \ref run(Node) "run()" or \ref init() @@ -709,13 +705,13 @@ Arc predArc(Node v) const { return (*_pred)[v];} - ///Returns the 'previous node' of the %DFS tree for the given node. + ///Returns the 'previous node' of the %DFS tree. ///This function returns the 'previous node' of the %DFS ///tree for the node \c v, i.e. it returns the last but one node - ///of a %DFS path from a root to \c v. It is \c INVALID + ///from a %DFS path from a root to \c v. It is \c INVALID ///if \c v is not reached from the root(s) or if \c v is a root. /// ///The %DFS tree used here is equal to the %DFS tree used in - ///\ref predArc() and \ref predMap(). + ///\ref predArc(). /// ///\pre Either \ref run(Node) "run()" or \ref init() @@ -738,5 +734,5 @@ /// ///Returns a const reference to the node map that stores the predecessor - ///arcs, which form the DFS tree (forest). + ///arcs, which form the DFS tree. /// ///\pre Either \ref run(Node) "run()" or \ref init() @@ -744,5 +740,5 @@ const PredMap &predMap() const { return *_pred;} - ///Checks if the given node. node is reached from the root(s). + ///Checks if a node is reached from the root(s). ///Returns \c true if \c v is reached from the root(s). @@ -770,5 +766,5 @@ ///The type of the map that stores the predecessor ///arcs of the %DFS paths. - ///It must conform to the \ref concepts::WriteMap "WriteMap" concept. + ///It must meet the \ref concepts::WriteMap "WriteMap" concept. typedef typename Digraph::template NodeMap PredMap; ///Instantiates a PredMap. @@ -785,6 +781,6 @@ ///The type of the map that indicates which nodes are processed. - ///It must conform to the \ref concepts::WriteMap "WriteMap" concept. - ///By default, it is a NullMap. + ///It must meet the \ref concepts::WriteMap "WriteMap" concept. + ///By default it is a NullMap. typedef NullMap ProcessedMap; ///Instantiates a ProcessedMap. @@ -805,6 +801,5 @@ ///The type of the map that indicates which nodes are reached. - ///It must conform to - ///the \ref concepts::ReadWriteMap "ReadWriteMap" concept. + ///It must meet the \ref concepts::ReadWriteMap "ReadWriteMap" concept. typedef typename Digraph::template NodeMap ReachedMap; ///Instantiates a ReachedMap. @@ -821,5 +816,5 @@ ///The type of the map that stores the distances of the nodes. - ///It must conform to the \ref concepts::WriteMap "WriteMap" concept. + ///It must meet the \ref concepts::WriteMap "WriteMap" concept. typedef typename Digraph::template NodeMap DistMap; ///Instantiates a DistMap. @@ -836,5 +831,5 @@ ///The type of the DFS paths. - ///It must conform to the \ref concepts::Path "Path" concept. + ///It must meet the \ref concepts::Path "Path" concept. typedef lemon::Path Path; }; @@ -842,6 +837,10 @@ /// Default traits class used by DfsWizard - /// Default traits class used by DfsWizard. - /// \tparam GR The type of the digraph. + /// To make it easier to use Dfs algorithm + /// we have created a wizard class. + /// This \ref DfsWizard class needs default traits, + /// as well as the \ref Dfs class. + /// The \ref DfsWizardBase is a class to be the default traits of the + /// \ref DfsWizard class. template class DfsWizardBase : public DfsWizardDefaultTraits @@ -871,5 +870,5 @@ /// Constructor. - /// This constructor does not require parameters, it initiates + /// This constructor does not require parameters, therefore it initiates /// all of the attributes to \c 0. DfsWizardBase() : _g(0), _reached(0), _processed(0), _pred(0), @@ -896,7 +895,4 @@ /// This class should only be used through the \ref dfs() function, /// which makes it easier to use the algorithm. - /// - /// \tparam TR The traits class that defines various types used by the - /// algorithm. template class DfsWizard : public TR @@ -904,4 +900,5 @@ typedef TR Base; + ///The type of the digraph the algorithm runs on. typedef typename TR::Digraph Digraph; @@ -911,8 +908,14 @@ typedef typename Digraph::OutArcIt OutArcIt; + ///\brief The type of the map that stores the predecessor + ///arcs of the DFS paths. typedef typename TR::PredMap PredMap; + ///\brief The type of the map that stores the distances of the nodes. typedef typename TR::DistMap DistMap; + ///\brief The type of the map that indicates which nodes are reached. typedef typename TR::ReachedMap ReachedMap; + ///\brief The type of the map that indicates which nodes are processed. typedef typename TR::ProcessedMap ProcessedMap; + ///The type of the DFS paths typedef typename TR::Path Path; @@ -984,6 +987,6 @@ ///Runs DFS algorithm to visit all nodes in the digraph. - ///This method runs DFS algorithm in order to visit all nodes - ///in the digraph. + ///This method runs DFS algorithm in order to compute + ///the DFS path to each node. void run() { @@ -997,10 +1000,9 @@ SetPredMapBase(const TR &b) : TR(b) {} }; - - ///\brief \ref named-templ-param "Named parameter" for setting - ///the predecessor map. - /// - ///\ref named-templ-param "Named parameter" function for setting - ///the map that stores the predecessor arcs of the nodes. + ///\brief \ref named-func-param "Named parameter" + ///for setting PredMap object. + /// + ///\ref named-func-param "Named parameter" + ///for setting PredMap object. template DfsWizard > predMap(const T &t) @@ -1016,10 +1018,9 @@ SetReachedMapBase(const TR &b) : TR(b) {} }; - - ///\brief \ref named-templ-param "Named parameter" for setting - ///the reached map. - /// - ///\ref named-templ-param "Named parameter" function for setting - ///the map that indicates which nodes are reached. + ///\brief \ref named-func-param "Named parameter" + ///for setting ReachedMap object. + /// + /// \ref named-func-param "Named parameter" + ///for setting ReachedMap object. template DfsWizard > reachedMap(const T &t) @@ -1035,11 +1036,9 @@ SetDistMapBase(const TR &b) : TR(b) {} }; - - ///\brief \ref named-templ-param "Named parameter" for setting - ///the distance map. - /// - ///\ref named-templ-param "Named parameter" function for setting - ///the map that stores the distances of the nodes calculated - ///by the algorithm. + ///\brief \ref named-func-param "Named parameter" + ///for setting DistMap object. + /// + /// \ref named-func-param "Named parameter" + ///for setting DistMap object. template DfsWizard > distMap(const T &t) @@ -1055,10 +1054,9 @@ SetProcessedMapBase(const TR &b) : TR(b) {} }; - - ///\brief \ref named-func-param "Named parameter" for setting - ///the processed map. - /// - ///\ref named-templ-param "Named parameter" function for setting - ///the map that indicates which nodes are processed. + ///\brief \ref named-func-param "Named parameter" + ///for setting ProcessedMap object. + /// + /// \ref named-func-param "Named parameter" + ///for setting ProcessedMap object. template DfsWizard > processedMap(const T &t) @@ -1212,6 +1210,5 @@ /// /// The type of the map that indicates which nodes are reached. - /// It must conform to the - /// \ref concepts::ReadWriteMap "ReadWriteMap" concept. + /// It must meet the \ref concepts::ReadWriteMap "ReadWriteMap" concept. typedef typename Digraph::template NodeMap ReachedMap; @@ -1251,9 +1248,9 @@ /// does not observe the DFS events. If you want to observe the DFS /// events, you should implement your own visitor class. - /// \tparam TR The traits class that defines various types used by the - /// algorithm. By default, it is \ref DfsVisitDefaultTraits - /// "DfsVisitDefaultTraits". - /// In most cases, this parameter should not be set directly, - /// consider to use the named template parameters instead. + /// \tparam TR Traits class to set various data types used by the + /// algorithm. The default traits class is + /// \ref DfsVisitDefaultTraits "DfsVisitDefaultTraits". + /// See \ref DfsVisitDefaultTraits for the documentation of + /// a DFS visit traits class. #ifdef DOXYGEN template @@ -1374,6 +1371,6 @@ /// The simplest way to execute the DFS algorithm is to use one of the /// member functions called \ref run(Node) "run()".\n - /// If you need better control on the execution, you have to call - /// \ref init() first, then you can add a source node with \ref addSource() + /// If you need more control on the execution, first you have to call + /// \ref init(), then you can add a source node with \ref addSource() /// and perform the actual computation with \ref start(). /// This procedure can be repeated if there are nodes that have not @@ -1588,6 +1585,10 @@ /// \brief Runs the algorithm to visit all nodes in the digraph. - /// This method runs the %DFS algorithm in order to visit all nodes - /// in the digraph. + /// This method runs the %DFS algorithm in order to + /// compute the %DFS path to each node. + /// + /// The algorithm computes + /// - the %DFS tree (forest), + /// - the distance of each node from the root(s) in the %DFS tree. /// /// \note d.run() is just a shortcut of the following code. @@ -1621,5 +1622,5 @@ ///@{ - /// \brief Checks if the given node is reached from the root(s). + /// \brief Checks if a node is reached from the root(s). /// /// Returns \c true if \c v is reached from the root(s). Index: mon/dheap.h =================================================================== --- lemon/dheap.h (revision 855) +++ (revision ) @@ -1,352 +1,0 @@ -/* -*- mode: C++; indent-tabs-mode: nil; -*- - * - * This file is a part of LEMON, a generic C++ optimization library. - * - * Copyright (C) 2003-2009 - * Egervary Jeno Kombinatorikus Optimalizalasi Kutatocsoport - * (Egervary Research Group on Combinatorial Optimization, EGRES). - * - * Permission to use, modify and distribute this software is granted - * provided that this copyright notice appears in all copies. For - * precise terms see the accompanying LICENSE file. - * - * This software is provided "AS IS" with no warranty of any kind, - * express or implied, and with no claim as to its suitability for any - * purpose. - * - */ - -#ifndef LEMON_DHEAP_H -#define LEMON_DHEAP_H - -///\ingroup heaps -///\file -///\brief D-ary heap implementation. - -#include -#include -#include - -namespace lemon { - - /// \ingroup heaps - /// - ///\brief D-ary heap data structure. - /// - /// This class implements the \e D-ary \e heap data structure. - /// It fully conforms to the \ref concepts::Heap "heap concept". - /// - /// The \ref DHeap "D-ary heap" is a generalization of the - /// \ref BinHeap "binary heap" structure, its nodes have at most - /// \c D children, instead of two. - /// \ref BinHeap and \ref QuadHeap are specialized implementations - /// of this structure for D=2 and D=4, respectively. - /// - /// \tparam PR Type of the priorities of the items. - /// \tparam IM A read-writable item map with \c int values, used - /// internally to handle the cross references. - /// \tparam D The degree of the heap, each node have at most \e D - /// children. The default is 16. Powers of two are suggested to use - /// so that the multiplications and divisions needed to traverse the - /// nodes of the heap could be performed faster. - /// \tparam CMP A functor class for comparing the priorities. - /// The default is \c std::less. - /// - ///\sa BinHeap - ///\sa FouraryHeap -#ifdef DOXYGEN - template -#else - template > -#endif - class DHeap { - public: - /// Type of the item-int map. - typedef IM ItemIntMap; - /// Type of the priorities. - typedef PR Prio; - /// Type of the items stored in the heap. - typedef typename ItemIntMap::Key Item; - /// Type of the item-priority pairs. - typedef std::pair Pair; - /// Functor type for comparing the priorities. - typedef CMP Compare; - - /// \brief Type to represent the states of the items. - /// - /// Each item has a state associated to it. It can be "in heap", - /// "pre-heap" or "post-heap". The latter two are indifferent from the - /// heap's point of view, but may be useful to the user. - /// - /// The item-int map must be initialized in such way that it assigns - /// \c PRE_HEAP (-1) to any element to be put in the heap. - enum State { - IN_HEAP = 0, ///< = 0. - PRE_HEAP = -1, ///< = -1. - POST_HEAP = -2 ///< = -2. - }; - - private: - std::vector _data; - Compare _comp; - ItemIntMap &_iim; - - public: - /// \brief Constructor. - /// - /// Constructor. - /// \param map A map that assigns \c int values to the items. - /// It is used internally to handle the cross references. - /// The assigned value must be \c PRE_HEAP (-1) for each item. - explicit DHeap(ItemIntMap &map) : _iim(map) {} - - /// \brief Constructor. - /// - /// Constructor. - /// \param map A map that assigns \c int values to the items. - /// It is used internally to handle the cross references. - /// The assigned value must be \c PRE_HEAP (-1) for each item. - /// \param comp The function object used for comparing the priorities. - DHeap(ItemIntMap &map, const Compare &comp) - : _iim(map), _comp(comp) {} - - /// \brief The number of items stored in the heap. - /// - /// This function returns the number of items stored in the heap. - int size() const { return _data.size(); } - - /// \brief Check if the heap is empty. - /// - /// This function returns \c true if the heap is empty. - bool empty() const { return _data.empty(); } - - /// \brief Make the heap empty. - /// - /// This functon makes the heap empty. - /// It does not change the cross reference map. If you want to reuse - /// a heap that is not surely empty, you should first clear it and - /// then you should set the cross reference map to \c PRE_HEAP - /// for each item. - void clear() { _data.clear(); } - - private: - int parent(int i) { return (i-1)/D; } - int firstChild(int i) { return D*i+1; } - - bool less(const Pair &p1, const Pair &p2) const { - return _comp(p1.second, p2.second); - } - - void bubbleUp(int hole, Pair p) { - int par = parent(hole); - while( hole>0 && less(p,_data[par]) ) { - move(_data[par],hole); - hole = par; - par = parent(hole); - } - move(p, hole); - } - - void bubbleDown(int hole, Pair p, int length) { - if( length>1 ) { - int child = firstChild(hole); - while( child+D<=length ) { - int min=child; - for (int i=1; i0) bubbleDown(0, _data[n], n); - _data.pop_back(); - } - - /// \brief Remove the given item from the heap. - /// - /// This function removes the given item from the heap if it is - /// already stored. - /// \param i The item to delete. - /// \pre \e i must be in the heap. - void erase(const Item &i) { - int h = _iim[i]; - int n = _data.size()-1; - _iim.set(_data[h].first, POST_HEAP); - if( h=0) s=0; - return State(s); - } - - /// \brief Set the state of an item in the heap. - /// - /// This function sets the state of the given item in the heap. - /// It can be used to manually clear the heap when it is important - /// to achive better time complexity. - /// \param i The item. - /// \param st The state. It should not be \c IN_HEAP. - void state(const Item& i, State st) { - switch (st) { - case POST_HEAP: - case PRE_HEAP: - if (state(i) == IN_HEAP) erase(i); - _iim[i] = st; - break; - case IN_HEAP: - break; - } - } - - /// \brief Replace an item in the heap. - /// - /// This function replaces item \c i with item \c j. - /// Item \c i must be in the heap, while \c j must be out of the heap. - /// After calling this method, item \c i will be out of the - /// heap and \c j will be in the heap with the same prioriority - /// as item \c i had before. - void replace(const Item& i, const Item& j) { - int idx=_iim[i]; - _iim.set(i, _iim[j]); - _iim.set(j, idx); - _data[idx].first=j; - } - - }; // class DHeap - -} // namespace lemon - -#endif // LEMON_DHEAP_H Index: lemon/dijkstra.h =================================================================== --- lemon/dijkstra.h (revision 877) +++ lemon/dijkstra.h (revision 584) @@ -3,5 +3,5 @@ * This file is a part of LEMON, a generic C++ optimization library. * - * Copyright (C) 2003-2010 + * Copyright (C) 2003-2009 * Egervary Jeno Kombinatorikus Optimalizalasi Kutatocsoport * (Egervary Research Group on Combinatorial Optimization, EGRES). @@ -71,7 +71,7 @@ ///The type of the map that stores the arc lengths. - ///It must conform to the \ref concepts::ReadMap "ReadMap" concept. + ///It must meet the \ref concepts::ReadMap "ReadMap" concept. typedef LEN LengthMap; - ///The type of the arc lengths. + ///The type of the length of the arcs. typedef typename LEN::Value Value; @@ -117,5 +117,5 @@ ///The type of the map that stores the predecessor ///arcs of the shortest paths. - ///It must conform to the \ref concepts::WriteMap "WriteMap" concept. + ///It must meet the \ref concepts::WriteMap "WriteMap" concept. typedef typename Digraph::template NodeMap PredMap; ///Instantiates a \c PredMap. @@ -132,6 +132,6 @@ ///The type of the map that indicates which nodes are processed. - ///It must conform to the \ref concepts::WriteMap "WriteMap" concept. - ///By default, it is a NullMap. + ///It must meet the \ref concepts::WriteMap "WriteMap" concept. + ///By default it is a NullMap. typedef NullMap ProcessedMap; ///Instantiates a \c ProcessedMap. @@ -152,5 +152,5 @@ ///The type of the map that stores the distances of the nodes. - ///It must conform to the \ref concepts::WriteMap "WriteMap" concept. + ///It must meet the \ref concepts::WriteMap "WriteMap" concept. typedef typename Digraph::template NodeMap DistMap; ///Instantiates a \c DistMap. @@ -169,8 +169,4 @@ /// \ingroup shortest_path ///This class provides an efficient implementation of the %Dijkstra algorithm. - /// - ///The %Dijkstra algorithm solves the single-source shortest path problem - ///when all arc lengths are non-negative. If there are negative lengths, - ///the BellmanFord algorithm should be used instead. /// ///The arc lengths are passed to the algorithm using a @@ -193,9 +189,4 @@ ///it is necessary. The default map type is \ref ///concepts::Digraph::ArcMap "GR::ArcMap". - ///\tparam TR The traits class that defines various types used by the - ///algorithm. By default, it is \ref DijkstraDefaultTraits - ///"DijkstraDefaultTraits". - ///In most cases, this parameter should not be set directly, - ///consider to use the named template parameters instead. #ifdef DOXYGEN template @@ -211,6 +202,6 @@ typedef typename TR::Digraph Digraph; - ///The type of the arc lengths. - typedef typename TR::Value Value; + ///The type of the length of the arcs. + typedef typename TR::LengthMap::Value Value; ///The type of the map that stores the arc lengths. typedef typename TR::LengthMap LengthMap; @@ -314,5 +305,5 @@ ///\ref named-templ-param "Named parameter" for setting ///\c PredMap type. - ///It must conform to the \ref concepts::WriteMap "WriteMap" concept. + ///It must meet the \ref concepts::WriteMap "WriteMap" concept. template struct SetPredMap @@ -335,5 +326,5 @@ ///\ref named-templ-param "Named parameter" for setting ///\c DistMap type. - ///It must conform to the \ref concepts::WriteMap "WriteMap" concept. + ///It must meet the \ref concepts::WriteMap "WriteMap" concept. template struct SetDistMap @@ -356,5 +347,5 @@ ///\ref named-templ-param "Named parameter" for setting ///\c ProcessedMap type. - ///It must conform to the \ref concepts::WriteMap "WriteMap" concept. + ///It must meet the \ref concepts::WriteMap "WriteMap" concept. template struct SetProcessedMap @@ -432,5 +423,5 @@ ///passed to the constructor of the cross reference and the cross ///reference should be passed to the constructor of the heap). - ///However, external heap and cross reference objects could also be + ///However external heap and cross reference objects could also be ///passed to the algorithm using the \ref heap() function before ///calling \ref run(Node) "run()" or \ref init(). @@ -453,5 +444,4 @@ ///\ref named-templ-param "Named parameter" for setting ///\c OperationTraits type. - /// For more information, see \ref DijkstraDefaultOperationTraits. template struct SetOperationTraits @@ -595,6 +585,6 @@ ///The simplest way to execute the %Dijkstra algorithm is to use ///one of the member functions called \ref run(Node) "run()".\n - ///If you need better control on the execution, you have to call - ///\ref init() first, then you can add several source nodes with + ///If you need more control on the execution, first you have to call + ///\ref init(), then you can add several source nodes with ///\ref addSource(). Finally the actual path computation can be ///performed with one of the \ref start() functions. @@ -812,12 +802,12 @@ ///The results of the %Dijkstra algorithm can be obtained using these ///functions.\n - ///Either \ref run(Node) "run()" or \ref init() should be called + ///Either \ref run(Node) "run()" or \ref start() should be called ///before using them. ///@{ - ///The shortest path to the given node. - - ///Returns the shortest path to the given node from the root(s). + ///The shortest path to a node. + + ///Returns the shortest path to a node. /// ///\warning \c t should be reached from the root(s). @@ -827,7 +817,7 @@ Path path(Node t) const { return Path(*G, *_pred, t); } - ///The distance of the given node from the root(s). - - ///Returns the distance of the given node from the root(s). + ///The distance of a node from the root(s). + + ///Returns the distance of a node from the root(s). /// ///\warning If node \c v is not reached from the root(s), then @@ -838,7 +828,6 @@ Value dist(Node v) const { return (*_dist)[v]; } - ///\brief Returns the 'previous arc' of the shortest path tree for - ///the given node. - /// + ///Returns the 'previous arc' of the shortest path tree for a node. + ///This function returns the 'previous arc' of the shortest path ///tree for the node \c v, i.e. it returns the last arc of a @@ -847,5 +836,5 @@ /// ///The shortest path tree used here is equal to the shortest path - ///tree used in \ref predNode() and \ref predMap(). + ///tree used in \ref predNode(). /// ///\pre Either \ref run(Node) "run()" or \ref init() @@ -853,14 +842,13 @@ Arc predArc(Node v) const { return (*_pred)[v]; } - ///\brief Returns the 'previous node' of the shortest path tree for - ///the given node. - /// + ///Returns the 'previous node' of the shortest path tree for a node. + ///This function returns the 'previous node' of the shortest path ///tree for the node \c v, i.e. it returns the last but one node - ///of a shortest path from a root to \c v. It is \c INVALID + ///from a shortest path from a root to \c v. It is \c INVALID ///if \c v is not reached from the root(s) or if \c v is a root. /// ///The shortest path tree used here is equal to the shortest path - ///tree used in \ref predArc() and \ref predMap(). + ///tree used in \ref predArc(). /// ///\pre Either \ref run(Node) "run()" or \ref init() @@ -883,5 +871,5 @@ /// ///Returns a const reference to the node map that stores the predecessor - ///arcs, which form the shortest path tree (forest). + ///arcs, which form the shortest path tree. /// ///\pre Either \ref run(Node) "run()" or \ref init() @@ -889,5 +877,5 @@ const PredMap &predMap() const { return *_pred;} - ///Checks if the given node is reached from the root(s). + ///Checks if a node is reached from the root(s). ///Returns \c true if \c v is reached from the root(s). @@ -908,7 +896,7 @@ Heap::POST_HEAP; } - ///The current distance of the given node from the root(s). - - ///Returns the current distance of the given node from the root(s). + ///The current distance of a node from the root(s). + + ///Returns the current distance of a node from the root(s). ///It may be decreased in the following processes. /// @@ -937,7 +925,7 @@ ///The type of the map that stores the arc lengths. - ///It must conform to the \ref concepts::ReadMap "ReadMap" concept. + ///It must meet the \ref concepts::ReadMap "ReadMap" concept. typedef LEN LengthMap; - ///The type of the arc lengths. + ///The type of the length of the arcs. typedef typename LEN::Value Value; @@ -986,5 +974,5 @@ ///The type of the map that stores the predecessor ///arcs of the shortest paths. - ///It must conform to the \ref concepts::WriteMap "WriteMap" concept. + ///It must meet the \ref concepts::WriteMap "WriteMap" concept. typedef typename Digraph::template NodeMap PredMap; ///Instantiates a PredMap. @@ -1001,6 +989,6 @@ ///The type of the map that indicates which nodes are processed. - ///It must conform to the \ref concepts::WriteMap "WriteMap" concept. - ///By default, it is a NullMap. + ///It must meet the \ref concepts::WriteMap "WriteMap" concept. + ///By default it is a NullMap. typedef NullMap ProcessedMap; ///Instantiates a ProcessedMap. @@ -1021,5 +1009,5 @@ ///The type of the map that stores the distances of the nodes. - ///It must conform to the \ref concepts::WriteMap "WriteMap" concept. + ///It must meet the \ref concepts::WriteMap "WriteMap" concept. typedef typename Digraph::template NodeMap DistMap; ///Instantiates a DistMap. @@ -1036,5 +1024,5 @@ ///The type of the shortest paths. - ///It must conform to the \ref concepts::Path "Path" concept. + ///It must meet the \ref concepts::Path "Path" concept. typedef lemon::Path Path; }; @@ -1042,7 +1030,10 @@ /// Default traits class used by DijkstraWizard - /// Default traits class used by DijkstraWizard. - /// \tparam GR The type of the digraph. - /// \tparam LEN The type of the length map. + /// To make it easier to use Dijkstra algorithm + /// we have created a wizard class. + /// This \ref DijkstraWizard class needs default traits, + /// as well as the \ref Dijkstra class. + /// The \ref DijkstraWizardBase is a class to be the default traits of the + /// \ref DijkstraWizard class. template class DijkstraWizardBase : public DijkstraWizardDefaultTraits @@ -1098,7 +1089,4 @@ /// This class should only be used through the \ref dijkstra() function, /// which makes it easier to use the algorithm. - /// - /// \tparam TR The traits class that defines various types used by the - /// algorithm. template class DijkstraWizard : public TR @@ -1106,4 +1094,5 @@ typedef TR Base; + ///The type of the digraph the algorithm runs on. typedef typename TR::Digraph Digraph; @@ -1113,10 +1102,18 @@ typedef typename Digraph::OutArcIt OutArcIt; + ///The type of the map that stores the arc lengths. typedef typename TR::LengthMap LengthMap; + ///The type of the length of the arcs. typedef typename LengthMap::Value Value; + ///\brief The type of the map that stores the predecessor + ///arcs of the shortest paths. typedef typename TR::PredMap PredMap; + ///The type of the map that stores the distances of the nodes. typedef typename TR::DistMap DistMap; + ///The type of the map that indicates which nodes are processed. typedef typename TR::ProcessedMap ProcessedMap; + ///The type of the shortest paths typedef typename TR::Path Path; + ///The heap type used by the dijkstra algorithm. typedef typename TR::Heap Heap; @@ -1190,10 +1187,9 @@ SetPredMapBase(const TR &b) : TR(b) {} }; - - ///\brief \ref named-templ-param "Named parameter" for setting - ///the predecessor map. - /// - ///\ref named-templ-param "Named parameter" function for setting - ///the map that stores the predecessor arcs of the nodes. + ///\brief \ref named-func-param "Named parameter" + ///for setting PredMap object. + /// + ///\ref named-func-param "Named parameter" + ///for setting PredMap object. template DijkstraWizard > predMap(const T &t) @@ -1209,11 +1205,9 @@ SetDistMapBase(const TR &b) : TR(b) {} }; - - ///\brief \ref named-templ-param "Named parameter" for setting - ///the distance map. - /// - ///\ref named-templ-param "Named parameter" function for setting - ///the map that stores the distances of the nodes calculated - ///by the algorithm. + ///\brief \ref named-func-param "Named parameter" + ///for setting DistMap object. + /// + ///\ref named-func-param "Named parameter" + ///for setting DistMap object. template DijkstraWizard > distMap(const T &t) @@ -1229,10 +1223,9 @@ SetProcessedMapBase(const TR &b) : TR(b) {} }; - - ///\brief \ref named-func-param "Named parameter" for setting - ///the processed map. - /// - ///\ref named-templ-param "Named parameter" function for setting - ///the map that indicates which nodes are processed. + ///\brief \ref named-func-param "Named parameter" + ///for setting ProcessedMap object. + /// + /// \ref named-func-param "Named parameter" + ///for setting ProcessedMap object. template DijkstraWizard > processedMap(const T &t) @@ -1247,5 +1240,4 @@ SetPathBase(const TR &b) : TR(b) {} }; - ///\brief \ref named-func-param "Named parameter" ///for getting the shortest path to the target node. Index: lemon/dim2.h =================================================================== --- lemon/dim2.h (revision 714) +++ lemon/dim2.h (revision 440) @@ -22,7 +22,14 @@ #include -///\ingroup geomdat +///\ingroup misc ///\file ///\brief A simple two dimensional vector and a bounding box implementation +/// +/// The class \ref lemon::dim2::Point "dim2::Point" implements +/// a two dimensional vector with the usual operations. +/// +/// The class \ref lemon::dim2::Box "dim2::Box" can be used to determine +/// the rectangular bounding box of a set of +/// \ref lemon::dim2::Point "dim2::Point"'s. namespace lemon { @@ -34,5 +41,5 @@ namespace dim2 { - /// \addtogroup geomdat + /// \addtogroup misc /// @{ Index: lemon/dimacs.h =================================================================== --- lemon/dimacs.h (revision 877) +++ lemon/dimacs.h (revision 584) @@ -3,5 +3,5 @@ * This file is a part of LEMON, a generic C++ optimization library. * - * Copyright (C) 2003-2010 + * Copyright (C) 2003-2009 * Egervary Jeno Kombinatorikus Optimalizalasi Kutatocsoport * (Egervary Research Group on Combinatorial Optimization, EGRES). @@ -62,5 +62,5 @@ ///This function starts seeking the beginning of the given file for the - ///problem type and size info. + ///problem type and size info. ///The found data is returned in a special struct that can be evaluated ///and passed to the appropriate reader function. @@ -213,5 +213,5 @@ std::numeric_limits::infinity() : std::numeric_limits::max(); - + while (is >> c) { switch (c) { @@ -238,5 +238,5 @@ e = g.addArc(nodes[i], nodes[j]); capacity.set(e, _cap); - } + } else if (desc.type==DimacsDescriptor::MAX) { is >> i >> j >> _cap; @@ -363,9 +363,9 @@ g.addArc(s,t); } - + /// \brief DIMACS plain (di)graph reader function. /// /// This function reads a plain (di)graph without any designated nodes - /// and maps (e.g. a matching instance) from DIMACS format, i.e. from + /// and maps (e.g. a matching instance) from DIMACS format, i.e. from /// DIMACS files having a line starting with /// \code @@ -393,5 +393,5 @@ nodes[k] = g.addNode(); } - + while (is >> c) { switch (c) { Index: lemon/edge_set.h =================================================================== --- lemon/edge_set.h (revision 877) +++ lemon/edge_set.h (revision 670) @@ -3,5 +3,5 @@ * This file is a part of LEMON, a generic C++ optimization library. * - * Copyright (C) 2003-2010 + * Copyright (C) 2003-2008 * Egervary Jeno Kombinatorikus Optimalizalasi Kutatocsoport * (Egervary Research Group on Combinatorial Optimization, EGRES). @@ -256,12 +256,11 @@ /// all arcs incident to the given node is erased from the arc set. /// - /// This class fully conforms to the \ref concepts::Digraph - /// "Digraph" concept. - /// It provides only linear time counting for nodes and arcs. - /// /// \param GR The type of the graph which shares its node set with /// this class. Its interface must conform to the /// \ref concepts::Digraph "Digraph" or \ref concepts::Graph "Graph" /// concept. + /// + /// This class fully conforms to the \ref concepts::Digraph + /// "Digraph" concept. template class ListArcSet : public ArcSetExtender > { @@ -687,11 +686,10 @@ /// incident to the given node is erased from the arc set. /// - /// This class fully conforms to the \ref concepts::Graph "Graph" - /// concept. - /// It provides only linear time counting for nodes, edges and arcs. - /// /// \param GR The type of the graph which shares its node set /// with this class. Its interface must conform to the /// \ref concepts::Digraph "Digraph" or \ref concepts::Graph "Graph" + /// concept. + /// + /// This class fully conforms to the \ref concepts::Graph "Graph" /// concept. template @@ -870,5 +868,5 @@ } - static void next(Arc& arc) { + void next(Arc& arc) const { --arc.id; } @@ -957,12 +955,11 @@ /// arcs. Therefore the arcs cannot be erased from the arc sets. /// - /// This class fully conforms to the \ref concepts::Digraph "Digraph" - /// concept. - /// It provides only linear time counting for nodes and arcs. - /// /// \warning If a node is erased from the underlying graph and this /// node is the source or target of one arc in the arc set, then /// the arc set is invalidated, and it cannot be used anymore. The /// validity can be checked with the \c valid() member function. + /// + /// This class fully conforms to the \ref concepts::Digraph + /// "Digraph" concept. template class SmartArcSet : public ArcSetExtender > { @@ -1177,5 +1174,5 @@ } - static void next(Arc& arc) { + void next(Arc& arc) const { --arc.id; } @@ -1185,5 +1182,5 @@ } - static void next(Edge& arc) { + void next(Edge& arc) const { --arc.id; } @@ -1308,12 +1305,11 @@ /// edges cannot be erased from the edge sets. /// - /// This class fully conforms to the \ref concepts::Graph "Graph" - /// concept. - /// It provides only linear time counting for nodes, edges and arcs. - /// /// \warning If a node is erased from the underlying graph and this /// node is incident to one edge in the edge set, then the edge set /// is invalidated, and it cannot be used anymore. The validity can /// be checked with the \c valid() member function. + /// + /// This class fully conforms to the \ref concepts::Graph + /// "Graph" concept. template class SmartEdgeSet : public EdgeSetExtender > { Index: lemon/euler.h =================================================================== --- lemon/euler.h (revision 919) +++ lemon/euler.h (revision 648) @@ -3,5 +3,5 @@ * This file is a part of LEMON, a generic C++ optimization library. * - * Copyright (C) 2003-2010 + * Copyright (C) 2003-2009 * Egervary Jeno Kombinatorikus Optimalizalasi Kutatocsoport * (Egervary Research Group on Combinatorial Optimization, EGRES). @@ -27,5 +27,5 @@ /// \ingroup graph_properties /// \file -/// \brief Euler tour iterators and a function for checking the \e Eulerian +/// \brief Euler tour iterators and a function for checking the \e Eulerian /// property. /// @@ -37,10 +37,10 @@ ///Euler tour iterator for digraphs. - /// \ingroup graph_properties + /// \ingroup graph_prop ///This iterator provides an Euler tour (Eulerian circuit) of a \e directed ///graph (if there exists) and it converts to the \c Arc type of the digraph. /// ///For example, if the given digraph has an Euler tour (i.e it has only one - ///non-trivial component and the in-degree is equal to the out-degree + ///non-trivial component and the in-degree is equal to the out-degree ///for all nodes), then the following code will put the arcs of \c g ///to the vector \c et according to an Euler tour of \c g. @@ -139,5 +139,5 @@ ///and \c Edge types of the graph. /// - ///For example, if the given graph has an Euler tour (i.e it has only one + ///For example, if the given graph has an Euler tour (i.e it has only one ///non-trivial component and the degree of each node is even), ///the following code will print the arc IDs according to an @@ -148,5 +148,5 @@ /// } ///\endcode - ///Although this iterator is for undirected graphs, it still returns + ///Although this iterator is for undirected graphs, it still returns ///arcs in order to indicate the direction of the tour. ///(But arcs convert to edges, of course.) @@ -234,5 +234,5 @@ /// Postfix incrementation. /// - ///\warning This incrementation returns an \c Arc (which converts to + ///\warning This incrementation returns an \c Arc (which converts to ///an \c Edge), not an \ref EulerIt, as one may expect. Arc operator++(int) Index: lemon/fib_heap.h =================================================================== --- lemon/fib_heap.h (revision 711) +++ lemon/fib_heap.h (revision 683) @@ -21,9 +21,8 @@ ///\file -///\ingroup heaps -///\brief Fibonacci heap implementation. +///\ingroup auxdat +///\brief Fibonacci Heap implementation. #include -#include #include #include @@ -31,37 +30,42 @@ namespace lemon { - /// \ingroup heaps + /// \ingroup auxdat /// - /// \brief Fibonacci heap data structure. + ///\brief Fibonacci Heap. /// - /// This class implements the \e Fibonacci \e heap data structure. - /// It fully conforms to the \ref concepts::Heap "heap concept". + ///This class implements the \e Fibonacci \e heap data structure. A \e heap + ///is a data structure for storing items with specified values called \e + ///priorities in such a way that finding the item with minimum priority is + ///efficient. \c CMP specifies the ordering of the priorities. In a heap + ///one can change the priority of an item, add or erase an item, etc. /// - /// The methods \ref increase() and \ref erase() are not efficient in a - /// Fibonacci heap. In case of many calls of these operations, it is - /// better to use other heap structure, e.g. \ref BinHeap "binary heap". + ///The methods \ref increase and \ref erase are not efficient in a Fibonacci + ///heap. In case of many calls to these operations, it is better to use a + ///\ref BinHeap "binary heap". /// - /// \tparam PR Type of the priorities of the items. - /// \tparam IM A read-writable item map with \c int values, used - /// internally to handle the cross references. - /// \tparam CMP A functor class for comparing the priorities. - /// The default is \c std::less. + ///\param PRIO Type of the priority of the items. + ///\param IM A read and writable Item int map, used internally + ///to handle the cross references. + ///\param CMP A class for the ordering of the priorities. The + ///default is \c std::less. + /// + ///\sa BinHeap + ///\sa Dijkstra #ifdef DOXYGEN - template + template #else - template > + template > #endif class FibHeap { public: - - /// Type of the item-int map. + ///\e typedef IM ItemIntMap; - /// Type of the priorities. - typedef PR Prio; - /// Type of the items stored in the heap. + ///\e + typedef PRIO Prio; + ///\e typedef typename ItemIntMap::Key Item; - /// Type of the item-priority pairs. + ///\e typedef std::pair Pair; - /// Functor type for comparing the priorities. + ///\e typedef CMP Compare; @@ -77,8 +81,8 @@ public: - /// \brief Type to represent the states of the items. - /// - /// Each item has a state associated to it. It can be "in heap", - /// "pre-heap" or "post-heap". The latter two are indifferent from the + /// \brief Type to represent the items states. + /// + /// Each Item element have a state associated to it. It may be "in heap", + /// "pre heap" or "post heap". The latter two are indifferent from the /// heap's point of view, but may be useful to the user. /// @@ -91,20 +95,16 @@ }; - /// \brief Constructor. - /// - /// Constructor. - /// \param map A map that assigns \c int values to the items. - /// It is used internally to handle the cross references. - /// The assigned value must be \c PRE_HEAP (-1) for each item. + /// \brief The constructor + /// + /// \c map should be given to the constructor, since it is + /// used internally to handle the cross references. explicit FibHeap(ItemIntMap &map) : _minimum(0), _iim(map), _num() {} - /// \brief Constructor. - /// - /// Constructor. - /// \param map A map that assigns \c int values to the items. - /// It is used internally to handle the cross references. - /// The assigned value must be \c PRE_HEAP (-1) for each item. - /// \param comp The function object used for comparing the priorities. + /// \brief The constructor + /// + /// \c map should be given to the constructor, since it is used + /// internally to handle the cross references. \c comp is an + /// object for ordering of the priorities. FibHeap(ItemIntMap &map, const Compare &comp) : _minimum(0), _iim(map), _comp(comp), _num() {} @@ -112,31 +112,41 @@ /// \brief The number of items stored in the heap. /// - /// This function returns the number of items stored in the heap. + /// Returns the number of items stored in the heap. int size() const { return _num; } - /// \brief Check if the heap is empty. - /// - /// This function returns \c true if the heap is empty. + /// \brief Checks if the heap stores no items. + /// + /// Returns \c true if and only if the heap stores no items. bool empty() const { return _num==0; } - /// \brief Make the heap empty. - /// - /// This functon makes the heap empty. - /// It does not change the cross reference map. If you want to reuse - /// a heap that is not surely empty, you should first clear it and - /// then you should set the cross reference map to \c PRE_HEAP - /// for each item. + /// \brief Make empty this heap. + /// + /// Make empty this heap. It does not change the cross reference + /// map. If you want to reuse a heap what is not surely empty you + /// should first clear the heap and after that you should set the + /// cross reference map for each item to \c PRE_HEAP. void clear() { _data.clear(); _minimum = 0; _num = 0; } - /// \brief Insert an item into the heap with the given priority. - /// - /// This function inserts the given item into the heap with the - /// given priority. - /// \param item The item to insert. - /// \param prio The priority of the item. - /// \pre \e item must not be stored in the heap. - void push (const Item& item, const Prio& prio) { + /// \brief \c item gets to the heap with priority \c value independently + /// if \c item was already there. + /// + /// This method calls \ref push(\c item, \c value) if \c item is not + /// stored in the heap and it calls \ref decrease(\c item, \c value) or + /// \ref increase(\c item, \c value) otherwise. + void set (const Item& item, const Prio& value) { + int i=_iim[item]; + if ( i >= 0 && _data[i].in ) { + if ( _comp(value, _data[i].prio) ) decrease(item, value); + if ( _comp(_data[i].prio, value) ) increase(item, value); + } else push(item, value); + } + + /// \brief Adds \c item to the heap with priority \c value. + /// + /// Adds \c item to the heap with priority \c value. + /// \pre \c item must not be stored in the heap. + void push (const Item& item, const Prio& value) { int i=_iim[item]; if ( i < 0 ) { @@ -159,28 +169,38 @@ _data[_minimum].right_neighbor=i; _data[i].left_neighbor=_minimum; - if ( _comp( prio, _data[_minimum].prio) ) _minimum=i; + if ( _comp( value, _data[_minimum].prio) ) _minimum=i; } else { _data[i].right_neighbor=_data[i].left_neighbor=i; _minimum=i; } - _data[i].prio=prio; + _data[i].prio=value; ++_num; } - /// \brief Return the item having minimum priority. - /// - /// This function returns the item having minimum priority. - /// \pre The heap must be non-empty. + /// \brief Returns the item with minimum priority relative to \c Compare. + /// + /// This method returns the item with minimum priority relative to \c + /// Compare. + /// \pre The heap must be nonempty. Item top() const { return _data[_minimum].name; } - /// \brief The minimum priority. - /// - /// This function returns the minimum priority. - /// \pre The heap must be non-empty. - Prio prio() const { return _data[_minimum].prio; } - - /// \brief Remove the item having minimum priority. - /// - /// This function removes the item having minimum priority. + /// \brief Returns the minimum priority relative to \c Compare. + /// + /// It returns the minimum priority relative to \c Compare. + /// \pre The heap must be nonempty. + const Prio& prio() const { return _data[_minimum].prio; } + + /// \brief Returns the priority of \c item. + /// + /// It returns the priority of \c item. + /// \pre \c item must be in the heap. + const Prio& operator[](const Item& item) const { + return _data[_iim[item]].prio; + } + + /// \brief Deletes the item with minimum priority relative to \c Compare. + /// + /// This method deletes the item with minimum priority relative to \c + /// Compare from the heap. /// \pre The heap must be non-empty. void pop() { @@ -189,5 +209,5 @@ _data[_minimum].in=false; if ( _data[_minimum].degree!=0 ) { - makeRoot(_data[_minimum].child); + makeroot(_data[_minimum].child); _minimum=_data[_minimum].child; balance(); @@ -202,5 +222,5 @@ int last_child=_data[child].left_neighbor; - makeRoot(child); + makeroot(child); _data[left].right_neighbor=child; @@ -215,10 +235,8 @@ } - /// \brief Remove the given item from the heap. - /// - /// This function removes the given item from the heap if it is - /// already stored. - /// \param item The item to delete. - /// \pre \e item must be in the heap. + /// \brief Deletes \c item from the heap. + /// + /// This method deletes \c item from the heap, if \c item was already + /// stored in the heap. It is quite inefficient in Fibonacci heaps. void erase (const Item& item) { int i=_iim[item]; @@ -235,66 +253,41 @@ } - /// \brief The priority of the given item. - /// - /// This function returns the priority of the given item. - /// \param item The item. - /// \pre \e item must be in the heap. - Prio operator[](const Item& item) const { - return _data[_iim[item]].prio; - } - - /// \brief Set the priority of an item or insert it, if it is - /// not stored in the heap. - /// - /// This method sets the priority of the given item if it is - /// already stored in the heap. Otherwise it inserts the given - /// item into the heap with the given priority. - /// \param item The item. - /// \param prio The priority. - void set (const Item& item, const Prio& prio) { + /// \brief Decreases the priority of \c item to \c value. + /// + /// This method decreases the priority of \c item to \c value. + /// \pre \c item must be stored in the heap with priority at least \c + /// value relative to \c Compare. + void decrease (Item item, const Prio& value) { int i=_iim[item]; - if ( i >= 0 && _data[i].in ) { - if ( _comp(prio, _data[i].prio) ) decrease(item, prio); - if ( _comp(_data[i].prio, prio) ) increase(item, prio); - } else push(item, prio); - } - - /// \brief Decrease the priority of an item to the given value. - /// - /// This function decreases the priority of an item to the given value. - /// \param item The item. - /// \param prio The priority. - /// \pre \e item must be stored in the heap with priority at least \e prio. - void decrease (const Item& item, const Prio& prio) { - int i=_iim[item]; - _data[i].prio=prio; + _data[i].prio=value; int p=_data[i].parent; - if ( p!=-1 && _comp(prio, _data[p].prio) ) { + if ( p!=-1 && _comp(value, _data[p].prio) ) { cut(i,p); cascade(p); } - if ( _comp(prio, _data[_minimum].prio) ) _minimum=i; - } - - /// \brief Increase the priority of an item to the given value. - /// - /// This function increases the priority of an item to the given value. - /// \param item The item. - /// \param prio The priority. - /// \pre \e item must be stored in the heap with priority at most \e prio. - void increase (const Item& item, const Prio& prio) { + if ( _comp(value, _data[_minimum].prio) ) _minimum=i; + } + + /// \brief Increases the priority of \c item to \c value. + /// + /// This method sets the priority of \c item to \c value. Though + /// there is no precondition on the priority of \c item, this + /// method should be used only if it is indeed necessary to increase + /// (relative to \c Compare) the priority of \c item, because this + /// method is inefficient. + void increase (Item item, const Prio& value) { erase(item); - push(item, prio); - } - - /// \brief Return the state of an item. - /// - /// This method returns \c PRE_HEAP if the given item has never - /// been in the heap, \c IN_HEAP if it is in the heap at the moment, - /// and \c POST_HEAP otherwise. - /// In the latter case it is possible that the item will get back - /// to the heap again. - /// \param item The item. + push(item, value); + } + + + /// \brief Returns if \c item is in, has already been in, or has never + /// been in the heap. + /// + /// This method returns PRE_HEAP if \c item has never been in the + /// heap, IN_HEAP if it is in the heap at the moment, and POST_HEAP + /// otherwise. In the latter case it is possible that \c item will + /// get back to the heap again. State state(const Item &item) const { int i=_iim[item]; @@ -306,9 +299,9 @@ } - /// \brief Set the state of an item in the heap. - /// - /// This function sets the state of the given item in the heap. - /// It can be used to manually clear the heap when it is important - /// to achive better time complexity. + /// \brief Sets the state of the \c item in the heap. + /// + /// Sets the state of the \c item in the heap. It can be used to + /// manually clear the heap when it is important to achive the + /// better time _complexity. /// \param i The item. /// \param st The state. It should not be \c IN_HEAP. @@ -373,5 +366,5 @@ } - void makeRoot(int c) { + void makeroot(int c) { int s=c; do { Index: mon/fractional_matching.h =================================================================== --- lemon/fractional_matching.h (revision 877) +++ (revision ) @@ -1,2139 +1,0 @@ -/* -*- mode: C++; indent-tabs-mode: nil; -*- - * - * This file is a part of LEMON, a generic C++ optimization library. - * - * Copyright (C) 2003-2010 - * Egervary Jeno Kombinatorikus Optimalizalasi Kutatocsoport - * (Egervary Research Group on Combinatorial Optimization, EGRES). - * - * Permission to use, modify and distribute this software is granted - * provided that this copyright notice appears in all copies. For - * precise terms see the accompanying LICENSE file. - * - * This software is provided "AS IS" with no warranty of any kind, - * express or implied, and with no claim as to its suitability for any - * purpose. - * - */ - -#ifndef LEMON_FRACTIONAL_MATCHING_H -#define LEMON_FRACTIONAL_MATCHING_H - -#include -#include -#include -#include - -#include -#include -#include -#include -#include -#include - -///\ingroup matching -///\file -///\brief Fractional matching algorithms in general graphs. - -namespace lemon { - - /// \brief Default traits class of MaxFractionalMatching class. - /// - /// Default traits class of MaxFractionalMatching class. - /// \tparam GR Graph type. - template - struct MaxFractionalMatchingDefaultTraits { - - /// \brief The type of the graph the algorithm runs on. - typedef GR Graph; - - /// \brief The type of the map that stores the matching. - /// - /// The type of the map that stores the matching arcs. - /// It must meet the \ref concepts::ReadWriteMap "ReadWriteMap" concept. - typedef typename Graph::template NodeMap MatchingMap; - - /// \brief Instantiates a MatchingMap. - /// - /// This function instantiates a \ref MatchingMap. - /// \param graph The graph for which we would like to define - /// the matching map. - static MatchingMap* createMatchingMap(const Graph& graph) { - return new MatchingMap(graph); - } - - /// \brief The elevator type used by MaxFractionalMatching algorithm. - /// - /// The elevator type used by MaxFractionalMatching algorithm. - /// - /// \sa Elevator - /// \sa LinkedElevator - typedef LinkedElevator Elevator; - - /// \brief Instantiates an Elevator. - /// - /// This function instantiates an \ref Elevator. - /// \param graph The graph for which we would like to define - /// the elevator. - /// \param max_level The maximum level of the elevator. - static Elevator* createElevator(const Graph& graph, int max_level) { - return new Elevator(graph, max_level); - } - }; - - /// \ingroup matching - /// - /// \brief Max cardinality fractional matching - /// - /// This class provides an implementation of fractional matching - /// algorithm based on push-relabel principle. - /// - /// The maximum cardinality fractional matching is a relaxation of the - /// maximum cardinality matching problem where the odd set constraints - /// are omitted. - /// It can be formulated with the following linear program. - /// \f[ \sum_{e \in \delta(u)}x_e \le 1 \quad \forall u\in V\f] - /// \f[x_e \ge 0\quad \forall e\in E\f] - /// \f[\max \sum_{e\in E}x_e\f] - /// where \f$\delta(X)\f$ is the set of edges incident to a node in - /// \f$X\f$. The result can be represented as the union of a - /// matching with one value edges and a set of odd length cycles - /// with half value edges. - /// - /// The algorithm calculates an optimal fractional matching and a - /// barrier. The number of adjacents of any node set minus the size - /// of node set is a lower bound on the uncovered nodes in the - /// graph. For maximum matching a barrier is computed which - /// maximizes this difference. - /// - /// The algorithm can be executed with the run() function. After it - /// the matching (the primal solution) and the barrier (the dual - /// solution) can be obtained using the query functions. - /// - /// The primal solution is multiplied by - /// \ref MaxFractionalMatching::primalScale "2". - /// - /// \tparam GR The undirected graph type the algorithm runs on. -#ifdef DOXYGEN - template -#else - template > -#endif - class MaxFractionalMatching { - public: - - /// \brief The \ref MaxFractionalMatchingDefaultTraits "traits - /// class" of the algorithm. - typedef TR Traits; - /// The type of the graph the algorithm runs on. - typedef typename TR::Graph Graph; - /// The type of the matching map. - typedef typename TR::MatchingMap MatchingMap; - /// The type of the elevator. - typedef typename TR::Elevator Elevator; - - /// \brief Scaling factor for primal solution - /// - /// Scaling factor for primal solution. - static const int primalScale = 2; - - private: - - const Graph &_graph; - int _node_num; - bool _allow_loops; - int _empty_level; - - TEMPLATE_GRAPH_TYPEDEFS(Graph); - - bool _local_matching; - MatchingMap *_matching; - - bool _local_level; - Elevator *_level; - - typedef typename Graph::template NodeMap InDegMap; - InDegMap *_indeg; - - void createStructures() { - _node_num = countNodes(_graph); - - if (!_matching) { - _local_matching = true; - _matching = Traits::createMatchingMap(_graph); - } - if (!_level) { - _local_level = true; - _level = Traits::createElevator(_graph, _node_num); - } - if (!_indeg) { - _indeg = new InDegMap(_graph); - } - } - - void destroyStructures() { - if (_local_matching) { - delete _matching; - } - if (_local_level) { - delete _level; - } - if (_indeg) { - delete _indeg; - } - } - - void postprocessing() { - for (NodeIt n(_graph); n != INVALID; ++n) { - if ((*_indeg)[n] != 0) continue; - _indeg->set(n, -1); - Node u = n; - while ((*_matching)[u] != INVALID) { - Node v = _graph.target((*_matching)[u]); - _indeg->set(v, -1); - Arc a = _graph.oppositeArc((*_matching)[u]); - u = _graph.target((*_matching)[v]); - _indeg->set(u, -1); - _matching->set(v, a); - } - } - - for (NodeIt n(_graph); n != INVALID; ++n) { - if ((*_indeg)[n] != 1) continue; - _indeg->set(n, -1); - - int num = 1; - Node u = _graph.target((*_matching)[n]); - while (u != n) { - _indeg->set(u, -1); - u = _graph.target((*_matching)[u]); - ++num; - } - if (num % 2 == 0 && num > 2) { - Arc prev = _graph.oppositeArc((*_matching)[n]); - Node v = _graph.target((*_matching)[n]); - u = _graph.target((*_matching)[v]); - _matching->set(v, prev); - while (u != n) { - prev = _graph.oppositeArc((*_matching)[u]); - v = _graph.target((*_matching)[u]); - u = _graph.target((*_matching)[v]); - _matching->set(v, prev); - } - } - } - } - - public: - - typedef MaxFractionalMatching Create; - - ///\name Named Template Parameters - - ///@{ - - template - struct SetMatchingMapTraits : public Traits { - typedef T MatchingMap; - static MatchingMap *createMatchingMap(const Graph&) { - LEMON_ASSERT(false, "MatchingMap is not initialized"); - return 0; // ignore warnings - } - }; - - /// \brief \ref named-templ-param "Named parameter" for setting - /// MatchingMap type - /// - /// \ref named-templ-param "Named parameter" for setting MatchingMap - /// type. - template - struct SetMatchingMap - : public MaxFractionalMatching > { - typedef MaxFractionalMatching > Create; - }; - - template - struct SetElevatorTraits : public Traits { - typedef T Elevator; - static Elevator *createElevator(const Graph&, int) { - LEMON_ASSERT(false, "Elevator is not initialized"); - return 0; // ignore warnings - } - }; - - /// \brief \ref named-templ-param "Named parameter" for setting - /// Elevator type - /// - /// \ref named-templ-param "Named parameter" for setting Elevator - /// type. If this named parameter is used, then an external - /// elevator object must be passed to the algorithm using the - /// \ref elevator(Elevator&) "elevator()" function before calling - /// \ref run() or \ref init(). - /// \sa SetStandardElevator - template - struct SetElevator - : public MaxFractionalMatching > { - typedef MaxFractionalMatching > Create; - }; - - template - struct SetStandardElevatorTraits : public Traits { - typedef T Elevator; - static Elevator *createElevator(const Graph& graph, int max_level) { - return new Elevator(graph, max_level); - } - }; - - /// \brief \ref named-templ-param "Named parameter" for setting - /// Elevator type with automatic allocation - /// - /// \ref named-templ-param "Named parameter" for setting Elevator - /// type with automatic allocation. - /// The Elevator should have standard constructor interface to be - /// able to automatically created by the algorithm (i.e. the - /// graph and the maximum level should be passed to it). - /// However an external elevator object could also be passed to the - /// algorithm with the \ref elevator(Elevator&) "elevator()" function - /// before calling \ref run() or \ref init(). - /// \sa SetElevator - template - struct SetStandardElevator - : public MaxFractionalMatching > { - typedef MaxFractionalMatching > Create; - }; - - /// @} - - protected: - - MaxFractionalMatching() {} - - public: - - /// \brief Constructor - /// - /// Constructor. - /// - MaxFractionalMatching(const Graph &graph, bool allow_loops = true) - : _graph(graph), _allow_loops(allow_loops), - _local_matching(false), _matching(0), - _local_level(false), _level(0), _indeg(0) - {} - - ~MaxFractionalMatching() { - destroyStructures(); - } - - /// \brief Sets the matching map. - /// - /// Sets the matching map. - /// If you don't use this function before calling \ref run() or - /// \ref init(), an instance will be allocated automatically. - /// The destructor deallocates this automatically allocated map, - /// of course. - /// \return (*this) - MaxFractionalMatching& matchingMap(MatchingMap& map) { - if (_local_matching) { - delete _matching; - _local_matching = false; - } - _matching = ↦ - return *this; - } - - /// \brief Sets the elevator used by algorithm. - /// - /// Sets the elevator used by algorithm. - /// If you don't use this function before calling \ref run() or - /// \ref init(), an instance will be allocated automatically. - /// The destructor deallocates this automatically allocated elevator, - /// of course. - /// \return (*this) - MaxFractionalMatching& elevator(Elevator& elevator) { - if (_local_level) { - delete _level; - _local_level = false; - } - _level = &elevator; - return *this; - } - - /// \brief Returns a const reference to the elevator. - /// - /// Returns a const reference to the elevator. - /// - /// \pre Either \ref run() or \ref init() must be called before - /// using this function. - const Elevator& elevator() const { - return *_level; - } - - /// \name Execution control - /// The simplest way to execute the algorithm is to use one of the - /// member functions called \c run(). \n - /// If you need more control on the execution, first - /// you must call \ref init() and then one variant of the start() - /// member. - - /// @{ - - /// \brief Initializes the internal data structures. - /// - /// Initializes the internal data structures and sets the initial - /// matching. - void init() { - createStructures(); - - _level->initStart(); - for (NodeIt n(_graph); n != INVALID; ++n) { - _indeg->set(n, 0); - _matching->set(n, INVALID); - _level->initAddItem(n); - } - _level->initFinish(); - - _empty_level = _node_num; - for (NodeIt n(_graph); n != INVALID; ++n) { - for (OutArcIt a(_graph, n); a != INVALID; ++a) { - if (_graph.target(a) == n && !_allow_loops) continue; - _matching->set(n, a); - Node v = _graph.target((*_matching)[n]); - _indeg->set(v, (*_indeg)[v] + 1); - break; - } - } - - for (NodeIt n(_graph); n != INVALID; ++n) { - if ((*_indeg)[n] == 0) { - _level->activate(n); - } - } - } - - /// \brief Starts the algorithm and computes a fractional matching - /// - /// The algorithm computes a maximum fractional matching. - /// - /// \param postprocess The algorithm computes first a matching - /// which is a union of a matching with one value edges, cycles - /// with half value edges and even length paths with half value - /// edges. If the parameter is true, then after the push-relabel - /// algorithm it postprocesses the matching to contain only - /// matching edges and half value odd cycles. - void start(bool postprocess = true) { - Node n; - while ((n = _level->highestActive()) != INVALID) { - int level = _level->highestActiveLevel(); - int new_level = _level->maxLevel(); - for (InArcIt a(_graph, n); a != INVALID; ++a) { - Node u = _graph.source(a); - if (n == u && !_allow_loops) continue; - Node v = _graph.target((*_matching)[u]); - if ((*_level)[v] < level) { - _indeg->set(v, (*_indeg)[v] - 1); - if ((*_indeg)[v] == 0) { - _level->activate(v); - } - _matching->set(u, a); - _indeg->set(n, (*_indeg)[n] + 1); - _level->deactivate(n); - goto no_more_push; - } else if (new_level > (*_level)[v]) { - new_level = (*_level)[v]; - } - } - - if (new_level + 1 < _level->maxLevel()) { - _level->liftHighestActive(new_level + 1); - } else { - _level->liftHighestActiveToTop(); - } - if (_level->emptyLevel(level)) { - _level->liftToTop(level); - } - no_more_push: - ; - } - for (NodeIt n(_graph); n != INVALID; ++n) { - if ((*_matching)[n] == INVALID) continue; - Node u = _graph.target((*_matching)[n]); - if ((*_indeg)[u] > 1) { - _indeg->set(u, (*_indeg)[u] - 1); - _matching->set(n, INVALID); - } - } - if (postprocess) { - postprocessing(); - } - } - - /// \brief Starts the algorithm and computes a perfect fractional - /// matching - /// - /// The algorithm computes a perfect fractional matching. If it - /// does not exists, then the algorithm returns false and the - /// matching is undefined and the barrier. - /// - /// \param postprocess The algorithm computes first a matching - /// which is a union of a matching with one value edges, cycles - /// with half value edges and even length paths with half value - /// edges. If the parameter is true, then after the push-relabel - /// algorithm it postprocesses the matching to contain only - /// matching edges and half value odd cycles. - bool startPerfect(bool postprocess = true) { - Node n; - while ((n = _level->highestActive()) != INVALID) { - int level = _level->highestActiveLevel(); - int new_level = _level->maxLevel(); - for (InArcIt a(_graph, n); a != INVALID; ++a) { - Node u = _graph.source(a); - if (n == u && !_allow_loops) continue; - Node v = _graph.target((*_matching)[u]); - if ((*_level)[v] < level) { - _indeg->set(v, (*_indeg)[v] - 1); - if ((*_indeg)[v] == 0) { - _level->activate(v); - } - _matching->set(u, a); - _indeg->set(n, (*_indeg)[n] + 1); - _level->deactivate(n); - goto no_more_push; - } else if (new_level > (*_level)[v]) { - new_level = (*_level)[v]; - } - } - - if (new_level + 1 < _level->maxLevel()) { - _level->liftHighestActive(new_level + 1); - } else { - _level->liftHighestActiveToTop(); - _empty_level = _level->maxLevel() - 1; - return false; - } - if (_level->emptyLevel(level)) { - _level->liftToTop(level); - _empty_level = level; - return false; - } - no_more_push: - ; - } - if (postprocess) { - postprocessing(); - } - return true; - } - - /// \brief Runs the algorithm - /// - /// Just a shortcut for the next code: - ///\code - /// init(); - /// start(); - ///\endcode - void run(bool postprocess = true) { - init(); - start(postprocess); - } - - /// \brief Runs the algorithm to find a perfect fractional matching - /// - /// Just a shortcut for the next code: - ///\code - /// init(); - /// startPerfect(); - ///\endcode - bool runPerfect(bool postprocess = true) { - init(); - return startPerfect(postprocess); - } - - ///@} - - /// \name Query Functions - /// The result of the %Matching algorithm can be obtained using these - /// functions.\n - /// Before the use of these functions, - /// either run() or start() must be called. - ///@{ - - - /// \brief Return the number of covered nodes in the matching. - /// - /// This function returns the number of covered nodes in the matching. - /// - /// \pre Either run() or start() must be called before using this function. - int matchingSize() const { - int num = 0; - for (NodeIt n(_graph); n != INVALID; ++n) { - if ((*_matching)[n] != INVALID) { - ++num; - } - } - return num; - } - - /// \brief Returns a const reference to the matching map. - /// - /// Returns a const reference to the node map storing the found - /// fractional matching. This method can be called after - /// running the algorithm. - /// - /// \pre Either \ref run() or \ref init() must be called before - /// using this function. - const MatchingMap& matchingMap() const { - return *_matching; - } - - /// \brief Return \c true if the given edge is in the matching. - /// - /// This function returns \c true if the given edge is in the - /// found matching. The result is scaled by \ref primalScale - /// "primal scale". - /// - /// \pre Either run() or start() must be called before using this function. - int matching(const Edge& edge) const { - return (edge == (*_matching)[_graph.u(edge)] ? 1 : 0) + - (edge == (*_matching)[_graph.v(edge)] ? 1 : 0); - } - - /// \brief Return the fractional matching arc (or edge) incident - /// to the given node. - /// - /// This function returns one of the fractional matching arc (or - /// edge) incident to the given node in the found matching or \c - /// INVALID if the node is not covered by the matching or if the - /// node is on an odd length cycle then it is the successor edge - /// on the cycle. - /// - /// \pre Either run() or start() must be called before using this function. - Arc matching(const Node& node) const { - return (*_matching)[node]; - } - - /// \brief Returns true if the node is in the barrier - /// - /// The barrier is a subset of the nodes. If the nodes in the - /// barrier have less adjacent nodes than the size of the barrier, - /// then at least as much nodes cannot be covered as the - /// difference of the two subsets. - bool barrier(const Node& node) const { - return (*_level)[node] >= _empty_level; - } - - /// @} - - }; - - /// \ingroup matching - /// - /// \brief Weighted fractional matching in general graphs - /// - /// This class provides an efficient implementation of fractional - /// matching algorithm. The implementation uses priority queues and - /// provides \f$O(nm\log n)\f$ time complexity. - /// - /// The maximum weighted fractional matching is a relaxation of the - /// maximum weighted matching problem where the odd set constraints - /// are omitted. - /// It can be formulated with the following linear program. - /// \f[ \sum_{e \in \delta(u)}x_e \le 1 \quad \forall u\in V\f] - /// \f[x_e \ge 0\quad \forall e\in E\f] - /// \f[\max \sum_{e\in E}x_ew_e\f] - /// where \f$\delta(X)\f$ is the set of edges incident to a node in - /// \f$X\f$. The result must be the union of a matching with one - /// value edges and a set of odd length cycles with half value edges. - /// - /// The algorithm calculates an optimal fractional matching and a - /// proof of the optimality. The solution of the dual problem can be - /// used to check the result of the algorithm. The dual linear - /// problem is the following. - /// \f[ y_u + y_v \ge w_{uv} \quad \forall uv\in E\f] - /// \f[y_u \ge 0 \quad \forall u \in V\f] - /// \f[\min \sum_{u \in V}y_u \f] - /// - /// The algorithm can be executed with the run() function. - /// After it the matching (the primal solution) and the dual solution - /// can be obtained using the query functions. - /// - /// The primal solution is multiplied by - /// \ref MaxWeightedFractionalMatching::primalScale "2". - /// If the value type is integer, then the dual - /// solution is scaled by - /// \ref MaxWeightedFractionalMatching::dualScale "4". - /// - /// \tparam GR The undirected graph type the algorithm runs on. - /// \tparam WM The type edge weight map. The default type is - /// \ref concepts::Graph::EdgeMap "GR::EdgeMap". -#ifdef DOXYGEN - template -#else - template > -#endif - class MaxWeightedFractionalMatching { - public: - - /// The graph type of the algorithm - typedef GR Graph; - /// The type of the edge weight map - typedef WM WeightMap; - /// The value type of the edge weights - typedef typename WeightMap::Value Value; - - /// The type of the matching map - typedef typename Graph::template NodeMap - MatchingMap; - - /// \brief Scaling factor for primal solution - /// - /// Scaling factor for primal solution. - static const int primalScale = 2; - - /// \brief Scaling factor for dual solution - /// - /// Scaling factor for dual solution. It is equal to 4 or 1 - /// according to the value type. - static const int dualScale = - std::numeric_limits::is_integer ? 4 : 1; - - private: - - TEMPLATE_GRAPH_TYPEDEFS(Graph); - - typedef typename Graph::template NodeMap NodePotential; - - const Graph& _graph; - const WeightMap& _weight; - - MatchingMap* _matching; - NodePotential* _node_potential; - - int _node_num; - bool _allow_loops; - - enum Status { - EVEN = -1, MATCHED = 0, ODD = 1 - }; - - typedef typename Graph::template NodeMap StatusMap; - StatusMap* _status; - - typedef typename Graph::template NodeMap PredMap; - PredMap* _pred; - - typedef ExtendFindEnum TreeSet; - - IntNodeMap *_tree_set_index; - TreeSet *_tree_set; - - IntNodeMap *_delta1_index; - BinHeap *_delta1; - - IntNodeMap *_delta2_index; - BinHeap *_delta2; - - IntEdgeMap *_delta3_index; - BinHeap *_delta3; - - Value _delta_sum; - - void createStructures() { - _node_num = countNodes(_graph); - - if (!_matching) { - _matching = new MatchingMap(_graph); - } - if (!_node_potential) { - _node_potential = new NodePotential(_graph); - } - if (!_status) { - _status = new StatusMap(_graph); - } - if (!_pred) { - _pred = new PredMap(_graph); - } - if (!_tree_set) { - _tree_set_index = new IntNodeMap(_graph); - _tree_set = new TreeSet(*_tree_set_index); - } - if (!_delta1) { - _delta1_index = new IntNodeMap(_graph); - _delta1 = new BinHeap(*_delta1_index); - } - if (!_delta2) { - _delta2_index = new IntNodeMap(_graph); - _delta2 = new BinHeap(*_delta2_index); - } - if (!_delta3) { - _delta3_index = new IntEdgeMap(_graph); - _delta3 = new BinHeap(*_delta3_index); - } - } - - void destroyStructures() { - if (_matching) { - delete _matching; - } - if (_node_potential) { - delete _node_potential; - } - if (_status) { - delete _status; - } - if (_pred) { - delete _pred; - } - if (_tree_set) { - delete _tree_set_index; - delete _tree_set; - } - if (_delta1) { - delete _delta1_index; - delete _delta1; - } - if (_delta2) { - delete _delta2_index; - delete _delta2; - } - if (_delta3) { - delete _delta3_index; - delete _delta3; - } - } - - void matchedToEven(Node node, int tree) { - _tree_set->insert(node, tree); - _node_potential->set(node, (*_node_potential)[node] + _delta_sum); - _delta1->push(node, (*_node_potential)[node]); - - if (_delta2->state(node) == _delta2->IN_HEAP) { - _delta2->erase(node); - } - - for (InArcIt a(_graph, node); a != INVALID; ++a) { - Node v = _graph.source(a); - Value rw = (*_node_potential)[node] + (*_node_potential)[v] - - dualScale * _weight[a]; - if (node == v) { - if (_allow_loops && _graph.direction(a)) { - _delta3->push(a, rw / 2); - } - } else if ((*_status)[v] == EVEN) { - _delta3->push(a, rw / 2); - } else if ((*_status)[v] == MATCHED) { - if (_delta2->state(v) != _delta2->IN_HEAP) { - _pred->set(v, a); - _delta2->push(v, rw); - } else if ((*_delta2)[v] > rw) { - _pred->set(v, a); - _delta2->decrease(v, rw); - } - } - } - } - - void matchedToOdd(Node node, int tree) { - _tree_set->insert(node, tree); - _node_potential->set(node, (*_node_potential)[node] - _delta_sum); - - if (_delta2->state(node) == _delta2->IN_HEAP) { - _delta2->erase(node); - } - } - - void evenToMatched(Node node, int tree) { - _delta1->erase(node); - _node_potential->set(node, (*_node_potential)[node] - _delta_sum); - Arc min = INVALID; - Value minrw = std::numeric_limits::max(); - for (InArcIt a(_graph, node); a != INVALID; ++a) { - Node v = _graph.source(a); - Value rw = (*_node_potential)[node] + (*_node_potential)[v] - - dualScale * _weight[a]; - - if (node == v) { - if (_allow_loops && _graph.direction(a)) { - _delta3->erase(a); - } - } else if ((*_status)[v] == EVEN) { - _delta3->erase(a); - if (minrw > rw) { - min = _graph.oppositeArc(a); - minrw = rw; - } - } else if ((*_status)[v] == MATCHED) { - if ((*_pred)[v] == a) { - Arc mina = INVALID; - Value minrwa = std::numeric_limits::max(); - for (OutArcIt aa(_graph, v); aa != INVALID; ++aa) { - Node va = _graph.target(aa); - if ((*_status)[va] != EVEN || - _tree_set->find(va) == tree) continue; - Value rwa = (*_node_potential)[v] + (*_node_potential)[va] - - dualScale * _weight[aa]; - if (minrwa > rwa) { - minrwa = rwa; - mina = aa; - } - } - if (mina != INVALID) { - _pred->set(v, mina); - _delta2->increase(v, minrwa); - } else { - _pred->set(v, INVALID); - _delta2->erase(v); - } - } - } - } - if (min != INVALID) { - _pred->set(node, min); - _delta2->push(node, minrw); - } else { - _pred->set(node, INVALID); - } - } - - void oddToMatched(Node node) { - _node_potential->set(node, (*_node_potential)[node] + _delta_sum); - Arc min = INVALID; - Value minrw = std::numeric_limits::max(); - for (InArcIt a(_graph, node); a != INVALID; ++a) { - Node v = _graph.source(a); - if ((*_status)[v] != EVEN) continue; - Value rw = (*_node_potential)[node] + (*_node_potential)[v] - - dualScale * _weight[a]; - - if (minrw > rw) { - min = _graph.oppositeArc(a); - minrw = rw; - } - } - if (min != INVALID) { - _pred->set(node, min); - _delta2->push(node, minrw); - } else { - _pred->set(node, INVALID); - } - } - - void alternatePath(Node even, int tree) { - Node odd; - - _status->set(even, MATCHED); - evenToMatched(even, tree); - - Arc prev = (*_matching)[even]; - while (prev != INVALID) { - odd = _graph.target(prev); - even = _graph.target((*_pred)[odd]); - _matching->set(odd, (*_pred)[odd]); - _status->set(odd, MATCHED); - oddToMatched(odd); - - prev = (*_matching)[even]; - _status->set(even, MATCHED); - _matching->set(even, _graph.oppositeArc((*_matching)[odd])); - evenToMatched(even, tree); - } - } - - void destroyTree(int tree) { - for (typename TreeSet::ItemIt n(*_tree_set, tree); n != INVALID; ++n) { - if ((*_status)[n] == EVEN) { - _status->set(n, MATCHED); - evenToMatched(n, tree); - } else if ((*_status)[n] == ODD) { - _status->set(n, MATCHED); - oddToMatched(n); - } - } - _tree_set->eraseClass(tree); - } - - - void unmatchNode(const Node& node) { - int tree = _tree_set->find(node); - - alternatePath(node, tree); - destroyTree(tree); - - _matching->set(node, INVALID); - } - - - void augmentOnEdge(const Edge& edge) { - Node left = _graph.u(edge); - int left_tree = _tree_set->find(left); - - alternatePath(left, left_tree); - destroyTree(left_tree); - _matching->set(left, _graph.direct(edge, true)); - - Node right = _graph.v(edge); - int right_tree = _tree_set->find(right); - - alternatePath(right, right_tree); - destroyTree(right_tree); - _matching->set(right, _graph.direct(edge, false)); - } - - void augmentOnArc(const Arc& arc) { - Node left = _graph.source(arc); - _status->set(left, MATCHED); - _matching->set(left, arc); - _pred->set(left, arc); - - Node right = _graph.target(arc); - int right_tree = _tree_set->find(right); - - alternatePath(right, right_tree); - destroyTree(right_tree); - _matching->set(right, _graph.oppositeArc(arc)); - } - - void extendOnArc(const Arc& arc) { - Node base = _graph.target(arc); - int tree = _tree_set->find(base); - - Node odd = _graph.source(arc); - _tree_set->insert(odd, tree); - _status->set(odd, ODD); - matchedToOdd(odd, tree); - _pred->set(odd, arc); - - Node even = _graph.target((*_matching)[odd]); - _tree_set->insert(even, tree); - _status->set(even, EVEN); - matchedToEven(even, tree); - } - - void cycleOnEdge(const Edge& edge, int tree) { - Node nca = INVALID; - std::vector left_path, right_path; - - { - std::set left_set, right_set; - Node left = _graph.u(edge); - left_path.push_back(left); - left_set.insert(left); - - Node right = _graph.v(edge); - right_path.push_back(right); - right_set.insert(right); - - while (true) { - - if (left_set.find(right) != left_set.end()) { - nca = right; - break; - } - - if ((*_matching)[left] == INVALID) break; - - left = _graph.target((*_matching)[left]); - left_path.push_back(left); - left = _graph.target((*_pred)[left]); - left_path.push_back(left); - - left_set.insert(left); - - if (right_set.find(left) != right_set.end()) { - nca = left; - break; - } - - if ((*_matching)[right] == INVALID) break; - - right = _graph.target((*_matching)[right]); - right_path.push_back(right); - right = _graph.target((*_pred)[right]); - right_path.push_back(right); - - right_set.insert(right); - - } - - if (nca == INVALID) { - if ((*_matching)[left] == INVALID) { - nca = right; - while (left_set.find(nca) == left_set.end()) { - nca = _graph.target((*_matching)[nca]); - right_path.push_back(nca); - nca = _graph.target((*_pred)[nca]); - right_path.push_back(nca); - } - } else { - nca = left; - while (right_set.find(nca) == right_set.end()) { - nca = _graph.target((*_matching)[nca]); - left_path.push_back(nca); - nca = _graph.target((*_pred)[nca]); - left_path.push_back(nca); - } - } - } - } - - alternatePath(nca, tree); - Arc prev; - - prev = _graph.direct(edge, true); - for (int i = 0; left_path[i] != nca; i += 2) { - _matching->set(left_path[i], prev); - _status->set(left_path[i], MATCHED); - evenToMatched(left_path[i], tree); - - prev = _graph.oppositeArc((*_pred)[left_path[i + 1]]); - _status->set(left_path[i + 1], MATCHED); - oddToMatched(left_path[i + 1]); - } - _matching->set(nca, prev); - - for (int i = 0; right_path[i] != nca; i += 2) { - _status->set(right_path[i], MATCHED); - evenToMatched(right_path[i], tree); - - _matching->set(right_path[i + 1], (*_pred)[right_path[i + 1]]); - _status->set(right_path[i + 1], MATCHED); - oddToMatched(right_path[i + 1]); - } - - destroyTree(tree); - } - - void extractCycle(const Arc &arc) { - Node left = _graph.source(arc); - Node odd = _graph.target((*_matching)[left]); - Arc prev; - while (odd != left) { - Node even = _graph.target((*_matching)[odd]); - prev = (*_matching)[odd]; - odd = _graph.target((*_matching)[even]); - _matching->set(even, _graph.oppositeArc(prev)); - } - _matching->set(left, arc); - - Node right = _graph.target(arc); - int right_tree = _tree_set->find(right); - alternatePath(right, right_tree); - destroyTree(right_tree); - _matching->set(right, _graph.oppositeArc(arc)); - } - - public: - - /// \brief Constructor - /// - /// Constructor. - MaxWeightedFractionalMatching(const Graph& graph, const WeightMap& weight, - bool allow_loops = true) - : _graph(graph), _weight(weight), _matching(0), - _node_potential(0), _node_num(0), _allow_loops(allow_loops), - _status(0), _pred(0), - _tree_set_index(0), _tree_set(0), - - _delta1_index(0), _delta1(0), - _delta2_index(0), _delta2(0), - _delta3_index(0), _delta3(0), - - _delta_sum() {} - - ~MaxWeightedFractionalMatching() { - destroyStructures(); - } - - /// \name Execution Control - /// The simplest way to execute the algorithm is to use the - /// \ref run() member function. - - ///@{ - - /// \brief Initialize the algorithm - /// - /// This function initializes the algorithm. - void init() { - createStructures(); - - for (NodeIt n(_graph); n != INVALID; ++n) { - (*_delta1_index)[n] = _delta1->PRE_HEAP; - (*_delta2_index)[n] = _delta2->PRE_HEAP; - } - for (EdgeIt e(_graph); e != INVALID; ++e) { - (*_delta3_index)[e] = _delta3->PRE_HEAP; - } - - _delta1->clear(); - _delta2->clear(); - _delta3->clear(); - _tree_set->clear(); - - for (NodeIt n(_graph); n != INVALID; ++n) { - Value max = 0; - for (OutArcIt e(_graph, n); e != INVALID; ++e) { - if (_graph.target(e) == n && !_allow_loops) continue; - if ((dualScale * _weight[e]) / 2 > max) { - max = (dualScale * _weight[e]) / 2; - } - } - _node_potential->set(n, max); - _delta1->push(n, max); - - _tree_set->insert(n); - - _matching->set(n, INVALID); - _status->set(n, EVEN); - } - - for (EdgeIt e(_graph); e != INVALID; ++e) { - Node left = _graph.u(e); - Node right = _graph.v(e); - if (left == right && !_allow_loops) continue; - _delta3->push(e, ((*_node_potential)[left] + - (*_node_potential)[right] - - dualScale * _weight[e]) / 2); - } - } - - /// \brief Start the algorithm - /// - /// This function starts the algorithm. - /// - /// \pre \ref init() must be called before using this function. - void start() { - enum OpType { - D1, D2, D3 - }; - - int unmatched = _node_num; - while (unmatched > 0) { - Value d1 = !_delta1->empty() ? - _delta1->prio() : std::numeric_limits::max(); - - Value d2 = !_delta2->empty() ? - _delta2->prio() : std::numeric_limits::max(); - - Value d3 = !_delta3->empty() ? - _delta3->prio() : std::numeric_limits::max(); - - _delta_sum = d3; OpType ot = D3; - if (d1 < _delta_sum) { _delta_sum = d1; ot = D1; } - if (d2 < _delta_sum) { _delta_sum = d2; ot = D2; } - - switch (ot) { - case D1: - { - Node n = _delta1->top(); - unmatchNode(n); - --unmatched; - } - break; - case D2: - { - Node n = _delta2->top(); - Arc a = (*_pred)[n]; - if ((*_matching)[n] == INVALID) { - augmentOnArc(a); - --unmatched; - } else { - Node v = _graph.target((*_matching)[n]); - if ((*_matching)[n] != - _graph.oppositeArc((*_matching)[v])) { - extractCycle(a); - --unmatched; - } else { - extendOnArc(a); - } - } - } break; - case D3: - { - Edge e = _delta3->top(); - - Node left = _graph.u(e); - Node right = _graph.v(e); - - int left_tree = _tree_set->find(left); - int right_tree = _tree_set->find(right); - - if (left_tree == right_tree) { - cycleOnEdge(e, left_tree); - --unmatched; - } else { - augmentOnEdge(e); - unmatched -= 2; - } - } break; - } - } - } - - /// \brief Run the algorithm. - /// - /// This method runs the \c %MaxWeightedFractionalMatching algorithm. - /// - /// \note mwfm.run() is just a shortcut of the following code. - /// \code - /// mwfm.init(); - /// mwfm.start(); - /// \endcode - void run() { - init(); - start(); - } - - /// @} - - /// \name Primal Solution - /// Functions to get the primal solution, i.e. the maximum weighted - /// matching.\n - /// Either \ref run() or \ref start() function should be called before - /// using them. - - /// @{ - - /// \brief Return the weight of the matching. - /// - /// This function returns the weight of the found matching. This - /// value is scaled by \ref primalScale "primal scale". - /// - /// \pre Either run() or start() must be called before using this function. - Value matchingWeight() const { - Value sum = 0; - for (NodeIt n(_graph); n != INVALID; ++n) { - if ((*_matching)[n] != INVALID) { - sum += _weight[(*_matching)[n]]; - } - } - return sum * primalScale / 2; - } - - /// \brief Return the number of covered nodes in the matching. - /// - /// This function returns the number of covered nodes in the matching. - /// - /// \pre Either run() or start() must be called before using this function. - int matchingSize() const { - int num = 0; - for (NodeIt n(_graph); n != INVALID; ++n) { - if ((*_matching)[n] != INVALID) { - ++num; - } - } - return num; - } - - /// \brief Return \c true if the given edge is in the matching. - /// - /// This function returns \c true if the given edge is in the - /// found matching. The result is scaled by \ref primalScale - /// "primal scale". - /// - /// \pre Either run() or start() must be called before using this function. - int matching(const Edge& edge) const { - return (edge == (*_matching)[_graph.u(edge)] ? 1 : 0) - + (edge == (*_matching)[_graph.v(edge)] ? 1 : 0); - } - - /// \brief Return the fractional matching arc (or edge) incident - /// to the given node. - /// - /// This function returns one of the fractional matching arc (or - /// edge) incident to the given node in the found matching or \c - /// INVALID if the node is not covered by the matching or if the - /// node is on an odd length cycle then it is the successor edge - /// on the cycle. - /// - /// \pre Either run() or start() must be called before using this function. - Arc matching(const Node& node) const { - return (*_matching)[node]; - } - - /// \brief Return a const reference to the matching map. - /// - /// This function returns a const reference to a node map that stores - /// the matching arc (or edge) incident to each node. - const MatchingMap& matchingMap() const { - return *_matching; - } - - /// @} - - /// \name Dual Solution - /// Functions to get the dual solution.\n - /// Either \ref run() or \ref start() function should be called before - /// using them. - - /// @{ - - /// \brief Return the value of the dual solution. - /// - /// This function returns the value of the dual solution. - /// It should be equal to the primal value scaled by \ref dualScale - /// "dual scale". - /// - /// \pre Either run() or start() must be called before using this function. - Value dualValue() const { - Value sum = 0; - for (NodeIt n(_graph); n != INVALID; ++n) { - sum += nodeValue(n); - } - return sum; - } - - /// \brief Return the dual value (potential) of the given node. - /// - /// This function returns the dual value (potential) of the given node. - /// - /// \pre Either run() or start() must be called before using this function. - Value nodeValue(const Node& n) const { - return (*_node_potential)[n]; - } - - /// @} - - }; - - /// \ingroup matching - /// - /// \brief Weighted fractional perfect matching in general graphs - /// - /// This class provides an efficient implementation of fractional - /// matching algorithm. The implementation uses priority queues and - /// provides \f$O(nm\log n)\f$ time complexity. - /// - /// The maximum weighted fractional perfect matching is a relaxation - /// of the maximum weighted perfect matching problem where the odd - /// set constraints are omitted. - /// It can be formulated with the following linear program. - /// \f[ \sum_{e \in \delta(u)}x_e = 1 \quad \forall u\in V\f] - /// \f[x_e \ge 0\quad \forall e\in E\f] - /// \f[\max \sum_{e\in E}x_ew_e\f] - /// where \f$\delta(X)\f$ is the set of edges incident to a node in - /// \f$X\f$. The result must be the union of a matching with one - /// value edges and a set of odd length cycles with half value edges. - /// - /// The algorithm calculates an optimal fractional matching and a - /// proof of the optimality. The solution of the dual problem can be - /// used to check the result of the algorithm. The dual linear - /// problem is the following. - /// \f[ y_u + y_v \ge w_{uv} \quad \forall uv\in E\f] - /// \f[\min \sum_{u \in V}y_u \f] - /// - /// The algorithm can be executed with the run() function. - /// After it the matching (the primal solution) and the dual solution - /// can be obtained using the query functions. - /// - /// The primal solution is multiplied by - /// \ref MaxWeightedPerfectFractionalMatching::primalScale "2". - /// If the value type is integer, then the dual - /// solution is scaled by - /// \ref MaxWeightedPerfectFractionalMatching::dualScale "4". - /// - /// \tparam GR The undirected graph type the algorithm runs on. - /// \tparam WM The type edge weight map. The default type is - /// \ref concepts::Graph::EdgeMap "GR::EdgeMap". -#ifdef DOXYGEN - template -#else - template > -#endif - class MaxWeightedPerfectFractionalMatching { - public: - - /// The graph type of the algorithm - typedef GR Graph; - /// The type of the edge weight map - typedef WM WeightMap; - /// The value type of the edge weights - typedef typename WeightMap::Value Value; - - /// The type of the matching map - typedef typename Graph::template NodeMap - MatchingMap; - - /// \brief Scaling factor for primal solution - /// - /// Scaling factor for primal solution. - static const int primalScale = 2; - - /// \brief Scaling factor for dual solution - /// - /// Scaling factor for dual solution. It is equal to 4 or 1 - /// according to the value type. - static const int dualScale = - std::numeric_limits::is_integer ? 4 : 1; - - private: - - TEMPLATE_GRAPH_TYPEDEFS(Graph); - - typedef typename Graph::template NodeMap NodePotential; - - const Graph& _graph; - const WeightMap& _weight; - - MatchingMap* _matching; - NodePotential* _node_potential; - - int _node_num; - bool _allow_loops; - - enum Status { - EVEN = -1, MATCHED = 0, ODD = 1 - }; - - typedef typename Graph::template NodeMap StatusMap; - StatusMap* _status; - - typedef typename Graph::template NodeMap PredMap; - PredMap* _pred; - - typedef ExtendFindEnum TreeSet; - - IntNodeMap *_tree_set_index; - TreeSet *_tree_set; - - IntNodeMap *_delta2_index; - BinHeap *_delta2; - - IntEdgeMap *_delta3_index; - BinHeap *_delta3; - - Value _delta_sum; - - void createStructures() { - _node_num = countNodes(_graph); - - if (!_matching) { - _matching = new MatchingMap(_graph); - } - if (!_node_potential) { - _node_potential = new NodePotential(_graph); - } - if (!_status) { - _status = new StatusMap(_graph); - } - if (!_pred) { - _pred = new PredMap(_graph); - } - if (!_tree_set) { - _tree_set_index = new IntNodeMap(_graph); - _tree_set = new TreeSet(*_tree_set_index); - } - if (!_delta2) { - _delta2_index = new IntNodeMap(_graph); - _delta2 = new BinHeap(*_delta2_index); - } - if (!_delta3) { - _delta3_index = new IntEdgeMap(_graph); - _delta3 = new BinHeap(*_delta3_index); - } - } - - void destroyStructures() { - if (_matching) { - delete _matching; - } - if (_node_potential) { - delete _node_potential; - } - if (_status) { - delete _status; - } - if (_pred) { - delete _pred; - } - if (_tree_set) { - delete _tree_set_index; - delete _tree_set; - } - if (_delta2) { - delete _delta2_index; - delete _delta2; - } - if (_delta3) { - delete _delta3_index; - delete _delta3; - } - } - - void matchedToEven(Node node, int tree) { - _tree_set->insert(node, tree); - _node_potential->set(node, (*_node_potential)[node] + _delta_sum); - - if (_delta2->state(node) == _delta2->IN_HEAP) { - _delta2->erase(node); - } - - for (InArcIt a(_graph, node); a != INVALID; ++a) { - Node v = _graph.source(a); - Value rw = (*_node_potential)[node] + (*_node_potential)[v] - - dualScale * _weight[a]; - if (node == v) { - if (_allow_loops && _graph.direction(a)) { - _delta3->push(a, rw / 2); - } - } else if ((*_status)[v] == EVEN) { - _delta3->push(a, rw / 2); - } else if ((*_status)[v] == MATCHED) { - if (_delta2->state(v) != _delta2->IN_HEAP) { - _pred->set(v, a); - _delta2->push(v, rw); - } else if ((*_delta2)[v] > rw) { - _pred->set(v, a); - _delta2->decrease(v, rw); - } - } - } - } - - void matchedToOdd(Node node, int tree) { - _tree_set->insert(node, tree); - _node_potential->set(node, (*_node_potential)[node] - _delta_sum); - - if (_delta2->state(node) == _delta2->IN_HEAP) { - _delta2->erase(node); - } - } - - void evenToMatched(Node node, int tree) { - _node_potential->set(node, (*_node_potential)[node] - _delta_sum); - Arc min = INVALID; - Value minrw = std::numeric_limits::max(); - for (InArcIt a(_graph, node); a != INVALID; ++a) { - Node v = _graph.source(a); - Value rw = (*_node_potential)[node] + (*_node_potential)[v] - - dualScale * _weight[a]; - - if (node == v) { - if (_allow_loops && _graph.direction(a)) { - _delta3->erase(a); - } - } else if ((*_status)[v] == EVEN) { - _delta3->erase(a); - if (minrw > rw) { - min = _graph.oppositeArc(a); - minrw = rw; - } - } else if ((*_status)[v] == MATCHED) { - if ((*_pred)[v] == a) { - Arc mina = INVALID; - Value minrwa = std::numeric_limits::max(); - for (OutArcIt aa(_graph, v); aa != INVALID; ++aa) { - Node va = _graph.target(aa); - if ((*_status)[va] != EVEN || - _tree_set->find(va) == tree) continue; - Value rwa = (*_node_potential)[v] + (*_node_potential)[va] - - dualScale * _weight[aa]; - if (minrwa > rwa) { - minrwa = rwa; - mina = aa; - } - } - if (mina != INVALID) { - _pred->set(v, mina); - _delta2->increase(v, minrwa); - } else { - _pred->set(v, INVALID); - _delta2->erase(v); - } - } - } - } - if (min != INVALID) { - _pred->set(node, min); - _delta2->push(node, minrw); - } else { - _pred->set(node, INVALID); - } - } - - void oddToMatched(Node node) { - _node_potential->set(node, (*_node_potential)[node] + _delta_sum); - Arc min = INVALID; - Value minrw = std::numeric_limits::max(); - for (InArcIt a(_graph, node); a != INVALID; ++a) { - Node v = _graph.source(a); - if ((*_status)[v] != EVEN) continue; - Value rw = (*_node_potential)[node] + (*_node_potential)[v] - - dualScale * _weight[a]; - - if (minrw > rw) { - min = _graph.oppositeArc(a); - minrw = rw; - } - } - if (min != INVALID) { - _pred->set(node, min); - _delta2->push(node, minrw); - } else { - _pred->set(node, INVALID); - } - } - - void alternatePath(Node even, int tree) { - Node odd; - - _status->set(even, MATCHED); - evenToMatched(even, tree); - - Arc prev = (*_matching)[even]; - while (prev != INVALID) { - odd = _graph.target(prev); - even = _graph.target((*_pred)[odd]); - _matching->set(odd, (*_pred)[odd]); - _status->set(odd, MATCHED); - oddToMatched(odd); - - prev = (*_matching)[even]; - _status->set(even, MATCHED); - _matching->set(even, _graph.oppositeArc((*_matching)[odd])); - evenToMatched(even, tree); - } - } - - void destroyTree(int tree) { - for (typename TreeSet::ItemIt n(*_tree_set, tree); n != INVALID; ++n) { - if ((*_status)[n] == EVEN) { - _status->set(n, MATCHED); - evenToMatched(n, tree); - } else if ((*_status)[n] == ODD) { - _status->set(n, MATCHED); - oddToMatched(n); - } - } - _tree_set->eraseClass(tree); - } - - void augmentOnEdge(const Edge& edge) { - Node left = _graph.u(edge); - int left_tree = _tree_set->find(left); - - alternatePath(left, left_tree); - destroyTree(left_tree); - _matching->set(left, _graph.direct(edge, true)); - - Node right = _graph.v(edge); - int right_tree = _tree_set->find(right); - - alternatePath(right, right_tree); - destroyTree(right_tree); - _matching->set(right, _graph.direct(edge, false)); - } - - void augmentOnArc(const Arc& arc) { - Node left = _graph.source(arc); - _status->set(left, MATCHED); - _matching->set(left, arc); - _pred->set(left, arc); - - Node right = _graph.target(arc); - int right_tree = _tree_set->find(right); - - alternatePath(right, right_tree); - destroyTree(right_tree); - _matching->set(right, _graph.oppositeArc(arc)); - } - - void extendOnArc(const Arc& arc) { - Node base = _graph.target(arc); - int tree = _tree_set->find(base); - - Node odd = _graph.source(arc); - _tree_set->insert(odd, tree); - _status->set(odd, ODD); - matchedToOdd(odd, tree); - _pred->set(odd, arc); - - Node even = _graph.target((*_matching)[odd]); - _tree_set->insert(even, tree); - _status->set(even, EVEN); - matchedToEven(even, tree); - } - - void cycleOnEdge(const Edge& edge, int tree) { - Node nca = INVALID; - std::vector left_path, right_path; - - { - std::set left_set, right_set; - Node left = _graph.u(edge); - left_path.push_back(left); - left_set.insert(left); - - Node right = _graph.v(edge); - right_path.push_back(right); - right_set.insert(right); - - while (true) { - - if (left_set.find(right) != left_set.end()) { - nca = right; - break; - } - - if ((*_matching)[left] == INVALID) break; - - left = _graph.target((*_matching)[left]); - left_path.push_back(left); - left = _graph.target((*_pred)[left]); - left_path.push_back(left); - - left_set.insert(left); - - if (right_set.find(left) != right_set.end()) { - nca = left; - break; - } - - if ((*_matching)[right] == INVALID) break; - - right = _graph.target((*_matching)[right]); - right_path.push_back(right); - right = _graph.target((*_pred)[right]); - right_path.push_back(right); - - right_set.insert(right); - - } - - if (nca == INVALID) { - if ((*_matching)[left] == INVALID) { - nca = right; - while (left_set.find(nca) == left_set.end()) { - nca = _graph.target((*_matching)[nca]); - right_path.push_back(nca); - nca = _graph.target((*_pred)[nca]); - right_path.push_back(nca); - } - } else { - nca = left; - while (right_set.find(nca) == right_set.end()) { - nca = _graph.target((*_matching)[nca]); - left_path.push_back(nca); - nca = _graph.target((*_pred)[nca]); - left_path.push_back(nca); - } - } - } - } - - alternatePath(nca, tree); - Arc prev; - - prev = _graph.direct(edge, true); - for (int i = 0; left_path[i] != nca; i += 2) { - _matching->set(left_path[i], prev); - _status->set(left_path[i], MATCHED); - evenToMatched(left_path[i], tree); - - prev = _graph.oppositeArc((*_pred)[left_path[i + 1]]); - _status->set(left_path[i + 1], MATCHED); - oddToMatched(left_path[i + 1]); - } - _matching->set(nca, prev); - - for (int i = 0; right_path[i] != nca; i += 2) { - _status->set(right_path[i], MATCHED); - evenToMatched(right_path[i], tree); - - _matching->set(right_path[i + 1], (*_pred)[right_path[i + 1]]); - _status->set(right_path[i + 1], MATCHED); - oddToMatched(right_path[i + 1]); - } - - destroyTree(tree); - } - - void extractCycle(const Arc &arc) { - Node left = _graph.source(arc); - Node odd = _graph.target((*_matching)[left]); - Arc prev; - while (odd != left) { - Node even = _graph.target((*_matching)[odd]); - prev = (*_matching)[odd]; - odd = _graph.target((*_matching)[even]); - _matching->set(even, _graph.oppositeArc(prev)); - } - _matching->set(left, arc); - - Node right = _graph.target(arc); - int right_tree = _tree_set->find(right); - alternatePath(right, right_tree); - destroyTree(right_tree); - _matching->set(right, _graph.oppositeArc(arc)); - } - - public: - - /// \brief Constructor - /// - /// Constructor. - MaxWeightedPerfectFractionalMatching(const Graph& graph, - const WeightMap& weight, - bool allow_loops = true) - : _graph(graph), _weight(weight), _matching(0), - _node_potential(0), _node_num(0), _allow_loops(allow_loops), - _status(0), _pred(0), - _tree_set_index(0), _tree_set(0), - - _delta2_index(0), _delta2(0), - _delta3_index(0), _delta3(0), - - _delta_sum() {} - - ~MaxWeightedPerfectFractionalMatching() { - destroyStructures(); - } - - /// \name Execution Control - /// The simplest way to execute the algorithm is to use the - /// \ref run() member function. - - ///@{ - - /// \brief Initialize the algorithm - /// - /// This function initializes the algorithm. - void init() { - createStructures(); - - for (NodeIt n(_graph); n != INVALID; ++n) { - (*_delta2_index)[n] = _delta2->PRE_HEAP; - } - for (EdgeIt e(_graph); e != INVALID; ++e) { - (*_delta3_index)[e] = _delta3->PRE_HEAP; - } - - _delta2->clear(); - _delta3->clear(); - _tree_set->clear(); - - for (NodeIt n(_graph); n != INVALID; ++n) { - Value max = - std::numeric_limits::max(); - for (OutArcIt e(_graph, n); e != INVALID; ++e) { - if (_graph.target(e) == n && !_allow_loops) continue; - if ((dualScale * _weight[e]) / 2 > max) { - max = (dualScale * _weight[e]) / 2; - } - } - _node_potential->set(n, max); - - _tree_set->insert(n); - - _matching->set(n, INVALID); - _status->set(n, EVEN); - } - - for (EdgeIt e(_graph); e != INVALID; ++e) { - Node left = _graph.u(e); - Node right = _graph.v(e); - if (left == right && !_allow_loops) continue; - _delta3->push(e, ((*_node_potential)[left] + - (*_node_potential)[right] - - dualScale * _weight[e]) / 2); - } - } - - /// \brief Start the algorithm - /// - /// This function starts the algorithm. - /// - /// \pre \ref init() must be called before using this function. - bool start() { - enum OpType { - D2, D3 - }; - - int unmatched = _node_num; - while (unmatched > 0) { - Value d2 = !_delta2->empty() ? - _delta2->prio() : std::numeric_limits::max(); - - Value d3 = !_delta3->empty() ? - _delta3->prio() : std::numeric_limits::max(); - - _delta_sum = d3; OpType ot = D3; - if (d2 < _delta_sum) { _delta_sum = d2; ot = D2; } - - if (_delta_sum == std::numeric_limits::max()) { - return false; - } - - switch (ot) { - case D2: - { - Node n = _delta2->top(); - Arc a = (*_pred)[n]; - if ((*_matching)[n] == INVALID) { - augmentOnArc(a); - --unmatched; - } else { - Node v = _graph.target((*_matching)[n]); - if ((*_matching)[n] != - _graph.oppositeArc((*_matching)[v])) { - extractCycle(a); - --unmatched; - } else { - extendOnArc(a); - } - } - } break; - case D3: - { - Edge e = _delta3->top(); - - Node left = _graph.u(e); - Node right = _graph.v(e); - - int left_tree = _tree_set->find(left); - int right_tree = _tree_set->find(right); - - if (left_tree == right_tree) { - cycleOnEdge(e, left_tree); - --unmatched; - } else { - augmentOnEdge(e); - unmatched -= 2; - } - } break; - } - } - return true; - } - - /// \brief Run the algorithm. - /// - /// This method runs the \c %MaxWeightedPerfectFractionalMatching - /// algorithm. - /// - /// \note mwfm.run() is just a shortcut of the following code. - /// \code - /// mwpfm.init(); - /// mwpfm.start(); - /// \endcode - bool run() { - init(); - return start(); - } - - /// @} - - /// \name Primal Solution - /// Functions to get the primal solution, i.e. the maximum weighted - /// matching.\n - /// Either \ref run() or \ref start() function should be called before - /// using them. - - /// @{ - - /// \brief Return the weight of the matching. - /// - /// This function returns the weight of the found matching. This - /// value is scaled by \ref primalScale "primal scale". - /// - /// \pre Either run() or start() must be called before using this function. - Value matchingWeight() const { - Value sum = 0; - for (NodeIt n(_graph); n != INVALID; ++n) { - if ((*_matching)[n] != INVALID) { - sum += _weight[(*_matching)[n]]; - } - } - return sum * primalScale / 2; - } - - /// \brief Return the number of covered nodes in the matching. - /// - /// This function returns the number of covered nodes in the matching. - /// - /// \pre Either run() or start() must be called before using this function. - int matchingSize() const { - int num = 0; - for (NodeIt n(_graph); n != INVALID; ++n) { - if ((*_matching)[n] != INVALID) { - ++num; - } - } - return num; - } - - /// \brief Return \c true if the given edge is in the matching. - /// - /// This function returns \c true if the given edge is in the - /// found matching. The result is scaled by \ref primalScale - /// "primal scale". - /// - /// \pre Either run() or start() must be called before using this function. - int matching(const Edge& edge) const { - return (edge == (*_matching)[_graph.u(edge)] ? 1 : 0) - + (edge == (*_matching)[_graph.v(edge)] ? 1 : 0); - } - - /// \brief Return the fractional matching arc (or edge) incident - /// to the given node. - /// - /// This function returns one of the fractional matching arc (or - /// edge) incident to the given node in the found matching or \c - /// INVALID if the node is not covered by the matching or if the - /// node is on an odd length cycle then it is the successor edge - /// on the cycle. - /// - /// \pre Either run() or start() must be called before using this function. - Arc matching(const Node& node) const { - return (*_matching)[node]; - } - - /// \brief Return a const reference to the matching map. - /// - /// This function returns a const reference to a node map that stores - /// the matching arc (or edge) incident to each node. - const MatchingMap& matchingMap() const { - return *_matching; - } - - /// @} - - /// \name Dual Solution - /// Functions to get the dual solution.\n - /// Either \ref run() or \ref start() function should be called before - /// using them. - - /// @{ - - /// \brief Return the value of the dual solution. - /// - /// This function returns the value of the dual solution. - /// It should be equal to the primal value scaled by \ref dualScale - /// "dual scale". - /// - /// \pre Either run() or start() must be called before using this function. - Value dualValue() const { - Value sum = 0; - for (NodeIt n(_graph); n != INVALID; ++n) { - sum += nodeValue(n); - } - return sum; - } - - /// \brief Return the dual value (potential) of the given node. - /// - /// This function returns the dual value (potential) of the given node. - /// - /// \pre Either run() or start() must be called before using this function. - Value nodeValue(const Node& n) const { - return (*_node_potential)[n]; - } - - /// @} - - }; - -} //END OF NAMESPACE LEMON - -#endif //LEMON_FRACTIONAL_MATCHING_H Index: lemon/full_graph.h =================================================================== --- lemon/full_graph.h (revision 877) +++ lemon/full_graph.h (revision 617) @@ -3,5 +3,5 @@ * This file is a part of LEMON, a generic C++ optimization library. * - * Copyright (C) 2003-2010 + * Copyright (C) 2003-2009 * Egervary Jeno Kombinatorikus Optimalizalasi Kutatocsoport * (Egervary Research Group on Combinatorial Optimization, EGRES). @@ -25,5 +25,5 @@ ///\ingroup graphs ///\file -///\brief FullDigraph and FullGraph classes. +///\brief FullGraph and FullDigraph classes. namespace lemon { @@ -52,5 +52,5 @@ Node operator()(int ix) const { return Node(ix); } - static int index(const Node& node) { return node._id; } + int index(const Node& node) const { return node._id; } Arc arc(const Node& s, const Node& t) const { @@ -149,26 +149,22 @@ /// \ingroup graphs /// - /// \brief A directed full graph class. - /// - /// FullDigraph is a simple and fast implmenetation of directed full - /// (complete) graphs. It contains an arc from each node to each node - /// (including a loop for each node), therefore the number of arcs - /// is the square of the number of nodes. - /// This class is completely static and it needs constant memory space. - /// Thus you can neither add nor delete nodes or arcs, however - /// the structure can be resized using resize(). - /// - /// This type fully conforms to the \ref concepts::Digraph "Digraph concept". - /// Most of its member functions and nested classes are documented - /// only in the concept class. - /// - /// This class provides constant time counting for nodes and arcs. - /// - /// \note FullDigraph and FullGraph classes are very similar, + /// \brief A full digraph class. + /// + /// This is a simple and fast directed full graph implementation. + /// From each node go arcs to each node (including the source node), + /// therefore the number of the arcs in the digraph is the square of + /// the node number. This digraph type is completely static, so you + /// can neither add nor delete either arcs or nodes, and it needs + /// constant space in memory. + /// + /// This class fully conforms to the \ref concepts::Digraph + /// "Digraph concept". + /// + /// The \c FullDigraph and \c FullGraph classes are very similar, /// but there are two differences. While this class conforms only - /// to the \ref concepts::Digraph "Digraph" concept, FullGraph - /// conforms to the \ref concepts::Graph "Graph" concept, - /// moreover FullGraph does not contain a loop for each - /// node as this class does. + /// to the \ref concepts::Digraph "Digraph" concept, the \c FullGraph + /// class conforms to the \ref concepts::Graph "Graph" concept, + /// moreover \c FullGraph does not contain a loop arc for each + /// node as \c FullDigraph does. /// /// \sa FullGraph @@ -178,7 +174,5 @@ public: - /// \brief Default constructor. - /// - /// Default constructor. The number of nodes and arcs will be zero. + /// \brief Constructor FullDigraph() { construct(0); } @@ -191,6 +185,6 @@ /// \brief Resizes the digraph /// - /// This function resizes the digraph. It fully destroys and - /// rebuilds the structure, therefore the maps of the digraph will be + /// Resizes the digraph. The function will fully destroy and + /// rebuild the digraph. This cause that the maps of the digraph will /// reallocated automatically and the previous values will be lost. void resize(int n) { @@ -204,8 +198,7 @@ /// \brief Returns the node with the given index. /// - /// Returns the node with the given index. Since this structure is - /// completely static, the nodes can be indexed with integers from - /// the range [0..nodeNum()-1]. - /// The index of a node is the same as its ID. + /// Returns the node with the given index. Since it is a static + /// digraph its nodes can be indexed with integers from the range + /// [0..nodeNum()-1]. /// \sa index() Node operator()(int ix) const { return Parent::operator()(ix); } @@ -213,15 +206,14 @@ /// \brief Returns the index of the given node. /// - /// Returns the index of the given node. Since this structure is - /// completely static, the nodes can be indexed with integers from - /// the range [0..nodeNum()-1]. - /// The index of a node is the same as its ID. - /// \sa operator()() - static int index(const Node& node) { return Parent::index(node); } + /// Returns the index of the given node. Since it is a static + /// digraph its nodes can be indexed with integers from the range + /// [0..nodeNum()-1]. + /// \sa operator() + int index(const Node& node) const { return Parent::index(node); } /// \brief Returns the arc connecting the given nodes. /// /// Returns the arc connecting the given nodes. - Arc arc(Node u, Node v) const { + Arc arc(const Node& u, const Node& v) const { return Parent::arc(u, v); } @@ -292,5 +284,5 @@ Node operator()(int ix) const { return Node(ix); } - static int index(const Node& node) { return node._id; } + int index(const Node& node) const { return node._id; } Edge edge(const Node& u, const Node& v) const { @@ -529,23 +521,19 @@ /// \brief An undirected full graph class. /// - /// FullGraph is a simple and fast implmenetation of undirected full - /// (complete) graphs. It contains an edge between every distinct pair - /// of nodes, therefore the number of edges is n(n-1)/2. - /// This class is completely static and it needs constant memory space. - /// Thus you can neither add nor delete nodes or edges, however - /// the structure can be resized using resize(). - /// - /// This type fully conforms to the \ref concepts::Graph "Graph concept". - /// Most of its member functions and nested classes are documented - /// only in the concept class. - /// - /// This class provides constant time counting for nodes, edges and arcs. - /// - /// \note FullDigraph and FullGraph classes are very similar, - /// but there are two differences. While FullDigraph + /// This is a simple and fast undirected full graph + /// implementation. From each node go edge to each other node, + /// therefore the number of edges in the graph is \f$n(n-1)/2\f$. + /// This graph type is completely static, so you can neither + /// add nor delete either edges or nodes, and it needs constant + /// space in memory. + /// + /// This class fully conforms to the \ref concepts::Graph "Graph concept". + /// + /// The \c FullGraph and \c FullDigraph classes are very similar, + /// but there are two differences. While the \c FullDigraph class /// conforms only to the \ref concepts::Digraph "Digraph" concept, /// this class conforms to the \ref concepts::Graph "Graph" concept, - /// moreover this class does not contain a loop for each - /// node as FullDigraph does. + /// moreover \c FullGraph does not contain a loop arc for each + /// node as \c FullDigraph does. /// /// \sa FullDigraph @@ -555,7 +543,5 @@ public: - /// \brief Default constructor. - /// - /// Default constructor. The number of nodes and edges will be zero. + /// \brief Constructor FullGraph() { construct(0); } @@ -568,6 +554,6 @@ /// \brief Resizes the graph /// - /// This function resizes the graph. It fully destroys and - /// rebuilds the structure, therefore the maps of the graph will be + /// Resizes the graph. The function will fully destroy and + /// rebuild the graph. This cause that the maps of the graph will /// reallocated automatically and the previous values will be lost. void resize(int n) { @@ -583,8 +569,7 @@ /// \brief Returns the node with the given index. /// - /// Returns the node with the given index. Since this structure is - /// completely static, the nodes can be indexed with integers from - /// the range [0..nodeNum()-1]. - /// The index of a node is the same as its ID. + /// Returns the node with the given index. Since it is a static + /// graph its nodes can be indexed with integers from the range + /// [0..nodeNum()-1]. /// \sa index() Node operator()(int ix) const { return Parent::operator()(ix); } @@ -592,22 +577,21 @@ /// \brief Returns the index of the given node. /// - /// Returns the index of the given node. Since this structure is - /// completely static, the nodes can be indexed with integers from - /// the range [0..nodeNum()-1]. - /// The index of a node is the same as its ID. - /// \sa operator()() - static int index(const Node& node) { return Parent::index(node); } + /// Returns the index of the given node. Since it is a static + /// graph its nodes can be indexed with integers from the range + /// [0..nodeNum()-1]. + /// \sa operator() + int index(const Node& node) const { return Parent::index(node); } /// \brief Returns the arc connecting the given nodes. /// /// Returns the arc connecting the given nodes. - Arc arc(Node s, Node t) const { + Arc arc(const Node& s, const Node& t) const { return Parent::arc(s, t); } - /// \brief Returns the edge connecting the given nodes. - /// - /// Returns the edge connecting the given nodes. - Edge edge(Node u, Node v) const { + /// \brief Returns the edge connects the given nodes. + /// + /// Returns the edge connects the given nodes. + Edge edge(const Node& u, const Node& v) const { return Parent::edge(u, v); } Index: lemon/glpk.cc =================================================================== --- lemon/glpk.cc (revision 989) +++ lemon/glpk.cc (revision 988) @@ -3,5 +3,5 @@ * This file is a part of LEMON, a generic C++ optimization library. * - * Copyright (C) 2003-2010 + * Copyright (C) 2003-2009 * Egervary Jeno Kombinatorikus Optimalizalasi Kutatocsoport * (Egervary Research Group on Combinatorial Optimization, EGRES). @@ -57,40 +57,4 @@ int i = glp_add_rows(lp, 1); glp_set_row_bnds(lp, i, GLP_FR, 0.0, 0.0); - return i; - } - - int GlpkBase::_addRow(Value lo, ExprIterator b, - ExprIterator e, Value up) { - int i = glp_add_rows(lp, 1); - - if (lo == -INF) { - if (up == INF) { - glp_set_row_bnds(lp, i, GLP_FR, lo, up); - } else { - glp_set_row_bnds(lp, i, GLP_UP, lo, up); - } - } else { - if (up == INF) { - glp_set_row_bnds(lp, i, GLP_LO, lo, up); - } else if (lo != up) { - glp_set_row_bnds(lp, i, GLP_DB, lo, up); - } else { - glp_set_row_bnds(lp, i, GLP_FX, lo, up); - } - } - - std::vector indexes; - std::vector values; - - indexes.push_back(0); - values.push_back(0); - - for(ExprIterator it = b; it != e; ++it) { - indexes.push_back(it->first); - values.push_back(it->second); - } - - glp_set_mat_row(lp, i, values.size() - 1, - &indexes.front(), &values.front()); return i; } Index: lemon/glpk.h =================================================================== --- lemon/glpk.h (revision 877) +++ lemon/glpk.h (revision 832) @@ -3,5 +3,5 @@ * This file is a part of LEMON, a generic C++ optimization library. * - * Copyright (C) 2003-2010 + * Copyright (C) 2003-2008 * Egervary Jeno Kombinatorikus Optimalizalasi Kutatocsoport * (Egervary Research Group on Combinatorial Optimization, EGRES). @@ -31,5 +31,5 @@ class VoidPtr { private: - void *_ptr; + void *_ptr; public: VoidPtr() : _ptr(0) {} @@ -39,6 +39,6 @@ template - VoidPtr& operator=(T* ptr) { - _ptr = reinterpret_cast(ptr); + VoidPtr& operator=(T* ptr) { + _ptr = reinterpret_cast(ptr); return *this; } @@ -66,5 +66,4 @@ virtual int _addCol(); virtual int _addRow(); - virtual int _addRow(Value l, ExprIterator b, ExprIterator e, Value u); virtual void _eraseCol(int i); @@ -125,11 +124,11 @@ } }; - + static FreeEnvHelper freeEnvHelper; protected: - + int _message_level; - + public: Index: lemon/gomory_hu.h =================================================================== --- lemon/gomory_hu.h (revision 877) +++ lemon/gomory_hu.h (revision 596) @@ -1,7 +1,7 @@ -/* -*- mode: C++; indent-tabs-mode: nil; -*- +/* -*- C++ -*- * - * This file is a part of LEMON, a generic C++ optimization library. + * This file is a part of LEMON, a generic C++ optimization library * - * Copyright (C) 2003-2010 + * Copyright (C) 2003-2008 * Egervary Jeno Kombinatorikus Optimalizalasi Kutatocsoport * (Egervary Research Group on Combinatorial Optimization, EGRES). @@ -28,5 +28,5 @@ /// \ingroup min_cut -/// \file +/// \file /// \brief Gomory-Hu cut tree in graphs. @@ -39,5 +39,5 @@ /// The Gomory-Hu tree is a tree on the node set of a given graph, but it /// may contain edges which are not in the original graph. It has the - /// property that the minimum capacity edge of the path between two nodes + /// property that the minimum capacity edge of the path between two nodes /// in this tree has the same weight as the minimum cut in the graph /// between these nodes. Moreover the components obtained by removing @@ -45,5 +45,5 @@ /// Therefore once this tree is computed, the minimum cut between any pair /// of nodes can easily be obtained. - /// + /// /// The algorithm calculates \e n-1 distinct minimum cuts (currently with /// the \ref Preflow algorithm), thus it has \f$O(n^3\sqrt{e})\f$ overall @@ -61,8 +61,8 @@ #ifdef DOXYGEN template + typename CAP> #else template > + typename CAP = typename GR::template EdgeMap > #endif class GomoryHu { @@ -75,5 +75,5 @@ /// The value type of capacities typedef typename Capacity::Value Value; - + private: @@ -90,11 +90,11 @@ void createStructures() { if (!_pred) { - _pred = new typename Graph::template NodeMap(_graph); + _pred = new typename Graph::template NodeMap(_graph); } if (!_weight) { - _weight = new typename Graph::template NodeMap(_graph); + _weight = new typename Graph::template NodeMap(_graph); } if (!_order) { - _order = new typename Graph::template NodeMap(_graph); + _order = new typename Graph::template NodeMap(_graph); } } @@ -102,14 +102,14 @@ void destroyStructures() { if (_pred) { - delete _pred; + delete _pred; } if (_weight) { - delete _weight; + delete _weight; } if (_order) { - delete _order; - } - } - + delete _order; + } + } + public: @@ -119,7 +119,7 @@ /// \param graph The undirected graph the algorithm runs on. /// \param capacity The edge capacity map. - GomoryHu(const Graph& graph, const Capacity& capacity) + GomoryHu(const Graph& graph, const Capacity& capacity) : _graph(graph), _capacity(capacity), - _pred(0), _weight(0), _order(0) + _pred(0), _weight(0), _order(0) { checkConcept, Capacity>(); @@ -135,5 +135,5 @@ private: - + // Initialize the internal data structures void init() { @@ -146,5 +146,5 @@ } (*_pred)[_root] = INVALID; - (*_weight)[_root] = std::numeric_limits::max(); + (*_weight)[_root] = std::numeric_limits::max(); } @@ -155,25 +155,25 @@ for (NodeIt n(_graph); n != INVALID; ++n) { - if (n == _root) continue; - - Node pn = (*_pred)[n]; - fa.source(n); - fa.target(pn); - - fa.runMinCut(); - - (*_weight)[n] = fa.flowValue(); - - for (NodeIt nn(_graph); nn != INVALID; ++nn) { - if (nn != n && fa.minCut(nn) && (*_pred)[nn] == pn) { - (*_pred)[nn] = n; - } - } - if ((*_pred)[pn] != INVALID && fa.minCut((*_pred)[pn])) { - (*_pred)[n] = (*_pred)[pn]; - (*_pred)[pn] = n; - (*_weight)[n] = (*_weight)[pn]; - (*_weight)[pn] = fa.flowValue(); - } + if (n == _root) continue; + + Node pn = (*_pred)[n]; + fa.source(n); + fa.target(pn); + + fa.runMinCut(); + + (*_weight)[n] = fa.flowValue(); + + for (NodeIt nn(_graph); nn != INVALID; ++nn) { + if (nn != n && fa.minCut(nn) && (*_pred)[nn] == pn) { + (*_pred)[nn] = n; + } + } + if ((*_pred)[pn] != INVALID && fa.minCut((*_pred)[pn])) { + (*_pred)[n] = (*_pred)[pn]; + (*_pred)[pn] = n; + (*_weight)[n] = (*_weight)[pn]; + (*_weight)[pn] = fa.flowValue(); + } } @@ -182,14 +182,14 @@ for (NodeIt n(_graph); n != INVALID; ++n) { - std::vector 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 st; + Node nn = n; + while ((*_order)[nn] == -1) { + st.push_back(nn); + nn = (*_pred)[nn]; + } + while (!st.empty()) { + (*_order)[st.back()] = index++; + st.pop_back(); + } } } @@ -198,5 +198,5 @@ ///\name Execution Control - + ///@{ @@ -208,5 +208,5 @@ start(); } - + /// @} @@ -233,5 +233,5 @@ /// Gomory-Hu tree. /// - /// This function returns the weight of the predecessor edge of the + /// This function returns the weight of the predecessor edge of the /// given node in the Gomory-Hu tree. /// If \c node is the root of the tree, the result is undefined. @@ -255,5 +255,5 @@ /// /// This function returns the minimum cut value between the nodes - /// \c s and \c t. + /// \c s and \c t. /// It finds the nearest common ancestor of the given nodes in the /// Gomory-Hu tree and calculates the minimum weight edge on the @@ -264,13 +264,13 @@ Node sn = s, tn = t; Value value = std::numeric_limits::max(); - + while (sn != tn) { - if ((*_order)[sn] < (*_order)[tn]) { - if ((*_weight)[tn] <= value) value = (*_weight)[tn]; - tn = (*_pred)[tn]; - } else { - if ((*_weight)[sn] <= value) value = (*_weight)[sn]; - sn = (*_pred)[sn]; - } + if ((*_order)[sn] < (*_order)[tn]) { + if ((*_weight)[tn] <= value) value = (*_weight)[tn]; + tn = (*_pred)[tn]; + } else { + if ((*_weight)[sn] <= value) value = (*_weight)[sn]; + sn = (*_pred)[sn]; + } } return value; @@ -295,7 +295,9 @@ /// \pre \ref run() must be called before using this function. template - Value minCutMap(const Node& s, + Value minCutMap(const Node& s, ///< const Node& t, + ///< CutMap& cutMap + ///< ) const { Node sn = s, tn = t; @@ -303,21 +305,21 @@ Node rn = INVALID; Value value = std::numeric_limits::max(); - + while (sn != tn) { - if ((*_order)[sn] < (*_order)[tn]) { - if ((*_weight)[tn] <= value) { - rn = tn; + if ((*_order)[sn] < (*_order)[tn]) { + if ((*_weight)[tn] <= value) { + rn = tn; s_root = false; - value = (*_weight)[tn]; - } - tn = (*_pred)[tn]; - } else { - if ((*_weight)[sn] <= value) { - rn = sn; + value = (*_weight)[tn]; + } + tn = (*_pred)[tn]; + } else { + if ((*_weight)[sn] <= value) { + rn = sn; s_root = true; - value = (*_weight)[sn]; - } - sn = (*_pred)[sn]; - } + value = (*_weight)[sn]; + } + sn = (*_pred)[sn]; + } } @@ -330,16 +332,16 @@ std::vector st; for (NodeIt n(_graph); n != INVALID; ++n) { - st.clear(); + st.clear(); Node nn = n; - while (!reached[nn]) { - st.push_back(nn); - nn = (*_pred)[nn]; - } - while (!st.empty()) { - cutMap.set(st.back(), cutMap[nn]); - st.pop_back(); - } - } - + while (!reached[nn]) { + st.push_back(nn); + nn = (*_pred)[nn]; + } + while (!st.empty()) { + cutMap.set(st.back(), cutMap[nn]); + st.pop_back(); + } + } + return value; } @@ -350,5 +352,5 @@ /// Iterate on the nodes of a minimum cut - + /// This iterator class lists the nodes of a minimum cut found by /// GomoryHu. Before using it, you must allocate a GomoryHu class @@ -358,8 +360,8 @@ /// \c t. /// \code - /// GomoryHu gom(g, capacities); + /// GomoruHu gom(g, capacities); /// gom.run(); /// int cnt=0; - /// for(GomoryHu::MinCutNodeIt n(gom,s,t); n!=INVALID; ++n) ++cnt; + /// for(GomoruHu::MinCutNodeIt n(gom,s,t); n!=INVALID; ++n) ++cnt; /// \endcode class MinCutNodeIt @@ -393,5 +395,5 @@ /// \endcode /// does not necessarily give the same set of nodes. - /// However, it is ensured that + /// However it is ensured that /// \code /// MinCutNodeIt(gomory, s, t, true); @@ -443,9 +445,9 @@ } }; - + friend class MinCutEdgeIt; - + /// Iterate on the edges of a minimum cut - + /// This iterator class lists the edges of a minimum cut found by /// GomoryHu. Before using it, you must allocate a GomoryHu class @@ -455,8 +457,8 @@ /// \c t. /// \code - /// GomoryHu gom(g, capacities); + /// GomoruHu gom(g, capacities); /// gom.run(); /// int value=0; - /// for(GomoryHu::MinCutEdgeIt e(gom,s,t); e!=INVALID; ++e) + /// for(GomoruHu::MinCutEdgeIt e(gom,s,t); e!=INVALID; ++e) /// value+=capacities[e]; /// \endcode @@ -480,5 +482,5 @@ } } - + public: /// Constructor @@ -549,5 +551,5 @@ } /// Postfix incrementation - + /// Postfix incrementation. /// Index: lemon/graph_to_eps.h =================================================================== --- lemon/graph_to_eps.h (revision 998) +++ lemon/graph_to_eps.h (revision 997) @@ -3,5 +3,5 @@ * This file is a part of LEMON, a generic C++ optimization library. * - * Copyright (C) 2003-2010 + * Copyright (C) 2003-2009 * Egervary Jeno Kombinatorikus Optimalizalasi Kutatocsoport * (Egervary Research Group on Combinatorial Optimization, EGRES). @@ -143,5 +143,5 @@ ///\param gr Reference to the graph to be printed. ///\param ost Reference to the output stream. - ///By default, it is std::cout. + ///By default it is std::cout. ///\param pros If it is \c true, then the \c ostream referenced by \c os ///will be explicitly deallocated by the destructor. @@ -513,5 +513,5 @@ ///Turn on/off pre-scaling - ///By default, graphToEps() rescales the whole image in order to avoid + ///By default graphToEps() rescales the whole image in order to avoid ///very big or very small bounding boxes. /// @@ -1115,5 +1115,5 @@ ///\param g Reference to the graph to be printed. ///\param os Reference to the output stream. -///By default, it is std::cout. +///By default it is std::cout. /// ///This function also has a lot of @@ -1127,5 +1127,5 @@ ///\endcode /// -///For more detailed examples, see the \ref graph_to_eps_demo.cc demo file. +///For more detailed examples see the \ref graph_to_eps_demo.cc demo file. /// ///\warning Don't forget to put the \ref GraphToEps::run() "run()" Index: lemon/grid_graph.h =================================================================== --- lemon/grid_graph.h (revision 787) +++ lemon/grid_graph.h (revision 617) @@ -471,19 +471,15 @@ /// \brief Grid graph class /// - /// GridGraph implements a special graph type. The nodes of the - /// graph can be indexed by two integer values \c (i,j) where \c i is - /// in the range [0..width()-1] and j is in the range - /// [0..height()-1]. Two nodes are connected in the graph if - /// the indices differ exactly on one position and the difference is - /// also exactly one. The nodes of the graph can be obtained by position - /// using the \c operator()() function and the indices of the nodes can - /// be obtained using \c pos(), \c col() and \c row() members. The outgoing + /// This class implements a special graph type. The nodes of the + /// graph can be indexed by two integer \c (i,j) value where \c i is + /// in the \c [0..width()-1] range and j is in the \c + /// [0..height()-1] range. Two nodes are connected in the graph if + /// the indexes differ exactly on one position and exactly one is + /// the difference. The nodes of the graph can be indexed by position + /// with the \c operator()() function. The positions of the nodes can be + /// get with \c pos(), \c col() and \c row() members. The outgoing /// arcs can be retrieved with the \c right(), \c up(), \c left() /// and \c down() functions, where the bottom-left corner is the /// origin. - /// - /// This class is completely static and it needs constant memory space. - /// Thus you can neither add nor delete nodes or edges, however - /// the structure can be resized using resize(). /// /// \image html grid_graph.png @@ -501,9 +497,6 @@ ///\endcode /// - /// This type fully conforms to the \ref concepts::Graph "Graph concept". - /// Most of its member functions and nested classes are documented - /// only in the concept class. - /// - /// This class provides constant time counting for nodes, edges and arcs. + /// This graph type fully conforms to the \ref concepts::Graph + /// "Graph concept". class GridGraph : public ExtendedGridGraphBase { typedef ExtendedGridGraphBase Parent; @@ -511,9 +504,7 @@ public: - /// \brief Map to get the indices of the nodes as \ref dim2::Point - /// "dim2::Point". - /// - /// Map to get the indices of the nodes as \ref dim2::Point - /// "dim2::Point". + /// \brief Map to get the indices of the nodes as dim2::Point. + /// + /// Map to get the indices of the nodes as dim2::Point. class IndexMap { public: @@ -524,7 +515,11 @@ /// \brief Constructor + /// + /// Constructor IndexMap(const GridGraph& graph) : _graph(graph) {} /// \brief The subscript operator + /// + /// The subscript operator. Value operator[](Key key) const { return _graph.pos(key); @@ -546,7 +541,11 @@ /// \brief Constructor + /// + /// Constructor ColMap(const GridGraph& graph) : _graph(graph) {} /// \brief The subscript operator + /// + /// The subscript operator. Value operator[](Key key) const { return _graph.col(key); @@ -568,7 +567,11 @@ /// \brief Constructor + /// + /// Constructor RowMap(const GridGraph& graph) : _graph(graph) {} /// \brief The subscript operator + /// + /// The subscript operator. Value operator[](Key key) const { return _graph.row(key); @@ -581,12 +584,13 @@ /// \brief Constructor /// - /// Construct a grid graph with the given size. + /// Construct a grid graph with given size. GridGraph(int width, int height) { construct(width, height); } - /// \brief Resizes the graph - /// - /// This function resizes the graph. It fully destroys and - /// rebuilds the structure, therefore the maps of the graph will be - /// reallocated automatically and the previous values will be lost. + /// \brief Resize the graph + /// + /// Resize the graph. The function will fully destroy and rebuild + /// the graph. This cause that the maps of the graph will + /// reallocated automatically and the previous values will be + /// lost. void resize(int width, int height) { Parent::notifier(Arc()).clear(); @@ -606,5 +610,5 @@ } - /// \brief The column index of the node. + /// \brief Gives back the column index of the node. /// /// Gives back the column index of the node. @@ -613,5 +617,5 @@ } - /// \brief The row index of the node. + /// \brief Gives back the row index of the node. /// /// Gives back the row index of the node. @@ -620,5 +624,5 @@ } - /// \brief The position of the node. + /// \brief Gives back the position of the node. /// /// Gives back the position of the node, ie. the (col,row) pair. @@ -627,5 +631,5 @@ } - /// \brief The number of the columns. + /// \brief Gives back the number of the columns. /// /// Gives back the number of the columns. @@ -634,5 +638,5 @@ } - /// \brief The number of the rows. + /// \brief Gives back the number of the rows. /// /// Gives back the number of the rows. @@ -641,5 +645,5 @@ } - /// \brief The arc goes right from the node. + /// \brief Gives back the arc goes right from the node. /// /// Gives back the arc goes right from the node. If there is not @@ -649,5 +653,5 @@ } - /// \brief The arc goes left from the node. + /// \brief Gives back the arc goes left from the node. /// /// Gives back the arc goes left from the node. If there is not @@ -657,5 +661,5 @@ } - /// \brief The arc goes up from the node. + /// \brief Gives back the arc goes up from the node. /// /// Gives back the arc goes up from the node. If there is not @@ -665,5 +669,5 @@ } - /// \brief The arc goes down from the node. + /// \brief Gives back the arc goes down from the node. /// /// Gives back the arc goes down from the node. If there is not Index: mon/grosso_locatelli_pullan_mc.h =================================================================== --- lemon/grosso_locatelli_pullan_mc.h (revision 918) +++ (revision ) @@ -1,840 +1,0 @@ -/* -*- mode: C++; indent-tabs-mode: nil; -*- - * - * This file is a part of LEMON, a generic C++ optimization library. - * - * Copyright (C) 2003-2010 - * Egervary Jeno Kombinatorikus Optimalizalasi Kutatocsoport - * (Egervary Research Group on Combinatorial Optimization, EGRES). - * - * Permission to use, modify and distribute this software is granted - * provided that this copyright notice appears in all copies. For - * precise terms see the accompanying LICENSE file. - * - * This software is provided "AS IS" with no warranty of any kind, - * express or implied, and with no claim as to its suitability for any - * purpose. - * - */ - -#ifndef LEMON_GROSSO_LOCATELLI_PULLAN_MC_H -#define LEMON_GROSSO_LOCATELLI_PULLAN_MC_H - -/// \ingroup approx_algs -/// -/// \file -/// \brief The iterated local search algorithm of Grosso, Locatelli, and Pullan -/// for the maximum clique problem - -#include -#include -#include -#include - -namespace lemon { - - /// \addtogroup approx_algs - /// @{ - - /// \brief Implementation of the iterated local search algorithm of Grosso, - /// Locatelli, and Pullan for the maximum clique problem - /// - /// \ref GrossoLocatelliPullanMc implements the iterated local search - /// algorithm of Grosso, Locatelli, and Pullan for solving the \e maximum - /// \e clique \e problem \ref grosso08maxclique. - /// It is to find the largest complete subgraph (\e clique) in an - /// undirected graph, i.e., the largest set of nodes where each - /// pair of nodes is connected. - /// - /// This class provides a simple but highly efficient and robust heuristic - /// method that quickly finds a quite large clique, but not necessarily the - /// largest one. - /// The algorithm performs a certain number of iterations to find several - /// cliques and selects the largest one among them. Various limits can be - /// specified to control the running time and the effectiveness of the - /// search process. - /// - /// \tparam GR The undirected graph type the algorithm runs on. - /// - /// \note %GrossoLocatelliPullanMc provides three different node selection - /// rules, from which the most powerful one is used by default. - /// For more information, see \ref SelectionRule. - template - class GrossoLocatelliPullanMc - { - public: - - /// \brief Constants for specifying the node selection rule. - /// - /// Enum type containing constants for specifying the node selection rule - /// for the \ref run() function. - /// - /// During the algorithm, nodes are selected for addition to the current - /// clique according to the applied rule. - /// In general, the PENALTY_BASED rule turned out to be the most powerful - /// and the most robust, thus it is the default option. - /// However, another selection rule can be specified using the \ref run() - /// function with the proper parameter. - enum SelectionRule { - - /// A node is selected randomly without any evaluation at each step. - RANDOM, - - /// A node of maximum degree is selected randomly at each step. - DEGREE_BASED, - - /// A node of minimum penalty is selected randomly at each step. - /// The node penalties are updated adaptively after each stage of the - /// search process. - PENALTY_BASED - }; - - /// \brief Constants for the causes of search termination. - /// - /// Enum type containing constants for the different causes of search - /// termination. The \ref run() function returns one of these values. - enum TerminationCause { - - /// The iteration count limit is reached. - ITERATION_LIMIT, - - /// The step count limit is reached. - STEP_LIMIT, - - /// The clique size limit is reached. - SIZE_LIMIT - }; - - private: - - TEMPLATE_GRAPH_TYPEDEFS(GR); - - typedef std::vector IntVector; - typedef std::vector BoolVector; - typedef std::vector BoolMatrix; - // Note: vector is used instead of vector for efficiency reasons - - // The underlying graph - const GR &_graph; - IntNodeMap _id; - - // Internal matrix representation of the graph - BoolMatrix _gr; - int _n; - - // Search options - bool _delta_based_restart; - int _restart_delta_limit; - - // Search limits - int _iteration_limit; - int _step_limit; - int _size_limit; - - // The current clique - BoolVector _clique; - int _size; - - // The best clique found so far - BoolVector _best_clique; - int _best_size; - - // The "distances" of the nodes from the current clique. - // _delta[u] is the number of nodes in the clique that are - // not connected with u. - IntVector _delta; - - // The current tabu set - BoolVector _tabu; - - // Random number generator - Random _rnd; - - private: - - // Implementation of the RANDOM node selection rule. - class RandomSelectionRule - { - private: - - // References to the algorithm instance - const BoolVector &_clique; - const IntVector &_delta; - const BoolVector &_tabu; - Random &_rnd; - - // Pivot rule data - int _n; - - public: - - // Constructor - RandomSelectionRule(GrossoLocatelliPullanMc &mc) : - _clique(mc._clique), _delta(mc._delta), _tabu(mc._tabu), - _rnd(mc._rnd), _n(mc._n) - {} - - // Return a node index for a feasible add move or -1 if no one exists - int nextFeasibleAddNode() const { - int start_node = _rnd[_n]; - for (int i = start_node; i != _n; i++) { - if (_delta[i] == 0 && !_tabu[i]) return i; - } - for (int i = 0; i != start_node; i++) { - if (_delta[i] == 0 && !_tabu[i]) return i; - } - return -1; - } - - // Return a node index for a feasible swap move or -1 if no one exists - int nextFeasibleSwapNode() const { - int start_node = _rnd[_n]; - for (int i = start_node; i != _n; i++) { - if (!_clique[i] && _delta[i] == 1 && !_tabu[i]) return i; - } - for (int i = 0; i != start_node; i++) { - if (!_clique[i] && _delta[i] == 1 && !_tabu[i]) return i; - } - return -1; - } - - // Return a node index for an add move or -1 if no one exists - int nextAddNode() const { - int start_node = _rnd[_n]; - for (int i = start_node; i != _n; i++) { - if (_delta[i] == 0) return i; - } - for (int i = 0; i != start_node; i++) { - if (_delta[i] == 0) return i; - } - return -1; - } - - // Update internal data structures between stages (if necessary) - void update() {} - - }; //class RandomSelectionRule - - - // Implementation of the DEGREE_BASED node selection rule. - class DegreeBasedSelectionRule - { - private: - - // References to the algorithm instance - const BoolVector &_clique; - const IntVector &_delta; - const BoolVector &_tabu; - Random &_rnd; - - // Pivot rule data - int _n; - IntVector _deg; - - public: - - // Constructor - DegreeBasedSelectionRule(GrossoLocatelliPullanMc &mc) : - _clique(mc._clique), _delta(mc._delta), _tabu(mc._tabu), - _rnd(mc._rnd), _n(mc._n), _deg(_n) - { - for (int i = 0; i != _n; i++) { - int d = 0; - BoolVector &row = mc._gr[i]; - for (int j = 0; j != _n; j++) { - if (row[j]) d++; - } - _deg[i] = d; - } - } - - // Return a node index for a feasible add move or -1 if no one exists - int nextFeasibleAddNode() const { - int start_node = _rnd[_n]; - int node = -1, max_deg = -1; - for (int i = start_node; i != _n; i++) { - if (_delta[i] == 0 && !_tabu[i] && _deg[i] > max_deg) { - node = i; - max_deg = _deg[i]; - } - } - for (int i = 0; i != start_node; i++) { - if (_delta[i] == 0 && !_tabu[i] && _deg[i] > max_deg) { - node = i; - max_deg = _deg[i]; - } - } - return node; - } - - // Return a node index for a feasible swap move or -1 if no one exists - int nextFeasibleSwapNode() const { - int start_node = _rnd[_n]; - int node = -1, max_deg = -1; - for (int i = start_node; i != _n; i++) { - if (!_clique[i] && _delta[i] == 1 && !_tabu[i] && - _deg[i] > max_deg) { - node = i; - max_deg = _deg[i]; - } - } - for (int i = 0; i != start_node; i++) { - if (!_clique[i] && _delta[i] == 1 && !_tabu[i] && - _deg[i] > max_deg) { - node = i; - max_deg = _deg[i]; - } - } - return node; - } - - // Return a node index for an add move or -1 if no one exists - int nextAddNode() const { - int start_node = _rnd[_n]; - int node = -1, max_deg = -1; - for (int i = start_node; i != _n; i++) { - if (_delta[i] == 0 && _deg[i] > max_deg) { - node = i; - max_deg = _deg[i]; - } - } - for (int i = 0; i != start_node; i++) { - if (_delta[i] == 0 && _deg[i] > max_deg) { - node = i; - max_deg = _deg[i]; - } - } - return node; - } - - // Update internal data structures between stages (if necessary) - void update() {} - - }; //class DegreeBasedSelectionRule - - - // Implementation of the PENALTY_BASED node selection rule. - class PenaltyBasedSelectionRule - { - private: - - // References to the algorithm instance - const BoolVector &_clique; - const IntVector &_delta; - const BoolVector &_tabu; - Random &_rnd; - - // Pivot rule data - int _n; - IntVector _penalty; - - public: - - // Constructor - PenaltyBasedSelectionRule(GrossoLocatelliPullanMc &mc) : - _clique(mc._clique), _delta(mc._delta), _tabu(mc._tabu), - _rnd(mc._rnd), _n(mc._n), _penalty(_n, 0) - {} - - // Return a node index for a feasible add move or -1 if no one exists - int nextFeasibleAddNode() const { - int start_node = _rnd[_n]; - int node = -1, min_p = std::numeric_limits::max(); - for (int i = start_node; i != _n; i++) { - if (_delta[i] == 0 && !_tabu[i] && _penalty[i] < min_p) { - node = i; - min_p = _penalty[i]; - } - } - for (int i = 0; i != start_node; i++) { - if (_delta[i] == 0 && !_tabu[i] && _penalty[i] < min_p) { - node = i; - min_p = _penalty[i]; - } - } - return node; - } - - // Return a node index for a feasible swap move or -1 if no one exists - int nextFeasibleSwapNode() const { - int start_node = _rnd[_n]; - int node = -1, min_p = std::numeric_limits::max(); - for (int i = start_node; i != _n; i++) { - if (!_clique[i] && _delta[i] == 1 && !_tabu[i] && - _penalty[i] < min_p) { - node = i; - min_p = _penalty[i]; - } - } - for (int i = 0; i != start_node; i++) { - if (!_clique[i] && _delta[i] == 1 && !_tabu[i] && - _penalty[i] < min_p) { - node = i; - min_p = _penalty[i]; - } - } - return node; - } - - // Return a node index for an add move or -1 if no one exists - int nextAddNode() const { - int start_node = _rnd[_n]; - int node = -1, min_p = std::numeric_limits::max(); - for (int i = start_node; i != _n; i++) { - if (_delta[i] == 0 && _penalty[i] < min_p) { - node = i; - min_p = _penalty[i]; - } - } - for (int i = 0; i != start_node; i++) { - if (_delta[i] == 0 && _penalty[i] < min_p) { - node = i; - min_p = _penalty[i]; - } - } - return node; - } - - // Update internal data structures between stages (if necessary) - void update() {} - - }; //class PenaltyBasedSelectionRule - - public: - - /// \brief Constructor. - /// - /// Constructor. - /// The global \ref rnd "random number generator instance" is used - /// during the algorithm. - /// - /// \param graph The undirected graph the algorithm runs on. - GrossoLocatelliPullanMc(const GR& graph) : - _graph(graph), _id(_graph), _rnd(rnd) - { - initOptions(); - } - - /// \brief Constructor with random seed. - /// - /// Constructor with random seed. - /// - /// \param graph The undirected graph the algorithm runs on. - /// \param seed Seed value for the internal random number generator - /// that is used during the algorithm. - GrossoLocatelliPullanMc(const GR& graph, int seed) : - _graph(graph), _id(_graph), _rnd(seed) - { - initOptions(); - } - - /// \brief Constructor with random number generator. - /// - /// Constructor with random number generator. - /// - /// \param graph The undirected graph the algorithm runs on. - /// \param random A random number generator that is used during the - /// algorithm. - GrossoLocatelliPullanMc(const GR& graph, const Random& random) : - _graph(graph), _id(_graph), _rnd(random) - { - initOptions(); - } - - /// \name Execution Control - /// The \ref run() function can be used to execute the algorithm.\n - /// The functions \ref iterationLimit(int), \ref stepLimit(int), and - /// \ref sizeLimit(int) can be used to specify various limits for the - /// search process. - - /// @{ - - /// \brief Sets the maximum number of iterations. - /// - /// This function sets the maximum number of iterations. - /// Each iteration of the algorithm finds a maximal clique (but not - /// necessarily the largest one) by performing several search steps - /// (node selections). - /// - /// This limit controls the running time and the success of the - /// algorithm. For larger values, the algorithm runs slower, but it more - /// likely finds larger cliques. For smaller values, the algorithm is - /// faster but probably gives worse results. - /// - /// The default value is \c 1000. - /// \c -1 means that number of iterations is not limited. - /// - /// \warning You should specify a reasonable limit for the number of - /// iterations and/or the number of search steps. - /// - /// \return (*this) - /// - /// \sa stepLimit(int) - /// \sa sizeLimit(int) - GrossoLocatelliPullanMc& iterationLimit(int limit) { - _iteration_limit = limit; - return *this; - } - - /// \brief Sets the maximum number of search steps. - /// - /// This function sets the maximum number of elementary search steps. - /// Each iteration of the algorithm finds a maximal clique (but not - /// necessarily the largest one) by performing several search steps - /// (node selections). - /// - /// This limit controls the running time and the success of the - /// algorithm. For larger values, the algorithm runs slower, but it more - /// likely finds larger cliques. For smaller values, the algorithm is - /// faster but probably gives worse results. - /// - /// The default value is \c -1, which means that number of steps - /// is not limited explicitly. However, the number of iterations is - /// limited and each iteration performs a finite number of search steps. - /// - /// \warning You should specify a reasonable limit for the number of - /// iterations and/or the number of search steps. - /// - /// \return (*this) - /// - /// \sa iterationLimit(int) - /// \sa sizeLimit(int) - GrossoLocatelliPullanMc& stepLimit(int limit) { - _step_limit = limit; - return *this; - } - - /// \brief Sets the desired clique size. - /// - /// This function sets the desired clique size that serves as a search - /// limit. If a clique of this size (or a larger one) is found, then the - /// algorithm terminates. - /// - /// This function is especially useful if you know an exact upper bound - /// for the size of the cliques in the graph or if any clique above - /// a certain size limit is sufficient for your application. - /// - /// The default value is \c -1, which means that the size limit is set to - /// the number of nodes in the graph. - /// - /// \return (*this) - /// - /// \sa iterationLimit(int) - /// \sa stepLimit(int) - GrossoLocatelliPullanMc& sizeLimit(int limit) { - _size_limit = limit; - return *this; - } - - /// \brief The maximum number of iterations. - /// - /// This function gives back the maximum number of iterations. - /// \c -1 means that no limit is specified. - /// - /// \sa iterationLimit(int) - int iterationLimit() const { - return _iteration_limit; - } - - /// \brief The maximum number of search steps. - /// - /// This function gives back the maximum number of search steps. - /// \c -1 means that no limit is specified. - /// - /// \sa stepLimit(int) - int stepLimit() const { - return _step_limit; - } - - /// \brief The desired clique size. - /// - /// This function gives back the desired clique size that serves as a - /// search limit. \c -1 means that this limit is set to the number of - /// nodes in the graph. - /// - /// \sa sizeLimit(int) - int sizeLimit() const { - return _size_limit; - } - - /// \brief Runs the algorithm. - /// - /// This function runs the algorithm. If one of the specified limits - /// is reached, the search process terminates. - /// - /// \param rule The node selection rule. For more information, see - /// \ref SelectionRule. - /// - /// \return The termination cause of the search. For more information, - /// see \ref TerminationCause. - TerminationCause run(SelectionRule rule = PENALTY_BASED) - { - init(); - switch (rule) { - case RANDOM: - return start(); - case DEGREE_BASED: - return start(); - default: - return start(); - } - } - - /// @} - - /// \name Query Functions - /// The results of the algorithm can be obtained using these functions.\n - /// The run() function must be called before using them. - - /// @{ - - /// \brief The size of the found clique - /// - /// This function returns the size of the found clique. - /// - /// \pre run() must be called before using this function. - int cliqueSize() const { - return _best_size; - } - - /// \brief Gives back the found clique in a \c bool node map - /// - /// This function gives back the characteristic vector of the found - /// clique in the given node map. - /// It must be a \ref concepts::WriteMap "writable" node map with - /// \c bool (or convertible) value type. - /// - /// \pre run() must be called before using this function. - template - void cliqueMap(CliqueMap &map) const { - for (NodeIt n(_graph); n != INVALID; ++n) { - map[n] = static_cast(_best_clique[_id[n]]); - } - } - - /// \brief Iterator to list the nodes of the found clique - /// - /// This iterator class lists the nodes of the found clique. - /// Before using it, you must allocate a GrossoLocatelliPullanMc instance - /// and call its \ref GrossoLocatelliPullanMc::run() "run()" method. - /// - /// The following example prints out the IDs of the nodes in the found - /// clique. - /// \code - /// GrossoLocatelliPullanMc mc(g); - /// mc.run(); - /// for (GrossoLocatelliPullanMc::CliqueNodeIt n(mc); - /// n != INVALID; ++n) - /// { - /// std::cout << g.id(n) << std::endl; - /// } - /// \endcode - class CliqueNodeIt - { - private: - NodeIt _it; - BoolNodeMap _map; - - public: - - /// Constructor - - /// Constructor. - /// \param mc The algorithm instance. - CliqueNodeIt(const GrossoLocatelliPullanMc &mc) - : _map(mc._graph) - { - mc.cliqueMap(_map); - for (_it = NodeIt(mc._graph); _it != INVALID && !_map[_it]; ++_it) ; - } - - /// Conversion to \c Node - operator Node() const { return _it; } - - bool operator==(Invalid) const { return _it == INVALID; } - bool operator!=(Invalid) const { return _it != INVALID; } - - /// Next node - CliqueNodeIt &operator++() { - for (++_it; _it != INVALID && !_map[_it]; ++_it) ; - return *this; - } - - /// Postfix incrementation - - /// Postfix incrementation. - /// - /// \warning This incrementation returns a \c Node, not a - /// \c CliqueNodeIt as one may expect. - typename GR::Node operator++(int) { - Node n=*this; - ++(*this); - return n; - } - - }; - - /// @} - - private: - - // Initialize search options and limits - void initOptions() { - // Search options - _delta_based_restart = true; - _restart_delta_limit = 4; - - // Search limits - _iteration_limit = 1000; - _step_limit = -1; // this is disabled by default - _size_limit = -1; // this is disabled by default - } - - // Adds a node to the current clique - void addCliqueNode(int u) { - if (_clique[u]) return; - _clique[u] = true; - _size++; - BoolVector &row = _gr[u]; - for (int i = 0; i != _n; i++) { - if (!row[i]) _delta[i]++; - } - } - - // Removes a node from the current clique - void delCliqueNode(int u) { - if (!_clique[u]) return; - _clique[u] = false; - _size--; - BoolVector &row = _gr[u]; - for (int i = 0; i != _n; i++) { - if (!row[i]) _delta[i]--; - } - } - - // Initialize data structures - void init() { - _n = countNodes(_graph); - int ui = 0; - for (NodeIt u(_graph); u != INVALID; ++u) { - _id[u] = ui++; - } - _gr.clear(); - _gr.resize(_n, BoolVector(_n, false)); - ui = 0; - for (NodeIt u(_graph); u != INVALID; ++u) { - for (IncEdgeIt e(_graph, u); e != INVALID; ++e) { - int vi = _id[_graph.runningNode(e)]; - _gr[ui][vi] = true; - _gr[vi][ui] = true; - } - ++ui; - } - - _clique.clear(); - _clique.resize(_n, false); - _size = 0; - _best_clique.clear(); - _best_clique.resize(_n, false); - _best_size = 0; - _delta.clear(); - _delta.resize(_n, 0); - _tabu.clear(); - _tabu.resize(_n, false); - } - - // Executes the algorithm - template - TerminationCause start() { - if (_n == 0) return SIZE_LIMIT; - if (_n == 1) { - _best_clique[0] = true; - _best_size = 1; - return SIZE_LIMIT; - } - - // Iterated local search algorithm - const int max_size = _size_limit >= 0 ? _size_limit : _n; - const int max_restart = _iteration_limit >= 0 ? - _iteration_limit : std::numeric_limits::max(); - const int max_select = _step_limit >= 0 ? - _step_limit : std::numeric_limits::max(); - - SelectionRuleImpl sel_method(*this); - int select = 0, restart = 0; - IntVector restart_nodes; - while (select < max_select && restart < max_restart) { - - // Perturbation/restart - restart++; - if (_delta_based_restart) { - restart_nodes.clear(); - for (int i = 0; i != _n; i++) { - if (_delta[i] >= _restart_delta_limit) - restart_nodes.push_back(i); - } - } - int rs_node = -1; - if (restart_nodes.size() > 0) { - rs_node = restart_nodes[_rnd[restart_nodes.size()]]; - } else { - rs_node = _rnd[_n]; - } - BoolVector &row = _gr[rs_node]; - for (int i = 0; i != _n; i++) { - if (_clique[i] && !row[i]) delCliqueNode(i); - } - addCliqueNode(rs_node); - - // Local search - _tabu.clear(); - _tabu.resize(_n, false); - bool tabu_empty = true; - int max_swap = _size; - while (select < max_select) { - select++; - int u; - if ((u = sel_method.nextFeasibleAddNode()) != -1) { - // Feasible add move - addCliqueNode(u); - if (tabu_empty) max_swap = _size; - } - else if ((u = sel_method.nextFeasibleSwapNode()) != -1) { - // Feasible swap move - int v = -1; - BoolVector &row = _gr[u]; - for (int i = 0; i != _n; i++) { - if (_clique[i] && !row[i]) { - v = i; - break; - } - } - addCliqueNode(u); - delCliqueNode(v); - _tabu[v] = true; - tabu_empty = false; - if (--max_swap <= 0) break; - } - else if ((u = sel_method.nextAddNode()) != -1) { - // Non-feasible add move - addCliqueNode(u); - } - else break; - } - if (_size > _best_size) { - _best_clique = _clique; - _best_size = _size; - if (_best_size >= max_size) return SIZE_LIMIT; - } - sel_method.update(); - } - - return (restart >= max_restart ? ITERATION_LIMIT : STEP_LIMIT); - } - - }; //class GrossoLocatelliPullanMc - - ///@} - -} //namespace lemon - -#endif //LEMON_GROSSO_LOCATELLI_PULLAN_MC_H Index: lemon/hao_orlin.h =================================================================== --- lemon/hao_orlin.h (revision 915) +++ lemon/hao_orlin.h (revision 597) @@ -3,5 +3,5 @@ * This file is a part of LEMON, a generic C++ optimization library. * - * Copyright (C) 2003-2010 + * Copyright (C) 2003-2009 * Egervary Jeno Kombinatorikus Optimalizalasi Kutatocsoport * (Egervary Research Group on Combinatorial Optimization, EGRES). @@ -32,5 +32,5 @@ /// \brief Implementation of the Hao-Orlin algorithm. /// -/// Implementation of the Hao-Orlin algorithm for finding a minimum cut +/// Implementation of the Hao-Orlin algorithm for finding a minimum cut /// in a digraph. @@ -42,5 +42,5 @@ /// /// This class implements the Hao-Orlin algorithm for finding a minimum - /// value cut in a directed graph \f$D=(V,A)\f$. + /// value cut in a directed graph \f$D=(V,A)\f$. /// It takes a fixed node \f$ source \in V \f$ and /// consists of two phases: in the first phase it determines a @@ -54,10 +54,10 @@ /// preflow push-relabel algorithm. Our implementation calculates /// the minimum cut in \f$ O(n^2\sqrt{m}) \f$ time (we use the - /// highest-label rule), or in \f$O(nm)\f$ for unit capacities. A notable - /// use of this algorithm is testing network reliability. + /// highest-label rule), or in \f$O(nm)\f$ for unit capacities. The + /// purpose of such algorithm is e.g. testing network reliability. /// /// For an undirected graph you can run just the first phase of the /// algorithm or you can use the algorithm of Nagamochi and Ibaraki, - /// which solves the undirected problem in \f$ O(nm + n^2 \log n) \f$ + /// which solves the undirected problem in \f$ O(nm + n^2 \log n) \f$ /// time. It is implemented in the NagamochiIbaraki algorithm class. /// @@ -77,5 +77,5 @@ class HaoOrlin { public: - + /// The digraph type of the algorithm typedef GR Digraph; @@ -164,21 +164,4 @@ delete _flow; } - } - - /// \brief Set the tolerance used by the algorithm. - /// - /// This function sets the tolerance object used by the algorithm. - /// \return (*this) - HaoOrlin& tolerance(const Tolerance& tolerance) { - _tolerance = tolerance; - return *this; - } - - /// \brief Returns a const reference to the tolerance. - /// - /// This function returns a const reference to the tolerance object - /// used by the algorithm. - const Tolerance& tolerance() const { - return _tolerance; } @@ -865,5 +848,5 @@ /// /// This function initializes the internal data structures. It creates - /// the maps and some bucket structures for the algorithm. + /// the maps and some bucket structures for the algorithm. /// The given node is used as the source node for the push-relabel /// algorithm. @@ -913,6 +896,4 @@ /// source-side (i.e. a set \f$ X\subsetneq V \f$ with /// \f$ source \in X \f$ and minimal outgoing capacity). - /// It updates the stored cut if (and only if) the newly found one - /// is better. /// /// \pre \ref init() must be called before using this function. @@ -927,6 +908,4 @@ /// sink-side (i.e. a set \f$ X\subsetneq V \f$ with /// \f$ source \notin X \f$ and minimal outgoing capacity). - /// It updates the stored cut if (and only if) the newly found one - /// is better. /// /// \pre \ref init() must be called before using this function. @@ -938,6 +917,6 @@ /// \brief Run the algorithm. /// - /// This function runs the algorithm. It chooses source node, - /// then calls \ref init(), \ref calculateOut() + /// This function runs the algorithm. It finds nodes \c source and + /// \c target arbitrarily and then calls \ref init(), \ref calculateOut() /// and \ref calculateIn(). void run() { @@ -949,7 +928,7 @@ /// \brief Run the algorithm. /// - /// This function runs the algorithm. It calls \ref init(), - /// \ref calculateOut() and \ref calculateIn() with the given - /// source node. + /// This function runs the algorithm. It uses the given \c source node, + /// finds a proper \c target node and then calls the \ref init(), + /// \ref calculateOut() and \ref calculateIn(). void run(const Node& s) { init(s); @@ -963,5 +942,5 @@ /// The result of the %HaoOrlin algorithm /// can be obtained using these functions.\n - /// \ref run(), \ref calculateOut() or \ref calculateIn() + /// \ref run(), \ref calculateOut() or \ref calculateIn() /// should be called before using them. @@ -970,9 +949,7 @@ /// \brief Return the value of the minimum cut. /// - /// This function returns the value of the best cut found by the - /// previously called \ref run(), \ref calculateOut() or \ref - /// calculateIn(). - /// - /// \pre \ref run(), \ref calculateOut() or \ref calculateIn() + /// This function returns the value of the minimum cut. + /// + /// \pre \ref run(), \ref calculateOut() or \ref calculateIn() /// must be called before using this function. Value minCutValue() const { @@ -983,11 +960,7 @@ /// \brief Return a minimum cut. /// - /// This function gives the best cut found by the - /// previously called \ref run(), \ref calculateOut() or \ref - /// calculateIn(). - /// - /// It sets \c cutMap to the characteristic vector of the found - /// minimum value cut - a non-empty set \f$ X\subsetneq V \f$ - /// of minimum outgoing capacity (i.e. \c cutMap will be \c true exactly + /// This function sets \c cutMap to the characteristic vector of a + /// minimum value cut: it will give a non-empty set \f$ X\subsetneq V \f$ + /// with minimal outgoing capacity (i.e. \c cutMap will be \c true exactly /// for the nodes of \f$ X \f$). /// @@ -997,5 +970,5 @@ /// \return The value of the minimum cut. /// - /// \pre \ref run(), \ref calculateOut() or \ref calculateIn() + /// \pre \ref run(), \ref calculateOut() or \ref calculateIn() /// must be called before using this function. template Index: mon/hartmann_orlin_mmc.h =================================================================== --- lemon/hartmann_orlin_mmc.h (revision 1002) +++ (revision ) @@ -1,650 +1,0 @@ -/* -*- mode: C++; indent-tabs-mode: nil; -*- - * - * This file is a part of LEMON, a generic C++ optimization library. - * - * Copyright (C) 2003-2010 - * Egervary Jeno Kombinatorikus Optimalizalasi Kutatocsoport - * (Egervary Research Group on Combinatorial Optimization, EGRES). - * - * Permission to use, modify and distribute this software is granted - * provided that this copyright notice appears in all copies. For - * precise terms see the accompanying LICENSE file. - * - * This software is provided "AS IS" with no warranty of any kind, - * express or implied, and with no claim as to its suitability for any - * purpose. - * - */ - -#ifndef LEMON_HARTMANN_ORLIN_MMC_H -#define LEMON_HARTMANN_ORLIN_MMC_H - -/// \ingroup min_mean_cycle -/// -/// \file -/// \brief Hartmann-Orlin's algorithm for finding a minimum mean cycle. - -#include -#include -#include -#include -#include -#include - -namespace lemon { - - /// \brief Default traits class of HartmannOrlinMmc class. - /// - /// Default traits class of HartmannOrlinMmc class. - /// \tparam GR The type of the digraph. - /// \tparam CM The type of the cost map. - /// It must conform to the \ref concepts::ReadMap "ReadMap" concept. -#ifdef DOXYGEN - template -#else - template ::is_integer> -#endif - struct HartmannOrlinMmcDefaultTraits - { - /// The type of the digraph - typedef GR Digraph; - /// The type of the cost map - typedef CM CostMap; - /// The type of the arc costs - typedef typename CostMap::Value Cost; - - /// \brief The large cost type used for internal computations - /// - /// The large cost type used for internal computations. - /// It is \c long \c long if the \c Cost type is integer, - /// otherwise it is \c double. - /// \c Cost must be convertible to \c LargeCost. - typedef double LargeCost; - - /// The tolerance type used for internal computations - typedef lemon::Tolerance Tolerance; - - /// \brief The path type of the found cycles - /// - /// The path type of the found cycles. - /// It must conform to the \ref lemon::concepts::Path "Path" concept - /// and it must have an \c addFront() function. - typedef lemon::Path Path; - }; - - // Default traits class for integer cost types - template - struct HartmannOrlinMmcDefaultTraits - { - typedef GR Digraph; - typedef CM CostMap; - typedef typename CostMap::Value Cost; -#ifdef LEMON_HAVE_LONG_LONG - typedef long long LargeCost; -#else - typedef long LargeCost; -#endif - typedef lemon::Tolerance Tolerance; - typedef lemon::Path Path; - }; - - - /// \addtogroup min_mean_cycle - /// @{ - - /// \brief Implementation of the Hartmann-Orlin algorithm for finding - /// a minimum mean cycle. - /// - /// This class implements the Hartmann-Orlin algorithm for finding - /// a directed cycle of minimum mean cost in a digraph - /// \ref hartmann93finding, \ref dasdan98minmeancycle. - /// It is an improved version of \ref KarpMmc "Karp"'s original algorithm, - /// it applies an efficient early termination scheme. - /// It runs in time O(ne) and uses space O(n2+e). - /// - /// \tparam GR The type of the digraph the algorithm runs on. - /// \tparam CM The type of the cost map. The default - /// map type is \ref concepts::Digraph::ArcMap "GR::ArcMap". - /// \tparam TR The traits class that defines various types used by the - /// algorithm. By default, it is \ref HartmannOrlinMmcDefaultTraits - /// "HartmannOrlinMmcDefaultTraits". - /// In most cases, this parameter should not be set directly, - /// consider to use the named template parameters instead. -#ifdef DOXYGEN - template -#else - template < typename GR, - typename CM = typename GR::template ArcMap, - typename TR = HartmannOrlinMmcDefaultTraits > -#endif - class HartmannOrlinMmc - { - public: - - /// The type of the digraph - typedef typename TR::Digraph Digraph; - /// The type of the cost map - typedef typename TR::CostMap CostMap; - /// The type of the arc costs - typedef typename TR::Cost Cost; - - /// \brief The large cost type - /// - /// The large cost type used for internal computations. - /// By default, it is \c long \c long if the \c Cost type is integer, - /// otherwise it is \c double. - typedef typename TR::LargeCost LargeCost; - - /// The tolerance type - typedef typename TR::Tolerance Tolerance; - - /// \brief The path type of the found cycles - /// - /// The path type of the found cycles. - /// Using the \ref HartmannOrlinMmcDefaultTraits "default traits class", - /// it is \ref lemon::Path "Path". - typedef typename TR::Path Path; - - /// The \ref HartmannOrlinMmcDefaultTraits "traits class" of the algorithm - typedef TR Traits; - - private: - - TEMPLATE_DIGRAPH_TYPEDEFS(Digraph); - - // Data sturcture for path data - struct PathData - { - LargeCost dist; - Arc pred; - PathData(LargeCost d, Arc p = INVALID) : - dist(d), pred(p) {} - }; - - typedef typename Digraph::template NodeMap > - PathDataNodeMap; - - private: - - // The digraph the algorithm runs on - const Digraph &_gr; - // The cost of the arcs - const CostMap &_cost; - - // Data for storing the strongly connected components - int _comp_num; - typename Digraph::template NodeMap _comp; - std::vector > _comp_nodes; - std::vector* _nodes; - typename Digraph::template NodeMap > _out_arcs; - - // Data for the found cycles - bool _curr_found, _best_found; - LargeCost _curr_cost, _best_cost; - int _curr_size, _best_size; - Node _curr_node, _best_node; - int _curr_level, _best_level; - - Path *_cycle_path; - bool _local_path; - - // Node map for storing path data - PathDataNodeMap _data; - // The processed nodes in the last round - std::vector _process; - - Tolerance _tolerance; - - // Infinite constant - const LargeCost INF; - - public: - - /// \name Named Template Parameters - /// @{ - - template - struct SetLargeCostTraits : public Traits { - typedef T LargeCost; - typedef lemon::Tolerance Tolerance; - }; - - /// \brief \ref named-templ-param "Named parameter" for setting - /// \c LargeCost type. - /// - /// \ref named-templ-param "Named parameter" for setting \c LargeCost - /// type. It is used for internal computations in the algorithm. - template - struct SetLargeCost - : public HartmannOrlinMmc > { - typedef HartmannOrlinMmc > Create; - }; - - template - struct SetPathTraits : public Traits { - typedef T Path; - }; - - /// \brief \ref named-templ-param "Named parameter" for setting - /// \c %Path type. - /// - /// \ref named-templ-param "Named parameter" for setting the \c %Path - /// type of the found cycles. - /// It must conform to the \ref lemon::concepts::Path "Path" concept - /// and it must have an \c addFront() function. - template - struct SetPath - : public HartmannOrlinMmc > { - typedef HartmannOrlinMmc > Create; - }; - - /// @} - - protected: - - HartmannOrlinMmc() {} - - public: - - /// \brief Constructor. - /// - /// The constructor of the class. - /// - /// \param digraph The digraph the algorithm runs on. - /// \param cost The costs of the arcs. - HartmannOrlinMmc( const Digraph &digraph, - const CostMap &cost ) : - _gr(digraph), _cost(cost), _comp(digraph), _out_arcs(digraph), - _best_found(false), _best_cost(0), _best_size(1), - _cycle_path(NULL), _local_path(false), _data(digraph), - INF(std::numeric_limits::has_infinity ? - std::numeric_limits::infinity() : - std::numeric_limits::max()) - {} - - /// Destructor. - ~HartmannOrlinMmc() { - if (_local_path) delete _cycle_path; - } - - /// \brief Set the path structure for storing the found cycle. - /// - /// This function sets an external path structure for storing the - /// found cycle. - /// - /// If you don't call this function before calling \ref run() or - /// \ref findCycleMean(), it will allocate a local \ref Path "path" - /// structure. The destuctor deallocates this automatically - /// allocated object, of course. - /// - /// \note The algorithm calls only the \ref lemon::Path::addFront() - /// "addFront()" function of the given path structure. - /// - /// \return (*this) - HartmannOrlinMmc& cycle(Path &path) { - if (_local_path) { - delete _cycle_path; - _local_path = false; - } - _cycle_path = &path; - return *this; - } - - /// \brief Set the tolerance used by the algorithm. - /// - /// This function sets the tolerance object used by the algorithm. - /// - /// \return (*this) - HartmannOrlinMmc& tolerance(const Tolerance& tolerance) { - _tolerance = tolerance; - return *this; - } - - /// \brief Return a const reference to the tolerance. - /// - /// This function returns a const reference to the tolerance object - /// used by the algorithm. - const Tolerance& tolerance() const { - return _tolerance; - } - - /// \name Execution control - /// The simplest way to execute the algorithm is to call the \ref run() - /// function.\n - /// If you only need the minimum mean cost, you may call - /// \ref findCycleMean(). - - /// @{ - - /// \brief Run the algorithm. - /// - /// This function runs the algorithm. - /// It can be called more than once (e.g. if the underlying digraph - /// and/or the arc costs have been modified). - /// - /// \return \c true if a directed cycle exists in the digraph. - /// - /// \note mmc.run() is just a shortcut of the following code. - /// \code - /// return mmc.findCycleMean() && mmc.findCycle(); - /// \endcode - bool run() { - return findCycleMean() && findCycle(); - } - - /// \brief Find the minimum cycle mean. - /// - /// This function finds the minimum mean cost of the directed - /// cycles in the digraph. - /// - /// \return \c true if a directed cycle exists in the digraph. - bool findCycleMean() { - // Initialization and find strongly connected components - init(); - findComponents(); - - // Find the minimum cycle mean in the components - for (int comp = 0; comp < _comp_num; ++comp) { - if (!initComponent(comp)) continue; - processRounds(); - - // Update the best cycle (global minimum mean cycle) - if ( _curr_found && (!_best_found || - _curr_cost * _best_size < _best_cost * _curr_size) ) { - _best_found = true; - _best_cost = _curr_cost; - _best_size = _curr_size; - _best_node = _curr_node; - _best_level = _curr_level; - } - } - return _best_found; - } - - /// \brief Find a minimum mean directed cycle. - /// - /// This function finds a directed cycle of minimum mean cost - /// in the digraph using the data computed by findCycleMean(). - /// - /// \return \c true if a directed cycle exists in the digraph. - /// - /// \pre \ref findCycleMean() must be called before using this function. - bool findCycle() { - if (!_best_found) return false; - IntNodeMap reached(_gr, -1); - int r = _best_level + 1; - Node u = _best_node; - while (reached[u] < 0) { - reached[u] = --r; - u = _gr.source(_data[u][r].pred); - } - r = reached[u]; - Arc e = _data[u][r].pred; - _cycle_path->addFront(e); - _best_cost = _cost[e]; - _best_size = 1; - Node v; - while ((v = _gr.source(e)) != u) { - e = _data[v][--r].pred; - _cycle_path->addFront(e); - _best_cost += _cost[e]; - ++_best_size; - } - return true; - } - - /// @} - - /// \name Query Functions - /// The results of the algorithm can be obtained using these - /// functions.\n - /// The algorithm should be executed before using them. - - /// @{ - - /// \brief Return the total cost of the found cycle. - /// - /// This function returns the total cost of the found cycle. - /// - /// \pre \ref run() or \ref findCycleMean() must be called before - /// using this function. - Cost cycleCost() const { - return static_cast(_best_cost); - } - - /// \brief Return the number of arcs on the found cycle. - /// - /// This function returns the number of arcs on the found cycle. - /// - /// \pre \ref run() or \ref findCycleMean() must be called before - /// using this function. - int cycleSize() const { - return _best_size; - } - - /// \brief Return the mean cost of the found cycle. - /// - /// This function returns the mean cost of the found cycle. - /// - /// \note alg.cycleMean() is just a shortcut of the - /// following code. - /// \code - /// return static_cast(alg.cycleCost()) / alg.cycleSize(); - /// \endcode - /// - /// \pre \ref run() or \ref findCycleMean() must be called before - /// using this function. - double cycleMean() const { - return static_cast(_best_cost) / _best_size; - } - - /// \brief Return the found cycle. - /// - /// This function returns a const reference to the path structure - /// storing the found cycle. - /// - /// \pre \ref run() or \ref findCycle() must be called before using - /// this function. - const Path& cycle() const { - return *_cycle_path; - } - - ///@} - - private: - - // Initialization - void init() { - if (!_cycle_path) { - _local_path = true; - _cycle_path = new Path; - } - _cycle_path->clear(); - _best_found = false; - _best_cost = 0; - _best_size = 1; - _cycle_path->clear(); - for (NodeIt u(_gr); u != INVALID; ++u) - _data[u].clear(); - } - - // Find strongly connected components and initialize _comp_nodes - // and _out_arcs - void findComponents() { - _comp_num = stronglyConnectedComponents(_gr, _comp); - _comp_nodes.resize(_comp_num); - if (_comp_num == 1) { - _comp_nodes[0].clear(); - for (NodeIt n(_gr); n != INVALID; ++n) { - _comp_nodes[0].push_back(n); - _out_arcs[n].clear(); - for (OutArcIt a(_gr, n); a != INVALID; ++a) { - _out_arcs[n].push_back(a); - } - } - } else { - for (int i = 0; i < _comp_num; ++i) - _comp_nodes[i].clear(); - for (NodeIt n(_gr); n != INVALID; ++n) { - int k = _comp[n]; - _comp_nodes[k].push_back(n); - _out_arcs[n].clear(); - for (OutArcIt a(_gr, n); a != INVALID; ++a) { - if (_comp[_gr.target(a)] == k) _out_arcs[n].push_back(a); - } - } - } - } - - // Initialize path data for the current component - bool initComponent(int comp) { - _nodes = &(_comp_nodes[comp]); - int n = _nodes->size(); - if (n < 1 || (n == 1 && _out_arcs[(*_nodes)[0]].size() == 0)) { - return false; - } - for (int i = 0; i < n; ++i) { - _data[(*_nodes)[i]].resize(n + 1, PathData(INF)); - } - return true; - } - - // Process all rounds of computing path data for the current component. - // _data[v][k] is the cost of a shortest directed walk from the root - // node to node v containing exactly k arcs. - void processRounds() { - Node start = (*_nodes)[0]; - _data[start][0] = PathData(0); - _process.clear(); - _process.push_back(start); - - int k, n = _nodes->size(); - int next_check = 4; - bool terminate = false; - for (k = 1; k <= n && int(_process.size()) < n && !terminate; ++k) { - processNextBuildRound(k); - if (k == next_check || k == n) { - terminate = checkTermination(k); - next_check = next_check * 3 / 2; - } - } - for ( ; k <= n && !terminate; ++k) { - processNextFullRound(k); - if (k == next_check || k == n) { - terminate = checkTermination(k); - next_check = next_check * 3 / 2; - } - } - } - - // Process one round and rebuild _process - void processNextBuildRound(int k) { - std::vector next; - Node u, v; - Arc e; - LargeCost d; - for (int i = 0; i < int(_process.size()); ++i) { - u = _process[i]; - for (int j = 0; j < int(_out_arcs[u].size()); ++j) { - e = _out_arcs[u][j]; - v = _gr.target(e); - d = _data[u][k-1].dist + _cost[e]; - if (_tolerance.less(d, _data[v][k].dist)) { - if (_data[v][k].dist == INF) next.push_back(v); - _data[v][k] = PathData(d, e); - } - } - } - _process.swap(next); - } - - // Process one round using _nodes instead of _process - void processNextFullRound(int k) { - Node u, v; - Arc e; - LargeCost d; - for (int i = 0; i < int(_nodes->size()); ++i) { - u = (*_nodes)[i]; - for (int j = 0; j < int(_out_arcs[u].size()); ++j) { - e = _out_arcs[u][j]; - v = _gr.target(e); - d = _data[u][k-1].dist + _cost[e]; - if (_tolerance.less(d, _data[v][k].dist)) { - _data[v][k] = PathData(d, e); - } - } - } - } - - // Check early termination - bool checkTermination(int k) { - typedef std::pair Pair; - typename GR::template NodeMap level(_gr, Pair(-1, 0)); - typename GR::template NodeMap pi(_gr); - int n = _nodes->size(); - LargeCost cost; - int size; - Node u; - - // Search for cycles that are already found - _curr_found = false; - for (int i = 0; i < n; ++i) { - u = (*_nodes)[i]; - if (_data[u][k].dist == INF) continue; - for (int j = k; j >= 0; --j) { - if (level[u].first == i && level[u].second > 0) { - // A cycle is found - cost = _data[u][level[u].second].dist - _data[u][j].dist; - size = level[u].second - j; - if (!_curr_found || cost * _curr_size < _curr_cost * size) { - _curr_cost = cost; - _curr_size = size; - _curr_node = u; - _curr_level = level[u].second; - _curr_found = true; - } - } - level[u] = Pair(i, j); - if (j != 0) { - u = _gr.source(_data[u][j].pred); - } - } - } - - // If at least one cycle is found, check the optimality condition - LargeCost d; - if (_curr_found && k < n) { - // Find node potentials - for (int i = 0; i < n; ++i) { - u = (*_nodes)[i]; - pi[u] = INF; - for (int j = 0; j <= k; ++j) { - if (_data[u][j].dist < INF) { - d = _data[u][j].dist * _curr_size - j * _curr_cost; - if (_tolerance.less(d, pi[u])) pi[u] = d; - } - } - } - - // Check the optimality condition for all arcs - bool done = true; - for (ArcIt a(_gr); a != INVALID; ++a) { - if (_tolerance.less(_cost[a] * _curr_size - _curr_cost, - pi[_gr.target(a)] - pi[_gr.source(a)]) ) { - done = false; - break; - } - } - return done; - } - return (k == n); - } - - }; //class HartmannOrlinMmc - - ///@} - -} //namespace lemon - -#endif //LEMON_HARTMANN_ORLIN_MMC_H Index: mon/howard_mmc.h =================================================================== --- lemon/howard_mmc.h (revision 1002) +++ (revision ) @@ -1,605 +1,0 @@ -/* -*- mode: C++; indent-tabs-mode: nil; -*- - * - * This file is a part of LEMON, a generic C++ optimization library. - * - * Copyright (C) 2003-2010 - * Egervary Jeno Kombinatorikus Optimalizalasi Kutatocsoport - * (Egervary Research Group on Combinatorial Optimization, EGRES). - * - * Permission to use, modify and distribute this software is granted - * provided that this copyright notice appears in all copies. For - * precise terms see the accompanying LICENSE file. - * - * This software is provided "AS IS" with no warranty of any kind, - * express or implied, and with no claim as to its suitability for any - * purpose. - * - */ - -#ifndef LEMON_HOWARD_MMC_H -#define LEMON_HOWARD_MMC_H - -/// \ingroup min_mean_cycle -/// -/// \file -/// \brief Howard's algorithm for finding a minimum mean cycle. - -#include -#include -#include -#include -#include -#include - -namespace lemon { - - /// \brief Default traits class of HowardMmc class. - /// - /// Default traits class of HowardMmc class. - /// \tparam GR The type of the digraph. - /// \tparam CM The type of the cost map. - /// It must conform to the \ref concepts::ReadMap "ReadMap" concept. -#ifdef DOXYGEN - template -#else - template ::is_integer> -#endif - struct HowardMmcDefaultTraits - { - /// The type of the digraph - typedef GR Digraph; - /// The type of the cost map - typedef CM CostMap; - /// The type of the arc costs - typedef typename CostMap::Value Cost; - - /// \brief The large cost type used for internal computations - /// - /// The large cost type used for internal computations. - /// It is \c long \c long if the \c Cost type is integer, - /// otherwise it is \c double. - /// \c Cost must be convertible to \c LargeCost. - typedef double LargeCost; - - /// The tolerance type used for internal computations - typedef lemon::Tolerance Tolerance; - - /// \brief The path type of the found cycles - /// - /// The path type of the found cycles. - /// It must conform to the \ref lemon::concepts::Path "Path" concept - /// and it must have an \c addBack() function. - typedef lemon::Path Path; - }; - - // Default traits class for integer cost types - template - struct HowardMmcDefaultTraits - { - typedef GR Digraph; - typedef CM CostMap; - typedef typename CostMap::Value Cost; -#ifdef LEMON_HAVE_LONG_LONG - typedef long long LargeCost; -#else - typedef long LargeCost; -#endif - typedef lemon::Tolerance Tolerance; - typedef lemon::Path Path; - }; - - - /// \addtogroup min_mean_cycle - /// @{ - - /// \brief Implementation of Howard's algorithm for finding a minimum - /// mean cycle. - /// - /// This class implements Howard's policy iteration algorithm for finding - /// a directed cycle of minimum mean cost in a digraph - /// \ref dasdan98minmeancycle, \ref dasdan04experimental. - /// This class provides the most efficient algorithm for the - /// minimum mean cycle problem, though the best known theoretical - /// bound on its running time is exponential. - /// - /// \tparam GR The type of the digraph the algorithm runs on. - /// \tparam CM The type of the cost map. The default - /// map type is \ref concepts::Digraph::ArcMap "GR::ArcMap". - /// \tparam TR The traits class that defines various types used by the - /// algorithm. By default, it is \ref HowardMmcDefaultTraits - /// "HowardMmcDefaultTraits". - /// In most cases, this parameter should not be set directly, - /// consider to use the named template parameters instead. -#ifdef DOXYGEN - template -#else - template < typename GR, - typename CM = typename GR::template ArcMap, - typename TR = HowardMmcDefaultTraits > -#endif - class HowardMmc - { - public: - - /// The type of the digraph - typedef typename TR::Digraph Digraph; - /// The type of the cost map - typedef typename TR::CostMap CostMap; - /// The type of the arc costs - typedef typename TR::Cost Cost; - - /// \brief The large cost type - /// - /// The large cost type used for internal computations. - /// By default, it is \c long \c long if the \c Cost type is integer, - /// otherwise it is \c double. - typedef typename TR::LargeCost LargeCost; - - /// The tolerance type - typedef typename TR::Tolerance Tolerance; - - /// \brief The path type of the found cycles - /// - /// The path type of the found cycles. - /// Using the \ref HowardMmcDefaultTraits "default traits class", - /// it is \ref lemon::Path "Path". - typedef typename TR::Path Path; - - /// The \ref HowardMmcDefaultTraits "traits class" of the algorithm - typedef TR Traits; - - private: - - TEMPLATE_DIGRAPH_TYPEDEFS(Digraph); - - // The digraph the algorithm runs on - const Digraph &_gr; - // The cost of the arcs - const CostMap &_cost; - - // Data for the found cycles - bool _curr_found, _best_found; - LargeCost _curr_cost, _best_cost; - int _curr_size, _best_size; - Node _curr_node, _best_node; - - Path *_cycle_path; - bool _local_path; - - // Internal data used by the algorithm - typename Digraph::template NodeMap _policy; - typename Digraph::template NodeMap _reached; - typename Digraph::template NodeMap _level; - typename Digraph::template NodeMap _dist; - - // Data for storing the strongly connected components - int _comp_num; - typename Digraph::template NodeMap _comp; - std::vector > _comp_nodes; - std::vector* _nodes; - typename Digraph::template NodeMap > _in_arcs; - - // Queue used for BFS search - std::vector _queue; - int _qfront, _qback; - - Tolerance _tolerance; - - // Infinite constant - const LargeCost INF; - - public: - - /// \name Named Template Parameters - /// @{ - - template - struct SetLargeCostTraits : public Traits { - typedef T LargeCost; - typedef lemon::Tolerance Tolerance; - }; - - /// \brief \ref named-templ-param "Named parameter" for setting - /// \c LargeCost type. - /// - /// \ref named-templ-param "Named parameter" for setting \c LargeCost - /// type. It is used for internal computations in the algorithm. - template - struct SetLargeCost - : public HowardMmc > { - typedef HowardMmc > Create; - }; - - template - struct SetPathTraits : public Traits { - typedef T Path; - }; - - /// \brief \ref named-templ-param "Named parameter" for setting - /// \c %Path type. - /// - /// \ref named-templ-param "Named parameter" for setting the \c %Path - /// type of the found cycles. - /// It must conform to the \ref lemon::concepts::Path "Path" concept - /// and it must have an \c addBack() function. - template - struct SetPath - : public HowardMmc > { - typedef HowardMmc > Create; - }; - - /// @} - - protected: - - HowardMmc() {} - - public: - - /// \brief Constructor. - /// - /// The constructor of the class. - /// - /// \param digraph The digraph the algorithm runs on. - /// \param cost The costs of the arcs. - HowardMmc( const Digraph &digraph, - const CostMap &cost ) : - _gr(digraph), _cost(cost), _best_found(false), - _best_cost(0), _best_size(1), _cycle_path(NULL), _local_path(false), - _policy(digraph), _reached(digraph), _level(digraph), _dist(digraph), - _comp(digraph), _in_arcs(digraph), - INF(std::numeric_limits::has_infinity ? - std::numeric_limits::infinity() : - std::numeric_limits::max()) - {} - - /// Destructor. - ~HowardMmc() { - if (_local_path) delete _cycle_path; - } - - /// \brief Set the path structure for storing the found cycle. - /// - /// This function sets an external path structure for storing the - /// found cycle. - /// - /// If you don't call this function before calling \ref run() or - /// \ref findCycleMean(), it will allocate a local \ref Path "path" - /// structure. The destuctor deallocates this automatically - /// allocated object, of course. - /// - /// \note The algorithm calls only the \ref lemon::Path::addBack() - /// "addBack()" function of the given path structure. - /// - /// \return (*this) - HowardMmc& cycle(Path &path) { - if (_local_path) { - delete _cycle_path; - _local_path = false; - } - _cycle_path = &path; - return *this; - } - - /// \brief Set the tolerance used by the algorithm. - /// - /// This function sets the tolerance object used by the algorithm. - /// - /// \return (*this) - HowardMmc& tolerance(const Tolerance& tolerance) { - _tolerance = tolerance; - return *this; - } - - /// \brief Return a const reference to the tolerance. - /// - /// This function returns a const reference to the tolerance object - /// used by the algorithm. - const Tolerance& tolerance() const { - return _tolerance; - } - - /// \name Execution control - /// The simplest way to execute the algorithm is to call the \ref run() - /// function.\n - /// If you only need the minimum mean cost, you may call - /// \ref findCycleMean(). - - /// @{ - - /// \brief Run the algorithm. - /// - /// This function runs the algorithm. - /// It can be called more than once (e.g. if the underlying digraph - /// and/or the arc costs have been modified). - /// - /// \return \c true if a directed cycle exists in the digraph. - /// - /// \note mmc.run() is just a shortcut of the following code. - /// \code - /// return mmc.findCycleMean() && mmc.findCycle(); - /// \endcode - bool run() { - return findCycleMean() && findCycle(); - } - - /// \brief Find the minimum cycle mean. - /// - /// This function finds the minimum mean cost of the directed - /// cycles in the digraph. - /// - /// \return \c true if a directed cycle exists in the digraph. - bool findCycleMean() { - // Initialize and find strongly connected components - init(); - findComponents(); - - // Find the minimum cycle mean in the components - for (int comp = 0; comp < _comp_num; ++comp) { - // Find the minimum mean cycle in the current component - if (!buildPolicyGraph(comp)) continue; - while (true) { - findPolicyCycle(); - if (!computeNodeDistances()) break; - } - // Update the best cycle (global minimum mean cycle) - if ( _curr_found && (!_best_found || - _curr_cost * _best_size < _best_cost * _curr_size) ) { - _best_found = true; - _best_cost = _curr_cost; - _best_size = _curr_size; - _best_node = _curr_node; - } - } - return _best_found; - } - - /// \brief Find a minimum mean directed cycle. - /// - /// This function finds a directed cycle of minimum mean cost - /// in the digraph using the data computed by findCycleMean(). - /// - /// \return \c true if a directed cycle exists in the digraph. - /// - /// \pre \ref findCycleMean() must be called before using this function. - bool findCycle() { - if (!_best_found) return false; - _cycle_path->addBack(_policy[_best_node]); - for ( Node v = _best_node; - (v = _gr.target(_policy[v])) != _best_node; ) { - _cycle_path->addBack(_policy[v]); - } - return true; - } - - /// @} - - /// \name Query Functions - /// The results of the algorithm can be obtained using these - /// functions.\n - /// The algorithm should be executed before using them. - - /// @{ - - /// \brief Return the total cost of the found cycle. - /// - /// This function returns the total cost of the found cycle. - /// - /// \pre \ref run() or \ref findCycleMean() must be called before - /// using this function. - Cost cycleCost() const { - return static_cast(_best_cost); - } - - /// \brief Return the number of arcs on the found cycle. - /// - /// This function returns the number of arcs on the found cycle. - /// - /// \pre \ref run() or \ref findCycleMean() must be called before - /// using this function. - int cycleSize() const { - return _best_size; - } - - /// \brief Return the mean cost of the found cycle. - /// - /// This function returns the mean cost of the found cycle. - /// - /// \note alg.cycleMean() is just a shortcut of the - /// following code. - /// \code - /// return static_cast(alg.cycleCost()) / alg.cycleSize(); - /// \endcode - /// - /// \pre \ref run() or \ref findCycleMean() must be called before - /// using this function. - double cycleMean() const { - return static_cast(_best_cost) / _best_size; - } - - /// \brief Return the found cycle. - /// - /// This function returns a const reference to the path structure - /// storing the found cycle. - /// - /// \pre \ref run() or \ref findCycle() must be called before using - /// this function. - const Path& cycle() const { - return *_cycle_path; - } - - ///@} - - private: - - // Initialize - void init() { - if (!_cycle_path) { - _local_path = true; - _cycle_path = new Path; - } - _queue.resize(countNodes(_gr)); - _best_found = false; - _best_cost = 0; - _best_size = 1; - _cycle_path->clear(); - } - - // Find strongly connected components and initialize _comp_nodes - // and _in_arcs - void findComponents() { - _comp_num = stronglyConnectedComponents(_gr, _comp); - _comp_nodes.resize(_comp_num); - if (_comp_num == 1) { - _comp_nodes[0].clear(); - for (NodeIt n(_gr); n != INVALID; ++n) { - _comp_nodes[0].push_back(n); - _in_arcs[n].clear(); - for (InArcIt a(_gr, n); a != INVALID; ++a) { - _in_arcs[n].push_back(a); - } - } - } else { - for (int i = 0; i < _comp_num; ++i) - _comp_nodes[i].clear(); - for (NodeIt n(_gr); n != INVALID; ++n) { - int k = _comp[n]; - _comp_nodes[k].push_back(n); - _in_arcs[n].clear(); - for (InArcIt a(_gr, n); a != INVALID; ++a) { - if (_comp[_gr.source(a)] == k) _in_arcs[n].push_back(a); - } - } - } - } - - // Build the policy graph in the given strongly connected component - // (the out-degree of every node is 1) - bool buildPolicyGraph(int comp) { - _nodes = &(_comp_nodes[comp]); - if (_nodes->size() < 1 || - (_nodes->size() == 1 && _in_arcs[(*_nodes)[0]].size() == 0)) { - return false; - } - for (int i = 0; i < int(_nodes->size()); ++i) { - _dist[(*_nodes)[i]] = INF; - } - Node u, v; - Arc e; - for (int i = 0; i < int(_nodes->size()); ++i) { - v = (*_nodes)[i]; - for (int j = 0; j < int(_in_arcs[v].size()); ++j) { - e = _in_arcs[v][j]; - u = _gr.source(e); - if (_cost[e] < _dist[u]) { - _dist[u] = _cost[e]; - _policy[u] = e; - } - } - } - return true; - } - - // Find the minimum mean cycle in the policy graph - void findPolicyCycle() { - for (int i = 0; i < int(_nodes->size()); ++i) { - _level[(*_nodes)[i]] = -1; - } - LargeCost ccost; - int csize; - Node u, v; - _curr_found = false; - for (int i = 0; i < int(_nodes->size()); ++i) { - u = (*_nodes)[i]; - if (_level[u] >= 0) continue; - for (; _level[u] < 0; u = _gr.target(_policy[u])) { - _level[u] = i; - } - if (_level[u] == i) { - // A cycle is found - ccost = _cost[_policy[u]]; - csize = 1; - for (v = u; (v = _gr.target(_policy[v])) != u; ) { - ccost += _cost[_policy[v]]; - ++csize; - } - if ( !_curr_found || - (ccost * _curr_size < _curr_cost * csize) ) { - _curr_found = true; - _curr_cost = ccost; - _curr_size = csize; - _curr_node = u; - } - } - } - } - - // Contract the policy graph and compute node distances - bool computeNodeDistances() { - // Find the component of the main cycle and compute node distances - // using reverse BFS - for (int i = 0; i < int(_nodes->size()); ++i) { - _reached[(*_nodes)[i]] = false; - } - _qfront = _qback = 0; - _queue[0] = _curr_node; - _reached[_curr_node] = true; - _dist[_curr_node] = 0; - Node u, v; - Arc e; - while (_qfront <= _qback) { - v = _queue[_qfront++]; - for (int j = 0; j < int(_in_arcs[v].size()); ++j) { - e = _in_arcs[v][j]; - u = _gr.source(e); - if (_policy[u] == e && !_reached[u]) { - _reached[u] = true; - _dist[u] = _dist[v] + _cost[e] * _curr_size - _curr_cost; - _queue[++_qback] = u; - } - } - } - - // Connect all other nodes to this component and compute node - // distances using reverse BFS - _qfront = 0; - while (_qback < int(_nodes->size())-1) { - v = _queue[_qfront++]; - for (int j = 0; j < int(_in_arcs[v].size()); ++j) { - e = _in_arcs[v][j]; - u = _gr.source(e); - if (!_reached[u]) { - _reached[u] = true; - _policy[u] = e; - _dist[u] = _dist[v] + _cost[e] * _curr_size - _curr_cost; - _queue[++_qback] = u; - } - } - } - - // Improve node distances - bool improved = false; - for (int i = 0; i < int(_nodes->size()); ++i) { - v = (*_nodes)[i]; - for (int j = 0; j < int(_in_arcs[v].size()); ++j) { - e = _in_arcs[v][j]; - u = _gr.source(e); - LargeCost delta = _dist[v] + _cost[e] * _curr_size - _curr_cost; - if (_tolerance.less(delta, _dist[u])) { - _dist[u] = delta; - _policy[u] = e; - improved = true; - } - } - } - return improved; - } - - }; //class HowardMmc - - ///@} - -} //namespace lemon - -#endif //LEMON_HOWARD_MMC_H Index: lemon/hypercube_graph.h =================================================================== --- lemon/hypercube_graph.h (revision 788) +++ lemon/hypercube_graph.h (revision 617) @@ -263,5 +263,5 @@ } - static int index(Node node) { + int index(Node node) const { return node._id; } @@ -283,21 +283,15 @@ /// \brief Hypercube graph class /// - /// HypercubeGraph implements a special graph type. The nodes of the - /// graph are indexed with integers having at most \c dim binary digits. + /// This class implements a special graph type. The nodes of the graph + /// are indiced with integers with at most \c dim binary digits. /// Two nodes are connected in the graph if and only if their indices /// differ only on one position in the binary form. - /// This class is completely static and it needs constant memory space. - /// Thus you can neither add nor delete nodes or edges, however, - /// the structure can be resized using resize(). - /// - /// This type fully conforms to the \ref concepts::Graph "Graph concept". - /// Most of its member functions and nested classes are documented - /// only in the concept class. - /// - /// This class provides constant time counting for nodes, edges and arcs. /// /// \note The type of the indices is chosen to \c int for efficiency /// reasons. Thus the maximum dimension of this implementation is 26 /// (assuming that the size of \c int is 32 bit). + /// + /// This graph type fully conforms to the \ref concepts::Graph + /// "Graph concept". class HypercubeGraph : public ExtendedHypercubeGraphBase { typedef ExtendedHypercubeGraphBase Parent; @@ -309,19 +303,4 @@ /// Constructs a hypercube graph with \c dim dimensions. HypercubeGraph(int dim) { construct(dim); } - - /// \brief Resizes the graph - /// - /// This function resizes the graph. It fully destroys and - /// rebuilds the structure, therefore the maps of the graph will be - /// reallocated automatically and the previous values will be lost. - void resize(int dim) { - Parent::notifier(Arc()).clear(); - Parent::notifier(Edge()).clear(); - Parent::notifier(Node()).clear(); - construct(dim); - Parent::notifier(Node()).build(); - Parent::notifier(Edge()).build(); - Parent::notifier(Arc()).build(); - } /// \brief The number of dimensions. @@ -342,5 +321,5 @@ /// /// Gives back the dimension id of the given edge. - /// It is in the range [0..dim-1]. + /// It is in the [0..dim-1] range. int dimension(Edge edge) const { return Parent::dimension(edge); @@ -350,5 +329,5 @@ /// /// Gives back the dimension id of the given arc. - /// It is in the range [0..dim-1]. + /// It is in the [0..dim-1] range. int dimension(Arc arc) const { return Parent::dimension(arc); @@ -359,5 +338,5 @@ /// Gives back the index of the given node. /// The lower bits of the integer describes the node. - static int index(Node node) { + int index(Node node) const { return Parent::index(node); } Index: mon/karp_mmc.h =================================================================== --- lemon/karp_mmc.h (revision 1002) +++ (revision ) @@ -1,590 +1,0 @@ -/* -*- mode: C++; indent-tabs-mode: nil; -*- - * - * This file is a part of LEMON, a generic C++ optimization library. - * - * Copyright (C) 2003-2010 - * Egervary Jeno Kombinatorikus Optimalizalasi Kutatocsoport - * (Egervary Research Group on Combinatorial Optimization, EGRES). - * - * Permission to use, modify and distribute this software is granted - * provided that this copyright notice appears in all copies. For - * precise terms see the accompanying LICENSE file. - * - * This software is provided "AS IS" with no warranty of any kind, - * express or implied, and with no claim as to its suitability for any - * purpose. - * - */ - -#ifndef LEMON_KARP_MMC_H -#define LEMON_KARP_MMC_H - -/// \ingroup min_mean_cycle -/// -/// \file -/// \brief Karp's algorithm for finding a minimum mean cycle. - -#include -#include -#include -#include -#include -#include - -namespace lemon { - - /// \brief Default traits class of KarpMmc class. - /// - /// Default traits class of KarpMmc class. - /// \tparam GR The type of the digraph. - /// \tparam CM The type of the cost map. - /// It must conform to the \ref concepts::ReadMap "ReadMap" concept. -#ifdef DOXYGEN - template -#else - template ::is_integer> -#endif - struct KarpMmcDefaultTraits - { - /// The type of the digraph - typedef GR Digraph; - /// The type of the cost map - typedef CM CostMap; - /// The type of the arc costs - typedef typename CostMap::Value Cost; - - /// \brief The large cost type used for internal computations - /// - /// The large cost type used for internal computations. - /// It is \c long \c long if the \c Cost type is integer, - /// otherwise it is \c double. - /// \c Cost must be convertible to \c LargeCost. - typedef double LargeCost; - - /// The tolerance type used for internal computations - typedef lemon::Tolerance Tolerance; - - /// \brief The path type of the found cycles - /// - /// The path type of the found cycles. - /// It must conform to the \ref lemon::concepts::Path "Path" concept - /// and it must have an \c addFront() function. - typedef lemon::Path Path; - }; - - // Default traits class for integer cost types - template - struct KarpMmcDefaultTraits - { - typedef GR Digraph; - typedef CM CostMap; - typedef typename CostMap::Value Cost; -#ifdef LEMON_HAVE_LONG_LONG - typedef long long LargeCost; -#else - typedef long LargeCost; -#endif - typedef lemon::Tolerance Tolerance; - typedef lemon::Path Path; - }; - - - /// \addtogroup min_mean_cycle - /// @{ - - /// \brief Implementation of Karp's algorithm for finding a minimum - /// mean cycle. - /// - /// This class implements Karp's algorithm for finding a directed - /// cycle of minimum mean cost in a digraph - /// \ref karp78characterization, \ref dasdan98minmeancycle. - /// It runs in time O(ne) and uses space O(n2+e). - /// - /// \tparam GR The type of the digraph the algorithm runs on. - /// \tparam CM The type of the cost map. The default - /// map type is \ref concepts::Digraph::ArcMap "GR::ArcMap". - /// \tparam TR The traits class that defines various types used by the - /// algorithm. By default, it is \ref KarpMmcDefaultTraits - /// "KarpMmcDefaultTraits". - /// In most cases, this parameter should not be set directly, - /// consider to use the named template parameters instead. -#ifdef DOXYGEN - template -#else - template < typename GR, - typename CM = typename GR::template ArcMap, - typename TR = KarpMmcDefaultTraits > -#endif - class KarpMmc - { - public: - - /// The type of the digraph - typedef typename TR::Digraph Digraph; - /// The type of the cost map - typedef typename TR::CostMap CostMap; - /// The type of the arc costs - typedef typename TR::Cost Cost; - - /// \brief The large cost type - /// - /// The large cost type used for internal computations. - /// By default, it is \c long \c long if the \c Cost type is integer, - /// otherwise it is \c double. - typedef typename TR::LargeCost LargeCost; - - /// The tolerance type - typedef typename TR::Tolerance Tolerance; - - /// \brief The path type of the found cycles - /// - /// The path type of the found cycles. - /// Using the \ref KarpMmcDefaultTraits "default traits class", - /// it is \ref lemon::Path "Path". - typedef typename TR::Path Path; - - /// The \ref KarpMmcDefaultTraits "traits class" of the algorithm - typedef TR Traits; - - private: - - TEMPLATE_DIGRAPH_TYPEDEFS(Digraph); - - // Data sturcture for path data - struct PathData - { - LargeCost dist; - Arc pred; - PathData(LargeCost d, Arc p = INVALID) : - dist(d), pred(p) {} - }; - - typedef typename Digraph::template NodeMap > - PathDataNodeMap; - - private: - - // The digraph the algorithm runs on - const Digraph &_gr; - // The cost of the arcs - const CostMap &_cost; - - // Data for storing the strongly connected components - int _comp_num; - typename Digraph::template NodeMap _comp; - std::vector > _comp_nodes; - std::vector* _nodes; - typename Digraph::template NodeMap > _out_arcs; - - // Data for the found cycle - LargeCost _cycle_cost; - int _cycle_size; - Node _cycle_node; - - Path *_cycle_path; - bool _local_path; - - // Node map for storing path data - PathDataNodeMap _data; - // The processed nodes in the last round - std::vector _process; - - Tolerance _tolerance; - - // Infinite constant - const LargeCost INF; - - public: - - /// \name Named Template Parameters - /// @{ - - template - struct SetLargeCostTraits : public Traits { - typedef T LargeCost; - typedef lemon::Tolerance Tolerance; - }; - - /// \brief \ref named-templ-param "Named parameter" for setting - /// \c LargeCost type. - /// - /// \ref named-templ-param "Named parameter" for setting \c LargeCost - /// type. It is used for internal computations in the algorithm. - template - struct SetLargeCost - : public KarpMmc > { - typedef KarpMmc > Create; - }; - - template - struct SetPathTraits : public Traits { - typedef T Path; - }; - - /// \brief \ref named-templ-param "Named parameter" for setting - /// \c %Path type. - /// - /// \ref named-templ-param "Named parameter" for setting the \c %Path - /// type of the found cycles. - /// It must conform to the \ref lemon::concepts::Path "Path" concept - /// and it must have an \c addFront() function. - template - struct SetPath - : public KarpMmc > { - typedef KarpMmc > Create; - }; - - /// @} - - protected: - - KarpMmc() {} - - public: - - /// \brief Constructor. - /// - /// The constructor of the class. - /// - /// \param digraph The digraph the algorithm runs on. - /// \param cost The costs of the arcs. - KarpMmc( const Digraph &digraph, - const CostMap &cost ) : - _gr(digraph), _cost(cost), _comp(digraph), _out_arcs(digraph), - _cycle_cost(0), _cycle_size(1), _cycle_node(INVALID), - _cycle_path(NULL), _local_path(false), _data(digraph), - INF(std::numeric_limits::has_infinity ? - std::numeric_limits::infinity() : - std::numeric_limits::max()) - {} - - /// Destructor. - ~KarpMmc() { - if (_local_path) delete _cycle_path; - } - - /// \brief Set the path structure for storing the found cycle. - /// - /// This function sets an external path structure for storing the - /// found cycle. - /// - /// If you don't call this function before calling \ref run() or - /// \ref findCycleMean(), it will allocate a local \ref Path "path" - /// structure. The destuctor deallocates this automatically - /// allocated object, of course. - /// - /// \note The algorithm calls only the \ref lemon::Path::addFront() - /// "addFront()" function of the given path structure. - /// - /// \return (*this) - KarpMmc& cycle(Path &path) { - if (_local_path) { - delete _cycle_path; - _local_path = false; - } - _cycle_path = &path; - return *this; - } - - /// \brief Set the tolerance used by the algorithm. - /// - /// This function sets the tolerance object used by the algorithm. - /// - /// \return (*this) - KarpMmc& tolerance(const Tolerance& tolerance) { - _tolerance = tolerance; - return *this; - } - - /// \brief Return a const reference to the tolerance. - /// - /// This function returns a const reference to the tolerance object - /// used by the algorithm. - const Tolerance& tolerance() const { - return _tolerance; - } - - /// \name Execution control - /// The simplest way to execute the algorithm is to call the \ref run() - /// function.\n - /// If you only need the minimum mean cost, you may call - /// \ref findCycleMean(). - - /// @{ - - /// \brief Run the algorithm. - /// - /// This function runs the algorithm. - /// It can be called more than once (e.g. if the underlying digraph - /// and/or the arc costs have been modified). - /// - /// \return \c true if a directed cycle exists in the digraph. - /// - /// \note mmc.run() is just a shortcut of the following code. - /// \code - /// return mmc.findCycleMean() && mmc.findCycle(); - /// \endcode - bool run() { - return findCycleMean() && findCycle(); - } - - /// \brief Find the minimum cycle mean. - /// - /// This function finds the minimum mean cost of the directed - /// cycles in the digraph. - /// - /// \return \c true if a directed cycle exists in the digraph. - bool findCycleMean() { - // Initialization and find strongly connected components - init(); - findComponents(); - - // Find the minimum cycle mean in the components - for (int comp = 0; comp < _comp_num; ++comp) { - if (!initComponent(comp)) continue; - processRounds(); - updateMinMean(); - } - return (_cycle_node != INVALID); - } - - /// \brief Find a minimum mean directed cycle. - /// - /// This function finds a directed cycle of minimum mean cost - /// in the digraph using the data computed by findCycleMean(). - /// - /// \return \c true if a directed cycle exists in the digraph. - /// - /// \pre \ref findCycleMean() must be called before using this function. - bool findCycle() { - if (_cycle_node == INVALID) return false; - IntNodeMap reached(_gr, -1); - int r = _data[_cycle_node].size(); - Node u = _cycle_node; - while (reached[u] < 0) { - reached[u] = --r; - u = _gr.source(_data[u][r].pred); - } - r = reached[u]; - Arc e = _data[u][r].pred; - _cycle_path->addFront(e); - _cycle_cost = _cost[e]; - _cycle_size = 1; - Node v; - while ((v = _gr.source(e)) != u) { - e = _data[v][--r].pred; - _cycle_path->addFront(e); - _cycle_cost += _cost[e]; - ++_cycle_size; - } - return true; - } - - /// @} - - /// \name Query Functions - /// The results of the algorithm can be obtained using these - /// functions.\n - /// The algorithm should be executed before using them. - - /// @{ - - /// \brief Return the total cost of the found cycle. - /// - /// This function returns the total cost of the found cycle. - /// - /// \pre \ref run() or \ref findCycleMean() must be called before - /// using this function. - Cost cycleCost() const { - return static_cast(_cycle_cost); - } - - /// \brief Return the number of arcs on the found cycle. - /// - /// This function returns the number of arcs on the found cycle. - /// - /// \pre \ref run() or \ref findCycleMean() must be called before - /// using this function. - int cycleSize() const { - return _cycle_size; - } - - /// \brief Return the mean cost of the found cycle. - /// - /// This function returns the mean cost of the found cycle. - /// - /// \note alg.cycleMean() is just a shortcut of the - /// following code. - /// \code - /// return static_cast(alg.cycleCost()) / alg.cycleSize(); - /// \endcode - /// - /// \pre \ref run() or \ref findCycleMean() must be called before - /// using this function. - double cycleMean() const { - return static_cast(_cycle_cost) / _cycle_size; - } - - /// \brief Return the found cycle. - /// - /// This function returns a const reference to the path structure - /// storing the found cycle. - /// - /// \pre \ref run() or \ref findCycle() must be called before using - /// this function. - const Path& cycle() const { - return *_cycle_path; - } - - ///@} - - private: - - // Initialization - void init() { - if (!_cycle_path) { - _local_path = true; - _cycle_path = new Path; - } - _cycle_path->clear(); - _cycle_cost = 0; - _cycle_size = 1; - _cycle_node = INVALID; - for (NodeIt u(_gr); u != INVALID; ++u) - _data[u].clear(); - } - - // Find strongly connected components and initialize _comp_nodes - // and _out_arcs - void findComponents() { - _comp_num = stronglyConnectedComponents(_gr, _comp); - _comp_nodes.resize(_comp_num); - if (_comp_num == 1) { - _comp_nodes[0].clear(); - for (NodeIt n(_gr); n != INVALID; ++n) { - _comp_nodes[0].push_back(n); - _out_arcs[n].clear(); - for (OutArcIt a(_gr, n); a != INVALID; ++a) { - _out_arcs[n].push_back(a); - } - } - } else { - for (int i = 0; i < _comp_num; ++i) - _comp_nodes[i].clear(); - for (NodeIt n(_gr); n != INVALID; ++n) { - int k = _comp[n]; - _comp_nodes[k].push_back(n); - _out_arcs[n].clear(); - for (OutArcIt a(_gr, n); a != INVALID; ++a) { - if (_comp[_gr.target(a)] == k) _out_arcs[n].push_back(a); - } - } - } - } - - // Initialize path data for the current component - bool initComponent(int comp) { - _nodes = &(_comp_nodes[comp]); - int n = _nodes->size(); - if (n < 1 || (n == 1 && _out_arcs[(*_nodes)[0]].size() == 0)) { - return false; - } - for (int i = 0; i < n; ++i) { - _data[(*_nodes)[i]].resize(n + 1, PathData(INF)); - } - return true; - } - - // Process all rounds of computing path data for the current component. - // _data[v][k] is the cost of a shortest directed walk from the root - // node to node v containing exactly k arcs. - void processRounds() { - Node start = (*_nodes)[0]; - _data[start][0] = PathData(0); - _process.clear(); - _process.push_back(start); - - int k, n = _nodes->size(); - for (k = 1; k <= n && int(_process.size()) < n; ++k) { - processNextBuildRound(k); - } - for ( ; k <= n; ++k) { - processNextFullRound(k); - } - } - - // Process one round and rebuild _process - void processNextBuildRound(int k) { - std::vector next; - Node u, v; - Arc e; - LargeCost d; - for (int i = 0; i < int(_process.size()); ++i) { - u = _process[i]; - for (int j = 0; j < int(_out_arcs[u].size()); ++j) { - e = _out_arcs[u][j]; - v = _gr.target(e); - d = _data[u][k-1].dist + _cost[e]; - if (_tolerance.less(d, _data[v][k].dist)) { - if (_data[v][k].dist == INF) next.push_back(v); - _data[v][k] = PathData(d, e); - } - } - } - _process.swap(next); - } - - // Process one round using _nodes instead of _process - void processNextFullRound(int k) { - Node u, v; - Arc e; - LargeCost d; - for (int i = 0; i < int(_nodes->size()); ++i) { - u = (*_nodes)[i]; - for (int j = 0; j < int(_out_arcs[u].size()); ++j) { - e = _out_arcs[u][j]; - v = _gr.target(e); - d = _data[u][k-1].dist + _cost[e]; - if (_tolerance.less(d, _data[v][k].dist)) { - _data[v][k] = PathData(d, e); - } - } - } - } - - // Update the minimum cycle mean - void updateMinMean() { - int n = _nodes->size(); - for (int i = 0; i < n; ++i) { - Node u = (*_nodes)[i]; - if (_data[u][n].dist == INF) continue; - LargeCost cost, max_cost = 0; - int size, max_size = 1; - bool found_curr = false; - for (int k = 0; k < n; ++k) { - if (_data[u][k].dist == INF) continue; - cost = _data[u][n].dist - _data[u][k].dist; - size = n - k; - if (!found_curr || cost * max_size > max_cost * size) { - found_curr = true; - max_cost = cost; - max_size = size; - } - } - if ( found_curr && (_cycle_node == INVALID || - max_cost * _cycle_size < _cycle_cost * max_size) ) { - _cycle_cost = max_cost; - _cycle_size = max_size; - _cycle_node = u; - } - } - } - - }; //class KarpMmc - - ///@} - -} //namespace lemon - -#endif //LEMON_KARP_MMC_H Index: lemon/kruskal.h =================================================================== --- lemon/kruskal.h (revision 921) +++ lemon/kruskal.h (revision 584) @@ -31,4 +31,7 @@ ///\file ///\brief Kruskal's algorithm to compute a minimum cost spanning tree +/// +///Kruskal's algorithm to compute a minimum cost spanning tree. +/// namespace lemon { Index: lemon/lemon.pc.cmake =================================================================== --- lemon/lemon.pc.cmake (revision 908) +++ lemon/lemon.pc.cmake (revision 908) @@ -0,0 +1,10 @@ +prefix=@CMAKE_INSTALL_PREFIX@ +exec_prefix=@CMAKE_INSTALL_PREFIX@/bin +libdir=@CMAKE_INSTALL_PREFIX@/lib +includedir=@CMAKE_INSTALL_PREFIX@/include + +Name: @PROJECT_NAME@ +Description: Library for Efficient Modeling and Optimization in Networks +Version: @PROJECT_VERSION@ +Libs: -L${libdir} -lemon @GLPK_LIBS@ @CPLEX_LIBS@ @SOPLEX_LIBS@ @CLP_LIBS@ @CBC_LIBS@ +Cflags: -I${includedir} Index: lemon/lemon.pc.in =================================================================== --- lemon/lemon.pc.in (revision 981) +++ lemon/lemon.pc.in (revision 658) @@ -1,10 +1,10 @@ -prefix=@CMAKE_INSTALL_PREFIX@ -exec_prefix=@CMAKE_INSTALL_PREFIX@/bin -libdir=@CMAKE_INSTALL_PREFIX@/lib -includedir=@CMAKE_INSTALL_PREFIX@/include +prefix=@prefix@ +exec_prefix=@exec_prefix@ +libdir=@libdir@ +includedir=@includedir@ -Name: @PROJECT_NAME@ +Name: @PACKAGE_NAME@ Description: Library for Efficient Modeling and Optimization in Networks -Version: @PROJECT_VERSION@ +Version: @PACKAGE_VERSION@ Libs: -L${libdir} -lemon @GLPK_LIBS@ @CPLEX_LIBS@ @SOPLEX_LIBS@ @CLP_LIBS@ @CBC_LIBS@ Cflags: -I${includedir} Index: lemon/lgf_reader.h =================================================================== --- lemon/lgf_reader.h (revision 966) +++ lemon/lgf_reader.h (revision 959) @@ -428,5 +428,5 @@ ///\endcode /// - /// By default, the reader uses the first section in the file of the + /// By default the reader uses the first section in the file of the /// proper type. If a section has an optional name, then it can be /// selected for reading by giving an optional name parameter to the @@ -563,5 +563,5 @@ friend DigraphReader digraphReader(TDGR& digraph, std::istream& is); template - friend DigraphReader digraphReader(TDGR& digraph, + friend DigraphReader digraphReader(TDGR& digraph, const std::string& fn); template @@ -1195,5 +1195,5 @@ }; - + /// \ingroup lemon_io /// @@ -1202,5 +1202,5 @@ /// This function just returns a \ref DigraphReader class. /// - /// With this function a digraph can be read from an + /// With this function a digraph can be read from an /// \ref lgf-format "LGF" file or input stream with several maps and /// attributes. For example, there is network flow problem on a @@ -1257,5 +1257,5 @@ template class GraphReader; - + template GraphReader graphReader(TGR& graph, std::istream& is = std::cin); @@ -1394,5 +1394,5 @@ friend GraphReader graphReader(TGR& graph, std::istream& is); template - friend GraphReader graphReader(TGR& graph, const std::string& fn); + friend GraphReader graphReader(TGR& graph, const std::string& fn); template friend GraphReader graphReader(TGR& graph, const char *fn); @@ -2078,7 +2078,7 @@ /// \brief Return a \ref GraphReader class /// - /// This function just returns a \ref GraphReader class. - /// - /// With this function a graph can be read from an + /// This function just returns a \ref GraphReader class. + /// + /// With this function a graph can be read from an /// \ref lgf-format "LGF" file or input stream with several maps and /// attributes. For example, there is weighted matching problem on a @@ -2236,5 +2236,5 @@ /// whitespaces are trimmed from each processed string. /// - /// For example, let's see a section, which contain several + /// For example let's see a section, which contain several /// integers, which should be inserted into a vector. ///\code Index: lemon/lgf_writer.h =================================================================== --- lemon/lgf_writer.h (revision 877) +++ lemon/lgf_writer.h (revision 599) @@ -3,5 +3,5 @@ * This file is a part of LEMON, a generic C++ optimization library. * - * Copyright (C) 2003-2010 + * Copyright (C) 2003-2009 * Egervary Jeno Kombinatorikus Optimalizalasi Kutatocsoport * (Egervary Research Group on Combinatorial Optimization, EGRES). @@ -352,5 +352,5 @@ template - DigraphWriter digraphWriter(const TDGR& digraph, + DigraphWriter digraphWriter(const TDGR& digraph, std::ostream& os = std::cout); template @@ -505,5 +505,5 @@ template - friend DigraphWriter digraphWriter(const TDGR& digraph, + friend DigraphWriter digraphWriter(const TDGR& digraph, std::ostream& os); template @@ -918,5 +918,5 @@ /// \brief Return a \ref DigraphWriter class /// - /// This function just returns a \ref DigraphWriter class. + /// This function just returns a \ref DigraphWriter class. /// /// With this function a digraph can be write to a file or output @@ -958,5 +958,5 @@ /// \sa digraphWriter(const TDGR& digraph, std::ostream& os) template - DigraphWriter digraphWriter(const TDGR& digraph, + DigraphWriter digraphWriter(const TDGR& digraph, const std::string& fn) { DigraphWriter tmp(digraph, fn); @@ -1102,9 +1102,9 @@ friend GraphWriter graphWriter(const TGR& graph, std::ostream& os); template - friend GraphWriter graphWriter(const TGR& graph, + friend GraphWriter graphWriter(const TGR& graph, const std::string& fn); template friend GraphWriter graphWriter(const TGR& graph, const char *fn); - + GraphWriter(GraphWriter& other) : _os(other._os), local_os(other.local_os), _graph(other._graph), @@ -1557,5 +1557,5 @@ /// \brief Return a \ref GraphWriter class /// - /// This function just returns a \ref GraphWriter class. + /// This function just returns a \ref GraphWriter class. /// /// With this function a graph can be write to a file or output Index: lemon/list_graph.h =================================================================== --- lemon/list_graph.h (revision 877) +++ lemon/list_graph.h (revision 617) @@ -3,5 +3,5 @@ * This file is a part of LEMON, a generic C++ optimization library. * - * Copyright (C) 2003-2010 + * Copyright (C) 2003-2009 * Egervary Jeno Kombinatorikus Optimalizalasi Kutatocsoport * (Egervary Research Group on Combinatorial Optimization, EGRES). @@ -22,5 +22,5 @@ ///\ingroup graphs ///\file -///\brief ListDigraph and ListGraph classes. +///\brief ListDigraph, ListGraph classes. #include @@ -32,6 +32,4 @@ namespace lemon { - - class ListDigraph; class ListDigraphBase { @@ -65,5 +63,4 @@ class Node { friend class ListDigraphBase; - friend class ListDigraph; protected: @@ -81,5 +78,4 @@ class Arc { friend class ListDigraphBase; - friend class ListDigraph; protected: @@ -121,18 +117,18 @@ int n; for(n = first_node; - n != -1 && nodes[n].first_out == -1; + n!=-1 && nodes[n].first_in == -1; n = nodes[n].next) {} - arc.id = (n == -1) ? -1 : nodes[n].first_out; + arc.id = (n == -1) ? -1 : nodes[n].first_in; } void next(Arc& arc) const { - if (arcs[arc.id].next_out != -1) { - arc.id = arcs[arc.id].next_out; + if (arcs[arc.id].next_in != -1) { + arc.id = arcs[arc.id].next_in; } else { int n; - for(n = nodes[arcs[arc.id].source].next; - n != -1 && nodes[n].first_out == -1; + for(n = nodes[arcs[arc.id].target].next; + n!=-1 && nodes[n].first_in == -1; n = nodes[n].next) {} - arc.id = (n == -1) ? -1 : nodes[n].first_out; + arc.id = (n == -1) ? -1 : nodes[n].first_in; } } @@ -316,25 +312,29 @@ ///A general directed graph structure. - ///\ref ListDigraph is a versatile and fast directed graph - ///implementation based on linked lists that are stored in + ///\ref ListDigraph is a simple and fast directed graph + ///implementation based on static linked lists that are stored in ///\c std::vector structures. /// - ///This type fully conforms to the \ref concepts::Digraph "Digraph concept" - ///and it also provides several useful additional functionalities. - ///Most of its member functions and nested classes are documented + ///It conforms to the \ref concepts::Digraph "Digraph concept" and it + ///also provides several useful additional functionalities. + ///Most of the member functions and nested classes are documented ///only in the concept class. /// - ///This class provides only linear time counting for nodes and arcs. - /// ///\sa concepts::Digraph - ///\sa ListGraph + class ListDigraph : public ExtendedListDigraphBase { typedef ExtendedListDigraphBase Parent; private: - /// Digraphs are \e not copy constructible. Use DigraphCopy instead. + ///ListDigraph is \e not copy constructible. Use copyDigraph() instead. + + ///ListDigraph is \e not copy constructible. Use copyDigraph() instead. + /// ListDigraph(const ListDigraph &) :ExtendedListDigraphBase() {}; - /// \brief Assignment of a digraph to another one is \e not allowed. - /// Use DigraphCopy instead. + ///\brief Assignment of ListDigraph to another one is \e not allowed. + ///Use copyDigraph() instead. + + ///Assignment of ListDigraph to another one is \e not allowed. + ///Use copyDigraph() instead. void operator=(const ListDigraph &) {} public: @@ -348,5 +348,5 @@ ///Add a new node to the digraph. - ///This function adds a new node to the digraph. + ///Add a new node to the digraph. ///\return The new node. Node addNode() { return Parent::addNode(); } @@ -354,8 +354,8 @@ ///Add a new arc to the digraph. - ///This function adds a new arc to the digraph with source node \c s + ///Add a new arc to the digraph with source node \c s ///and target node \c t. ///\return The new arc. - Arc addArc(Node s, Node t) { + Arc addArc(const Node& s, const Node& t) { return Parent::addArc(s, t); } @@ -363,43 +363,41 @@ ///\brief Erase a node from the digraph. /// - ///This function erases the given node along with its outgoing and - ///incoming arcs from the digraph. - /// - ///\note All iterators referencing the removed node or the connected - ///arcs are invalidated, of course. - void erase(Node n) { Parent::erase(n); } + ///Erase a node from the digraph. + /// + void erase(const Node& n) { Parent::erase(n); } ///\brief Erase an arc from the digraph. /// - ///This function erases the given arc from the digraph. - /// - ///\note All iterators referencing the removed arc are invalidated, - ///of course. - void erase(Arc a) { Parent::erase(a); } + ///Erase an arc from the digraph. + /// + void erase(const Arc& a) { Parent::erase(a); } /// Node validity check - /// This function gives back \c true if the given node is valid, - /// i.e. it is a real node of the digraph. - /// - /// \warning A removed node could become valid again if new nodes are - /// added to the digraph. + /// This function gives back true if the given node is valid, + /// ie. it is a real node of the graph. + /// + /// \warning A Node pointing to a removed item + /// could become valid again later if new nodes are + /// added to the graph. bool valid(Node n) const { return Parent::valid(n); } /// Arc validity check - /// This function gives back \c true if the given arc is valid, - /// i.e. it is a real arc of the digraph. - /// - /// \warning A removed arc could become valid again if new arcs are - /// added to the digraph. + /// This function gives back true if the given arc is valid, + /// ie. it is a real arc of the graph. + /// + /// \warning An Arc pointing to a removed item + /// could become valid again later if new nodes are + /// added to the graph. bool valid(Arc a) const { return Parent::valid(a); } - /// Change the target node of an arc - - /// This function changes the target node of the given arc \c a to \c n. - /// - ///\note \c ArcIt and \c OutArcIt iterators referencing the changed - ///arc remain valid, but \c InArcIt iterators are invalidated. + /// Change the target of \c a to \c n + + /// Change the target of \c a to \c n + /// + ///\note The ArcIts and OutArcIts referencing + ///the changed arc remain valid. However InArcIts are + ///invalidated. /// ///\warning This functionality cannot be used together with the Snapshot @@ -408,10 +406,11 @@ Parent::changeTarget(a,n); } - /// Change the source node of an arc - - /// This function changes the source node of the given arc \c a to \c n. - /// - ///\note \c InArcIt iterators referencing the changed arc remain - ///valid, but \c ArcIt and \c OutArcIt iterators are invalidated. + /// Change the source of \c a to \c n + + /// Change the source of \c a to \c n + /// + ///\note The InArcIts referencing the changed arc remain + ///valid. However the ArcIts and OutArcIts are + ///invalidated. /// ///\warning This functionality cannot be used together with the Snapshot @@ -421,74 +420,92 @@ } - /// Reverse the direction of an arc. - - /// This function reverses the direction of the given arc. - ///\note \c ArcIt, \c OutArcIt and \c InArcIt iterators referencing - ///the changed arc are invalidated. + /// Invert the direction of an arc. + + ///\note The ArcIts referencing the changed arc remain + ///valid. However OutArcIts and InArcIts are + ///invalidated. /// ///\warning This functionality cannot be used together with the Snapshot ///feature. - void reverseArc(Arc a) { - Node t=target(a); - changeTarget(a,source(a)); - changeSource(a,t); - } + void reverseArc(Arc e) { + Node t=target(e); + changeTarget(e,source(e)); + changeSource(e,t); + } + + /// Reserve memory for nodes. + + /// Using this function it is possible to avoid the superfluous memory + /// allocation: if you know that the digraph you want to build will + /// be very large (e.g. it will contain millions of nodes and/or arcs) + /// then it is worth reserving space for this amount before starting + /// to build the digraph. + /// \sa reserveArc + void reserveNode(int n) { nodes.reserve(n); }; + + /// Reserve memory for arcs. + + /// Using this function it is possible to avoid the superfluous memory + /// allocation: if you know that the digraph you want to build will + /// be very large (e.g. it will contain millions of nodes and/or arcs) + /// then it is worth reserving space for this amount before starting + /// to build the digraph. + /// \sa reserveNode + void reserveArc(int m) { arcs.reserve(m); }; ///Contract two nodes. - ///This function contracts the given two nodes. - ///Node \c v is removed, but instead of deleting its - ///incident arcs, they are joined to node \c u. - ///If the last parameter \c r is \c true (this is the default value), - ///then the newly created loops are removed. - /// - ///\note The moved arcs are joined to node \c u using changeSource() - ///or changeTarget(), thus \c ArcIt and \c OutArcIt iterators are - ///invalidated for the outgoing arcs of node \c v and \c InArcIt - ///iterators are invalidated for the incomming arcs of \c v. - ///Moreover all iterators referencing node \c v or the removed - ///loops are also invalidated. Other iterators remain valid. + ///This function contracts two nodes. + ///Node \p b will be removed but instead of deleting + ///incident arcs, they will be joined to \p a. + ///The last parameter \p r controls whether to remove loops. \c true + ///means that loops will be removed. + /// + ///\note The ArcIts referencing a moved arc remain + ///valid. However InArcIts and OutArcIts + ///may be invalidated. /// ///\warning This functionality cannot be used together with the Snapshot ///feature. - void contract(Node u, Node v, bool r = true) + void contract(Node a, Node b, bool r = true) { - for(OutArcIt e(*this,v);e!=INVALID;) { + for(OutArcIt e(*this,b);e!=INVALID;) { OutArcIt f=e; ++f; - if(r && target(e)==u) erase(e); - else changeSource(e,u); + if(r && target(e)==a) erase(e); + else changeSource(e,a); e=f; } - for(InArcIt e(*this,v);e!=INVALID;) { + for(InArcIt e(*this,b);e!=INVALID;) { InArcIt f=e; ++f; - if(r && source(e)==u) erase(e); - else changeTarget(e,u); + if(r && source(e)==a) erase(e); + else changeTarget(e,a); e=f; } - erase(v); + erase(b); } ///Split a node. - ///This function splits the given node. First, a new node is added - ///to the digraph, then the source of each outgoing arc of node \c n - ///is moved to this new node. - ///If the second parameter \c connect is \c true (this is the default - ///value), then a new arc from node \c n to the newly created node - ///is also added. + ///This function splits a node. First a new node is added to the digraph, + ///then the source of each outgoing arc of \c n is moved to this new node. + ///If \c connect is \c true (this is the default value), then a new arc + ///from \c n to the newly created node is also added. ///\return The newly created node. /// - ///\note All iterators remain valid. - /// - ///\warning This functionality cannot be used together with the + ///\note The ArcIts referencing a moved arc remain + ///valid. However InArcIts and OutArcIts may + ///be invalidated. + /// + ///\warning This functionality cannot be used in conjunction with the ///Snapshot feature. Node split(Node n, bool connect = true) { Node b = addNode(); - nodes[b.id].first_out=nodes[n.id].first_out; - nodes[n.id].first_out=-1; - for(int i=nodes[b.id].first_out; i!=-1; i=arcs[i].next_out) { - arcs[i].source=b.id; + for(OutArcIt e(*this,n);e!=INVALID;) { + OutArcIt f=e; + ++f; + changeSource(e,b); + e=f; } if (connect) addArc(n,b); @@ -498,50 +515,18 @@ ///Split an arc. - ///This function splits the given arc. First, a new node \c v is - ///added to the digraph, then the target node of the original arc - ///is set to \c v. Finally, an arc from \c v to the original target - ///is added. + ///This function splits an arc. First a new node \c b is added to + ///the digraph, then the original arc is re-targeted to \c + ///b. Finally an arc from \c b to the original target is added. + /// ///\return The newly created node. - /// - ///\note \c InArcIt iterators referencing the original arc are - ///invalidated. Other iterators remain valid. /// ///\warning This functionality cannot be used together with the ///Snapshot feature. - Node split(Arc a) { - Node v = addNode(); - addArc(v,target(a)); - changeTarget(a,v); - return v; - } - - ///Clear the digraph. - - ///This function erases all nodes and arcs from the digraph. - /// - ///\note All iterators of the digraph are invalidated, of course. - void clear() { - Parent::clear(); - } - - /// Reserve memory for nodes. - - /// Using this function, it is possible to avoid superfluous memory - /// allocation: if you know that the digraph you want to build will - /// be large (e.g. it will contain millions of nodes and/or arcs), - /// then it is worth reserving space for this amount before starting - /// to build the digraph. - /// \sa reserveArc() - void reserveNode(int n) { nodes.reserve(n); }; - - /// Reserve memory for arcs. - - /// Using this function, it is possible to avoid superfluous memory - /// allocation: if you know that the digraph you want to build will - /// be large (e.g. it will contain millions of nodes and/or arcs), - /// then it is worth reserving space for this amount before starting - /// to build the digraph. - /// \sa reserveNode() - void reserveArc(int m) { arcs.reserve(m); }; + Node split(Arc e) { + Node b = addNode(); + addArc(b,target(e)); + changeTarget(e,b); + return b; + } /// \brief Class to make a snapshot of the digraph and restore @@ -553,13 +538,7 @@ /// restore() function. /// - /// \note After a state is restored, you cannot restore a later state, - /// i.e. you cannot add the removed nodes and arcs again using - /// another Snapshot instance. - /// - /// \warning Node and arc deletions and other modifications (e.g. - /// reversing, contracting, splitting arcs or nodes) cannot be + /// \warning Arc and node deletions and other modifications (e.g. + /// contracting, splitting, reversing arcs or nodes) cannot be /// restored. These events invalidate the snapshot. - /// However, the arcs and nodes that were added to the digraph after - /// making the current snapshot can be removed without invalidating it. class Snapshot { protected: @@ -731,5 +710,5 @@ /// /// Default constructor. - /// You have to call save() to actually make a snapshot. + /// To actually make a snapshot you must call save(). Snapshot() : digraph(0), node_observer_proxy(*this), @@ -738,31 +717,30 @@ /// \brief Constructor that immediately makes a snapshot. /// - /// This constructor immediately makes a snapshot of the given digraph. - Snapshot(ListDigraph &gr) + /// This constructor immediately makes a snapshot of the digraph. + /// \param _digraph The digraph we make a snapshot of. + Snapshot(ListDigraph &_digraph) : node_observer_proxy(*this), arc_observer_proxy(*this) { - attach(gr); + attach(_digraph); } /// \brief Make a snapshot. /// - /// This function makes a snapshot of the given digraph. - /// It can be called more than once. In case of a repeated + /// Make a snapshot of the digraph. + /// + /// This function can be called more than once. In case of a repeated /// call, the previous snapshot gets lost. - void save(ListDigraph &gr) { + /// \param _digraph The digraph we make the snapshot of. + void save(ListDigraph &_digraph) { if (attached()) { detach(); clear(); } - attach(gr); + attach(_digraph); } /// \brief Undo the changes until the last snapshot. - /// - /// This function undos the changes until the last snapshot - /// created by save() or Snapshot(ListDigraph&). - /// - /// \warning This method invalidates the snapshot, i.e. repeated - /// restoring is not supported unless you call save() again. + // + /// Undo the changes until the last snapshot created by save(). void restore() { detach(); @@ -778,7 +756,7 @@ } - /// \brief Returns \c true if the snapshot is valid. + /// \brief Gives back true when the snapshot is valid. /// - /// This function returns \c true if the snapshot is valid. + /// Gives back true when the snapshot is valid. bool valid() const { return attached(); @@ -817,4 +795,8 @@ typedef ListGraphBase Graph; + + class Node; + class Arc; + class Edge; class Node { @@ -866,4 +848,6 @@ bool operator<(const Arc& arc) const {return id < arc.id;} }; + + ListGraphBase() @@ -1181,25 +1165,29 @@ ///A general undirected graph structure. - ///\ref ListGraph is a versatile and fast undirected graph - ///implementation based on linked lists that are stored in + ///\ref ListGraph is a simple and fast undirected graph + ///implementation based on static linked lists that are stored in ///\c std::vector structures. /// - ///This type fully conforms to the \ref concepts::Graph "Graph concept" - ///and it also provides several useful additional functionalities. - ///Most of its member functions and nested classes are documented + ///It conforms to the \ref concepts::Graph "Graph concept" and it + ///also provides several useful additional functionalities. + ///Most of the member functions and nested classes are documented ///only in the concept class. /// - ///This class provides only linear time counting for nodes, edges and arcs. - /// ///\sa concepts::Graph - ///\sa ListDigraph + class ListGraph : public ExtendedListGraphBase { typedef ExtendedListGraphBase Parent; private: - /// Graphs are \e not copy constructible. Use GraphCopy instead. + ///ListGraph is \e not copy constructible. Use copyGraph() instead. + + ///ListGraph is \e not copy constructible. Use copyGraph() instead. + /// ListGraph(const ListGraph &) :ExtendedListGraphBase() {}; - /// \brief Assignment of a graph to another one is \e not allowed. - /// Use GraphCopy instead. + ///\brief Assignment of ListGraph to another one is \e not allowed. + ///Use copyGraph() instead. + + ///Assignment of ListGraph to another one is \e not allowed. + ///Use copyGraph() instead. void operator=(const ListGraph &) {} public: @@ -1214,5 +1202,5 @@ /// \brief Add a new node to the graph. /// - /// This function adds a new node to the graph. + /// Add a new node to the graph. /// \return The new node. Node addNode() { return Parent::addNode(); } @@ -1220,60 +1208,57 @@ /// \brief Add a new edge to the graph. /// - /// This function adds a new edge to the graph between nodes - /// \c u and \c v with inherent orientation from node \c u to - /// node \c v. + /// Add a new edge to the graph with source node \c s + /// and target node \c t. /// \return The new edge. - Edge addEdge(Node u, Node v) { - return Parent::addEdge(u, v); - } - - ///\brief Erase a node from the graph. - /// - /// This function erases the given node along with its incident arcs - /// from the graph. - /// - /// \note All iterators referencing the removed node or the incident - /// edges are invalidated, of course. - void erase(Node n) { Parent::erase(n); } - - ///\brief Erase an edge from the graph. - /// - /// This function erases the given edge from the graph. - /// - /// \note All iterators referencing the removed edge are invalidated, - /// of course. - void erase(Edge e) { Parent::erase(e); } + Edge addEdge(const Node& s, const Node& t) { + return Parent::addEdge(s, t); + } + + /// \brief Erase a node from the graph. + /// + /// Erase a node from the graph. + /// + void erase(const Node& n) { Parent::erase(n); } + + /// \brief Erase an edge from the graph. + /// + /// Erase an edge from the graph. + /// + void erase(const Edge& e) { Parent::erase(e); } /// Node validity check - /// This function gives back \c true if the given node is valid, - /// i.e. it is a real node of the graph. - /// - /// \warning A removed node could become valid again if new nodes are + /// This function gives back true if the given node is valid, + /// ie. it is a real node of the graph. + /// + /// \warning A Node pointing to a removed item + /// could become valid again later if new nodes are /// added to the graph. bool valid(Node n) const { return Parent::valid(n); } + /// Arc validity check + + /// This function gives back true if the given arc is valid, + /// ie. it is a real arc of the graph. + /// + /// \warning An Arc pointing to a removed item + /// could become valid again later if new edges are + /// added to the graph. + bool valid(Arc a) const { return Parent::valid(a); } /// Edge validity check - /// This function gives back \c true if the given edge is valid, - /// i.e. it is a real edge of the graph. - /// - /// \warning A removed edge could become valid again if new edges are + /// This function gives back true if the given edge is valid, + /// ie. it is a real arc of the graph. + /// + /// \warning A Edge pointing to a removed item + /// could become valid again later if new edges are /// added to the graph. bool valid(Edge e) const { return Parent::valid(e); } - /// Arc validity check - - /// This function gives back \c true if the given arc is valid, - /// i.e. it is a real arc of the graph. - /// - /// \warning A removed arc could become valid again if new edges are - /// added to the graph. - bool valid(Arc a) const { return Parent::valid(a); } - - /// \brief Change the first node of an edge. - /// - /// This function changes the first node of the given edge \c e to \c n. - /// - ///\note \c EdgeIt and \c ArcIt iterators referencing the - ///changed edge are invalidated and all other iterators whose - ///base node is the changed node are also invalidated. + /// \brief Change the end \c u of \c e to \c n + /// + /// This function changes the end \c u of \c e to node \c n. + /// + ///\note The EdgeIts and ArcIts referencing the + ///changed edge are invalidated and if the changed node is the + ///base node of an iterator then this iterator is also + ///invalidated. /// ///\warning This functionality cannot be used together with the @@ -1282,12 +1267,11 @@ Parent::changeU(e,n); } - /// \brief Change the second node of an edge. - /// - /// This function changes the second node of the given edge \c e to \c n. - /// - ///\note \c EdgeIt iterators referencing the changed edge remain - ///valid, but \c ArcIt iterators referencing the changed edge and - ///all other iterators whose base node is the changed node are also - ///invalidated. + /// \brief Change the end \c v of \c e to \c n + /// + /// This function changes the end \c v of \c e to \c n. + /// + ///\note The EdgeIts referencing the changed edge remain + ///valid, however ArcIts and if the changed node is the + ///base node of an iterator then this iterator is invalidated. /// ///\warning This functionality cannot be used together with the @@ -1296,18 +1280,14 @@ Parent::changeV(e,n); } - /// \brief Contract two nodes. /// - /// This function contracts the given two nodes. - /// Node \c b is removed, but instead of deleting - /// its incident edges, they are joined to node \c a. - /// If the last parameter \c r is \c true (this is the default value), - /// then the newly created loops are removed. - /// - /// \note The moved edges are joined to node \c a using changeU() - /// or changeV(), thus all edge and arc iterators whose base node is - /// \c b are invalidated. - /// Moreover all iterators referencing node \c b or the removed - /// loops are also invalidated. Other iterators remain valid. + /// This function contracts two nodes. + /// Node \p b will be removed but instead of deleting + /// its neighboring arcs, they will be joined to \p a. + /// The last parameter \p r controls whether to remove loops. \c true + /// means that loops will be removed. + /// + /// \note The ArcIts referencing a moved arc remain + /// valid. /// ///\warning This functionality cannot be used together with the @@ -1328,32 +1308,4 @@ } - ///Clear the graph. - - ///This function erases all nodes and arcs from the graph. - /// - ///\note All iterators of the graph are invalidated, of course. - void clear() { - Parent::clear(); - } - - /// Reserve memory for nodes. - - /// Using this function, it is possible to avoid superfluous memory - /// allocation: if you know that the graph you want to build will - /// be large (e.g. it will contain millions of nodes and/or edges), - /// then it is worth reserving space for this amount before starting - /// to build the graph. - /// \sa reserveEdge() - void reserveNode(int n) { nodes.reserve(n); }; - - /// Reserve memory for edges. - - /// Using this function, it is possible to avoid superfluous memory - /// allocation: if you know that the graph you want to build will - /// be large (e.g. it will contain millions of nodes and/or edges), - /// then it is worth reserving space for this amount before starting - /// to build the graph. - /// \sa reserveNode() - void reserveEdge(int m) { arcs.reserve(2 * m); }; /// \brief Class to make a snapshot of the graph and restore @@ -1365,13 +1317,7 @@ /// using the restore() function. /// - /// \note After a state is restored, you cannot restore a later state, - /// i.e. you cannot add the removed nodes and edges again using - /// another Snapshot instance. - /// - /// \warning Node and edge deletions and other modifications - /// (e.g. changing the end-nodes of edges or contracting nodes) - /// cannot be restored. These events invalidate the snapshot. - /// However, the edges and nodes that were added to the graph after - /// making the current snapshot can be removed without invalidating it. + /// \warning Edge and node deletions and other modifications + /// (e.g. changing nodes of edges, contracting nodes) cannot be + /// restored. These events invalidate the snapshot. class Snapshot { protected: @@ -1543,5 +1489,5 @@ /// /// Default constructor. - /// You have to call save() to actually make a snapshot. + /// To actually make a snapshot you must call save(). Snapshot() : graph(0), node_observer_proxy(*this), @@ -1550,31 +1496,30 @@ /// \brief Constructor that immediately makes a snapshot. /// - /// This constructor immediately makes a snapshot of the given graph. - Snapshot(ListGraph &gr) + /// This constructor immediately makes a snapshot of the graph. + /// \param _graph The graph we make a snapshot of. + Snapshot(ListGraph &_graph) : node_observer_proxy(*this), edge_observer_proxy(*this) { - attach(gr); + attach(_graph); } /// \brief Make a snapshot. /// - /// This function makes a snapshot of the given graph. - /// It can be called more than once. In case of a repeated + /// Make a snapshot of the graph. + /// + /// This function can be called more than once. In case of a repeated /// call, the previous snapshot gets lost. - void save(ListGraph &gr) { + /// \param _graph The graph we make the snapshot of. + void save(ListGraph &_graph) { if (attached()) { detach(); clear(); } - attach(gr); + attach(_graph); } /// \brief Undo the changes until the last snapshot. - /// - /// This function undos the changes until the last snapshot - /// created by save() or Snapshot(ListGraph&). - /// - /// \warning This method invalidates the snapshot, i.e. repeated - /// restoring is not supported unless you call save() again. + // + /// Undo the changes until the last snapshot created by save(). void restore() { detach(); @@ -1590,7 +1535,7 @@ } - /// \brief Returns \c true if the snapshot is valid. + /// \brief Gives back true when the snapshot is valid. /// - /// This function returns \c true if the snapshot is valid. + /// Gives back true when the snapshot is valid. bool valid() const { return attached(); Index: lemon/lp.h =================================================================== --- lemon/lp.h (revision 877) +++ lemon/lp.h (revision 627) @@ -3,5 +3,5 @@ * This file is a part of LEMON, a generic C++ optimization library. * - * Copyright (C) 2003-2010 + * Copyright (C) 2003-2008 * Egervary Jeno Kombinatorikus Optimalizalasi Kutatocsoport * (Egervary Research Group on Combinatorial Optimization, EGRES). @@ -85,5 +85,5 @@ #elif LEMON_HAVE_CLP # define DEFAULT_LP CLP - typedef ClpLp Lp; + typedef ClpLp Lp; #endif #endif Index: lemon/lp_base.cc =================================================================== --- lemon/lp_base.cc (revision 877) +++ lemon/lp_base.cc (revision 486) @@ -3,5 +3,5 @@ * This file is a part of LEMON, a generic C++ optimization library. * - * Copyright (C) 2003-2010 + * Copyright (C) 2003-2008 * Egervary Jeno Kombinatorikus Optimalizalasi Kutatocsoport * (Egervary Research Group on Combinatorial Optimization, EGRES). Index: lemon/lp_base.h =================================================================== --- lemon/lp_base.h (revision 989) +++ lemon/lp_base.h (revision 988) @@ -3,5 +3,5 @@ * This file is a part of LEMON, a generic C++ optimization library. * - * Copyright (C) 2003-2010 + * Copyright (C) 2003-2008 * Egervary Jeno Kombinatorikus Optimalizalasi Kutatocsoport * (Egervary Research Group on Combinatorial Optimization, EGRES). @@ -83,5 +83,5 @@ MESSAGE_VERBOSE }; - + ///The floating point type used by the solver @@ -115,12 +115,12 @@ typedef True LpCol; /// Default constructor - + /// \warning The default constructor sets the Col to an /// undefined value. Col() {} /// Invalid constructor \& conversion. - + /// This constructor initializes the Col to be invalid. - /// \sa Invalid for more details. + /// \sa Invalid for more details. Col(const Invalid&) : _id(-1) {} /// Equality operator @@ -147,5 +147,5 @@ ///Iterator for iterate over the columns of an LP problem - /// Its usage is quite simple, for example, you can count the number + /// Its usage is quite simple, for example you can count the number /// of columns in an LP \c lp: ///\code @@ -157,10 +157,10 @@ public: /// Default constructor - + /// \warning The default constructor sets the iterator /// to an undefined value. ColIt() {} /// Sets the iterator to the first Col - + /// Sets the iterator to the first Col. /// @@ -170,10 +170,10 @@ } /// Invalid constructor \& conversion - + /// Initialize the iterator to be invalid. /// \sa Invalid for more details. ColIt(const Invalid&) : Col(INVALID) {} /// Next column - + /// Assign the iterator to the next column. /// @@ -210,12 +210,12 @@ typedef True LpRow; /// Default constructor - + /// \warning The default constructor sets the Row to an /// undefined value. Row() {} /// Invalid constructor \& conversion. - + /// This constructor initializes the Row to be invalid. - /// \sa Invalid for more details. + /// \sa Invalid for more details. Row(const Invalid&) : _id(-1) {} /// Equality operator @@ -225,5 +225,5 @@ bool operator==(Row r) const {return _id == r._id;} /// Inequality operator - + /// \sa operator==(Row r) /// @@ -242,5 +242,5 @@ ///Iterator for iterate over the rows of an LP problem - /// Its usage is quite simple, for example, you can count the number + /// Its usage is quite simple, for example you can count the number /// of rows in an LP \c lp: ///\code @@ -252,10 +252,10 @@ public: /// Default constructor - + /// \warning The default constructor sets the iterator /// to an undefined value. RowIt() {} /// Sets the iterator to the first Row - + /// Sets the iterator to the first Row. /// @@ -265,10 +265,10 @@ } /// Invalid constructor \& conversion - + /// Initialize the iterator to be invalid. /// \sa Invalid for more details. RowIt(const Invalid&) : Row(INVALID) {} /// Next row - + /// Assign the iterator to the next row. /// @@ -348,5 +348,5 @@ typedef True SolverExpr; /// Default constructor - + /// Construct an empty expression, the coefficients and /// the constant component are initialized to zero. @@ -449,7 +449,7 @@ ///Iterator over the expression - - ///The iterator iterates over the terms of the expression. - /// + + ///The iterator iterates over the terms of the expression. + /// ///\code ///double s=0; @@ -465,5 +465,5 @@ /// Sets the iterator to the first term - + /// Sets the iterator to the first term of the expression. /// @@ -482,5 +482,5 @@ const Value& operator*() const { return _it->second; } /// Next term - + /// Assign the iterator to the next term. /// @@ -494,7 +494,7 @@ /// Const iterator over the expression - - ///The iterator iterates over the terms of the expression. - /// + + ///The iterator iterates over the terms of the expression. + /// ///\code ///double s=0; @@ -510,5 +510,5 @@ /// Sets the iterator to the first term - + /// Sets the iterator to the first term of the expression. /// @@ -525,5 +525,5 @@ /// Next term - + /// Assign the iterator to the next term. /// @@ -674,5 +674,5 @@ typedef True SolverExpr; /// Default constructor - + /// Construct an empty expression, the coefficients are /// initialized to zero. @@ -709,5 +709,5 @@ } /// \brief Removes the coefficients which's absolute value does - /// not exceed \c epsilon. + /// not exceed \c epsilon. void simplify(Value epsilon = 0.0) { std::map::iterator it=comps.begin(); @@ -758,7 +758,7 @@ ///Iterator over the expression - - ///The iterator iterates over the terms of the expression. - /// + + ///The iterator iterates over the terms of the expression. + /// ///\code ///double s=0; @@ -774,5 +774,5 @@ /// Sets the iterator to the first term - + /// Sets the iterator to the first term of the expression. /// @@ -792,5 +792,5 @@ /// Next term - + /// Assign the iterator to the next term. /// @@ -804,7 +804,7 @@ ///Iterator over the expression - - ///The iterator iterates over the terms of the expression. - /// + + ///The iterator iterates over the terms of the expression. + /// ///\code ///double s=0; @@ -820,5 +820,5 @@ /// Sets the iterator to the first term - + /// Sets the iterator to the first term of the expression. /// @@ -835,5 +835,5 @@ /// Next term - + /// Assign the iterator to the next term. /// @@ -943,12 +943,4 @@ virtual int _addCol() = 0; virtual int _addRow() = 0; - - virtual int _addRow(Value l, ExprIterator b, ExprIterator e, Value u) { - int row = _addRow(); - _setRowCoeffs(row, b, e); - _setRowLowerBound(row, l); - _setRowUpperBound(row, u); - return row; - } virtual void _eraseCol(int col) = 0; @@ -1216,8 +1208,6 @@ ///\return The created row. Row addRow(Value l,const Expr &e, Value u) { - Row r; - e.simplify(); - r._id = _addRowId(_addRow(l - *e, ExprIterator(e.comps.begin(), cols), - ExprIterator(e.comps.end(), cols), u - *e)); + Row r=addRow(); + row(r,l,e,u); return r; } @@ -1228,10 +1218,6 @@ ///\return The created row. Row addRow(const Constr &c) { - Row r; - c.expr().simplify(); - r._id = _addRowId(_addRow(c.lowerBounded()?c.lowerBound()-*c.expr():-INF, - ExprIterator(c.expr().comps.begin(), cols), - ExprIterator(c.expr().comps.end(), cols), - c.upperBounded()?c.upperBound()-*c.expr():INF)); + Row r=addRow(); + row(r,c); return r; } @@ -1818,8 +1804,8 @@ enum VarStatus { /// The variable is in the basis - BASIC, + BASIC, /// The variable is free, but not basic FREE, - /// The variable has active lower bound + /// The variable has active lower bound LOWER, /// The variable has active upper bound @@ -1900,5 +1886,5 @@ } /// Returns a component of the primal ray - + /// The primal ray is solution of the modified primal problem, /// where we change each finite bound to 0, and we looking for a @@ -1934,5 +1920,5 @@ /// Returns a component of the dual ray - + /// The dual ray is solution of the modified primal problem, where /// we change each finite bound to 0 (i.e. the objective function @@ -2076,5 +2062,5 @@ } ///The value of the objective function - + ///\return ///- \ref INF or -\ref INF means either infeasibility or unboundedness Index: lemon/lp_skeleton.cc =================================================================== --- lemon/lp_skeleton.cc (revision 877) +++ lemon/lp_skeleton.cc (revision 576) @@ -3,5 +3,5 @@ * This file is a part of LEMON, a generic C++ optimization library. * - * Copyright (C) 2003-2010 + * Copyright (C) 2003-2008 * Egervary Jeno Kombinatorikus Optimalizalasi Kutatocsoport * (Egervary Research Group on Combinatorial Optimization, EGRES). @@ -29,9 +29,4 @@ int SkeletonSolverBase::_addRow() - { - return ++row_num; - } - - int SkeletonSolverBase::_addRow(Value, ExprIterator, ExprIterator, Value) { return ++row_num; Index: lemon/lp_skeleton.h =================================================================== --- lemon/lp_skeleton.h (revision 877) +++ lemon/lp_skeleton.h (revision 576) @@ -3,5 +3,5 @@ * This file is a part of LEMON, a generic C++ optimization library. * - * Copyright (C) 2003-2010 + * Copyright (C) 2003-2008 * Egervary Jeno Kombinatorikus Optimalizalasi Kutatocsoport * (Egervary Research Group on Combinatorial Optimization, EGRES). @@ -24,5 +24,5 @@ ///\file ///\brief Skeleton file to implement LP/MIP solver interfaces -/// +/// ///The classes in this file do nothing, but they can serve as skeletons when ///implementing an interface to new solvers. @@ -30,5 +30,5 @@ ///A skeleton class to implement LP/MIP solver base interface - + ///This class does nothing, but it can serve as a skeleton when ///implementing an interface to new solvers. @@ -45,6 +45,4 @@ /// \e virtual int _addRow(); - /// \e - virtual int _addRow(Value l, ExprIterator b, ExprIterator e, Value u); /// \e virtual void _eraseCol(int i); Index: lemon/maps.h =================================================================== --- lemon/maps.h (revision 942) +++ lemon/maps.h (revision 684) @@ -3,5 +3,5 @@ * This file is a part of LEMON, a generic C++ optimization library. * - * Copyright (C) 2003-2010 + * Copyright (C) 2003-2009 * Egervary Jeno Kombinatorikus Optimalizalasi Kutatocsoport * (Egervary Research Group on Combinatorial Optimization, EGRES). @@ -23,5 +23,4 @@ #include #include -#include #include @@ -30,4 +29,6 @@ ///\ingroup maps ///\brief Miscellaneous property maps + +#include namespace lemon { @@ -57,5 +58,5 @@ /// but data written to it is not required (i.e. it will be sent to /// /dev/null). - /// It conforms to the \ref concepts::ReadWriteMap "ReadWriteMap" concept. + /// It conforms the \ref concepts::ReadWriteMap "ReadWriteMap" concept. /// /// \sa ConstMap @@ -90,5 +91,5 @@ /// /// In other aspects it is equivalent to \c NullMap. - /// So it conforms to the \ref concepts::ReadWriteMap "ReadWriteMap" + /// So it conforms the \ref concepts::ReadWriteMap "ReadWriteMap" /// concept, but it absorbs the data written to it. /// @@ -159,5 +160,5 @@ /// /// In other aspects it is equivalent to \c NullMap. - /// So it conforms to the \ref concepts::ReadWriteMap "ReadWriteMap" + /// So it conforms the \ref concepts::ReadWriteMap "ReadWriteMap" /// concept, but it absorbs the data written to it. /// @@ -231,7 +232,7 @@ /// This map is essentially a wrapper for \c std::vector. It assigns /// values to integer keys from the range [0..size-1]. - /// It can be used together with some data structures, e.g. - /// heap types and \c UnionFind, when the used items are small - /// integers. This map conforms to the \ref concepts::ReferenceMap + /// It can be used with some data structures, for example + /// \c UnionFind, \c BinHeap, when the used items are small + /// integers. This map conforms the \ref concepts::ReferenceMap /// "ReferenceMap" concept. /// @@ -341,5 +342,5 @@ /// stored actually. This value can be different from the default /// contructed value (i.e. \c %Value()). - /// This type conforms to the \ref concepts::ReferenceMap "ReferenceMap" + /// This type conforms the \ref concepts::ReferenceMap "ReferenceMap" /// concept. /// @@ -349,7 +350,7 @@ /// The name of this type also refers to this important usage. /// - /// Apart form that, this map can be used in many other cases since it + /// Apart form that this map can be used in many other cases since it /// is based on \c std::map, which is a general associative container. - /// However, keep in mind that it is usually not as efficient as other + /// However keep in mind that it is usually not as efficient as other /// maps. /// @@ -707,5 +708,5 @@ /// The \c Key type of it is inherited from \c M and the \c Value /// type is \c V. - /// This type conforms to the \ref concepts::ReadMap "ReadMap" concept. + /// This type conforms the \ref concepts::ReadMap "ReadMap" concept. /// /// The simplest way of using this map is through the convertMap() @@ -1786,13 +1787,13 @@ /// The most important usage of it is storing certain nodes or arcs /// that were marked \c true by an algorithm. - /// For example, it makes easier to store the nodes in the processing + /// For example it makes easier to store the nodes in the processing /// order of Dfs algorithm, as the following examples show. /// \code /// std::vector v; - /// dfs(g).processedMap(loggerBoolMap(std::back_inserter(v))).run(s); + /// dfs(g,s).processedMap(loggerBoolMap(std::back_inserter(v))).run(); /// \endcode /// \code /// std::vector v(countNodes(g)); - /// dfs(g).processedMap(loggerBoolMap(v.begin())).run(s); + /// dfs(g,s).processedMap(loggerBoolMap(v.begin())).run(); /// \endcode /// @@ -1801,5 +1802,5 @@ /// /// \note LoggerBoolMap is just \ref concepts::WriteMap "writable", so - /// it cannot be used when a readable map is needed, for example, as + /// it cannot be used when a readable map is needed, for example as /// \c ReachedMap for \c Bfs, \c Dfs and \c Dijkstra algorithms. /// @@ -1818,5 +1819,5 @@ /// /// IdMap provides a unique and immutable id for each item of the - /// same type (\c Node, \c Arc or \c Edge) in a graph. This id is + /// same type (\c Node, \c Arc or \c Edge) in a graph. This id is /// - \b unique: different items get different ids, /// - \b immutable: the id of an item does not change (even if you @@ -1826,5 +1827,5 @@ /// the items stored in the graph, which is returned by the \c id() /// function of the graph. This map can be inverted with its member - /// class \c InverseMap or with the \c operator()() member. + /// class \c InverseMap or with the \c operator() member. /// /// \tparam GR The graph type. @@ -1866,9 +1867,7 @@ public: - /// \brief The inverse map type of IdMap. - /// - /// The inverse map type of IdMap. The subscript operator gives back - /// an item by its id. - /// This type conforms to the \ref concepts::ReadMap "ReadMap" concept. + /// \brief This class represents the inverse of its owner (IdMap). + /// + /// This class represents the inverse of its owner (IdMap). /// \see inverse() class InverseMap { @@ -1885,7 +1884,7 @@ explicit InverseMap(const IdMap& map) : _graph(map._graph) {} - /// \brief Gives back an item by its id. + /// \brief Gives back the given item from its id. /// - /// Gives back an item by its id. + /// Gives back the given item from its id. Item operator[](int id) const { return _graph->fromId(id, Item());} @@ -1900,12 +1899,4 @@ }; - /// \brief Returns an \c IdMap class. - /// - /// This function just returns an \c IdMap class. - /// \relates IdMap - template - inline IdMap idMap(const GR& graph) { - return IdMap(graph); - } /// \brief General cross reference graph map type. @@ -1914,15 +1905,6 @@ /// It wraps a standard graph map (\c NodeMap, \c ArcMap or \c EdgeMap) /// and if a key is set to a new value, then stores it in the inverse map. - /// The graph items can be accessed by their values either using - /// \c InverseMap or \c operator()(), and the values of the map can be - /// accessed with an STL compatible forward iterator (\c ValueIt). - /// - /// This map is intended to be used when all associated values are - /// different (the map is actually invertable) or there are only a few - /// items with the same value. - /// Otherwise consider to use \c IterableValueMap, which is more - /// suitable and more efficient for such cases. It provides iterators - /// to traverse the items with the same associated value, but - /// it does not have \c InverseMap. + /// The values of the map can be accessed + /// with stl compatible forward iterator. /// /// This type is not reference map, so it cannot be modified with @@ -1965,38 +1947,31 @@ /// \brief Forward iterator for values. /// - /// This iterator is an STL compatible forward + /// This iterator is an stl compatible forward /// iterator on the values of the map. The values can /// be accessed in the [beginValue, endValue) range. /// They are considered with multiplicity, so each value is /// traversed for each item it is assigned to. - class ValueIt + class ValueIterator : public std::iterator { friend class CrossRefMap; private: - ValueIt(typename Container::const_iterator _it) + ValueIterator(typename Container::const_iterator _it) : it(_it) {} public: - /// Constructor - ValueIt() {} - - /// \e - ValueIt& operator++() { ++it; return *this; } - /// \e - ValueIt operator++(int) { - ValueIt tmp(*this); + ValueIterator() {} + + ValueIterator& operator++() { ++it; return *this; } + ValueIterator operator++(int) { + ValueIterator tmp(*this); operator++(); return tmp; } - /// \e const Value& operator*() const { return it->first; } - /// \e const Value* operator->() const { return &(it->first); } - /// \e - bool operator==(ValueIt jt) const { return it == jt.it; } - /// \e - bool operator!=(ValueIt jt) const { return it != jt.it; } + bool operator==(ValueIterator jt) const { return it == jt.it; } + bool operator!=(ValueIterator jt) const { return it != jt.it; } private: @@ -2004,25 +1979,22 @@ }; - /// Alias for \c ValueIt - typedef ValueIt ValueIterator; - /// \brief Returns an iterator to the first value. /// - /// Returns an STL compatible iterator to the + /// Returns an stl compatible iterator to the /// first value of the map. The values of the /// map can be accessed in the [beginValue, endValue) /// range. - ValueIt beginValue() const { - return ValueIt(_inv_map.begin()); + ValueIterator beginValue() const { + return ValueIterator(_inv_map.begin()); } /// \brief Returns an iterator after the last value. /// - /// Returns an STL compatible iterator after the + /// Returns an stl compatible iterator after the /// last value of the map. The values of the /// map can be accessed in the [beginValue, endValue) /// range. - ValueIt endValue() const { - return ValueIt(_inv_map.end()); + ValueIterator endValue() const { + return ValueIterator(_inv_map.end()); } @@ -2061,12 +2033,4 @@ typename Container::const_iterator it = _inv_map.find(val); return it != _inv_map.end() ? it->second : INVALID; - } - - /// \brief Returns the number of items with the given value. - /// - /// This function returns the number of items with the given value - /// associated with it. - int count(const Value &val) const { - return _inv_map.count(val); } @@ -2120,10 +2084,8 @@ public: - /// \brief The inverse map type of CrossRefMap. - /// - /// The inverse map type of CrossRefMap. The subscript operator gives - /// back an item by its value. - /// This type conforms to the \ref concepts::ReadMap "ReadMap" concept. - /// \see inverse() + /// \brief The inverse map type. + /// + /// The inverse of this map. The subscript operator of the map + /// gives back the item that was last assigned to the value. class InverseMap { public: @@ -2152,7 +2114,7 @@ }; - /// \brief Gives back the inverse of the map. - /// - /// Gives back the inverse of the CrossRefMap. + /// \brief It gives back the read-only inverse map. + /// + /// It gives back the read-only inverse map. InverseMap inverse() const { return InverseMap(*this); @@ -2161,9 +2123,9 @@ }; - /// \brief Provides continuous and unique id for the + /// \brief Provides continuous and unique ID for the /// items of a graph. /// /// RangeIdMap provides a unique and continuous - /// id for each item of a given type (\c Node, \c Arc or + /// ID for each item of a given type (\c Node, \c Arc or /// \c Edge) in a graph. This id is /// - \b unique: different items get different ids, @@ -2176,5 +2138,5 @@ /// the \c id() function of the graph or \ref IdMap. /// This map can be inverted with its member class \c InverseMap, - /// or with the \c operator()() member. + /// or with the \c operator() member. /// /// \tparam GR The graph type. @@ -2304,14 +2266,14 @@ } - /// \brief Gives back the \e range \e id of the item - /// - /// Gives back the \e range \e id of the item. + /// \brief Gives back the \e RangeId of the item + /// + /// Gives back the \e RangeId of the item. int operator[](const Item& item) const { return Map::operator[](item); } - /// \brief Gives back the item belonging to a \e range \e id - /// - /// Gives back the item belonging to the given \e range \e id. + /// \brief Gives back the item belonging to a \e RangeId + /// + /// Gives back the item belonging to a \e RangeId. Item operator()(int id) const { return _inv_map[id]; @@ -2327,7 +2289,5 @@ /// \brief The inverse map type of RangeIdMap. /// - /// The inverse map type of RangeIdMap. The subscript operator gives - /// back an item by its \e range \e id. - /// This type conforms to the \ref concepts::ReadMap "ReadMap" concept. + /// The inverse map type of RangeIdMap. class InverseMap { public: @@ -2347,5 +2307,5 @@ /// /// Subscript operator. It gives back the item - /// that the given \e range \e id currently belongs to. + /// that the descriptor currently belongs to. Value operator[](const Key& key) const { return _inverted(key); @@ -2365,928 +2325,8 @@ /// \brief Gives back the inverse of the map. /// - /// Gives back the inverse of the RangeIdMap. + /// Gives back the inverse of the map. const InverseMap inverse() const { return InverseMap(*this); } - }; - - /// \brief Returns a \c RangeIdMap class. - /// - /// This function just returns an \c RangeIdMap class. - /// \relates RangeIdMap - template - inline RangeIdMap rangeIdMap(const GR& graph) { - return RangeIdMap(graph); - } - - /// \brief Dynamic iterable \c bool map. - /// - /// This class provides a special graph map type which can store a - /// \c bool value for graph items (\c Node, \c Arc or \c Edge). - /// For both \c true and \c false values it is possible to iterate on - /// the keys mapped to the value. - /// - /// This type is a reference map, so it can be modified with the - /// subscript operator. - /// - /// \tparam GR The graph type. - /// \tparam K The key type of the map (\c GR::Node, \c GR::Arc or - /// \c GR::Edge). - /// - /// \see IterableIntMap, IterableValueMap - /// \see CrossRefMap - template - class IterableBoolMap - : protected ItemSetTraits::template Map::Type { - private: - typedef GR Graph; - - typedef typename ItemSetTraits::ItemIt KeyIt; - typedef typename ItemSetTraits::template Map::Type Parent; - - std::vector _array; - int _sep; - - public: - - /// Indicates that the map is reference map. - typedef True ReferenceMapTag; - - /// The key type - typedef K Key; - /// The value type - typedef bool Value; - /// The const reference type. - typedef const Value& ConstReference; - - private: - - int position(const Key& key) const { - return Parent::operator[](key); - } - - public: - - /// \brief Reference to the value of the map. - /// - /// This class is similar to the \c bool type. It can be converted to - /// \c bool and it provides the same operators. - class Reference { - friend class IterableBoolMap; - private: - Reference(IterableBoolMap& map, const Key& key) - : _key(key), _map(map) {} - public: - - Reference& operator=(const Reference& value) { - _map.set(_key, static_cast(value)); - return *this; - } - - operator bool() const { - return static_cast(_map)[_key]; - } - - Reference& operator=(bool value) { - _map.set(_key, value); - return *this; - } - Reference& operator&=(bool value) { - _map.set(_key, _map[_key] & value); - return *this; - } - Reference& operator|=(bool value) { - _map.set(_key, _map[_key] | value); - return *this; - } - Reference& operator^=(bool value) { - _map.set(_key, _map[_key] ^ value); - return *this; - } - private: - Key _key; - IterableBoolMap& _map; - }; - - /// \brief Constructor of the map with a default value. - /// - /// Constructor of the map with a default value. - explicit IterableBoolMap(const Graph& graph, bool def = false) - : Parent(graph) { - typename Parent::Notifier* nf = Parent::notifier(); - Key it; - for (nf->first(it); it != INVALID; nf->next(it)) { - Parent::set(it, _array.size()); - _array.push_back(it); - } - _sep = (def ? _array.size() : 0); - } - - /// \brief Const subscript operator of the map. - /// - /// Const subscript operator of the map. - bool operator[](const Key& key) const { - return position(key) < _sep; - } - - /// \brief Subscript operator of the map. - /// - /// Subscript operator of the map. - Reference operator[](const Key& key) { - return Reference(*this, key); - } - - /// \brief Set operation of the map. - /// - /// Set operation of the map. - void set(const Key& key, bool value) { - int pos = position(key); - if (value) { - if (pos < _sep) return; - Key tmp = _array[_sep]; - _array[_sep] = key; - Parent::set(key, _sep); - _array[pos] = tmp; - Parent::set(tmp, pos); - ++_sep; - } else { - if (pos >= _sep) return; - --_sep; - Key tmp = _array[_sep]; - _array[_sep] = key; - Parent::set(key, _sep); - _array[pos] = tmp; - Parent::set(tmp, pos); - } - } - - /// \brief Set all items. - /// - /// Set all items in the map. - /// \note Constant time operation. - void setAll(bool value) { - _sep = (value ? _array.size() : 0); - } - - /// \brief Returns the number of the keys mapped to \c true. - /// - /// Returns the number of the keys mapped to \c true. - int trueNum() const { - return _sep; - } - - /// \brief Returns the number of the keys mapped to \c false. - /// - /// Returns the number of the keys mapped to \c false. - int falseNum() const { - return _array.size() - _sep; - } - - /// \brief Iterator for the keys mapped to \c true. - /// - /// Iterator for the keys mapped to \c true. It works - /// like a graph item iterator, it can be converted to - /// the key type of the map, incremented with \c ++ operator, and - /// if the iterator leaves the last valid key, it will be equal to - /// \c INVALID. - class TrueIt : public Key { - public: - typedef Key Parent; - - /// \brief Creates an iterator. - /// - /// Creates an iterator. It iterates on the - /// keys mapped to \c true. - /// \param map The IterableBoolMap. - explicit TrueIt(const IterableBoolMap& map) - : Parent(map._sep > 0 ? map._array[map._sep - 1] : INVALID), - _map(&map) {} - - /// \brief Invalid constructor \& conversion. - /// - /// This constructor initializes the iterator to be invalid. - /// \sa Invalid for more details. - TrueIt(Invalid) : Parent(INVALID), _map(0) {} - - /// \brief Increment operator. - /// - /// Increment operator. - TrueIt& operator++() { - int pos = _map->position(*this); - Parent::operator=(pos > 0 ? _map->_array[pos - 1] : INVALID); - return *this; - } - - private: - const IterableBoolMap* _map; - }; - - /// \brief Iterator for the keys mapped to \c false. - /// - /// Iterator for the keys mapped to \c false. It works - /// like a graph item iterator, it can be converted to - /// the key type of the map, incremented with \c ++ operator, and - /// if the iterator leaves the last valid key, it will be equal to - /// \c INVALID. - class FalseIt : public Key { - public: - typedef Key Parent; - - /// \brief Creates an iterator. - /// - /// Creates an iterator. It iterates on the - /// keys mapped to \c false. - /// \param map The IterableBoolMap. - explicit FalseIt(const IterableBoolMap& map) - : Parent(map._sep < int(map._array.size()) ? - map._array.back() : INVALID), _map(&map) {} - - /// \brief Invalid constructor \& conversion. - /// - /// This constructor initializes the iterator to be invalid. - /// \sa Invalid for more details. - FalseIt(Invalid) : Parent(INVALID), _map(0) {} - - /// \brief Increment operator. - /// - /// Increment operator. - FalseIt& operator++() { - int pos = _map->position(*this); - Parent::operator=(pos > _map->_sep ? _map->_array[pos - 1] : INVALID); - return *this; - } - - private: - const IterableBoolMap* _map; - }; - - /// \brief Iterator for the keys mapped to a given value. - /// - /// Iterator for the keys mapped to a given value. It works - /// like a graph item iterator, it can be converted to - /// the key type of the map, incremented with \c ++ operator, and - /// if the iterator leaves the last valid key, it will be equal to - /// \c INVALID. - class ItemIt : public Key { - public: - typedef Key Parent; - - /// \brief Creates an iterator with a value. - /// - /// Creates an iterator with a value. It iterates on the - /// keys mapped to the given value. - /// \param map The IterableBoolMap. - /// \param value The value. - ItemIt(const IterableBoolMap& map, bool value) - : Parent(value ? - (map._sep > 0 ? - map._array[map._sep - 1] : INVALID) : - (map._sep < int(map._array.size()) ? - map._array.back() : INVALID)), _map(&map) {} - - /// \brief Invalid constructor \& conversion. - /// - /// This constructor initializes the iterator to be invalid. - /// \sa Invalid for more details. - ItemIt(Invalid) : Parent(INVALID), _map(0) {} - - /// \brief Increment operator. - /// - /// Increment operator. - ItemIt& operator++() { - int pos = _map->position(*this); - int _sep = pos >= _map->_sep ? _map->_sep : 0; - Parent::operator=(pos > _sep ? _map->_array[pos - 1] : INVALID); - return *this; - } - - private: - const IterableBoolMap* _map; - }; - - protected: - - virtual void add(const Key& key) { - Parent::add(key); - Parent::set(key, _array.size()); - _array.push_back(key); - } - - virtual void add(const std::vector& keys) { - Parent::add(keys); - for (int i = 0; i < int(keys.size()); ++i) { - Parent::set(keys[i], _array.size()); - _array.push_back(keys[i]); - } - } - - virtual void erase(const Key& key) { - int pos = position(key); - if (pos < _sep) { - --_sep; - Parent::set(_array[_sep], pos); - _array[pos] = _array[_sep]; - Parent::set(_array.back(), _sep); - _array[_sep] = _array.back(); - _array.pop_back(); - } else { - Parent::set(_array.back(), pos); - _array[pos] = _array.back(); - _array.pop_back(); - } - Parent::erase(key); - } - - virtual void erase(const std::vector& keys) { - for (int i = 0; i < int(keys.size()); ++i) { - int pos = position(keys[i]); - if (pos < _sep) { - --_sep; - Parent::set(_array[_sep], pos); - _array[pos] = _array[_sep]; - Parent::set(_array.back(), _sep); - _array[_sep] = _array.back(); - _array.pop_back(); - } else { - Parent::set(_array.back(), pos); - _array[pos] = _array.back(); - _array.pop_back(); - } - } - Parent::erase(keys); - } - - virtual void build() { - Parent::build(); - typename Parent::Notifier* nf = Parent::notifier(); - Key it; - for (nf->first(it); it != INVALID; nf->next(it)) { - Parent::set(it, _array.size()); - _array.push_back(it); - } - _sep = 0; - } - - virtual void clear() { - _array.clear(); - _sep = 0; - Parent::clear(); - } - - }; - - - namespace _maps_bits { - template - struct IterableIntMapNode { - IterableIntMapNode() : value(-1) {} - IterableIntMapNode(int _value) : value(_value) {} - Item prev, next; - int value; - }; - } - - /// \brief Dynamic iterable integer map. - /// - /// This class provides a special graph map type which can store an - /// integer value for graph items (\c Node, \c Arc or \c Edge). - /// For each non-negative value it is possible to iterate on the keys - /// mapped to the value. - /// - /// This map is intended to be used with small integer values, for which - /// it is efficient, and supports iteration only for non-negative values. - /// If you need large values and/or iteration for negative integers, - /// consider to use \ref IterableValueMap instead. - /// - /// This type is a reference map, so it can be modified with the - /// subscript operator. - /// - /// \note The size of the data structure depends on the largest - /// value in the map. - /// - /// \tparam GR The graph type. - /// \tparam K The key type of the map (\c GR::Node, \c GR::Arc or - /// \c GR::Edge). - /// - /// \see IterableBoolMap, IterableValueMap - /// \see CrossRefMap - template - class IterableIntMap - : protected ItemSetTraits:: - template Map<_maps_bits::IterableIntMapNode >::Type { - public: - typedef typename ItemSetTraits:: - template Map<_maps_bits::IterableIntMapNode >::Type Parent; - - /// The key type - typedef K Key; - /// The value type - typedef int Value; - /// The graph type - typedef GR Graph; - - /// \brief Constructor of the map. - /// - /// Constructor of the map. It sets all values to -1. - explicit IterableIntMap(const Graph& graph) - : Parent(graph) {} - - /// \brief Constructor of the map with a given value. - /// - /// Constructor of the map with a given value. - explicit IterableIntMap(const Graph& graph, int value) - : Parent(graph, _maps_bits::IterableIntMapNode(value)) { - if (value >= 0) { - for (typename Parent::ItemIt it(*this); it != INVALID; ++it) { - lace(it); - } - } - } - - private: - - void unlace(const Key& key) { - typename Parent::Value& node = Parent::operator[](key); - if (node.value < 0) return; - if (node.prev != INVALID) { - Parent::operator[](node.prev).next = node.next; - } else { - _first[node.value] = node.next; - } - if (node.next != INVALID) { - Parent::operator[](node.next).prev = node.prev; - } - while (!_first.empty() && _first.back() == INVALID) { - _first.pop_back(); - } - } - - void lace(const Key& key) { - typename Parent::Value& node = Parent::operator[](key); - if (node.value < 0) return; - if (node.value >= int(_first.size())) { - _first.resize(node.value + 1, INVALID); - } - node.prev = INVALID; - node.next = _first[node.value]; - if (node.next != INVALID) { - Parent::operator[](node.next).prev = key; - } - _first[node.value] = key; - } - - public: - - /// Indicates that the map is reference map. - typedef True ReferenceMapTag; - - /// \brief Reference to the value of the map. - /// - /// This class is similar to the \c int type. It can - /// be converted to \c int and it has the same operators. - class Reference { - friend class IterableIntMap; - private: - Reference(IterableIntMap& map, const Key& key) - : _key(key), _map(map) {} - public: - - Reference& operator=(const Reference& value) { - _map.set(_key, static_cast(value)); - return *this; - } - - operator const int&() const { - return static_cast(_map)[_key]; - } - - Reference& operator=(int value) { - _map.set(_key, value); - return *this; - } - Reference& operator++() { - _map.set(_key, _map[_key] + 1); - return *this; - } - int operator++(int) { - int value = _map[_key]; - _map.set(_key, value + 1); - return value; - } - Reference& operator--() { - _map.set(_key, _map[_key] - 1); - return *this; - } - int operator--(int) { - int value = _map[_key]; - _map.set(_key, value - 1); - return value; - } - Reference& operator+=(int value) { - _map.set(_key, _map[_key] + value); - return *this; - } - Reference& operator-=(int value) { - _map.set(_key, _map[_key] - value); - return *this; - } - Reference& operator*=(int value) { - _map.set(_key, _map[_key] * value); - return *this; - } - Reference& operator/=(int value) { - _map.set(_key, _map[_key] / value); - return *this; - } - Reference& operator%=(int value) { - _map.set(_key, _map[_key] % value); - return *this; - } - Reference& operator&=(int value) { - _map.set(_key, _map[_key] & value); - return *this; - } - Reference& operator|=(int value) { - _map.set(_key, _map[_key] | value); - return *this; - } - Reference& operator^=(int value) { - _map.set(_key, _map[_key] ^ value); - return *this; - } - Reference& operator<<=(int value) { - _map.set(_key, _map[_key] << value); - return *this; - } - Reference& operator>>=(int value) { - _map.set(_key, _map[_key] >> value); - return *this; - } - - private: - Key _key; - IterableIntMap& _map; - }; - - /// The const reference type. - typedef const Value& ConstReference; - - /// \brief Gives back the maximal value plus one. - /// - /// Gives back the maximal value plus one. - int size() const { - return _first.size(); - } - - /// \brief Set operation of the map. - /// - /// Set operation of the map. - void set(const Key& key, const Value& value) { - unlace(key); - Parent::operator[](key).value = value; - lace(key); - } - - /// \brief Const subscript operator of the map. - /// - /// Const subscript operator of the map. - const Value& operator[](const Key& key) const { - return Parent::operator[](key).value; - } - - /// \brief Subscript operator of the map. - /// - /// Subscript operator of the map. - Reference operator[](const Key& key) { - return Reference(*this, key); - } - - /// \brief Iterator for the keys with the same value. - /// - /// Iterator for the keys with the same value. It works - /// like a graph item iterator, it can be converted to - /// the item type of the map, incremented with \c ++ operator, and - /// if the iterator leaves the last valid item, it will be equal to - /// \c INVALID. - class ItemIt : public Key { - public: - typedef Key Parent; - - /// \brief Invalid constructor \& conversion. - /// - /// This constructor initializes the iterator to be invalid. - /// \sa Invalid for more details. - ItemIt(Invalid) : Parent(INVALID), _map(0) {} - - /// \brief Creates an iterator with a value. - /// - /// Creates an iterator with a value. It iterates on the - /// keys mapped to the given value. - /// \param map The IterableIntMap. - /// \param value The value. - ItemIt(const IterableIntMap& map, int value) : _map(&map) { - if (value < 0 || value >= int(_map->_first.size())) { - Parent::operator=(INVALID); - } else { - Parent::operator=(_map->_first[value]); - } - } - - /// \brief Increment operator. - /// - /// Increment operator. - ItemIt& operator++() { - Parent::operator=(_map->IterableIntMap::Parent:: - operator[](static_cast(*this)).next); - return *this; - } - - private: - const IterableIntMap* _map; - }; - - protected: - - virtual void erase(const Key& key) { - unlace(key); - Parent::erase(key); - } - - virtual void erase(const std::vector& keys) { - for (int i = 0; i < int(keys.size()); ++i) { - unlace(keys[i]); - } - Parent::erase(keys); - } - - virtual void clear() { - _first.clear(); - Parent::clear(); - } - - private: - std::vector _first; - }; - - namespace _maps_bits { - template - struct IterableValueMapNode { - IterableValueMapNode(Value _value = Value()) : value(_value) {} - Item prev, next; - Value value; - }; - } - - /// \brief Dynamic iterable map for comparable values. - /// - /// This class provides a special graph map type which can store a - /// comparable value for graph items (\c Node, \c Arc or \c Edge). - /// For each value it is possible to iterate on the keys mapped to - /// the value (\c ItemIt), and the values of the map can be accessed - /// with an STL compatible forward iterator (\c ValueIt). - /// The map stores a linked list for each value, which contains - /// the items mapped to the value, and the used values are stored - /// in balanced binary tree (\c std::map). - /// - /// \ref IterableBoolMap and \ref IterableIntMap are similar classes - /// specialized for \c bool and \c int values, respectively. - /// - /// This type is not reference map, so it cannot be modified with - /// the subscript operator. - /// - /// \tparam GR The graph type. - /// \tparam K The key type of the map (\c GR::Node, \c GR::Arc or - /// \c GR::Edge). - /// \tparam V The value type of the map. It can be any comparable - /// value type. - /// - /// \see IterableBoolMap, IterableIntMap - /// \see CrossRefMap - template - class IterableValueMap - : protected ItemSetTraits:: - template Map<_maps_bits::IterableValueMapNode >::Type { - public: - typedef typename ItemSetTraits:: - template Map<_maps_bits::IterableValueMapNode >::Type Parent; - - /// The key type - typedef K Key; - /// The value type - typedef V Value; - /// The graph type - typedef GR Graph; - - public: - - /// \brief Constructor of the map with a given value. - /// - /// Constructor of the map with a given value. - explicit IterableValueMap(const Graph& graph, - const Value& value = Value()) - : Parent(graph, _maps_bits::IterableValueMapNode(value)) { - for (typename Parent::ItemIt it(*this); it != INVALID; ++it) { - lace(it); - } - } - - protected: - - void unlace(const Key& key) { - typename Parent::Value& node = Parent::operator[](key); - if (node.prev != INVALID) { - Parent::operator[](node.prev).next = node.next; - } else { - if (node.next != INVALID) { - _first[node.value] = node.next; - } else { - _first.erase(node.value); - } - } - if (node.next != INVALID) { - Parent::operator[](node.next).prev = node.prev; - } - } - - void lace(const Key& key) { - typename Parent::Value& node = Parent::operator[](key); - typename std::map::iterator it = _first.find(node.value); - if (it == _first.end()) { - node.prev = node.next = INVALID; - _first.insert(std::make_pair(node.value, key)); - } else { - node.prev = INVALID; - node.next = it->second; - if (node.next != INVALID) { - Parent::operator[](node.next).prev = key; - } - it->second = key; - } - } - - public: - - /// \brief Forward iterator for values. - /// - /// This iterator is an STL compatible forward - /// iterator on the values of the map. The values can - /// be accessed in the [beginValue, endValue) range. - class ValueIt - : public std::iterator { - friend class IterableValueMap; - private: - ValueIt(typename std::map::const_iterator _it) - : it(_it) {} - public: - - /// Constructor - ValueIt() {} - - /// \e - ValueIt& operator++() { ++it; return *this; } - /// \e - ValueIt operator++(int) { - ValueIt tmp(*this); - operator++(); - return tmp; - } - - /// \e - const Value& operator*() const { return it->first; } - /// \e - const Value* operator->() const { return &(it->first); } - - /// \e - bool operator==(ValueIt jt) const { return it == jt.it; } - /// \e - bool operator!=(ValueIt jt) const { return it != jt.it; } - - private: - typename std::map::const_iterator it; - }; - - /// \brief Returns an iterator to the first value. - /// - /// Returns an STL compatible iterator to the - /// first value of the map. The values of the - /// map can be accessed in the [beginValue, endValue) - /// range. - ValueIt beginValue() const { - return ValueIt(_first.begin()); - } - - /// \brief Returns an iterator after the last value. - /// - /// Returns an STL compatible iterator after the - /// last value of the map. The values of the - /// map can be accessed in the [beginValue, endValue) - /// range. - ValueIt endValue() const { - return ValueIt(_first.end()); - } - - /// \brief Set operation of the map. - /// - /// Set operation of the map. - void set(const Key& key, const Value& value) { - unlace(key); - Parent::operator[](key).value = value; - lace(key); - } - - /// \brief Const subscript operator of the map. - /// - /// Const subscript operator of the map. - const Value& operator[](const Key& key) const { - return Parent::operator[](key).value; - } - - /// \brief Iterator for the keys with the same value. - /// - /// Iterator for the keys with the same value. It works - /// like a graph item iterator, it can be converted to - /// the item type of the map, incremented with \c ++ operator, and - /// if the iterator leaves the last valid item, it will be equal to - /// \c INVALID. - class ItemIt : public Key { - public: - typedef Key Parent; - - /// \brief Invalid constructor \& conversion. - /// - /// This constructor initializes the iterator to be invalid. - /// \sa Invalid for more details. - ItemIt(Invalid) : Parent(INVALID), _map(0) {} - - /// \brief Creates an iterator with a value. - /// - /// Creates an iterator with a value. It iterates on the - /// keys which have the given value. - /// \param map The IterableValueMap - /// \param value The value - ItemIt(const IterableValueMap& map, const Value& value) : _map(&map) { - typename std::map::const_iterator it = - map._first.find(value); - if (it == map._first.end()) { - Parent::operator=(INVALID); - } else { - Parent::operator=(it->second); - } - } - - /// \brief Increment operator. - /// - /// Increment Operator. - ItemIt& operator++() { - Parent::operator=(_map->IterableValueMap::Parent:: - operator[](static_cast(*this)).next); - return *this; - } - - - private: - const IterableValueMap* _map; - }; - - protected: - - virtual void add(const Key& key) { - Parent::add(key); - lace(key); - } - - virtual void add(const std::vector& keys) { - Parent::add(keys); - for (int i = 0; i < int(keys.size()); ++i) { - lace(keys[i]); - } - } - - virtual void erase(const Key& key) { - unlace(key); - Parent::erase(key); - } - - virtual void erase(const std::vector& keys) { - for (int i = 0; i < int(keys.size()); ++i) { - unlace(keys[i]); - } - Parent::erase(keys); - } - - virtual void build() { - Parent::build(); - for (typename Parent::ItemIt it(*this); it != INVALID; ++it) { - lace(it); - } - } - - virtual void clear() { - _first.clear(); - Parent::clear(); - } - - private: - std::map _first; }; @@ -3301,7 +2341,7 @@ public: - /// The key type (the \c Arc type of the digraph). + ///\e typedef typename GR::Arc Key; - /// The value type (the \c Node type of the digraph). + ///\e typedef typename GR::Node Value; @@ -3342,7 +2382,7 @@ public: - /// The key type (the \c Arc type of the digraph). + ///\e typedef typename GR::Arc Key; - /// The value type (the \c Node type of the digraph). + ///\e typedef typename GR::Node Value; @@ -3384,8 +2424,6 @@ public: - /// The key type (the \c Edge type of the digraph). + typedef typename GR::Arc Value; typedef typename GR::Edge Key; - /// The value type (the \c Arc type of the digraph). - typedef typename GR::Arc Value; /// \brief Constructor @@ -3426,8 +2464,6 @@ public: - /// The key type (the \c Edge type of the digraph). + typedef typename GR::Arc Value; typedef typename GR::Edge Key; - /// The value type (the \c Arc type of the digraph). - typedef typename GR::Arc Value; /// \brief Constructor @@ -3464,8 +2500,8 @@ /// whenever the digraph changes. /// - /// \warning Besides \c addNode() and \c addArc(), a digraph structure + /// \warning Besides \c addNode() and \c addArc(), a digraph structure /// may provide alternative ways to modify the digraph. /// The correct behavior of InDegMap is not guarantied if these additional - /// features are used. For example, the functions + /// features are used. For example the functions /// \ref ListDigraph::changeSource() "changeSource()", /// \ref ListDigraph::changeTarget() "changeTarget()" and @@ -3480,5 +2516,5 @@ public: - + /// The graph type of InDegMap typedef GR Graph; @@ -3594,8 +2630,8 @@ /// whenever the digraph changes. /// - /// \warning Besides \c addNode() and \c addArc(), a digraph structure + /// \warning Besides \c addNode() and \c addArc(), a digraph structure /// may provide alternative ways to modify the digraph. /// The correct behavior of OutDegMap is not guarantied if these additional - /// features are used. For example, the functions + /// features are used. For example the functions /// \ref ListDigraph::changeSource() "changeSource()", /// \ref ListDigraph::changeTarget() "changeTarget()" and @@ -3765,291 +2801,4 @@ } - - /// \brief Copy the values of a graph map to another map. - /// - /// This function copies the values of a graph map to another graph map. - /// \c To::Key must be equal or convertible to \c From::Key and - /// \c From::Value must be equal or convertible to \c To::Value. - /// - /// For example, an edge map of \c int value type can be copied to - /// an arc map of \c double value type in an undirected graph, but - /// an arc map cannot be copied to an edge map. - /// Note that even a \ref ConstMap can be copied to a standard graph map, - /// but \ref mapFill() can also be used for this purpose. - /// - /// \param gr The graph for which the maps are defined. - /// \param from The map from which the values have to be copied. - /// It must conform to the \ref concepts::ReadMap "ReadMap" concept. - /// \param to The map to which the values have to be copied. - /// It must conform to the \ref concepts::WriteMap "WriteMap" concept. - template - void mapCopy(const GR& gr, const From& from, To& to) { - typedef typename To::Key Item; - typedef typename ItemSetTraits::ItemIt ItemIt; - - for (ItemIt it(gr); it != INVALID; ++it) { - to.set(it, from[it]); - } - } - - /// \brief Compare two graph maps. - /// - /// This function compares the values of two graph maps. It returns - /// \c true if the maps assign the same value for all items in the graph. - /// The \c Key type of the maps (\c Node, \c Arc or \c Edge) must be equal - /// and their \c Value types must be comparable using \c %operator==(). - /// - /// \param gr The graph for which the maps are defined. - /// \param map1 The first map. - /// \param map2 The second map. - template - bool mapCompare(const GR& gr, const Map1& map1, const Map2& map2) { - typedef typename Map2::Key Item; - typedef typename ItemSetTraits::ItemIt ItemIt; - - for (ItemIt it(gr); it != INVALID; ++it) { - if (!(map1[it] == map2[it])) return false; - } - return true; - } - - /// \brief Return an item having minimum value of a graph map. - /// - /// This function returns an item (\c Node, \c Arc or \c Edge) having - /// minimum value of the given graph map. - /// If the item set is empty, it returns \c INVALID. - /// - /// \param gr The graph for which the map is defined. - /// \param map The graph map. - template - typename Map::Key mapMin(const GR& gr, const Map& map) { - return mapMin(gr, map, std::less()); - } - - /// \brief Return an item having minimum value of a graph map. - /// - /// This function returns an item (\c Node, \c Arc or \c Edge) having - /// minimum value of the given graph map. - /// If the item set is empty, it returns \c INVALID. - /// - /// \param gr The graph for which the map is defined. - /// \param map The graph map. - /// \param comp Comparison function object. - template - typename Map::Key mapMin(const GR& gr, const Map& map, const Comp& comp) { - typedef typename Map::Key Item; - typedef typename Map::Value Value; - typedef typename ItemSetTraits::ItemIt ItemIt; - - ItemIt min_item(gr); - if (min_item == INVALID) return INVALID; - Value min = map[min_item]; - for (ItemIt it(gr); it != INVALID; ++it) { - if (comp(map[it], min)) { - min = map[it]; - min_item = it; - } - } - return min_item; - } - - /// \brief Return an item having maximum value of a graph map. - /// - /// This function returns an item (\c Node, \c Arc or \c Edge) having - /// maximum value of the given graph map. - /// If the item set is empty, it returns \c INVALID. - /// - /// \param gr The graph for which the map is defined. - /// \param map The graph map. - template - typename Map::Key mapMax(const GR& gr, const Map& map) { - return mapMax(gr, map, std::less()); - } - - /// \brief Return an item having maximum value of a graph map. - /// - /// This function returns an item (\c Node, \c Arc or \c Edge) having - /// maximum value of the given graph map. - /// If the item set is empty, it returns \c INVALID. - /// - /// \param gr The graph for which the map is defined. - /// \param map The graph map. - /// \param comp Comparison function object. - template - typename Map::Key mapMax(const GR& gr, const Map& map, const Comp& comp) { - typedef typename Map::Key Item; - typedef typename Map::Value Value; - typedef typename ItemSetTraits::ItemIt ItemIt; - - ItemIt max_item(gr); - if (max_item == INVALID) return INVALID; - Value max = map[max_item]; - for (ItemIt it(gr); it != INVALID; ++it) { - if (comp(max, map[it])) { - max = map[it]; - max_item = it; - } - } - return max_item; - } - - /// \brief Return the minimum value of a graph map. - /// - /// This function returns the minimum value of the given graph map. - /// The corresponding item set of the graph must not be empty. - /// - /// \param gr The graph for which the map is defined. - /// \param map The graph map. - template - typename Map::Value mapMinValue(const GR& gr, const Map& map) { - return map[mapMin(gr, map, std::less())]; - } - - /// \brief Return the minimum value of a graph map. - /// - /// This function returns the minimum value of the given graph map. - /// The corresponding item set of the graph must not be empty. - /// - /// \param gr The graph for which the map is defined. - /// \param map The graph map. - /// \param comp Comparison function object. - template - typename Map::Value - mapMinValue(const GR& gr, const Map& map, const Comp& comp) { - return map[mapMin(gr, map, comp)]; - } - - /// \brief Return the maximum value of a graph map. - /// - /// This function returns the maximum value of the given graph map. - /// The corresponding item set of the graph must not be empty. - /// - /// \param gr The graph for which the map is defined. - /// \param map The graph map. - template - typename Map::Value mapMaxValue(const GR& gr, const Map& map) { - return map[mapMax(gr, map, std::less())]; - } - - /// \brief Return the maximum value of a graph map. - /// - /// This function returns the maximum value of the given graph map. - /// The corresponding item set of the graph must not be empty. - /// - /// \param gr The graph for which the map is defined. - /// \param map The graph map. - /// \param comp Comparison function object. - template - typename Map::Value - mapMaxValue(const GR& gr, const Map& map, const Comp& comp) { - return map[mapMax(gr, map, comp)]; - } - - /// \brief Return an item having a specified value in a graph map. - /// - /// This function returns an item (\c Node, \c Arc or \c Edge) having - /// the specified assigned value in the given graph map. - /// If no such item exists, it returns \c INVALID. - /// - /// \param gr The graph for which the map is defined. - /// \param map The graph map. - /// \param val The value that have to be found. - template - typename Map::Key - mapFind(const GR& gr, const Map& map, const typename Map::Value& val) { - typedef typename Map::Key Item; - typedef typename ItemSetTraits::ItemIt ItemIt; - - for (ItemIt it(gr); it != INVALID; ++it) { - if (map[it] == val) return it; - } - return INVALID; - } - - /// \brief Return an item having value for which a certain predicate is - /// true in a graph map. - /// - /// This function returns an item (\c Node, \c Arc or \c Edge) having - /// such assigned value for which the specified predicate is true - /// in the given graph map. - /// If no such item exists, it returns \c INVALID. - /// - /// \param gr The graph for which the map is defined. - /// \param map The graph map. - /// \param pred The predicate function object. - template - typename Map::Key - mapFindIf(const GR& gr, const Map& map, const Pred& pred) { - typedef typename Map::Key Item; - typedef typename ItemSetTraits::ItemIt ItemIt; - - for (ItemIt it(gr); it != INVALID; ++it) { - if (pred(map[it])) return it; - } - return INVALID; - } - - /// \brief Return the number of items having a specified value in a - /// graph map. - /// - /// This function returns the number of items (\c Node, \c Arc or \c Edge) - /// having the specified assigned value in the given graph map. - /// - /// \param gr The graph for which the map is defined. - /// \param map The graph map. - /// \param val The value that have to be counted. - template - int mapCount(const GR& gr, const Map& map, const typename Map::Value& val) { - typedef typename Map::Key Item; - typedef typename ItemSetTraits::ItemIt ItemIt; - - int cnt = 0; - for (ItemIt it(gr); it != INVALID; ++it) { - if (map[it] == val) ++cnt; - } - return cnt; - } - - /// \brief Return the number of items having values for which a certain - /// predicate is true in a graph map. - /// - /// This function returns the number of items (\c Node, \c Arc or \c Edge) - /// having such assigned values for which the specified predicate is true - /// in the given graph map. - /// - /// \param gr The graph for which the map is defined. - /// \param map The graph map. - /// \param pred The predicate function object. - template - int mapCountIf(const GR& gr, const Map& map, const Pred& pred) { - typedef typename Map::Key Item; - typedef typename ItemSetTraits::ItemIt ItemIt; - - int cnt = 0; - for (ItemIt it(gr); it != INVALID; ++it) { - if (pred(map[it])) ++cnt; - } - return cnt; - } - - /// \brief Fill a graph map with a certain value. - /// - /// This function sets the specified value for all items (\c Node, - /// \c Arc or \c Edge) in the given graph map. - /// - /// \param gr The graph for which the map is defined. - /// \param map The graph map. It must conform to the - /// \ref concepts::WriteMap "WriteMap" concept. - /// \param val The value. - template - void mapFill(const GR& gr, Map& map, const typename Map::Value& val) { - typedef typename Map::Key Item; - typedef typename ItemSetTraits::ItemIt ItemIt; - - for (ItemIt it(gr); it != INVALID; ++it) { - map.set(it, val); - } - } - /// @} } Index: lemon/matching.h =================================================================== --- lemon/matching.h (revision 877) +++ lemon/matching.h (revision 867) @@ -3,5 +3,5 @@ * This file is a part of LEMON, a generic C++ optimization library. * - * Copyright (C) 2003-2010 + * Copyright (C) 2003-2009 * Egervary Jeno Kombinatorikus Optimalizalasi Kutatocsoport * (Egervary Research Group on Combinatorial Optimization, EGRES). @@ -17,6 +17,6 @@ */ -#ifndef LEMON_MATCHING_H -#define LEMON_MATCHING_H +#ifndef LEMON_MAX_MATCHING_H +#define LEMON_MAX_MATCHING_H #include @@ -29,5 +29,4 @@ #include #include -#include ///\ingroup matching @@ -43,5 +42,5 @@ /// This class implements Edmonds' alternating forest matching algorithm /// for finding a maximum cardinality matching in a general undirected graph. - /// It can be started from an arbitrary initial matching + /// It can be started from an arbitrary initial matching /// (the default is the empty one). /// @@ -71,9 +70,9 @@ ///\brief Status constants for Gallai-Edmonds decomposition. /// - ///These constants are used for indicating the Gallai-Edmonds + ///These constants are used for indicating the Gallai-Edmonds ///decomposition of a graph. The nodes with status \c EVEN (or \c D) ///induce a subgraph with factor-critical components, the nodes with ///status \c ODD (or \c A) form the canonical barrier, and the nodes - ///with status \c MATCHED (or \c C) induce a subgraph having a + ///with status \c MATCHED (or \c C) induce a subgraph having a ///perfect matching. enum Status { @@ -514,5 +513,5 @@ } - /// \brief Start Edmonds' algorithm with a heuristic improvement + /// \brief Start Edmonds' algorithm with a heuristic improvement /// for dense graphs /// @@ -536,6 +535,6 @@ /// \brief Run Edmonds' algorithm /// - /// This function runs Edmonds' algorithm. An additional heuristic of - /// postponing shrinks is used for relatively dense graphs + /// This function runs Edmonds' algorithm. An additional heuristic of + /// postponing shrinks is used for relatively dense graphs /// (for which m>=2*n holds). void run() { @@ -558,5 +557,5 @@ /// \brief Return the size (cardinality) of the matching. /// - /// This function returns the size (cardinality) of the current matching. + /// This function returns the size (cardinality) of the current matching. /// After run() it returns the size of the maximum matching in the graph. int matchingSize() const { @@ -572,5 +571,5 @@ /// \brief Return \c true if the given edge is in the matching. /// - /// This function returns \c true if the given edge is in the current + /// This function returns \c true if the given edge is in the current /// matching. bool matching(const Edge& edge) const { @@ -581,5 +580,5 @@ /// /// This function returns the matching arc (or edge) incident to the - /// given node in the current matching or \c INVALID if the node is + /// given node in the current matching or \c INVALID if the node is /// not covered by the matching. Arc matching(const Node& n) const { @@ -597,5 +596,5 @@ /// \brief Return the mate of the given node. /// - /// This function returns the mate of the given node in the current + /// This function returns the mate of the given node in the current /// matching or \c INVALID if the node is not covered by the matching. Node mate(const Node& n) const { @@ -607,5 +606,5 @@ /// \name Dual Solution - /// Functions to get the dual solution, i.e. the Gallai-Edmonds + /// Functions to get the dual solution, i.e. the Gallai-Edmonds /// decomposition. @@ -650,6 +649,6 @@ /// \f$O(nm\log n)\f$ time complexity. /// - /// The maximum weighted matching problem is to find a subset of the - /// edges in an undirected graph with maximum overall weight for which + /// The maximum weighted matching problem is to find a subset of the + /// edges in an undirected graph with maximum overall weight for which /// each node has at most one incident edge. /// It can be formulated with the following linear program. @@ -675,14 +674,14 @@ \frac{\vert B \vert - 1}{2}z_B\f] */ /// - /// The algorithm can be executed with the run() function. + /// The algorithm can be executed with the run() function. /// After it the matching (the primal solution) and the dual solution - /// can be obtained using the query functions and the - /// \ref MaxWeightedMatching::BlossomIt "BlossomIt" nested class, - /// which is able to iterate on the nodes of a blossom. + /// can be obtained using the query functions and the + /// \ref MaxWeightedMatching::BlossomIt "BlossomIt" nested class, + /// which is able to iterate on the nodes of a blossom. /// If the value type is integer, then the dual solution is multiplied /// by \ref MaxWeightedMatching::dualScale "4". /// /// \tparam GR The undirected graph type the algorithm runs on. - /// \tparam WM The type edge weight map. The default type is + /// \tparam WM The type edge weight map. The default type is /// \ref concepts::Graph::EdgeMap "GR::EdgeMap". #ifdef DOXYGEN @@ -747,5 +746,5 @@ enum Status { - EVEN = -1, MATCHED = 0, ODD = 1 + EVEN = -1, MATCHED = 0, ODD = 1, UNMATCHED = -2 }; @@ -799,8 +798,4 @@ Value _delta_sum; - int _unmatched; - - typedef MaxWeightedFractionalMatching FractionalMatching; - FractionalMatching *_fractional; void createStructures() { @@ -869,4 +864,7 @@ void destroyStructures() { + _node_num = countNodes(_graph); + _blossom_num = _node_num * 3 / 2; + if (_matching) { delete _matching; @@ -944,5 +942,205 @@ _delta3->push(e, rw / 2); } + } else if ((*_blossom_data)[vb].status == UNMATCHED) { + if (_delta3->state(e) != _delta3->IN_HEAP) { + _delta3->push(e, rw); + } } else { + typename std::map::iterator it = + (*_node_data)[vi].heap_index.find(tree); + + if (it != (*_node_data)[vi].heap_index.end()) { + if ((*_node_data)[vi].heap[it->second] > rw) { + (*_node_data)[vi].heap.replace(it->second, e); + (*_node_data)[vi].heap.decrease(e, rw); + it->second = e; + } + } else { + (*_node_data)[vi].heap.push(e, rw); + (*_node_data)[vi].heap_index.insert(std::make_pair(tree, e)); + } + + if ((*_blossom_set)[v] > (*_node_data)[vi].heap.prio()) { + _blossom_set->decrease(v, (*_node_data)[vi].heap.prio()); + + if ((*_blossom_data)[vb].status == MATCHED) { + if (_delta2->state(vb) != _delta2->IN_HEAP) { + _delta2->push(vb, _blossom_set->classPrio(vb) - + (*_blossom_data)[vb].offset); + } else if ((*_delta2)[vb] > _blossom_set->classPrio(vb) - + (*_blossom_data)[vb].offset){ + _delta2->decrease(vb, _blossom_set->classPrio(vb) - + (*_blossom_data)[vb].offset); + } + } + } + } + } + } + (*_blossom_data)[blossom].offset = 0; + } + + void matchedToOdd(int blossom) { + if (_delta2->state(blossom) == _delta2->IN_HEAP) { + _delta2->erase(blossom); + } + (*_blossom_data)[blossom].offset += _delta_sum; + if (!_blossom_set->trivial(blossom)) { + _delta4->push(blossom, (*_blossom_data)[blossom].pot / 2 + + (*_blossom_data)[blossom].offset); + } + } + + void evenToMatched(int blossom, int tree) { + if (!_blossom_set->trivial(blossom)) { + (*_blossom_data)[blossom].pot += 2 * _delta_sum; + } + + for (typename BlossomSet::ItemIt n(*_blossom_set, blossom); + n != INVALID; ++n) { + int ni = (*_node_index)[n]; + (*_node_data)[ni].pot -= _delta_sum; + + _delta1->erase(n); + + for (InArcIt e(_graph, n); e != INVALID; ++e) { + Node v = _graph.source(e); + int vb = _blossom_set->find(v); + int vi = (*_node_index)[v]; + + Value rw = (*_node_data)[ni].pot + (*_node_data)[vi].pot - + dualScale * _weight[e]; + + if (vb == blossom) { + if (_delta3->state(e) == _delta3->IN_HEAP) { + _delta3->erase(e); + } + } else if ((*_blossom_data)[vb].status == EVEN) { + + if (_delta3->state(e) == _delta3->IN_HEAP) { + _delta3->erase(e); + } + + int vt = _tree_set->find(vb); + + if (vt != tree) { + + Arc r = _graph.oppositeArc(e); + + typename std::map::iterator it = + (*_node_data)[ni].heap_index.find(vt); + + if (it != (*_node_data)[ni].heap_index.end()) { + if ((*_node_data)[ni].heap[it->second] > rw) { + (*_node_data)[ni].heap.replace(it->second, r); + (*_node_data)[ni].heap.decrease(r, rw); + it->second = r; + } + } else { + (*_node_data)[ni].heap.push(r, rw); + (*_node_data)[ni].heap_index.insert(std::make_pair(vt, r)); + } + + if ((*_blossom_set)[n] > (*_node_data)[ni].heap.prio()) { + _blossom_set->decrease(n, (*_node_data)[ni].heap.prio()); + + if (_delta2->state(blossom) != _delta2->IN_HEAP) { + _delta2->push(blossom, _blossom_set->classPrio(blossom) - + (*_blossom_data)[blossom].offset); + } else if ((*_delta2)[blossom] > + _blossom_set->classPrio(blossom) - + (*_blossom_data)[blossom].offset){ + _delta2->decrease(blossom, _blossom_set->classPrio(blossom) - + (*_blossom_data)[blossom].offset); + } + } + } + + } else if ((*_blossom_data)[vb].status == UNMATCHED) { + if (_delta3->state(e) == _delta3->IN_HEAP) { + _delta3->erase(e); + } + } else { + + typename std::map::iterator it = + (*_node_data)[vi].heap_index.find(tree); + + if (it != (*_node_data)[vi].heap_index.end()) { + (*_node_data)[vi].heap.erase(it->second); + (*_node_data)[vi].heap_index.erase(it); + if ((*_node_data)[vi].heap.empty()) { + _blossom_set->increase(v, std::numeric_limits::max()); + } else if ((*_blossom_set)[v] < (*_node_data)[vi].heap.prio()) { + _blossom_set->increase(v, (*_node_data)[vi].heap.prio()); + } + + if ((*_blossom_data)[vb].status == MATCHED) { + if (_blossom_set->classPrio(vb) == + std::numeric_limits::max()) { + _delta2->erase(vb); + } else if ((*_delta2)[vb] < _blossom_set->classPrio(vb) - + (*_blossom_data)[vb].offset) { + _delta2->increase(vb, _blossom_set->classPrio(vb) - + (*_blossom_data)[vb].offset); + } + } + } + } + } + } + } + + void oddToMatched(int blossom) { + (*_blossom_data)[blossom].offset -= _delta_sum; + + if (_blossom_set->classPrio(blossom) != + std::numeric_limits::max()) { + _delta2->push(blossom, _blossom_set->classPrio(blossom) - + (*_blossom_data)[blossom].offset); + } + + if (!_blossom_set->trivial(blossom)) { + _delta4->erase(blossom); + } + } + + void oddToEven(int blossom, int tree) { + if (!_blossom_set->trivial(blossom)) { + _delta4->erase(blossom); + (*_blossom_data)[blossom].pot -= + 2 * (2 * _delta_sum - (*_blossom_data)[blossom].offset); + } + + for (typename BlossomSet::ItemIt n(*_blossom_set, blossom); + n != INVALID; ++n) { + int ni = (*_node_index)[n]; + + _blossom_set->increase(n, std::numeric_limits::max()); + + (*_node_data)[ni].heap.clear(); + (*_node_data)[ni].heap_index.clear(); + (*_node_data)[ni].pot += + 2 * _delta_sum - (*_blossom_data)[blossom].offset; + + _delta1->push(n, (*_node_data)[ni].pot); + + for (InArcIt e(_graph, n); e != INVALID; ++e) { + Node v = _graph.source(e); + int vb = _blossom_set->find(v); + int vi = (*_node_index)[v]; + + Value rw = (*_node_data)[ni].pot + (*_node_data)[vi].pot - + dualScale * _weight[e]; + + if ((*_blossom_data)[vb].status == EVEN) { + if (_delta3->state(e) != _delta3->IN_HEAP && blossom != vb) { + _delta3->push(e, rw / 2); + } + } else if ((*_blossom_data)[vb].status == UNMATCHED) { + if (_delta3->state(e) != _delta3->IN_HEAP) { + _delta3->push(e, rw); + } + } else { + typename std::map::iterator it = (*_node_data)[vi].heap_index.find(tree); @@ -979,18 +1177,8 @@ } - void matchedToOdd(int blossom) { + + void matchedToUnmatched(int blossom) { if (_delta2->state(blossom) == _delta2->IN_HEAP) { _delta2->erase(blossom); - } - (*_blossom_data)[blossom].offset += _delta_sum; - if (!_blossom_set->trivial(blossom)) { - _delta4->push(blossom, (*_blossom_data)[blossom].pot / 2 + - (*_blossom_data)[blossom].offset); - } - } - - void evenToMatched(int blossom, int tree) { - if (!_blossom_set->trivial(blossom)) { - (*_blossom_data)[blossom].pot += 2 * _delta_sum; } @@ -998,7 +1186,31 @@ n != INVALID; ++n) { int ni = (*_node_index)[n]; - (*_node_data)[ni].pot -= _delta_sum; - - _delta1->erase(n); + + _blossom_set->increase(n, std::numeric_limits::max()); + + (*_node_data)[ni].heap.clear(); + (*_node_data)[ni].heap_index.clear(); + + for (OutArcIt e(_graph, n); e != INVALID; ++e) { + Node v = _graph.target(e); + int vb = _blossom_set->find(v); + int vi = (*_node_index)[v]; + + Value rw = (*_node_data)[ni].pot + (*_node_data)[vi].pot - + dualScale * _weight[e]; + + if ((*_blossom_data)[vb].status == EVEN) { + if (_delta3->state(e) != _delta3->IN_HEAP) { + _delta3->push(e, rw); + } + } + } + } + } + + void unmatchedToMatched(int blossom) { + for (typename BlossomSet::ItemIt n(*_blossom_set, blossom); + n != INVALID; ++n) { + int ni = (*_node_index)[n]; for (InArcIt e(_graph, n); e != INVALID; ++e) { @@ -1022,146 +1234,40 @@ int vt = _tree_set->find(vb); - if (vt != tree) { - - Arc r = _graph.oppositeArc(e); - - typename std::map::iterator it = - (*_node_data)[ni].heap_index.find(vt); - - if (it != (*_node_data)[ni].heap_index.end()) { - if ((*_node_data)[ni].heap[it->second] > rw) { - (*_node_data)[ni].heap.replace(it->second, r); - (*_node_data)[ni].heap.decrease(r, rw); - it->second = r; - } - } else { - (*_node_data)[ni].heap.push(r, rw); - (*_node_data)[ni].heap_index.insert(std::make_pair(vt, r)); - } - - if ((*_blossom_set)[n] > (*_node_data)[ni].heap.prio()) { - _blossom_set->decrease(n, (*_node_data)[ni].heap.prio()); - - if (_delta2->state(blossom) != _delta2->IN_HEAP) { - _delta2->push(blossom, _blossom_set->classPrio(blossom) - - (*_blossom_data)[blossom].offset); - } else if ((*_delta2)[blossom] > - _blossom_set->classPrio(blossom) - - (*_blossom_data)[blossom].offset){ - _delta2->decrease(blossom, _blossom_set->classPrio(blossom) - - (*_blossom_data)[blossom].offset); - } - } - } - } else { + Arc r = _graph.oppositeArc(e); typename std::map::iterator it = - (*_node_data)[vi].heap_index.find(tree); - - if (it != (*_node_data)[vi].heap_index.end()) { - (*_node_data)[vi].heap.erase(it->second); - (*_node_data)[vi].heap_index.erase(it); - if ((*_node_data)[vi].heap.empty()) { - _blossom_set->increase(v, std::numeric_limits::max()); - } else if ((*_blossom_set)[v] < (*_node_data)[vi].heap.prio()) { - _blossom_set->increase(v, (*_node_data)[vi].heap.prio()); - } - - if ((*_blossom_data)[vb].status == MATCHED) { - if (_blossom_set->classPrio(vb) == - std::numeric_limits::max()) { - _delta2->erase(vb); - } else if ((*_delta2)[vb] < _blossom_set->classPrio(vb) - - (*_blossom_data)[vb].offset) { - _delta2->increase(vb, _blossom_set->classPrio(vb) - - (*_blossom_data)[vb].offset); - } - } - } - } - } - } - } - - void oddToMatched(int blossom) { - (*_blossom_data)[blossom].offset -= _delta_sum; - - if (_blossom_set->classPrio(blossom) != - std::numeric_limits::max()) { - _delta2->push(blossom, _blossom_set->classPrio(blossom) - - (*_blossom_data)[blossom].offset); - } - - if (!_blossom_set->trivial(blossom)) { - _delta4->erase(blossom); - } - } - - void oddToEven(int blossom, int tree) { - if (!_blossom_set->trivial(blossom)) { - _delta4->erase(blossom); - (*_blossom_data)[blossom].pot -= - 2 * (2 * _delta_sum - (*_blossom_data)[blossom].offset); - } - - for (typename BlossomSet::ItemIt n(*_blossom_set, blossom); - n != INVALID; ++n) { - int ni = (*_node_index)[n]; - - _blossom_set->increase(n, std::numeric_limits::max()); - - (*_node_data)[ni].heap.clear(); - (*_node_data)[ni].heap_index.clear(); - (*_node_data)[ni].pot += - 2 * _delta_sum - (*_blossom_data)[blossom].offset; - - _delta1->push(n, (*_node_data)[ni].pot); - - for (InArcIt e(_graph, n); e != INVALID; ++e) { - Node v = _graph.source(e); - int vb = _blossom_set->find(v); - int vi = (*_node_index)[v]; - - Value rw = (*_node_data)[ni].pot + (*_node_data)[vi].pot - - dualScale * _weight[e]; - - if ((*_blossom_data)[vb].status == EVEN) { - if (_delta3->state(e) != _delta3->IN_HEAP && blossom != vb) { - _delta3->push(e, rw / 2); - } - } else { - - typename std::map::iterator it = - (*_node_data)[vi].heap_index.find(tree); - - if (it != (*_node_data)[vi].heap_index.end()) { - if ((*_node_data)[vi].heap[it->second] > rw) { - (*_node_data)[vi].heap.replace(it->second, e); - (*_node_data)[vi].heap.decrease(e, rw); - it->second = e; + (*_node_data)[ni].heap_index.find(vt); + + if (it != (*_node_data)[ni].heap_index.end()) { + if ((*_node_data)[ni].heap[it->second] > rw) { + (*_node_data)[ni].heap.replace(it->second, r); + (*_node_data)[ni].heap.decrease(r, rw); + it->second = r; } } else { - (*_node_data)[vi].heap.push(e, rw); - (*_node_data)[vi].heap_index.insert(std::make_pair(tree, e)); - } - - if ((*_blossom_set)[v] > (*_node_data)[vi].heap.prio()) { - _blossom_set->decrease(v, (*_node_data)[vi].heap.prio()); - - if ((*_blossom_data)[vb].status == MATCHED) { - if (_delta2->state(vb) != _delta2->IN_HEAP) { - _delta2->push(vb, _blossom_set->classPrio(vb) - - (*_blossom_data)[vb].offset); - } else if ((*_delta2)[vb] > _blossom_set->classPrio(vb) - - (*_blossom_data)[vb].offset) { - _delta2->decrease(vb, _blossom_set->classPrio(vb) - - (*_blossom_data)[vb].offset); - } + (*_node_data)[ni].heap.push(r, rw); + (*_node_data)[ni].heap_index.insert(std::make_pair(vt, r)); + } + + if ((*_blossom_set)[n] > (*_node_data)[ni].heap.prio()) { + _blossom_set->decrease(n, (*_node_data)[ni].heap.prio()); + + if (_delta2->state(blossom) != _delta2->IN_HEAP) { + _delta2->push(blossom, _blossom_set->classPrio(blossom) - + (*_blossom_data)[blossom].offset); + } else if ((*_delta2)[blossom] > _blossom_set->classPrio(blossom)- + (*_blossom_data)[blossom].offset){ + _delta2->decrease(blossom, _blossom_set->classPrio(blossom) - + (*_blossom_data)[blossom].offset); } } + + } else if ((*_blossom_data)[vb].status == UNMATCHED) { + if (_delta3->state(e) == _delta3->IN_HEAP) { + _delta3->erase(e); + } } } } - (*_blossom_data)[blossom].offset = 0; } @@ -1208,7 +1314,9 @@ destroyTree(tree); + (*_blossom_data)[blossom].status = UNMATCHED; (*_blossom_data)[blossom].base = node; - (*_blossom_data)[blossom].next = INVALID; - } + matchedToUnmatched(blossom); + } + void augmentOnEdge(const Edge& edge) { @@ -1217,29 +1325,24 @@ int right = _blossom_set->find(_graph.v(edge)); - int left_tree = _tree_set->find(left); - alternatePath(left, left_tree); - destroyTree(left_tree); - - int right_tree = _tree_set->find(right); - alternatePath(right, right_tree); - destroyTree(right_tree); + if ((*_blossom_data)[left].status == EVEN) { + int left_tree = _tree_set->find(left); + alternatePath(left, left_tree); + destroyTree(left_tree); + } else { + (*_blossom_data)[left].status = MATCHED; + unmatchedToMatched(left); + } + + if ((*_blossom_data)[right].status == EVEN) { + int right_tree = _tree_set->find(right); + alternatePath(right, right_tree); + destroyTree(right_tree); + } else { + (*_blossom_data)[right].status = MATCHED; + unmatchedToMatched(right); + } (*_blossom_data)[left].next = _graph.direct(edge, true); (*_blossom_data)[right].next = _graph.direct(edge, false); - } - - void augmentOnArc(const Arc& arc) { - - int left = _blossom_set->find(_graph.source(arc)); - int right = _blossom_set->find(_graph.target(arc)); - - (*_blossom_data)[left].status = MATCHED; - - int right_tree = _tree_set->find(right); - alternatePath(right, right_tree); - destroyTree(right_tree); - - (*_blossom_data)[left].next = arc; - (*_blossom_data)[right].next = _graph.oppositeArc(arc); } @@ -1446,5 +1549,5 @@ (*_blossom_data)[sb].pred = pred; (*_blossom_data)[sb].next = - _graph.oppositeArc((*_blossom_data)[tb].next); + _graph.oppositeArc((*_blossom_data)[tb].next); pred = (*_blossom_data)[ub].next; @@ -1546,5 +1649,5 @@ for (int i = 0; i < int(blossoms.size()); ++i) { - if ((*_blossom_data)[blossoms[i]].next != INVALID) { + if ((*_blossom_data)[blossoms[i]].status == MATCHED) { Value offset = (*_blossom_data)[blossoms[i]].offset; @@ -1584,14 +1687,8 @@ _delta4_index(0), _delta4(0), - _delta_sum(), _unmatched(0), - - _fractional(0) - {} + _delta_sum() {} ~MaxWeightedMatching() { destroyStructures(); - if (_fractional) { - delete _fractional; - } } @@ -1624,7 +1721,5 @@ (*_delta4_index)[i] = _delta4->PRE_HEAP; } - - _unmatched = _node_num; - + _delta1->clear(); _delta2->clear(); @@ -1670,159 +1765,9 @@ } - /// \brief Initialize the algorithm with fractional matching - /// - /// This function initializes the algorithm with a fractional - /// matching. This initialization is also called jumpstart heuristic. - void fractionalInit() { - createStructures(); - - _blossom_node_list.clear(); - _blossom_potential.clear(); - - if (_fractional == 0) { - _fractional = new FractionalMatching(_graph, _weight, false); - } - _fractional->run(); - - for (ArcIt e(_graph); e != INVALID; ++e) { - (*_node_heap_index)[e] = BinHeap::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::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 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 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::iterator it = - (*_node_data)[ni].heap_index.find(vt); - - if (it != (*_node_data)[ni].heap_index.end()) { - if ((*_node_data)[ni].heap[it->second] > rw) { - (*_node_data)[ni].heap.replace(it->second, e); - (*_node_data)[ni].heap.decrease(e, rw); - it->second = e; - } - } else { - (*_node_data)[ni].heap.push(e, rw); - (*_node_data)[ni].heap_index.insert(std::make_pair(vt, e)); - } - } - } - - if (!(*_node_data)[ni].heap.empty()) { - _blossom_set->decrease(n, (*_node_data)[ni].heap.prio()); - _delta2->push(nb, _blossom_set->classPrio(nb)); - } - } - } - /// \brief Start the algorithm /// /// This function starts the algorithm. /// - /// \pre \ref init() or \ref fractionalInit() must be called - /// before using this function. + /// \pre \ref init() must be called before using this function. void start() { enum OpType { @@ -1830,5 +1775,6 @@ }; - while (_unmatched > 0) { + int unmatched = _node_num; + while (unmatched > 0) { Value d1 = !_delta1->empty() ? _delta1->prio() : std::numeric_limits::max(); @@ -1843,8 +1789,9 @@ _delta4->prio() : std::numeric_limits::max(); - _delta_sum = d3; OpType ot = D3; - if (d1 < _delta_sum) { _delta_sum = d1; ot = D1; } + _delta_sum = d1; OpType ot = D1; if (d2 < _delta_sum) { _delta_sum = d2; ot = D2; } + if (d3 < _delta_sum) { _delta_sum = d3; ot = D3; } if (d4 < _delta_sum) { _delta_sum = d4; ot = D4; } + switch (ot) { @@ -1853,5 +1800,5 @@ Node n = _delta1->top(); unmatchNode(n); - --_unmatched; + --unmatched; } break; @@ -1860,11 +1807,6 @@ int blossom = _delta2->top(); Node n = _blossom_set->classTop(blossom); - Arc a = (*_node_data)[(*_node_index)[n]].heap.top(); - if ((*_blossom_data)[blossom].next == INVALID) { - augmentOnArc(a); - --_unmatched; - } else { - extendOnArc(a); - } + Arc e = (*_node_data)[(*_node_index)[n]].heap.top(); + extendOnArc(e); } break; @@ -1879,6 +1821,18 @@ _delta3->pop(); } else { - int left_tree = _tree_set->find(left_blossom); - int right_tree = _tree_set->find(right_blossom); + int left_tree; + if ((*_blossom_data)[left_blossom].status == EVEN) { + left_tree = _tree_set->find(left_blossom); + } else { + left_tree = -1; + ++unmatched; + } + int right_tree; + if ((*_blossom_data)[right_blossom].status == EVEN) { + right_tree = _tree_set->find(right_blossom); + } else { + right_tree = -1; + ++unmatched; + } if (left_tree == right_tree) { @@ -1886,5 +1840,5 @@ } else { augmentOnEdge(e); - _unmatched -= 2; + unmatched -= 2; } } @@ -1904,9 +1858,9 @@ /// \note mwm.run() is just a shortcut of the following code. /// \code - /// mwm.fractionalInit(); + /// mwm.init(); /// mwm.start(); /// \endcode void run() { - fractionalInit(); + init(); start(); } @@ -1915,5 +1869,5 @@ /// \name Primal Solution - /// Functions to get the primal solution, i.e. the maximum weighted + /// Functions to get the primal solution, i.e. the maximum weighted /// matching.\n /// Either \ref run() or \ref start() function should be called before @@ -1934,5 +1888,5 @@ } } - return sum / 2; + return sum /= 2; } @@ -1954,5 +1908,5 @@ /// \brief Return \c true if the given edge is in the matching. /// - /// This function returns \c true if the given edge is in the found + /// This function returns \c true if the given edge is in the found /// matching. /// @@ -1965,5 +1919,5 @@ /// /// This function returns the matching arc (or edge) incident to the - /// given node in the found matching or \c INVALID if the node is + /// given node in the found matching or \c INVALID if the node is /// not covered by the matching. /// @@ -1983,5 +1937,5 @@ /// \brief Return the mate of the given node. /// - /// This function returns the mate of the given node in the found + /// This function returns the mate of the given node in the found /// matching or \c INVALID if the node is not covered by the matching. /// @@ -2003,6 +1957,6 @@ /// \brief Return the value of the dual solution. /// - /// This function returns the value of the dual solution. - /// It should be equal to the primal value scaled by \ref dualScale + /// This function returns the value of the dual solution. + /// It should be equal to the primal value scaled by \ref dualScale /// "dual scale". /// @@ -2059,7 +2013,7 @@ /// \brief Iterator for obtaining the nodes of a blossom. /// - /// This class provides an iterator for obtaining the nodes of the + /// This class provides an iterator for obtaining the nodes of the /// given blossom. It lists a subset of the nodes. - /// Before using this iterator, you must allocate a + /// Before using this iterator, you must allocate a /// MaxWeightedMatching class and execute it. class BlossomIt { @@ -2070,6 +2024,6 @@ /// Constructor to get the nodes of the given variable. /// - /// \pre Either \ref MaxWeightedMatching::run() "algorithm.run()" or - /// \ref MaxWeightedMatching::start() "algorithm.start()" must be + /// \pre Either \ref MaxWeightedMatching::run() "algorithm.run()" or + /// \ref MaxWeightedMatching::start() "algorithm.start()" must be /// called before initializing this iterator. BlossomIt(const MaxWeightedMatching& algorithm, int variable) @@ -2124,6 +2078,6 @@ /// \f$O(nm\log n)\f$ time complexity. /// - /// The maximum weighted perfect matching problem is to find a subset of - /// the edges in an undirected graph with maximum overall weight for which + /// The maximum weighted perfect matching problem is to find a subset of + /// the edges in an undirected graph with maximum overall weight for which /// each node has exactly one incident edge. /// It can be formulated with the following linear program. @@ -2148,14 +2102,14 @@ \frac{\vert B \vert - 1}{2}z_B\f] */ /// - /// The algorithm can be executed with the run() function. + /// The algorithm can be executed with the run() function. /// After it the matching (the primal solution) and the dual solution - /// can be obtained using the query functions and the - /// \ref MaxWeightedPerfectMatching::BlossomIt "BlossomIt" nested class, - /// which is able to iterate on the nodes of a blossom. + /// can be obtained using the query functions and the + /// \ref MaxWeightedPerfectMatching::BlossomIt "BlossomIt" nested class, + /// which is able to iterate on the nodes of a blossom. /// If the value type is integer, then the dual solution is multiplied /// by \ref MaxWeightedMatching::dualScale "4". /// /// \tparam GR The undirected graph type the algorithm runs on. - /// \tparam WM The type edge weight map. The default type is + /// \tparam WM The type edge weight map. The default type is /// \ref concepts::Graph::EdgeMap "GR::EdgeMap". #ifdef DOXYGEN @@ -2268,9 +2222,4 @@ Value _delta_sum; - int _unmatched; - - typedef MaxWeightedPerfectFractionalMatching - FractionalMatching; - FractionalMatching *_fractional; void createStructures() { @@ -2334,4 +2283,7 @@ void destroyStructures() { + _node_num = countNodes(_graph); + _blossom_num = _node_num * 3 / 2; + if (_matching) { delete _matching; @@ -3006,14 +2958,8 @@ _delta4_index(0), _delta4(0), - _delta_sum(), _unmatched(0), - - _fractional(0) - {} + _delta_sum() {} ~MaxWeightedPerfectMatching() { destroyStructures(); - if (_fractional) { - delete _fractional; - } } @@ -3043,6 +2989,4 @@ (*_delta4_index)[i] = _delta4->PRE_HEAP; } - - _unmatched = _node_num; _delta2->clear(); @@ -3087,153 +3031,9 @@ } - /// \brief Initialize the algorithm with fractional matching - /// - /// This function initializes the algorithm with a fractional - /// matching. This initialization is also called jumpstart heuristic. - void fractionalInit() { - createStructures(); - - _blossom_node_list.clear(); - _blossom_potential.clear(); - - if (_fractional == 0) { - _fractional = new FractionalMatching(_graph, _weight, false); - } - if (!_fractional->run()) { - _unmatched = -1; - return; - } - - for (ArcIt e(_graph); e != INVALID; ++e) { - (*_node_heap_index)[e] = BinHeap::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::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 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 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::iterator it = - (*_node_data)[ni].heap_index.find(vt); - - if (it != (*_node_data)[ni].heap_index.end()) { - if ((*_node_data)[ni].heap[it->second] > rw) { - (*_node_data)[ni].heap.replace(it->second, e); - (*_node_data)[ni].heap.decrease(e, rw); - it->second = e; - } - } else { - (*_node_data)[ni].heap.push(e, rw); - (*_node_data)[ni].heap_index.insert(std::make_pair(vt, e)); - } - } - } - - if (!(*_node_data)[ni].heap.empty()) { - _blossom_set->decrease(n, (*_node_data)[ni].heap.prio()); - _delta2->push(nb, _blossom_set->classPrio(nb)); - } - } - } - /// \brief Start the algorithm /// /// This function starts the algorithm. /// - /// \pre \ref init() or \ref fractionalInit() must be called before - /// using this function. + /// \pre \ref init() must be called before using this function. bool start() { enum OpType { @@ -3241,7 +3041,6 @@ }; - if (_unmatched == -1) return false; - - while (_unmatched > 0) { + int unmatched = _node_num; + while (unmatched > 0) { Value d2 = !_delta2->empty() ? _delta2->prio() : std::numeric_limits::max(); @@ -3253,6 +3052,6 @@ _delta4->prio() : std::numeric_limits::max(); - _delta_sum = d3; OpType ot = D3; - if (d2 < _delta_sum) { _delta_sum = d2; ot = D2; } + _delta_sum = d2; OpType ot = D2; + if (d3 < _delta_sum) { _delta_sum = d3; ot = D3; } if (d4 < _delta_sum) { _delta_sum = d4; ot = D4; } @@ -3287,5 +3086,5 @@ } else { augmentOnEdge(e); - _unmatched -= 2; + unmatched -= 2; } } @@ -3306,9 +3105,9 @@ /// \note mwpm.run() is just a shortcut of the following code. /// \code - /// mwpm.fractionalInit(); + /// mwpm.init(); /// mwpm.start(); /// \endcode bool run() { - fractionalInit(); + init(); return start(); } @@ -3317,5 +3116,5 @@ /// \name Primal Solution - /// Functions to get the primal solution, i.e. the maximum weighted + /// Functions to get the primal solution, i.e. the maximum weighted /// perfect matching.\n /// Either \ref run() or \ref start() function should be called before @@ -3336,10 +3135,10 @@ } } - return sum / 2; + return sum /= 2; } /// \brief Return \c true if the given edge is in the matching. /// - /// This function returns \c true if the given edge is in the found + /// This function returns \c true if the given edge is in the found /// matching. /// @@ -3352,5 +3151,5 @@ /// /// This function returns the matching arc (or edge) incident to the - /// given node in the found matching or \c INVALID if the node is + /// given node in the found matching or \c INVALID if the node is /// not covered by the matching. /// @@ -3370,5 +3169,5 @@ /// \brief Return the mate of the given node. /// - /// This function returns the mate of the given node in the found + /// This function returns the mate of the given node in the found /// matching or \c INVALID if the node is not covered by the matching. /// @@ -3389,6 +3188,6 @@ /// \brief Return the value of the dual solution. /// - /// This function returns the value of the dual solution. - /// It should be equal to the primal value scaled by \ref dualScale + /// This function returns the value of the dual solution. + /// It should be equal to the primal value scaled by \ref dualScale /// "dual scale". /// @@ -3445,7 +3244,7 @@ /// \brief Iterator for obtaining the nodes of a blossom. /// - /// This class provides an iterator for obtaining the nodes of the + /// This class provides an iterator for obtaining the nodes of the /// given blossom. It lists a subset of the nodes. - /// Before using this iterator, you must allocate a + /// Before using this iterator, you must allocate a /// MaxWeightedPerfectMatching class and execute it. class BlossomIt { @@ -3456,6 +3255,6 @@ /// Constructor to get the nodes of the given variable. /// - /// \pre Either \ref MaxWeightedPerfectMatching::run() "algorithm.run()" - /// or \ref MaxWeightedPerfectMatching::start() "algorithm.start()" + /// \pre Either \ref MaxWeightedPerfectMatching::run() "algorithm.run()" + /// or \ref MaxWeightedPerfectMatching::start() "algorithm.start()" /// must be called before initializing this iterator. BlossomIt(const MaxWeightedPerfectMatching& algorithm, int variable) @@ -3503,3 +3302,3 @@ } //END OF NAMESPACE LEMON -#endif //LEMON_MATCHING_H +#endif //LEMON_MAX_MATCHING_H Index: lemon/math.h =================================================================== --- lemon/math.h (revision 877) +++ lemon/math.h (revision 487) @@ -3,5 +3,5 @@ * This file is a part of LEMON, a generic C++ optimization library. * - * Copyright (C) 2003-2010 + * Copyright (C) 2003-2009 * Egervary Jeno Kombinatorikus Optimalizalasi Kutatocsoport * (Egervary Research Group on Combinatorial Optimization, EGRES). @@ -57,5 +57,5 @@ ///Check whether the parameter is NaN or not - + ///This function checks whether the parameter is NaN or not. ///Is should be equivalent with std::isnan(), but it is not Index: mon/max_cardinality_search.h =================================================================== --- lemon/max_cardinality_search.h (revision 977) +++ (revision ) @@ -1,793 +1,0 @@ -/* -*- C++ -*- - * - * This file is a part of LEMON, a generic C++ optimization library - * - * Copyright (C) 2003-2010 - * Egervary Jeno Kombinatorikus Optimalizalasi Kutatocsoport - * (Egervary Research Group on Combinatorial Optimization, EGRES). - * - * Permission to use, modify and distribute this software is granted - * provided that this copyright notice appears in all copies. For - * precise terms see the accompanying LICENSE file. - * - * This software is provided "AS IS" with no warranty of any kind, - * express or implied, and with no claim as to its suitability for any - * purpose. - * - */ - -#ifndef LEMON_MAX_CARDINALITY_SEARCH_H -#define LEMON_MAX_CARDINALITY_SEARCH_H - - -/// \ingroup search -/// \file -/// \brief Maximum cardinality search in undirected digraphs. - -#include -#include - -#include -#include - -#include - -namespace lemon { - - /// \brief Default traits class of MaxCardinalitySearch class. - /// - /// Default traits class of MaxCardinalitySearch class. - /// \param Digraph Digraph type. - /// \param CapacityMap Type of capacity map. - template - struct MaxCardinalitySearchDefaultTraits { - /// The digraph type the algorithm runs on. - typedef GR Digraph; - - template - struct CapMapSelector { - - typedef CM CapacityMap; - - static CapacityMap *createCapacityMap(const Digraph& g) { - return new CapacityMap(g); - } - }; - - template - struct CapMapSelector > > { - - typedef ConstMap > CapacityMap; - - static CapacityMap *createCapacityMap(const Digraph&) { - return new CapacityMap; - } - }; - - /// \brief The type of the map that stores the arc capacities. - /// - /// The type of the map that stores the arc capacities. - /// It must meet the \ref concepts::ReadMap "ReadMap" concept. - typedef typename CapMapSelector::CapacityMap CapacityMap; - - /// \brief The type of the capacity of the arcs. - typedef typename CapacityMap::Value Value; - - /// \brief Instantiates a CapacityMap. - /// - /// This function instantiates a \ref CapacityMap. - /// \param digraph is the digraph, to which we would like to define - /// the CapacityMap. - static CapacityMap *createCapacityMap(const Digraph& digraph) { - return CapMapSelector::createCapacityMap(digraph); - } - - /// \brief The cross reference type used by heap. - /// - /// The cross reference type used by heap. - /// Usually it is \c Digraph::NodeMap. - typedef typename Digraph::template NodeMap HeapCrossRef; - - /// \brief Instantiates a HeapCrossRef. - /// - /// This function instantiates a \ref HeapCrossRef. - /// \param digraph is the digraph, to which we would like to define the - /// HeapCrossRef. - static HeapCrossRef *createHeapCrossRef(const Digraph &digraph) { - return new HeapCrossRef(digraph); - } - - template - struct HeapSelector { - template - struct Selector { - typedef BinHeap > Heap; - }; - }; - - template - struct HeapSelector > > { - template - struct Selector { - typedef BucketHeap Heap; - }; - }; - - /// \brief The heap type used by MaxCardinalitySearch algorithm. - /// - /// The heap type used by MaxCardinalitySearch algorithm. It should - /// maximalize the priorities. The default heap type is - /// the \ref BinHeap, but it is specialized when the - /// CapacityMap is ConstMap > - /// to BucketHeap. - /// - /// \sa MaxCardinalitySearch - typedef typename HeapSelector - ::template Selector - ::Heap Heap; - - /// \brief Instantiates a Heap. - /// - /// This function instantiates a \ref Heap. - /// \param crossref The cross reference of the heap. - static Heap *createHeap(HeapCrossRef& crossref) { - return new Heap(crossref); - } - - /// \brief The type of the map that stores whether a node is processed. - /// - /// The type of the map that stores whether a node is processed. - /// It must meet the \ref concepts::WriteMap "WriteMap" concept. - /// By default it is a NullMap. - typedef NullMap ProcessedMap; - - /// \brief Instantiates a ProcessedMap. - /// - /// This function instantiates a \ref ProcessedMap. - /// \param digraph is the digraph, to which - /// we would like to define the \ref ProcessedMap -#ifdef DOXYGEN - static ProcessedMap *createProcessedMap(const Digraph &digraph) -#else - static ProcessedMap *createProcessedMap(const Digraph &) -#endif - { - return new ProcessedMap(); - } - - /// \brief The type of the map that stores the cardinalities of the nodes. - /// - /// The type of the map that stores the cardinalities of the nodes. - /// It must meet the \ref concepts::WriteMap "WriteMap" concept. - typedef typename Digraph::template NodeMap CardinalityMap; - - /// \brief Instantiates a CardinalityMap. - /// - /// This function instantiates a \ref CardinalityMap. - /// \param digraph is the digraph, to which we would like to define the \ref - /// CardinalityMap - static CardinalityMap *createCardinalityMap(const Digraph &digraph) { - return new CardinalityMap(digraph); - } - - - }; - - /// \ingroup search - /// - /// \brief Maximum Cardinality Search algorithm class. - /// - /// This class provides an efficient implementation of Maximum Cardinality - /// Search algorithm. The maximum cardinality search first chooses any - /// node of the digraph. Then every time it chooses one unprocessed node - /// with maximum cardinality, i.e the sum of capacities on out arcs to the nodes - /// which were previusly processed. - /// If there is a cut in the digraph the algorithm should choose - /// again any unprocessed node of the digraph. - - /// The arc capacities are passed to the algorithm using a - /// \ref concepts::ReadMap "ReadMap", so it is easy to change it to any - /// kind of capacity. - /// - /// The type of the capacity is determined by the \ref - /// concepts::ReadMap::Value "Value" of the capacity map. - /// - /// It is also possible to change the underlying priority heap. - /// - /// - /// \param GR The digraph type the algorithm runs on. The value of - /// Digraph is not used directly by the search algorithm, it - /// is only passed to \ref MaxCardinalitySearchDefaultTraits. - /// \param CAP This read-only ArcMap determines the capacities of - /// the arcs. It is read once for each arc, so the map may involve in - /// relatively time consuming process to compute the arc capacity if - /// it is necessary. The default map type is \ref - /// ConstMap "ConstMap >". The value - /// of CapacityMap is not used directly by search algorithm, it is only - /// passed to \ref MaxCardinalitySearchDefaultTraits. - /// \param TR Traits class to set various data types used by the - /// algorithm. The default traits class is - /// \ref MaxCardinalitySearchDefaultTraits - /// "MaxCardinalitySearchDefaultTraits". - /// See \ref MaxCardinalitySearchDefaultTraits - /// for the documentation of a MaxCardinalitySearch traits class. - -#ifdef DOXYGEN - template -#else - template >, - typename TR = - MaxCardinalitySearchDefaultTraits > -#endif - class MaxCardinalitySearch { - public: - - typedef TR Traits; - ///The type of the underlying digraph. - typedef typename Traits::Digraph Digraph; - - ///The type of the capacity of the arcs. - typedef typename Traits::CapacityMap::Value Value; - ///The type of the map that stores the arc capacities. - typedef typename Traits::CapacityMap CapacityMap; - ///The type of the map indicating if a node is processed. - typedef typename Traits::ProcessedMap ProcessedMap; - ///The type of the map that stores the cardinalities of the nodes. - typedef typename Traits::CardinalityMap CardinalityMap; - ///The cross reference type used for the current heap. - typedef typename Traits::HeapCrossRef HeapCrossRef; - ///The heap type used by the algorithm. It maximizes the priorities. - typedef typename Traits::Heap Heap; - private: - // Pointer to the underlying digraph. - const Digraph *_graph; - // Pointer to the capacity map - const CapacityMap *_capacity; - // Indicates if \ref _capacity is locally allocated (\c true) or not. - bool local_capacity; - // Pointer to the map of cardinality. - CardinalityMap *_cardinality; - // Indicates if \ref _cardinality is locally allocated (\c true) or not. - bool local_cardinality; - // Pointer to the map of processed status of the nodes. - ProcessedMap *_processed; - // Indicates if \ref _processed is locally allocated (\c true) or not. - bool local_processed; - // Pointer to the heap cross references. - HeapCrossRef *_heap_cross_ref; - // Indicates if \ref _heap_cross_ref is locally allocated (\c true) or not. - bool local_heap_cross_ref; - // Pointer to the heap. - Heap *_heap; - // Indicates if \ref _heap is locally allocated (\c true) or not. - bool local_heap; - - public : - - typedef MaxCardinalitySearch Create; - - ///\name Named template parameters - - ///@{ - - template - struct DefCapacityMapTraits : public Traits { - typedef T CapacityMap; - static CapacityMap *createCapacityMap(const Digraph &) { - LEMON_ASSERT(false,"Uninitialized parameter."); - return 0; - } - }; - /// \brief \ref named-templ-param "Named parameter" for setting - /// CapacityMap type - /// - /// \ref named-templ-param "Named parameter" for setting CapacityMap type - /// for the algorithm. - template - struct SetCapacityMap - : public MaxCardinalitySearch > { - typedef MaxCardinalitySearch > Create; - }; - - template - struct DefCardinalityMapTraits : public Traits { - typedef T CardinalityMap; - static CardinalityMap *createCardinalityMap(const Digraph &) - { - LEMON_ASSERT(false,"Uninitialized parameter."); - return 0; - } - }; - /// \brief \ref named-templ-param "Named parameter" for setting - /// CardinalityMap type - /// - /// \ref named-templ-param "Named parameter" for setting CardinalityMap - /// type for the algorithm. - template - struct SetCardinalityMap - : public MaxCardinalitySearch > { - typedef MaxCardinalitySearch > Create; - }; - - template - struct DefProcessedMapTraits : public Traits { - typedef T ProcessedMap; - static ProcessedMap *createProcessedMap(const Digraph &) { - LEMON_ASSERT(false,"Uninitialized parameter."); - return 0; - } - }; - /// \brief \ref named-templ-param "Named parameter" for setting - /// ProcessedMap type - /// - /// \ref named-templ-param "Named parameter" for setting ProcessedMap type - /// for the algorithm. - template - struct SetProcessedMap - : public MaxCardinalitySearch > { - typedef MaxCardinalitySearch > Create; - }; - - template - struct DefHeapTraits : public Traits { - typedef CR HeapCrossRef; - typedef H Heap; - static HeapCrossRef *createHeapCrossRef(const Digraph &) { - LEMON_ASSERT(false,"Uninitialized parameter."); - return 0; - } - static Heap *createHeap(HeapCrossRef &) { - LEMON_ASSERT(false,"Uninitialized parameter."); - return 0; - } - }; - /// \brief \ref named-templ-param "Named parameter" for setting heap - /// and cross reference type - /// - /// \ref named-templ-param "Named parameter" for setting heap and cross - /// reference type for the algorithm. - template > - struct SetHeap - : public MaxCardinalitySearch > { - typedef MaxCardinalitySearch< Digraph, CapacityMap, - DefHeapTraits > Create; - }; - - template - struct DefStandardHeapTraits : public Traits { - typedef CR HeapCrossRef; - typedef H Heap; - static HeapCrossRef *createHeapCrossRef(const Digraph &digraph) { - return new HeapCrossRef(digraph); - } - static Heap *createHeap(HeapCrossRef &crossref) { - return new Heap(crossref); - } - }; - - /// \brief \ref named-templ-param "Named parameter" for setting heap and - /// cross reference type with automatic allocation - /// - /// \ref named-templ-param "Named parameter" for setting heap and cross - /// reference type. It can allocate the heap and the cross reference - /// object if the cross reference's constructor waits for the digraph as - /// parameter and the heap's constructor waits for the cross reference. - template > - struct SetStandardHeap - : public MaxCardinalitySearch > { - typedef MaxCardinalitySearch > - Create; - }; - - ///@} - - - protected: - - MaxCardinalitySearch() {} - - public: - - /// \brief Constructor. - /// - ///\param digraph the digraph the algorithm will run on. - ///\param capacity the capacity map used by the algorithm. - MaxCardinalitySearch(const Digraph& digraph, - const CapacityMap& capacity) : - _graph(&digraph), - _capacity(&capacity), local_capacity(false), - _cardinality(0), local_cardinality(false), - _processed(0), local_processed(false), - _heap_cross_ref(0), local_heap_cross_ref(false), - _heap(0), local_heap(false) - { } - - /// \brief Constructor. - /// - ///\param digraph the digraph the algorithm will run on. - /// - ///A constant 1 capacity map will be allocated. - MaxCardinalitySearch(const Digraph& digraph) : - _graph(&digraph), - _capacity(0), local_capacity(false), - _cardinality(0), local_cardinality(false), - _processed(0), local_processed(false), - _heap_cross_ref(0), local_heap_cross_ref(false), - _heap(0), local_heap(false) - { } - - /// \brief Destructor. - ~MaxCardinalitySearch() { - if(local_capacity) delete _capacity; - if(local_cardinality) delete _cardinality; - if(local_processed) delete _processed; - if(local_heap_cross_ref) delete _heap_cross_ref; - if(local_heap) delete _heap; - } - - /// \brief Sets the capacity map. - /// - /// Sets the capacity map. - /// \return (*this) - MaxCardinalitySearch &capacityMap(const CapacityMap &m) { - if (local_capacity) { - delete _capacity; - local_capacity=false; - } - _capacity=&m; - return *this; - } - - /// \brief Returns a const reference to the capacity map. - /// - /// Returns a const reference to the capacity map used by - /// the algorithm. - const CapacityMap &capacityMap() const { - return *_capacity; - } - - /// \brief Sets the map storing the cardinalities calculated by the - /// algorithm. - /// - /// Sets the map storing the cardinalities calculated by the algorithm. - /// If you don't use this function before calling \ref run(), - /// it will allocate one. The destuctor deallocates this - /// automatically allocated map, of course. - /// \return (*this) - MaxCardinalitySearch &cardinalityMap(CardinalityMap &m) { - if(local_cardinality) { - delete _cardinality; - local_cardinality=false; - } - _cardinality = &m; - return *this; - } - - /// \brief Sets the map storing the processed nodes. - /// - /// Sets the map storing the processed nodes. - /// If you don't use this function before calling \ref run(), - /// it will allocate one. The destuctor deallocates this - /// automatically allocated map, of course. - /// \return (*this) - MaxCardinalitySearch &processedMap(ProcessedMap &m) - { - if(local_processed) { - delete _processed; - local_processed=false; - } - _processed = &m; - return *this; - } - - /// \brief Returns a const reference to the cardinality map. - /// - /// Returns a const reference to the cardinality map used by - /// the algorithm. - const ProcessedMap &processedMap() const { - return *_processed; - } - - /// \brief Sets the heap and the cross reference used by algorithm. - /// - /// Sets the heap and the cross reference used by algorithm. - /// If you don't use this function before calling \ref run(), - /// it will allocate one. The destuctor deallocates this - /// automatically allocated map, of course. - /// \return (*this) - MaxCardinalitySearch &heap(Heap& hp, HeapCrossRef &cr) { - if(local_heap_cross_ref) { - delete _heap_cross_ref; - local_heap_cross_ref = false; - } - _heap_cross_ref = &cr; - if(local_heap) { - delete _heap; - local_heap = false; - } - _heap = &hp; - return *this; - } - - /// \brief Returns a const reference to the heap. - /// - /// Returns a const reference to the heap used by - /// the algorithm. - const Heap &heap() const { - return *_heap; - } - - /// \brief Returns a const reference to the cross reference. - /// - /// Returns a const reference to the cross reference - /// of the heap. - const HeapCrossRef &heapCrossRef() const { - return *_heap_cross_ref; - } - - private: - - typedef typename Digraph::Node Node; - typedef typename Digraph::NodeIt NodeIt; - typedef typename Digraph::Arc Arc; - typedef typename Digraph::InArcIt InArcIt; - - void create_maps() { - if(!_capacity) { - local_capacity = true; - _capacity = Traits::createCapacityMap(*_graph); - } - if(!_cardinality) { - local_cardinality = true; - _cardinality = Traits::createCardinalityMap(*_graph); - } - if(!_processed) { - local_processed = true; - _processed = Traits::createProcessedMap(*_graph); - } - if (!_heap_cross_ref) { - local_heap_cross_ref = true; - _heap_cross_ref = Traits::createHeapCrossRef(*_graph); - } - if (!_heap) { - local_heap = true; - _heap = Traits::createHeap(*_heap_cross_ref); - } - } - - void finalizeNodeData(Node node, Value capacity) { - _processed->set(node, true); - _cardinality->set(node, capacity); - } - - public: - /// \name Execution control - /// The simplest way to execute the algorithm is to use - /// one of the member functions called \ref run(). - /// \n - /// If you need more control on the execution, - /// first you must call \ref init(), then you can add several source nodes - /// with \ref addSource(). - /// Finally \ref start() will perform the computation. - - ///@{ - - /// \brief Initializes the internal data structures. - /// - /// Initializes the internal data structures, and clears the heap. - void init() { - create_maps(); - _heap->clear(); - for (NodeIt it(*_graph) ; it != INVALID ; ++it) { - _processed->set(it, false); - _heap_cross_ref->set(it, Heap::PRE_HEAP); - } - } - - /// \brief Adds a new source node. - /// - /// Adds a new source node to the priority heap. - /// - /// It checks if the node has not yet been added to the heap. - void addSource(Node source, Value capacity = 0) { - if(_heap->state(source) == Heap::PRE_HEAP) { - _heap->push(source, capacity); - } - } - - /// \brief Processes the next node in the priority heap - /// - /// Processes the next node in the priority heap. - /// - /// \return The processed node. - /// - /// \warning The priority heap must not be empty! - Node processNextNode() { - Node node = _heap->top(); - finalizeNodeData(node, _heap->prio()); - _heap->pop(); - - for (InArcIt it(*_graph, node); it != INVALID; ++it) { - Node source = _graph->source(it); - switch (_heap->state(source)) { - case Heap::PRE_HEAP: - _heap->push(source, (*_capacity)[it]); - break; - case Heap::IN_HEAP: - _heap->decrease(source, (*_heap)[source] + (*_capacity)[it]); - break; - case Heap::POST_HEAP: - break; - } - } - return node; - } - - /// \brief Next node to be processed. - /// - /// Next node to be processed. - /// - /// \return The next node to be processed or INVALID if the - /// priority heap is empty. - Node nextNode() { - return !_heap->empty() ? _heap->top() : INVALID; - } - - /// \brief Returns \c false if there are nodes - /// to be processed in the priority heap - /// - /// Returns \c false if there are nodes - /// to be processed in the priority heap - bool emptyQueue() { return _heap->empty(); } - /// \brief Returns the number of the nodes to be processed - /// in the priority heap - /// - /// Returns the number of the nodes to be processed in the priority heap - int emptySize() { return _heap->size(); } - - /// \brief Executes the algorithm. - /// - /// Executes the algorithm. - /// - ///\pre init() must be called and at least one node should be added - /// with addSource() before using this function. - /// - /// This method runs the Maximum Cardinality Search algorithm from the - /// source node(s). - void start() { - while ( !_heap->empty() ) processNextNode(); - } - - /// \brief Executes the algorithm until \c dest is reached. - /// - /// Executes the algorithm until \c dest is reached. - /// - /// \pre init() must be called and at least one node should be added - /// with addSource() before using this function. - /// - /// This method runs the %MaxCardinalitySearch algorithm from the source - /// nodes. - void start(Node dest) { - while ( !_heap->empty() && _heap->top()!=dest ) processNextNode(); - if ( !_heap->empty() ) finalizeNodeData(_heap->top(), _heap->prio()); - } - - /// \brief Executes the algorithm until a condition is met. - /// - /// Executes the algorithm until a condition is met. - /// - /// \pre init() must be called and at least one node should be added - /// with addSource() before using this function. - /// - /// \param nm must be a bool (or convertible) node map. The algorithm - /// will stop when it reaches a node \c v with nm[v]==true. - template - void start(const NodeBoolMap &nm) { - while ( !_heap->empty() && !nm[_heap->top()] ) processNextNode(); - if ( !_heap->empty() ) finalizeNodeData(_heap->top(),_heap->prio()); - } - - /// \brief Runs the maximum cardinality search algorithm from node \c s. - /// - /// This method runs the %MaxCardinalitySearch algorithm from a root - /// node \c s. - /// - ///\note d.run(s) is just a shortcut of the following code. - ///\code - /// d.init(); - /// d.addSource(s); - /// d.start(); - ///\endcode - void run(Node s) { - init(); - addSource(s); - start(); - } - - /// \brief Runs the maximum cardinality search algorithm for the - /// whole digraph. - /// - /// This method runs the %MaxCardinalitySearch algorithm from all - /// unprocessed node of the digraph. - /// - ///\note d.run(s) is just a shortcut of the following code. - ///\code - /// d.init(); - /// for (NodeIt it(digraph); it != INVALID; ++it) { - /// if (!d.reached(it)) { - /// d.addSource(s); - /// d.start(); - /// } - /// } - ///\endcode - void run() { - init(); - for (NodeIt it(*_graph); it != INVALID; ++it) { - if (!reached(it)) { - addSource(it); - start(); - } - } - } - - ///@} - - /// \name Query Functions - /// The results of the maximum cardinality search algorithm can be - /// obtained using these functions. - /// \n - /// Before the use of these functions, either run() or start() must be - /// called. - - ///@{ - - /// \brief The cardinality of a node. - /// - /// Returns the cardinality of a node. - /// \pre \ref run() must be called before using this function. - /// \warning If node \c v in unreachable from the root the return value - /// of this funcion is undefined. - Value cardinality(Node node) const { return (*_cardinality)[node]; } - - /// \brief The current cardinality of a node. - /// - /// Returns the current cardinality of a node. - /// \pre the given node should be reached but not processed - Value currentCardinality(Node node) const { return (*_heap)[node]; } - - /// \brief Returns a reference to the NodeMap of cardinalities. - /// - /// Returns a reference to the NodeMap of cardinalities. \pre \ref run() - /// must be called before using this function. - const CardinalityMap &cardinalityMap() const { return *_cardinality;} - - /// \brief Checks if a node is reachable from the root. - /// - /// Returns \c true if \c v is reachable from the root. - /// \warning The source nodes are initated as unreached. - /// \pre \ref run() must be called before using this function. - bool reached(Node v) { return (*_heap_cross_ref)[v] != Heap::PRE_HEAP; } - - /// \brief Checks if a node is processed. - /// - /// Returns \c true if \c v is processed, i.e. the shortest - /// path to \c v has already found. - /// \pre \ref run() must be called before using this function. - bool processed(Node v) { return (*_heap_cross_ref)[v] == Heap::POST_HEAP; } - - ///@} - }; - -} - -#endif Index: lemon/min_cost_arborescence.h =================================================================== --- lemon/min_cost_arborescence.h (revision 877) +++ lemon/min_cost_arborescence.h (revision 625) @@ -3,5 +3,5 @@ * This file is a part of LEMON, a generic C++ optimization library. * - * Copyright (C) 2003-2010 + * Copyright (C) 2003-2008 * Egervary Jeno Kombinatorikus Optimalizalasi Kutatocsoport * (Egervary Research Group on Combinatorial Optimization, EGRES). @@ -113,9 +113,8 @@ /// it is necessary. The default map type is \ref /// concepts::Digraph::ArcMap "Digraph::ArcMap". - /// \tparam TR The traits class that defines various types used by the - /// algorithm. By default, it is \ref MinCostArborescenceDefaultTraits + /// \param TR Traits class to set various data types used + /// by the algorithm. The default traits class is + /// \ref MinCostArborescenceDefaultTraits /// "MinCostArborescenceDefaultTraits". - /// In most cases, this parameter should not be set directly, - /// consider to use the named template parameters instead. #ifndef DOXYGEN template > #else - template + template #endif class MinCostArborescence { public: - /// \brief The \ref MinCostArborescenceDefaultTraits "traits class" - /// of the algorithm. + /// \brief The \ref MinCostArborescenceDefaultTraits "traits class" + /// of the algorithm. typedef TR Traits; /// The type of the underlying digraph. @@ -437,5 +436,5 @@ /// \ref named-templ-param "Named parameter" for setting /// \c PredMap type. - /// It must meet the \ref concepts::WriteMap "WriteMap" concept, + /// It must meet the \ref concepts::WriteMap "WriteMap" concept, /// and its value type must be the \c Arc type of the digraph. template @@ -490,6 +489,6 @@ /// The simplest way to execute the algorithm is to use /// one of the member functions called \c run(...). \n - /// If you need better control on the execution, - /// you have to call \ref init() first, then you can add several + /// If you need more control on the execution, + /// first you must call \ref init(), then you can add several /// source nodes with \ref addSource(). /// Finally \ref start() will perform the arborescence Index: mon/nagamochi_ibaraki.h =================================================================== --- lemon/nagamochi_ibaraki.h (revision 978) +++ (revision ) @@ -1,702 +1,0 @@ -/* -*- mode: C++; indent-tabs-mode: nil; -*- - * - * This file is a part of LEMON, a generic C++ optimization library. - * - * Copyright (C) 2003-2010 - * Egervary Jeno Kombinatorikus Optimalizalasi Kutatocsoport - * (Egervary Research Group on Combinatorial Optimization, EGRES). - * - * Permission to use, modify and distribute this software is granted - * provided that this copyright notice appears in all copies. For - * precise terms see the accompanying LICENSE file. - * - * This software is provided "AS IS" with no warranty of any kind, - * express or implied, and with no claim as to its suitability for any - * purpose. - * - */ - -#ifndef LEMON_NAGAMOCHI_IBARAKI_H -#define LEMON_NAGAMOCHI_IBARAKI_H - - -/// \ingroup min_cut -/// \file -/// \brief Implementation of the Nagamochi-Ibaraki algorithm. - -#include -#include -#include -#include -#include -#include - -#include - -namespace lemon { - - /// \brief Default traits class for NagamochiIbaraki class. - /// - /// Default traits class for NagamochiIbaraki class. - /// \param GR The undirected graph type. - /// \param CM Type of capacity map. - template - struct NagamochiIbarakiDefaultTraits { - /// The type of the capacity map. - typedef typename CM::Value Value; - - /// The undirected graph type the algorithm runs on. - typedef GR Graph; - - /// \brief The type of the map that stores the edge capacities. - /// - /// The type of the map that stores the edge capacities. - /// It must meet the \ref concepts::ReadMap "ReadMap" concept. - typedef CM CapacityMap; - - /// \brief Instantiates a CapacityMap. - /// - /// This function instantiates a \ref CapacityMap. -#ifdef DOXYGEN - static CapacityMap *createCapacityMap(const Graph& graph) -#else - static CapacityMap *createCapacityMap(const Graph&) -#endif - { - LEMON_ASSERT(false, "CapacityMap is not initialized"); - return 0; // ignore warnings - } - - /// \brief The cross reference type used by heap. - /// - /// The cross reference type used by heap. - /// Usually \c Graph::NodeMap. - typedef typename Graph::template NodeMap HeapCrossRef; - - /// \brief Instantiates a HeapCrossRef. - /// - /// This function instantiates a \ref HeapCrossRef. - /// \param g is the graph, to which we would like to define the - /// \ref HeapCrossRef. - static HeapCrossRef *createHeapCrossRef(const Graph& g) { - return new HeapCrossRef(g); - } - - /// \brief The heap type used by NagamochiIbaraki algorithm. - /// - /// The heap type used by NagamochiIbaraki algorithm. It has to - /// maximize the priorities. - /// - /// \sa BinHeap - /// \sa NagamochiIbaraki - typedef BinHeap > Heap; - - /// \brief Instantiates a Heap. - /// - /// This function instantiates a \ref Heap. - /// \param r is the cross reference of the heap. - static Heap *createHeap(HeapCrossRef& r) { - return new Heap(r); - } - }; - - /// \ingroup min_cut - /// - /// \brief Calculates the minimum cut in an undirected graph. - /// - /// Calculates the minimum cut in an undirected graph with the - /// Nagamochi-Ibaraki algorithm. The algorithm separates the graph's - /// nodes into two partitions with the minimum sum of edge capacities - /// between the two partitions. The algorithm can be used to test - /// the network reliability, especially to test how many links have - /// to be destroyed in the network to split it to at least two - /// distinict subnetworks. - /// - /// The complexity of the algorithm is \f$ O(nm\log(n)) \f$ but with - /// \ref FibHeap "Fibonacci heap" it can be decreased to - /// \f$ O(nm+n^2\log(n)) \f$. When the edges have unit capacities, - /// \c BucketHeap can be used which yields \f$ O(nm) \f$ time - /// complexity. - /// - /// \warning The value type of the capacity map should be able to - /// hold any cut value of the graph, otherwise the result can - /// overflow. - /// \note This capacity is supposed to be integer type. -#ifdef DOXYGEN - template -#else - template , - typename TR = NagamochiIbarakiDefaultTraits > -#endif - class NagamochiIbaraki { - public: - - typedef TR Traits; - /// The type of the underlying graph. - typedef typename Traits::Graph Graph; - - /// The type of the capacity map. - typedef typename Traits::CapacityMap CapacityMap; - /// The value type of the capacity map. - typedef typename Traits::CapacityMap::Value Value; - - /// The heap type used by the algorithm. - typedef typename Traits::Heap Heap; - /// The cross reference type used for the heap. - typedef typename Traits::HeapCrossRef HeapCrossRef; - - ///\name Named template parameters - - ///@{ - - struct SetUnitCapacityTraits : public Traits { - typedef ConstMap > CapacityMap; - static CapacityMap *createCapacityMap(const Graph&) { - return new CapacityMap(); - } - }; - - /// \brief \ref named-templ-param "Named parameter" for setting - /// the capacity map to a constMap() instance - /// - /// \ref named-templ-param "Named parameter" for setting - /// the capacity map to a constMap() instance - struct SetUnitCapacity - : public NagamochiIbaraki { - typedef NagamochiIbaraki Create; - }; - - - template - struct SetHeapTraits : public Traits { - typedef CR HeapCrossRef; - typedef H Heap; - static HeapCrossRef *createHeapCrossRef(int num) { - LEMON_ASSERT(false, "HeapCrossRef is not initialized"); - return 0; // ignore warnings - } - static Heap *createHeap(HeapCrossRef &) { - LEMON_ASSERT(false, "Heap is not initialized"); - return 0; // ignore warnings - } - }; - - /// \brief \ref named-templ-param "Named parameter" for setting - /// heap and cross reference type - /// - /// \ref named-templ-param "Named parameter" for setting heap and - /// cross reference type. The heap has to maximize the priorities. - template > - struct SetHeap - : public NagamochiIbaraki > { - typedef NagamochiIbaraki< Graph, CapacityMap, SetHeapTraits > - Create; - }; - - template - struct SetStandardHeapTraits : public Traits { - typedef CR HeapCrossRef; - typedef H Heap; - static HeapCrossRef *createHeapCrossRef(int size) { - return new HeapCrossRef(size); - } - static Heap *createHeap(HeapCrossRef &crossref) { - return new Heap(crossref); - } - }; - - /// \brief \ref named-templ-param "Named parameter" for setting - /// heap and cross reference type with automatic allocation - /// - /// \ref named-templ-param "Named parameter" for setting heap and - /// cross reference type with automatic allocation. They should - /// have standard constructor interfaces to be able to - /// automatically created by the algorithm (i.e. the graph should - /// be passed to the constructor of the cross reference and the - /// cross reference should be passed to the constructor of the - /// heap). However, external heap and cross reference objects - /// could also be passed to the algorithm using the \ref heap() - /// function before calling \ref run() or \ref init(). The heap - /// has to maximize the priorities. - /// \sa SetHeap - template > - struct SetStandardHeap - : public NagamochiIbaraki > { - typedef NagamochiIbaraki > Create; - }; - - ///@} - - - private: - - const Graph &_graph; - const CapacityMap *_capacity; - bool _local_capacity; // unit capacity - - struct ArcData { - typename Graph::Node target; - int prev, next; - }; - struct EdgeData { - Value capacity; - Value cut; - }; - - struct NodeData { - int first_arc; - typename Graph::Node prev, next; - int curr_arc; - typename Graph::Node last_rep; - Value sum; - }; - - typename Graph::template NodeMap *_nodes; - std::vector _arcs; - std::vector _edges; - - typename Graph::Node _first_node; - int _node_num; - - Value _min_cut; - - HeapCrossRef *_heap_cross_ref; - bool _local_heap_cross_ref; - Heap *_heap; - bool _local_heap; - - typedef typename Graph::template NodeMap NodeList; - NodeList *_next_rep; - - typedef typename Graph::template NodeMap MinCutMap; - MinCutMap *_cut_map; - - void createStructures() { - if (!_nodes) { - _nodes = new (typename Graph::template NodeMap)(_graph); - } - if (!_capacity) { - _local_capacity = true; - _capacity = Traits::createCapacityMap(_graph); - } - if (!_heap_cross_ref) { - _local_heap_cross_ref = true; - _heap_cross_ref = Traits::createHeapCrossRef(_graph); - } - if (!_heap) { - _local_heap = true; - _heap = Traits::createHeap(*_heap_cross_ref); - } - if (!_next_rep) { - _next_rep = new NodeList(_graph); - } - if (!_cut_map) { - _cut_map = new MinCutMap(_graph); - } - } - - protected: - //This is here to avoid a gcc-3.3 compilation error. - //It should never be called. - NagamochiIbaraki() {} - - public: - - typedef NagamochiIbaraki Create; - - - /// \brief Constructor. - /// - /// \param graph The graph the algorithm runs on. - /// \param capacity The capacity map used by the algorithm. - NagamochiIbaraki(const Graph& graph, const CapacityMap& capacity) - : _graph(graph), _capacity(&capacity), _local_capacity(false), - _nodes(0), _arcs(), _edges(), _min_cut(), - _heap_cross_ref(0), _local_heap_cross_ref(false), - _heap(0), _local_heap(false), - _next_rep(0), _cut_map(0) {} - - /// \brief Constructor. - /// - /// This constructor can be used only when the Traits class - /// defines how can the local capacity map be instantiated. - /// If the SetUnitCapacity used the algorithm automatically - /// constructs the capacity map. - /// - ///\param graph The graph the algorithm runs on. - NagamochiIbaraki(const Graph& graph) - : _graph(graph), _capacity(0), _local_capacity(false), - _nodes(0), _arcs(), _edges(), _min_cut(), - _heap_cross_ref(0), _local_heap_cross_ref(false), - _heap(0), _local_heap(false), - _next_rep(0), _cut_map(0) {} - - /// \brief Destructor. - /// - /// Destructor. - ~NagamochiIbaraki() { - if (_local_capacity) delete _capacity; - if (_nodes) delete _nodes; - if (_local_heap) delete _heap; - if (_local_heap_cross_ref) delete _heap_cross_ref; - if (_next_rep) delete _next_rep; - if (_cut_map) delete _cut_map; - } - - /// \brief Sets the heap and the cross reference used by algorithm. - /// - /// Sets the heap and the cross reference used by algorithm. - /// If you don't use this function before calling \ref run(), - /// it will allocate one. The destuctor deallocates this - /// automatically allocated heap and cross reference, of course. - /// \return (*this) - NagamochiIbaraki &heap(Heap& hp, HeapCrossRef &cr) - { - if (_local_heap_cross_ref) { - delete _heap_cross_ref; - _local_heap_cross_ref = false; - } - _heap_cross_ref = &cr; - if (_local_heap) { - delete _heap; - _local_heap = false; - } - _heap = &hp; - return *this; - } - - /// \name Execution control - /// The simplest way to execute the algorithm is to use - /// one of the member functions called \c run(). - /// \n - /// If you need more control on the execution, - /// first you must call \ref init() and then call the start() - /// or proper times the processNextPhase() member functions. - - ///@{ - - /// \brief Initializes the internal data structures. - /// - /// Initializes the internal data structures. - void init() { - createStructures(); - - int edge_num = countEdges(_graph); - _edges.resize(edge_num); - _arcs.resize(2 * edge_num); - - typename Graph::Node prev = INVALID; - _node_num = 0; - for (typename Graph::NodeIt n(_graph); n != INVALID; ++n) { - (*_cut_map)[n] = false; - (*_next_rep)[n] = INVALID; - (*_nodes)[n].last_rep = n; - (*_nodes)[n].first_arc = -1; - (*_nodes)[n].curr_arc = -1; - (*_nodes)[n].prev = prev; - if (prev != INVALID) { - (*_nodes)[prev].next = n; - } - (*_nodes)[n].next = INVALID; - (*_nodes)[n].sum = 0; - prev = n; - ++_node_num; - } - - _first_node = typename Graph::NodeIt(_graph); - - int index = 0; - for (typename Graph::NodeIt n(_graph); n != INVALID; ++n) { - for (typename Graph::OutArcIt a(_graph, n); a != INVALID; ++a) { - typename Graph::Node m = _graph.target(a); - - if (!(n < m)) continue; - - (*_nodes)[n].sum += (*_capacity)[a]; - (*_nodes)[m].sum += (*_capacity)[a]; - - int c = (*_nodes)[m].curr_arc; - if (c != -1 && _arcs[c ^ 1].target == n) { - _edges[c >> 1].capacity += (*_capacity)[a]; - } else { - _edges[index].capacity = (*_capacity)[a]; - - _arcs[index << 1].prev = -1; - if ((*_nodes)[n].first_arc != -1) { - _arcs[(*_nodes)[n].first_arc].prev = (index << 1); - } - _arcs[index << 1].next = (*_nodes)[n].first_arc; - (*_nodes)[n].first_arc = (index << 1); - _arcs[index << 1].target = m; - - (*_nodes)[m].curr_arc = (index << 1); - - _arcs[(index << 1) | 1].prev = -1; - if ((*_nodes)[m].first_arc != -1) { - _arcs[(*_nodes)[m].first_arc].prev = ((index << 1) | 1); - } - _arcs[(index << 1) | 1].next = (*_nodes)[m].first_arc; - (*_nodes)[m].first_arc = ((index << 1) | 1); - _arcs[(index << 1) | 1].target = n; - - ++index; - } - } - } - - typename Graph::Node cut_node = INVALID; - _min_cut = std::numeric_limits::max(); - - for (typename Graph::Node n = _first_node; - n != INVALID; n = (*_nodes)[n].next) { - if ((*_nodes)[n].sum < _min_cut) { - cut_node = n; - _min_cut = (*_nodes)[n].sum; - } - } - (*_cut_map)[cut_node] = true; - if (_min_cut == 0) { - _first_node = INVALID; - } - } - - public: - - /// \brief Processes the next phase - /// - /// Processes the next phase in the algorithm. It must be called - /// at most one less the number of the nodes in the graph. - /// - ///\return %True when the algorithm finished. - bool processNextPhase() { - if (_first_node == INVALID) return true; - - _heap->clear(); - for (typename Graph::Node n = _first_node; - n != INVALID; n = (*_nodes)[n].next) { - (*_heap_cross_ref)[n] = Heap::PRE_HEAP; - } - - std::vector order; - order.reserve(_node_num); - int sep = 0; - - Value alpha = 0; - Value pmc = std::numeric_limits::max(); - - _heap->push(_first_node, static_cast(0)); - while (!_heap->empty()) { - typename Graph::Node n = _heap->top(); - Value v = _heap->prio(); - - _heap->pop(); - for (int a = (*_nodes)[n].first_arc; a != -1; a = _arcs[a].next) { - switch (_heap->state(_arcs[a].target)) { - case Heap::PRE_HEAP: - { - Value nv = _edges[a >> 1].capacity; - _heap->push(_arcs[a].target, nv); - _edges[a >> 1].cut = nv; - } break; - case Heap::IN_HEAP: - { - Value nv = _edges[a >> 1].capacity + (*_heap)[_arcs[a].target]; - _heap->decrease(_arcs[a].target, nv); - _edges[a >> 1].cut = nv; - } break; - case Heap::POST_HEAP: - break; - } - } - - alpha += (*_nodes)[n].sum; - alpha -= 2 * v; - - order.push_back(n); - if (!_heap->empty()) { - if (alpha < pmc) { - pmc = alpha; - sep = order.size(); - } - } - } - - if (static_cast(order.size()) < _node_num) { - _first_node = INVALID; - for (typename Graph::NodeIt n(_graph); n != INVALID; ++n) { - (*_cut_map)[n] = false; - } - for (int i = 0; i < static_cast(order.size()); ++i) { - typename Graph::Node n = order[i]; - while (n != INVALID) { - (*_cut_map)[n] = true; - n = (*_next_rep)[n]; - } - } - _min_cut = 0; - return true; - } - - if (pmc < _min_cut) { - for (typename Graph::NodeIt n(_graph); n != INVALID; ++n) { - (*_cut_map)[n] = false; - } - for (int i = 0; i < sep; ++i) { - typename Graph::Node n = order[i]; - while (n != INVALID) { - (*_cut_map)[n] = true; - n = (*_next_rep)[n]; - } - } - _min_cut = pmc; - } - - for (typename Graph::Node n = _first_node; - n != INVALID; n = (*_nodes)[n].next) { - bool merged = false; - for (int a = (*_nodes)[n].first_arc; a != -1; a = _arcs[a].next) { - if (!(_edges[a >> 1].cut < pmc)) { - if (!merged) { - for (int b = (*_nodes)[n].first_arc; b != -1; b = _arcs[b].next) { - (*_nodes)[_arcs[b].target].curr_arc = b; - } - merged = true; - } - typename Graph::Node m = _arcs[a].target; - int nb = 0; - for (int b = (*_nodes)[m].first_arc; b != -1; b = nb) { - nb = _arcs[b].next; - if ((b ^ a) == 1) continue; - typename Graph::Node o = _arcs[b].target; - int c = (*_nodes)[o].curr_arc; - if (c != -1 && _arcs[c ^ 1].target == n) { - _edges[c >> 1].capacity += _edges[b >> 1].capacity; - (*_nodes)[n].sum += _edges[b >> 1].capacity; - if (_edges[b >> 1].cut < _edges[c >> 1].cut) { - _edges[b >> 1].cut = _edges[c >> 1].cut; - } - if (_arcs[b ^ 1].prev != -1) { - _arcs[_arcs[b ^ 1].prev].next = _arcs[b ^ 1].next; - } else { - (*_nodes)[o].first_arc = _arcs[b ^ 1].next; - } - if (_arcs[b ^ 1].next != -1) { - _arcs[_arcs[b ^ 1].next].prev = _arcs[b ^ 1].prev; - } - } else { - if (_arcs[a].next != -1) { - _arcs[_arcs[a].next].prev = b; - } - _arcs[b].next = _arcs[a].next; - _arcs[b].prev = a; - _arcs[a].next = b; - _arcs[b ^ 1].target = n; - - (*_nodes)[n].sum += _edges[b >> 1].capacity; - (*_nodes)[o].curr_arc = b; - } - } - - if (_arcs[a].prev != -1) { - _arcs[_arcs[a].prev].next = _arcs[a].next; - } else { - (*_nodes)[n].first_arc = _arcs[a].next; - } - if (_arcs[a].next != -1) { - _arcs[_arcs[a].next].prev = _arcs[a].prev; - } - - (*_nodes)[n].sum -= _edges[a >> 1].capacity; - (*_next_rep)[(*_nodes)[n].last_rep] = m; - (*_nodes)[n].last_rep = (*_nodes)[m].last_rep; - - if ((*_nodes)[m].prev != INVALID) { - (*_nodes)[(*_nodes)[m].prev].next = (*_nodes)[m].next; - } else{ - _first_node = (*_nodes)[m].next; - } - if ((*_nodes)[m].next != INVALID) { - (*_nodes)[(*_nodes)[m].next].prev = (*_nodes)[m].prev; - } - --_node_num; - } - } - } - - if (_node_num == 1) { - _first_node = INVALID; - return true; - } - - return false; - } - - /// \brief Executes the algorithm. - /// - /// Executes the algorithm. - /// - /// \pre init() must be called - void start() { - while (!processNextPhase()) {} - } - - - /// \brief Runs %NagamochiIbaraki algorithm. - /// - /// This method runs the %Min cut algorithm - /// - /// \note mc.run(s) is just a shortcut of the following code. - ///\code - /// mc.init(); - /// mc.start(); - ///\endcode - void run() { - init(); - start(); - } - - ///@} - - /// \name Query Functions - /// - /// The result of the %NagamochiIbaraki - /// algorithm can be obtained using these functions.\n - /// Before the use of these functions, either run() or start() - /// must be called. - - ///@{ - - /// \brief Returns the min cut value. - /// - /// Returns the min cut value if the algorithm finished. - /// After the first processNextPhase() it is a value of a - /// valid cut in the graph. - Value minCutValue() const { - return _min_cut; - } - - /// \brief Returns a min cut in a NodeMap. - /// - /// It sets the nodes of one of the two partitions to true and - /// the other partition to false. - /// \param cutMap A \ref concepts::WriteMap "writable" node map with - /// \c bool (or convertible) value type. - template - Value minCutMap(CutMap& cutMap) const { - for (typename Graph::NodeIt n(_graph); n != INVALID; ++n) { - cutMap.set(n, (*_cut_map)[n]); - } - return minCutValue(); - } - - ///@} - - }; -} - -#endif Index: lemon/network_simplex.h =================================================================== --- lemon/network_simplex.h (revision 1004) +++ lemon/network_simplex.h (revision 888) @@ -3,5 +3,5 @@ * This file is a part of LEMON, a generic C++ optimization library. * - * Copyright (C) 2003-2010 + * Copyright (C) 2003-2009 * Egervary Jeno Kombinatorikus Optimalizalasi Kutatocsoport * (Egervary Research Group on Combinatorial Optimization, EGRES). @@ -41,16 +41,13 @@ /// /// \ref NetworkSimplex implements the primal Network Simplex algorithm - /// for finding a \ref min_cost_flow "minimum cost flow" - /// \ref amo93networkflows, \ref dantzig63linearprog, - /// \ref kellyoneill91netsimplex. - /// This algorithm is a highly efficient specialized version of the - /// linear programming simplex method directly for the minimum cost - /// flow problem. + /// for finding a \ref min_cost_flow "minimum cost flow". + /// This algorithm is a specialized version of the linear programming + /// simplex method directly for the minimum cost flow problem. + /// It is one of the most efficient solution methods. /// - /// In general, \ref NetworkSimplex and \ref CostScaling are the fastest - /// implementations available in LEMON for 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. + /// In general this class is the fastest implementation available + /// in LEMON for the minimum cost flow problem. + /// Moreover it supports both directions of the supply/demand inequality + /// constraints. For more information see \ref SupplyType. /// /// Most of the parameters of the problem (except for the digraph) @@ -60,16 +57,15 @@ /// /// \tparam GR The digraph type the algorithm runs on. - /// \tparam V The number type used for flow amounts, capacity bounds - /// and supply values in the algorithm. By default, it is \c int. - /// \tparam C The number type used for costs and potentials in the - /// algorithm. By default, it is the same as \c V. + /// \tparam V The value type used for flow amounts, capacity bounds + /// and supply values in the algorithm. By default it is \c int. + /// \tparam C The value type used for costs and potentials in the + /// algorithm. By default it is the same as \c V. /// - /// \warning Both \c V and \c C must be signed number types. - /// \warning All input data (capacities, supply values, and costs) must + /// \warning Both value types must be signed and all input data must /// be integer. /// /// \note %NetworkSimplex provides five different pivot rule /// implementations, from which the most efficient one is used - /// by default. For more information, see \ref PivotRule. + /// by default. For more information see \ref PivotRule. template class NetworkSimplex @@ -100,5 +96,5 @@ UNBOUNDED }; - + /// \brief Constants for selecting the type of the supply constraints. /// @@ -118,5 +114,5 @@ LEQ }; - + /// \brief Constants for selecting the pivot rule. /// @@ -124,27 +120,24 @@ /// the \ref run() function. /// - /// \ref NetworkSimplex provides five different implementations for - /// the pivot strategy that significantly affects the running time + /// \ref NetworkSimplex provides five different pivot rule + /// implementations that significantly affect the running time /// of the algorithm. - /// According to experimental tests conducted on various problem - /// instances, \ref BLOCK_SEARCH "Block Search" and - /// \ref ALTERING_LIST "Altering Candidate List" rules turned out - /// to be the most efficient. - /// Since \ref BLOCK_SEARCH "Block Search" is a simpler strategy that - /// seemed to be slightly more robust, it is used by default. - /// However, another pivot rule can easily be selected using the - /// \ref run() function with the proper parameter. + /// By default \ref BLOCK_SEARCH "Block Search" is used, which + /// proved to be the most efficient and the most robust on various + /// test inputs according to our benchmark tests. + /// However another pivot rule can be selected using the \ref run() + /// function with the proper parameter. enum PivotRule { - /// The \e First \e Eligible pivot rule. + /// The First Eligible pivot rule. /// The next eligible arc is selected in a wraparound fashion /// in every iteration. FIRST_ELIGIBLE, - /// The \e Best \e Eligible pivot rule. + /// The Best Eligible pivot rule. /// The best eligible arc is selected in every iteration. BEST_ELIGIBLE, - /// The \e Block \e Search pivot rule. + /// The Block Search pivot rule. /// A specified number of arcs are examined in every iteration /// in a wraparound fashion and the best eligible arc is selected @@ -152,5 +145,5 @@ BLOCK_SEARCH, - /// The \e Candidate \e List pivot rule. + /// The Candidate List pivot rule. /// In a major iteration a candidate list is built from eligible arcs /// in a wraparound fashion and in the following minor iterations @@ -158,33 +151,27 @@ CANDIDATE_LIST, - /// The \e Altering \e Candidate \e List pivot rule. + /// The Altering Candidate List pivot rule. /// It is a modified version of the Candidate List method. - /// It keeps only a few of the best eligible arcs from the former + /// It keeps only the several best eligible arcs from the former /// candidate list and extends this list in every iteration. ALTERING_LIST }; - + private: TEMPLATE_DIGRAPH_TYPEDEFS(GR); + typedef std::vector ArcVector; + typedef std::vector NodeVector; typedef std::vector IntVector; + typedef std::vector BoolVector; typedef std::vector ValueVector; typedef std::vector CostVector; - typedef std::vector CharVector; - // Note: vector is used instead of vector and - // vector for efficiency reasons // State constants for arcs - enum ArcState { + enum ArcStateEnum { STATE_UPPER = -1, STATE_TREE = 0, STATE_LOWER = 1 - }; - - // Direction constants for tree arcs - enum ArcDirection { - DIR_DOWN = -1, - DIR_UP = 1 }; @@ -208,5 +195,4 @@ IntVector _source; IntVector _target; - bool _arc_mixing; // Node and arc data @@ -226,17 +212,17 @@ IntVector _succ_num; IntVector _last_succ; - CharVector _pred_dir; - CharVector _state; IntVector _dirty_revs; + BoolVector _forward; + IntVector _state; int _root; // Temporary data used in the current pivot iteration int in_arc, join, u_in, v_in, u_out, v_out; + int first, second, right, last; + int stem, par_stem, new_stem; Value delta; - const Value MAX; - public: - + /// \brief Constant for infinite upper bounds (capacities). /// @@ -257,5 +243,5 @@ const IntVector &_target; const CostVector &_cost; - const CharVector &_state; + const IntVector &_state; const CostVector &_pi; int &_in_arc; @@ -278,5 +264,5 @@ bool findEnteringArc() { Cost c; - for (int e = _next_arc; e != _search_arc_num; ++e) { + for (int e = _next_arc; e < _search_arc_num; ++e) { c = _state[e] * (_cost[e] + _pi[_source[e]] - _pi[_target[e]]); if (c < 0) { @@ -286,5 +272,5 @@ } } - for (int e = 0; e != _next_arc; ++e) { + for (int e = 0; e < _next_arc; ++e) { c = _state[e] * (_cost[e] + _pi[_source[e]] - _pi[_target[e]]); if (c < 0) { @@ -309,5 +295,5 @@ const IntVector &_target; const CostVector &_cost; - const CharVector &_state; + const IntVector &_state; const CostVector &_pi; int &_in_arc; @@ -326,5 +312,5 @@ bool findEnteringArc() { Cost c, min = 0; - for (int e = 0; e != _search_arc_num; ++e) { + for (int e = 0; e < _search_arc_num; ++e) { c = _state[e] * (_cost[e] + _pi[_source[e]] - _pi[_target[e]]); if (c < min) { @@ -348,5 +334,5 @@ const IntVector &_target; const CostVector &_cost; - const CharVector &_state; + const IntVector &_state; const CostVector &_pi; int &_in_arc; @@ -367,5 +353,5 @@ { // The main parameters of the pivot rule - const double BLOCK_SIZE_FACTOR = 1.0; + const double BLOCK_SIZE_FACTOR = 0.5; const int MIN_BLOCK_SIZE = 10; @@ -379,30 +365,31 @@ Cost c, min = 0; int cnt = _block_size; - int e; - for (e = _next_arc; e != _search_arc_num; ++e) { + int e, min_arc = _next_arc; + for (e = _next_arc; e < _search_arc_num; ++e) { c = _state[e] * (_cost[e] + _pi[_source[e]] - _pi[_target[e]]); if (c < min) { min = c; - _in_arc = e; + min_arc = e; } if (--cnt == 0) { - if (min < 0) goto search_end; + if (min < 0) break; cnt = _block_size; } } - for (e = 0; e != _next_arc; ++e) { - c = _state[e] * (_cost[e] + _pi[_source[e]] - _pi[_target[e]]); - if (c < min) { - min = c; - _in_arc = e; - } - if (--cnt == 0) { - if (min < 0) goto search_end; - cnt = _block_size; + if (min == 0 || cnt > 0) { + for (e = 0; e < _next_arc; ++e) { + c = _state[e] * (_cost[e] + _pi[_source[e]] - _pi[_target[e]]); + if (c < min) { + min = c; + min_arc = e; + } + if (--cnt == 0) { + if (min < 0) break; + cnt = _block_size; + } } } if (min >= 0) return false; - - search_end: + _in_arc = min_arc; _next_arc = e; return true; @@ -421,5 +408,5 @@ const IntVector &_target; const CostVector &_cost; - const CharVector &_state; + const IntVector &_state; const CostVector &_pi; int &_in_arc; @@ -442,5 +429,5 @@ { // The main parameters of the pivot rule - const double LIST_LENGTH_FACTOR = 0.25; + const double LIST_LENGTH_FACTOR = 1.0; const int MIN_LIST_LENGTH = 10; const double MINOR_LIMIT_FACTOR = 0.1; @@ -459,5 +446,5 @@ bool findEnteringArc() { Cost min, c; - int e; + int e, min_arc = _next_arc; if (_curr_length > 0 && _minor_count < _minor_limit) { // Minor iteration: select the best eligible arc from the @@ -470,11 +457,14 @@ if (c < min) { min = c; - _in_arc = e; + min_arc = e; } - else if (c >= 0) { + if (c >= 0) { _candidates[i--] = _candidates[--_curr_length]; } } - if (min < 0) return true; + if (min < 0) { + _in_arc = min_arc; + return true; + } } @@ -482,5 +472,5 @@ min = 0; _curr_length = 0; - for (e = _next_arc; e != _search_arc_num; ++e) { + for (e = _next_arc; e < _search_arc_num; ++e) { c = _state[e] * (_cost[e] + _pi[_source[e]] - _pi[_target[e]]); if (c < 0) { @@ -488,24 +478,25 @@ if (c < min) { min = c; - _in_arc = e; + min_arc = e; } - if (_curr_length == _list_length) goto search_end; - } - } - for (e = 0; e != _next_arc; ++e) { - c = _state[e] * (_cost[e] + _pi[_source[e]] - _pi[_target[e]]); - if (c < 0) { - _candidates[_curr_length++] = e; - if (c < min) { - min = c; - _in_arc = e; + if (_curr_length == _list_length) break; + } + } + if (_curr_length < _list_length) { + for (e = 0; e < _next_arc; ++e) { + c = _state[e] * (_cost[e] + _pi[_source[e]] - _pi[_target[e]]); + if (c < 0) { + _candidates[_curr_length++] = e; + if (c < min) { + min = c; + min_arc = e; + } + if (_curr_length == _list_length) break; } - if (_curr_length == _list_length) goto search_end; } } if (_curr_length == 0) return false; - - search_end: _minor_count = 1; + _in_arc = min_arc; _next_arc = e; return true; @@ -524,5 +515,5 @@ const IntVector &_target; const CostVector &_cost; - const CharVector &_state; + const IntVector &_state; const CostVector &_pi; int &_in_arc; @@ -543,5 +534,5 @@ SortFunc(const CostVector &map) : _map(map) {} bool operator()(int left, int right) { - return _map[left] < _map[right]; + return _map[left] > _map[right]; } }; @@ -559,7 +550,7 @@ { // The main parameters of the pivot rule - const double BLOCK_SIZE_FACTOR = 1.0; + const double BLOCK_SIZE_FACTOR = 1.5; const int MIN_BLOCK_SIZE = 10; - const double HEAD_LENGTH_FACTOR = 0.01; + const double HEAD_LENGTH_FACTOR = 0.1; const int MIN_HEAD_LENGTH = 3; @@ -577,11 +568,9 @@ // Check the current candidate list int e; - Cost c; - for (int i = 0; i != _curr_length; ++i) { + for (int i = 0; i < _curr_length; ++i) { e = _candidates[i]; - c = _state[e] * (_cost[e] + _pi[_source[e]] - _pi[_target[e]]); - if (c < 0) { - _cand_cost[e] = c; - } else { + _cand_cost[e] = _state[e] * + (_cost[e] + _pi[_source[e]] - _pi[_target[e]]); + if (_cand_cost[e] >= 0) { _candidates[i--] = _candidates[--_curr_length]; } @@ -590,44 +579,47 @@ // Extend the list int cnt = _block_size; + int last_arc = 0; int limit = _head_length; - for (e = _next_arc; e != _search_arc_num; ++e) { - c = _state[e] * (_cost[e] + _pi[_source[e]] - _pi[_target[e]]); - if (c < 0) { - _cand_cost[e] = c; + for (int e = _next_arc; e < _search_arc_num; ++e) { + _cand_cost[e] = _state[e] * + (_cost[e] + _pi[_source[e]] - _pi[_target[e]]); + if (_cand_cost[e] < 0) { _candidates[_curr_length++] = e; + last_arc = e; } if (--cnt == 0) { - if (_curr_length > limit) goto search_end; + if (_curr_length > limit) break; limit = 0; cnt = _block_size; } } - for (e = 0; e != _next_arc; ++e) { - c = _state[e] * (_cost[e] + _pi[_source[e]] - _pi[_target[e]]); - if (c < 0) { - _cand_cost[e] = c; - _candidates[_curr_length++] = e; - } - if (--cnt == 0) { - if (_curr_length > limit) goto search_end; - limit = 0; - cnt = _block_size; + if (_curr_length <= limit) { + for (int e = 0; e < _next_arc; ++e) { + _cand_cost[e] = _state[e] * + (_cost[e] + _pi[_source[e]] - _pi[_target[e]]); + if (_cand_cost[e] < 0) { + _candidates[_curr_length++] = e; + last_arc = e; + } + if (--cnt == 0) { + if (_curr_length > limit) break; + limit = 0; + cnt = _block_size; + } } } if (_curr_length == 0) return false; - - search_end: - - // Perform partial sort operation on the candidate list - int new_length = std::min(_head_length + 1, _curr_length); - std::partial_sort(_candidates.begin(), _candidates.begin() + new_length, - _candidates.begin() + _curr_length, _sort_func); - - // Select the entering arc and remove it from the list + _next_arc = last_arc + 1; + + // Make heap of the candidate list (approximating a partial sort) + make_heap( _candidates.begin(), _candidates.begin() + _curr_length, + _sort_func ); + + // Pop the first element of the heap _in_arc = _candidates[0]; - _next_arc = e; - _candidates[0] = _candidates[new_length - 1]; - _curr_length = new_length - 1; + pop_heap( _candidates.begin(), _candidates.begin() + _curr_length, + _sort_func ); + _curr_length = std::min(_head_length, _curr_length - 1); return true; } @@ -642,24 +634,67 @@ /// /// \param graph The digraph the algorithm runs on. - /// \param arc_mixing Indicate if the arcs will be stored in a - /// mixed order in the internal data structure. - /// In general, it leads to similar performance as using the original - /// arc order, but it makes the algorithm more robust and in special - /// cases, even significantly faster. Therefore, it is enabled by default. - NetworkSimplex(const GR& graph, bool arc_mixing = true) : + NetworkSimplex(const GR& graph) : _graph(graph), _node_id(graph), _arc_id(graph), - _arc_mixing(arc_mixing), - MAX(std::numeric_limits::max()), INF(std::numeric_limits::has_infinity ? - std::numeric_limits::infinity() : MAX) + std::numeric_limits::infinity() : + std::numeric_limits::max()) { - // Check the number types + // Check the value types LEMON_ASSERT(std::numeric_limits::is_signed, "The flow type of NetworkSimplex must be signed"); LEMON_ASSERT(std::numeric_limits::is_signed, "The cost type of NetworkSimplex must be signed"); - - // Reset data structures - reset(); + + // Resize vectors + _node_num = countNodes(_graph); + _arc_num = countArcs(_graph); + int all_node_num = _node_num + 1; + int max_arc_num = _arc_num + 2 * _node_num; + + _source.resize(max_arc_num); + _target.resize(max_arc_num); + + _lower.resize(_arc_num); + _upper.resize(_arc_num); + _cap.resize(max_arc_num); + _cost.resize(max_arc_num); + _supply.resize(all_node_num); + _flow.resize(max_arc_num); + _pi.resize(all_node_num); + + _parent.resize(all_node_num); + _pred.resize(all_node_num); + _forward.resize(all_node_num); + _thread.resize(all_node_num); + _rev_thread.resize(all_node_num); + _succ_num.resize(all_node_num); + _last_succ.resize(all_node_num); + _state.resize(max_arc_num); + + // Copy the graph (store the arcs in a mixed order) + int i = 0; + for (NodeIt n(_graph); n != INVALID; ++n, ++i) { + _node_id[n] = i; + } + int k = std::max(int(std::sqrt(double(_arc_num))), 10); + i = 0; + for (ArcIt a(_graph); a != INVALID; ++a) { + _arc_id[a] = i; + _source[i] = _node_id[_graph.source(a)]; + _target[i] = _node_id[_graph.target(a)]; + if ((i += k) >= _arc_num) i = (i % k) + 1; + } + + // Initialize maps + for (int i = 0; i != _node_num; ++i) { + _supply[i] = 0; + } + for (int i = 0; i != _arc_num; ++i) { + _lower[i] = 0; + _upper[i] = INF; + _cost[i] = 1; + } + _have_lower = false; + _stype = GEQ; } @@ -695,5 +730,5 @@ /// If it is not used before calling \ref run(), the upper bounds /// will be set to \ref INF on all arcs (i.e. the flow value will be - /// unbounded from above). + /// unbounded from above on each arc). /// /// \param map An arc map storing the upper bounds. @@ -734,4 +769,5 @@ /// If neither this function nor \ref stSupply() is used before /// calling \ref run(), the supply of each node will be set to zero. + /// (It makes sense only if non-zero lower bounds are given.) /// /// \param map A node map storing the supply values. @@ -740,6 +776,4 @@ /// /// \return (*this) - /// - /// \sa supplyType() template NetworkSimplex& supplyMap(const SupplyMap& map) { @@ -756,7 +790,8 @@ /// If neither this function nor \ref supplyMap() is used before /// calling \ref run(), the supply of each node will be set to zero. + /// (It makes sense only if non-zero lower bounds are given.) /// /// Using this function has the same effect as using \ref supplyMap() - /// with a map in which \c k is assigned to \c s, \c -k is + /// with such a map in which \c k is assigned to \c s, \c -k is /// assigned to \c t and all other nodes have zero supply value. /// @@ -775,5 +810,5 @@ return *this; } - + /// \brief Set the type of the supply constraints. /// @@ -782,5 +817,5 @@ /// type will be used. /// - /// For more information, see \ref SupplyType. + /// For more information see \ref SupplyType. /// /// \return (*this) @@ -801,5 +836,5 @@ /// This function runs the algorithm. /// The paramters can be specified using functions \ref lowerMap(), - /// \ref upperMap(), \ref costMap(), \ref supplyMap(), \ref stSupply(), + /// \ref upperMap(), \ref costMap(), \ref supplyMap(), \ref stSupply(), /// \ref supplyType(). /// For example, @@ -810,13 +845,13 @@ /// \endcode /// - /// This function can be called more than once. All the given parameters - /// are kept for the next call, unless \ref resetParams() or \ref reset() - /// is used, thus only the modified parameters have to be set again. - /// If the underlying digraph was also modified after the construction - /// of the class (or the last \ref reset() call), then the \ref reset() - /// function must be called. + /// This function can be called more than once. All the parameters + /// that have been given are kept for the next call, unless + /// \ref reset() is called, thus only the modified parameters + /// have to be set again. See \ref reset() for examples. + /// However the underlying digraph must not be modified after this + /// class have been constructed, since it copies and extends the graph. /// /// \param pivot_rule The pivot rule that will be used during the - /// algorithm. For more information, see \ref PivotRule. + /// algorithm. For more information see \ref PivotRule. /// /// \return \c INFEASIBLE if no feasible flow exists, @@ -829,5 +864,4 @@ /// /// \see ProblemType, PivotRule - /// \see resetParams(), reset() ProblemType run(PivotRule pivot_rule = BLOCK_SEARCH) { if (!init()) return INFEASIBLE; @@ -841,10 +875,9 @@ /// \ref costMap(), \ref supplyMap(), \ref stSupply(), \ref supplyType(). /// - /// It is useful for multiple \ref run() calls. Basically, all the given - /// parameters are kept for the next \ref run() call, unless - /// \ref resetParams() or \ref reset() is used. - /// If the underlying digraph was also modified after the construction - /// of the class or the last \ref reset() call, then the \ref reset() - /// function must be used, otherwise \ref resetParams() is sufficient. + /// It is useful for multiple run() calls. If this function is not + /// used, all the parameters given before are kept for the next + /// \ref run() call. + /// However the underlying digraph must not be modified after this + /// class have been constructed, since it copies and extends the graph. /// /// For example, @@ -856,12 +889,12 @@ /// .supplyMap(sup).run(); /// - /// // Run again with modified cost map (resetParams() is not called, + /// // Run again with modified cost map (reset() is not called, /// // so only the cost map have to be set again) /// cost[e] += 100; /// ns.costMap(cost).run(); /// - /// // Run again from scratch using resetParams() + /// // Run again from scratch using reset() /// // (the lower bounds will be set to zero on all arcs) - /// ns.resetParams(); + /// ns.reset(); /// ns.upperMap(capacity).costMap(cost) /// .supplyMap(sup).run(); @@ -869,7 +902,5 @@ /// /// \return (*this) - /// - /// \see reset(), run() - NetworkSimplex& resetParams() { + NetworkSimplex& reset() { for (int i = 0; i != _node_num; ++i) { _supply[i] = 0; @@ -882,81 +913,4 @@ _have_lower = false; _stype = GEQ; - return *this; - } - - /// \brief Reset the internal data structures and all the parameters - /// that have been given before. - /// - /// This function resets the internal data structures and all the - /// paramaters that have been given before using functions \ref lowerMap(), - /// \ref upperMap(), \ref costMap(), \ref supplyMap(), \ref stSupply(), - /// \ref supplyType(). - /// - /// It is useful for multiple \ref run() calls. Basically, all the given - /// parameters are kept for the next \ref run() call, unless - /// \ref resetParams() or \ref reset() is used. - /// If the underlying digraph was also modified after the construction - /// of the class or the last \ref reset() call, then the \ref reset() - /// function must be used, otherwise \ref resetParams() is sufficient. - /// - /// See \ref resetParams() for examples. - /// - /// \return (*this) - /// - /// \see resetParams(), run() - NetworkSimplex& reset() { - // Resize vectors - _node_num = countNodes(_graph); - _arc_num = countArcs(_graph); - int all_node_num = _node_num + 1; - int max_arc_num = _arc_num + 2 * _node_num; - - _source.resize(max_arc_num); - _target.resize(max_arc_num); - - _lower.resize(_arc_num); - _upper.resize(_arc_num); - _cap.resize(max_arc_num); - _cost.resize(max_arc_num); - _supply.resize(all_node_num); - _flow.resize(max_arc_num); - _pi.resize(all_node_num); - - _parent.resize(all_node_num); - _pred.resize(all_node_num); - _pred_dir.resize(all_node_num); - _thread.resize(all_node_num); - _rev_thread.resize(all_node_num); - _succ_num.resize(all_node_num); - _last_succ.resize(all_node_num); - _state.resize(max_arc_num); - - // Copy the graph - int i = 0; - for (NodeIt n(_graph); n != INVALID; ++n, ++i) { - _node_id[n] = i; - } - if (_arc_mixing) { - // Store the arcs in a mixed order - const int skip = std::max(_arc_num / _node_num, 3); - int i = 0, j = 0; - for (ArcIt a(_graph); a != INVALID; ++a) { - _arc_id[a] = i; - _source[i] = _node_id[_graph.source(a)]; - _target[i] = _node_id[_graph.target(a)]; - if ((i += skip) >= _arc_num) i = ++j; - } - } else { - // Store the arcs in the original order - int i = 0; - for (ArcIt a(_graph); a != INVALID; ++a, ++i) { - _arc_id[a] = i; - _source[i] = _node_id[_graph.source(a)]; - _target[i] = _node_id[_graph.target(a)]; - } - } - - // Reset parameters - resetParams(); return *this; } @@ -1011,6 +965,5 @@ } - /// \brief Copy the flow values (the primal solution) into the - /// given map. + /// \brief Return the flow map (the primal solution). /// /// This function copies the flow value on each arc into the given @@ -1036,6 +989,5 @@ } - /// \brief Copy the potential values (the dual solution) into the - /// given map. + /// \brief Return the potential map (the dual solution). /// /// This function copies the potential (dual value) of each node @@ -1073,7 +1025,7 @@ Value c = _lower[i]; if (c >= 0) { - _cap[i] = _upper[i] < MAX ? _upper[i] - c : INF; + _cap[i] = _upper[i] < INF ? _upper[i] - c : INF; } else { - _cap[i] = _upper[i] < MAX + c ? _upper[i] - c : INF; + _cap[i] = _upper[i] < INF + c ? _upper[i] - c : INF; } _supply[_source[i]] -= c; @@ -1103,5 +1055,5 @@ _state[i] = STATE_LOWER; } - + // Set data for the artificial root node _root = _node_num; @@ -1130,5 +1082,5 @@ _state[e] = STATE_TREE; if (_supply[u] >= 0) { - _pred_dir[u] = DIR_UP; + _forward[u] = true; _pi[u] = 0; _source[e] = u; @@ -1137,5 +1089,5 @@ _cost[e] = 0; } else { - _pred_dir[u] = DIR_DOWN; + _forward[u] = false; _pi[u] = ART_COST; _source[e] = _root; @@ -1157,5 +1109,5 @@ _last_succ[u] = u; if (_supply[u] >= 0) { - _pred_dir[u] = DIR_UP; + _forward[u] = true; _pi[u] = 0; _pred[u] = e; @@ -1167,5 +1119,5 @@ _state[e] = STATE_TREE; } else { - _pred_dir[u] = DIR_DOWN; + _forward[u] = false; _pi[u] = ART_COST; _pred[u] = f; @@ -1198,5 +1150,5 @@ _last_succ[u] = u; if (_supply[u] <= 0) { - _pred_dir[u] = DIR_DOWN; + _forward[u] = false; _pi[u] = 0; _pred[u] = e; @@ -1208,5 +1160,5 @@ _state[e] = STATE_TREE; } else { - _pred_dir[u] = DIR_UP; + _forward[u] = true; _pi[u] = -ART_COST; _pred[u] = f; @@ -1251,5 +1203,4 @@ // Initialize first and second nodes according to the direction // of the cycle - int first, second; if (_state[in_arc] == STATE_LOWER) { first = _source[in_arc]; @@ -1261,15 +1212,12 @@ delta = _cap[in_arc]; int result = 0; - Value c, d; + Value d; int e; - // Search the cycle form the first node to the join node + // Search the cycle along the path form the first node to the root for (int u = first; u != join; u = _parent[u]) { e = _pred[u]; - d = _flow[e]; - if (_pred_dir[u] == DIR_DOWN) { - c = _cap[e]; - d = c >= MAX ? INF : c - d; - } + d = _forward[u] ? + _flow[e] : (_cap[e] == INF ? INF : _cap[e] - _flow[e]); if (d < delta) { delta = d; @@ -1278,13 +1226,9 @@ } } - - // Search the cycle form the second node to the join node + // Search the cycle along the path form the second node to the root for (int u = second; u != join; u = _parent[u]) { e = _pred[u]; - d = _flow[e]; - if (_pred_dir[u] == DIR_UP) { - c = _cap[e]; - d = c >= MAX ? INF : c - d; - } + d = _forward[u] ? + (_cap[e] == INF ? INF : _cap[e] - _flow[e]) : _flow[e]; if (d <= delta) { delta = d; @@ -1311,8 +1255,8 @@ _flow[in_arc] += val; for (int u = _source[in_arc]; u != join; u = _parent[u]) { - _flow[_pred[u]] -= _pred_dir[u] * val; + _flow[_pred[u]] += _forward[u] ? -val : val; } for (int u = _target[in_arc]; u != join; u = _parent[u]) { - _flow[_pred[u]] += _pred_dir[u] * val; + _flow[_pred[u]] += _forward[u] ? val : -val; } } @@ -1329,4 +1273,5 @@ // Update the tree structure void updateTreeStructure() { + int u, w; int old_rev_thread = _rev_thread[u_out]; int old_succ_num = _succ_num[u_out]; @@ -1334,225 +1279,126 @@ v_out = _parent[u_out]; - // Check if u_in and u_out coincide - if (u_in == u_out) { - // Update _parent, _pred, _pred_dir - _parent[u_in] = v_in; - _pred[u_in] = in_arc; - _pred_dir[u_in] = u_in == _source[in_arc] ? DIR_UP : DIR_DOWN; - - // Update _thread and _rev_thread - if (_thread[v_in] != u_out) { - int after = _thread[old_last_succ]; - _thread[old_rev_thread] = after; - _rev_thread[after] = old_rev_thread; - after = _thread[v_in]; - _thread[v_in] = u_out; - _rev_thread[u_out] = v_in; - _thread[old_last_succ] = after; - _rev_thread[after] = old_last_succ; - } + u = _last_succ[u_in]; // the last successor of u_in + right = _thread[u]; // the node after it + + // Handle the case when old_rev_thread equals to v_in + // (it also means that join and v_out coincide) + if (old_rev_thread == v_in) { + last = _thread[_last_succ[u_out]]; } else { - // Handle the case when old_rev_thread equals to v_in - // (it also means that join and v_out coincide) - int thread_continue = old_rev_thread == v_in ? - _thread[old_last_succ] : _thread[v_in]; - - // Update _thread and _parent along the stem nodes (i.e. the nodes - // between u_in and u_out, whose parent have to be changed) - int stem = u_in; // the current stem node - int par_stem = v_in; // the new parent of stem - int next_stem; // the next stem node - int last = _last_succ[u_in]; // the last successor of stem - int before, after = _thread[last]; - _thread[v_in] = u_in; - _dirty_revs.clear(); - _dirty_revs.push_back(v_in); - while (stem != u_out) { - // Insert the next stem node into the thread list - next_stem = _parent[stem]; - _thread[last] = next_stem; - _dirty_revs.push_back(last); - - // Remove the subtree of stem from the thread list - before = _rev_thread[stem]; - _thread[before] = after; - _rev_thread[after] = before; - - // Change the parent node and shift stem nodes - _parent[stem] = par_stem; - par_stem = stem; - stem = next_stem; - - // Update last and after - last = _last_succ[stem] == _last_succ[par_stem] ? - _rev_thread[par_stem] : _last_succ[stem]; - after = _thread[last]; - } - _parent[u_out] = par_stem; - _thread[last] = thread_continue; - _rev_thread[thread_continue] = last; - _last_succ[u_out] = last; - - // Remove the subtree of u_out from the thread list except for - // the case when old_rev_thread equals to v_in - if (old_rev_thread != v_in) { - _thread[old_rev_thread] = after; - _rev_thread[after] = old_rev_thread; - } - - // Update _rev_thread using the new _thread values - for (int i = 0; i != int(_dirty_revs.size()); ++i) { - int u = _dirty_revs[i]; - _rev_thread[_thread[u]] = u; - } - - // Update _pred, _pred_dir, _last_succ and _succ_num for the - // stem nodes from u_out to u_in - int tmp_sc = 0, tmp_ls = _last_succ[u_out]; - for (int u = u_out, p = _parent[u]; u != u_in; u = p, p = _parent[u]) { - _pred[u] = _pred[p]; - _pred_dir[u] = -_pred_dir[p]; - tmp_sc += _succ_num[u] - _succ_num[p]; - _succ_num[u] = tmp_sc; - _last_succ[p] = tmp_ls; - } - _pred[u_in] = in_arc; - _pred_dir[u_in] = u_in == _source[in_arc] ? DIR_UP : DIR_DOWN; - _succ_num[u_in] = old_succ_num; + last = _thread[v_in]; + } + + // Update _thread and _parent along the stem nodes (i.e. the nodes + // between u_in and u_out, whose parent have to be changed) + _thread[v_in] = stem = u_in; + _dirty_revs.clear(); + _dirty_revs.push_back(v_in); + par_stem = v_in; + while (stem != u_out) { + // Insert the next stem node into the thread list + new_stem = _parent[stem]; + _thread[u] = new_stem; + _dirty_revs.push_back(u); + + // Remove the subtree of stem from the thread list + w = _rev_thread[stem]; + _thread[w] = right; + _rev_thread[right] = w; + + // Change the parent node and shift stem nodes + _parent[stem] = par_stem; + par_stem = stem; + stem = new_stem; + + // Update u and right + u = _last_succ[stem] == _last_succ[par_stem] ? + _rev_thread[par_stem] : _last_succ[stem]; + right = _thread[u]; + } + _parent[u_out] = par_stem; + _thread[u] = last; + _rev_thread[last] = u; + _last_succ[u_out] = u; + + // Remove the subtree of u_out from the thread list except for + // the case when old_rev_thread equals to v_in + // (it also means that join and v_out coincide) + if (old_rev_thread != v_in) { + _thread[old_rev_thread] = right; + _rev_thread[right] = old_rev_thread; + } + + // Update _rev_thread using the new _thread values + for (int i = 0; i < int(_dirty_revs.size()); ++i) { + u = _dirty_revs[i]; + _rev_thread[_thread[u]] = u; + } + + // Update _pred, _forward, _last_succ and _succ_num for the + // stem nodes from u_out to u_in + int tmp_sc = 0, tmp_ls = _last_succ[u_out]; + u = u_out; + while (u != u_in) { + w = _parent[u]; + _pred[u] = _pred[w]; + _forward[u] = !_forward[w]; + tmp_sc += _succ_num[u] - _succ_num[w]; + _succ_num[u] = tmp_sc; + _last_succ[w] = tmp_ls; + u = w; + } + _pred[u_in] = in_arc; + _forward[u_in] = (u_in == _source[in_arc]); + _succ_num[u_in] = old_succ_num; + + // Set limits for updating _last_succ form v_in and v_out + // towards the root + int up_limit_in = -1; + int up_limit_out = -1; + if (_last_succ[join] == v_in) { + up_limit_out = join; + } else { + up_limit_in = join; } // Update _last_succ from v_in towards the root - int up_limit_out = _last_succ[join] == v_in ? join : -1; - int last_succ_out = _last_succ[u_out]; - for (int u = v_in; u != -1 && _last_succ[u] == v_in; u = _parent[u]) { - _last_succ[u] = last_succ_out; - } - + for (u = v_in; u != up_limit_in && _last_succ[u] == v_in; + u = _parent[u]) { + _last_succ[u] = _last_succ[u_out]; + } // Update _last_succ from v_out towards the root if (join != old_rev_thread && v_in != old_rev_thread) { - for (int u = v_out; u != up_limit_out && _last_succ[u] == old_last_succ; + for (u = v_out; u != up_limit_out && _last_succ[u] == old_last_succ; u = _parent[u]) { _last_succ[u] = old_rev_thread; } - } - else if (last_succ_out != old_last_succ) { - for (int u = v_out; u != up_limit_out && _last_succ[u] == old_last_succ; + } else { + for (u = v_out; u != up_limit_out && _last_succ[u] == old_last_succ; u = _parent[u]) { - _last_succ[u] = last_succ_out; + _last_succ[u] = _last_succ[u_out]; } } // Update _succ_num from v_in to join - for (int u = v_in; u != join; u = _parent[u]) { + for (u = v_in; u != join; u = _parent[u]) { _succ_num[u] += old_succ_num; } // Update _succ_num from v_out to join - for (int u = v_out; u != join; u = _parent[u]) { + for (u = v_out; u != join; u = _parent[u]) { _succ_num[u] -= old_succ_num; } } - // Update potentials in the subtree that has been moved + // Update potentials void updatePotential() { - Cost sigma = _pi[v_in] - _pi[u_in] - - _pred_dir[u_in] * _cost[in_arc]; + Cost sigma = _forward[u_in] ? + _pi[v_in] - _pi[u_in] - _cost[_pred[u_in]] : + _pi[v_in] - _pi[u_in] + _cost[_pred[u_in]]; + // Update potentials in the subtree, which has been moved int end = _thread[_last_succ[u_in]]; for (int u = u_in; u != end; u = _thread[u]) { _pi[u] += sigma; } - } - - // Heuristic initial pivots - bool initialPivots() { - Value curr, total = 0; - std::vector 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 reached(_graph, false); - Node s = supply_nodes[0], t = demand_nodes[0]; - std::vector stack; - reached[t] = true; - stack.push_back(t); - while (!stack.empty()) { - Node u, v = stack.back(); - stack.pop_back(); - if (v == s) break; - for (InArcIt a(_graph, v); a != INVALID; ++a) { - if (reached[u = _graph.source(a)]) continue; - int j = _arc_id[a]; - if (_cap[j] >= total) { - arc_vector.push_back(j); - reached[u] = true; - stack.push_back(u); - } - } - } - } else { - // Find the min. cost incomming arc for each demand node - for (int i = 0; i != int(demand_nodes.size()); ++i) { - Node v = demand_nodes[i]; - Cost c, min_cost = std::numeric_limits::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::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; } @@ -1579,12 +1425,9 @@ PivotRuleImpl pivot(*this); - // Perform heuristic initial pivots - if (!initialPivots()) return UNBOUNDED; - // Execute the Network Simplex algorithm while (pivot.findEnteringArc()) { findJoinNode(); bool change = findLeavingArc(); - if (delta >= MAX) return UNBOUNDED; + if (delta >= INF) return UNBOUNDED; changeFlow(change); if (change) { @@ -1593,5 +1436,5 @@ } } - + // Check feasibility for (int e = _search_arc_num; e != _all_arc_num; ++e) { @@ -1610,5 +1453,5 @@ } } - + // Shift potentials to meet the requirements of the GEQ/LEQ type // optimality conditions Index: mon/pairing_heap.h =================================================================== --- lemon/pairing_heap.h (revision 705) +++ (revision ) @@ -1,474 +1,0 @@ -/* -*- mode: C++; indent-tabs-mode: nil; -*- - * - * This file is a part of LEMON, a generic C++ optimization library. - * - * Copyright (C) 2003-2009 - * Egervary Jeno Kombinatorikus Optimalizalasi Kutatocsoport - * (Egervary Research Group on Combinatorial Optimization, EGRES). - * - * Permission to use, modify and distribute this software is granted - * provided that this copyright notice appears in all copies. For - * precise terms see the accompanying LICENSE file. - * - * This software is provided "AS IS" with no warranty of any kind, - * express or implied, and with no claim as to its suitability for any - * purpose. - * - */ - -#ifndef LEMON_PAIRING_HEAP_H -#define LEMON_PAIRING_HEAP_H - -///\file -///\ingroup heaps -///\brief Pairing heap implementation. - -#include -#include -#include -#include - -namespace lemon { - - /// \ingroup heaps - /// - ///\brief Pairing Heap. - /// - /// This class implements the \e pairing \e heap data structure. - /// It fully conforms to the \ref concepts::Heap "heap concept". - /// - /// The methods \ref increase() and \ref erase() are not efficient - /// in a pairing heap. In case of many calls of these operations, - /// it is better to use other heap structure, e.g. \ref BinHeap - /// "binary heap". - /// - /// \tparam PR Type of the priorities of the items. - /// \tparam IM A read-writable item map with \c int values, used - /// internally to handle the cross references. - /// \tparam CMP A functor class for comparing the priorities. - /// The default is \c std::less. -#ifdef DOXYGEN - template -#else - template > -#endif - class PairingHeap { - public: - /// Type of the item-int map. - typedef IM ItemIntMap; - /// Type of the priorities. - typedef PR Prio; - /// Type of the items stored in the heap. - typedef typename ItemIntMap::Key Item; - /// Functor type for comparing the priorities. - typedef CMP Compare; - - /// \brief Type to represent the states of the items. - /// - /// Each item has a state associated to it. It can be "in heap", - /// "pre-heap" or "post-heap". The latter two are indifferent from the - /// heap's point of view, but may be useful to the user. - /// - /// The item-int map must be initialized in such way that it assigns - /// \c PRE_HEAP (-1) to any element to be put in the heap. - enum State { - IN_HEAP = 0, ///< = 0. - PRE_HEAP = -1, ///< = -1. - POST_HEAP = -2 ///< = -2. - }; - - private: - class store; - - std::vector _data; - int _min; - ItemIntMap &_iim; - Compare _comp; - int _num_items; - - public: - /// \brief Constructor. - /// - /// Constructor. - /// \param map A map that assigns \c int values to the items. - /// It is used internally to handle the cross references. - /// The assigned value must be \c PRE_HEAP (-1) for each item. - explicit PairingHeap(ItemIntMap &map) - : _min(0), _iim(map), _num_items(0) {} - - /// \brief Constructor. - /// - /// Constructor. - /// \param map A map that assigns \c int values to the items. - /// It is used internally to handle the cross references. - /// The assigned value must be \c PRE_HEAP (-1) for each item. - /// \param comp The function object used for comparing the priorities. - PairingHeap(ItemIntMap &map, const Compare &comp) - : _min(0), _iim(map), _comp(comp), _num_items(0) {} - - /// \brief The number of items stored in the heap. - /// - /// This function returns the number of items stored in the heap. - int size() const { return _num_items; } - - /// \brief Check if the heap is empty. - /// - /// This function returns \c true if the heap is empty. - bool empty() const { return _num_items==0; } - - /// \brief Make the heap empty. - /// - /// This functon makes the heap empty. - /// It does not change the cross reference map. If you want to reuse - /// a heap that is not surely empty, you should first clear it and - /// then you should set the cross reference map to \c PRE_HEAP - /// for each item. - void clear() { - _data.clear(); - _min = 0; - _num_items = 0; - } - - /// \brief Set the priority of an item or insert it, if it is - /// not stored in the heap. - /// - /// This method sets the priority of the given item if it is - /// already stored in the heap. Otherwise it inserts the given - /// item into the heap with the given priority. - /// \param item The item. - /// \param value The priority. - void set (const Item& item, const Prio& value) { - int i=_iim[item]; - if ( i>=0 && _data[i].in ) { - if ( _comp(value, _data[i].prio) ) decrease(item, value); - if ( _comp(_data[i].prio, value) ) increase(item, value); - } else push(item, value); - } - - /// \brief Insert an item into the heap with the given priority. - /// - /// This function inserts the given item into the heap with the - /// given priority. - /// \param item The item to insert. - /// \param value The priority of the item. - /// \pre \e item must not be stored in the heap. - void push (const Item& item, const Prio& value) { - int i=_iim[item]; - if( i<0 ) { - int s=_data.size(); - _iim.set(item, s); - store st; - st.name=item; - _data.push_back(st); - i=s; - } else { - _data[i].parent=_data[i].child=-1; - _data[i].left_child=false; - _data[i].degree=0; - _data[i].in=true; - } - - _data[i].prio=value; - - if ( _num_items!=0 ) { - if ( _comp( value, _data[_min].prio) ) { - fuse(i,_min); - _min=i; - } - else fuse(_min,i); - } - else _min=i; - - ++_num_items; - } - - /// \brief Return the item having minimum priority. - /// - /// This function returns the item having minimum priority. - /// \pre The heap must be non-empty. - Item top() const { return _data[_min].name; } - - /// \brief The minimum priority. - /// - /// This function returns the minimum priority. - /// \pre The heap must be non-empty. - const Prio& prio() const { return _data[_min].prio; } - - /// \brief The priority of the given item. - /// - /// This function returns the priority of the given item. - /// \param item The item. - /// \pre \e item must be in the heap. - const Prio& operator[](const Item& item) const { - return _data[_iim[item]].prio; - } - - /// \brief Remove the item having minimum priority. - /// - /// This function removes the item having minimum priority. - /// \pre The heap must be non-empty. - void pop() { - std::vector trees; - int i=0, child_right = 0; - _data[_min].in=false; - - if( -1!=_data[_min].child ) { - i=_data[_min].child; - trees.push_back(i); - _data[i].parent = -1; - _data[_min].child = -1; - - int ch=-1; - while( _data[i].child!=-1 ) { - ch=_data[i].child; - if( _data[ch].left_child && i==_data[ch].parent ) { - break; - } else { - if( _data[ch].left_child ) { - child_right=_data[ch].parent; - _data[ch].parent = i; - --_data[i].degree; - } - else { - child_right=ch; - _data[i].child=-1; - _data[i].degree=0; - } - _data[child_right].parent = -1; - trees.push_back(child_right); - i = child_right; - } - } - - int num_child = trees.size(); - int other; - for( i=0; i=2) { - if ( _comp(_data[trees[i]].prio, _data[trees[i-2]].prio) ) { - other=trees[i]; - trees[i]=trees[i-2]; - trees[i-2]=other; - } - fuse( trees[i-2], trees[i] ); - i-=2; - } - _min = trees[0]; - } - else { - _min = _data[_min].child; - } - - if (_min >= 0) _data[_min].left_child = false; - --_num_items; - } - - /// \brief Remove the given item from the heap. - /// - /// This function removes the given item from the heap if it is - /// already stored. - /// \param item The item to delete. - /// \pre \e item must be in the heap. - void erase (const Item& item) { - int i=_iim[item]; - if ( i>=0 && _data[i].in ) { - decrease( item, _data[_min].prio-1 ); - pop(); - } - } - - /// \brief Decrease the priority of an item to the given value. - /// - /// This function decreases the priority of an item to the given value. - /// \param item The item. - /// \param value The priority. - /// \pre \e item must be stored in the heap with priority at least \e value. - void decrease (Item item, const Prio& value) { - int i=_iim[item]; - _data[i].prio=value; - int p=_data[i].parent; - - if( _data[i].left_child && i!=_data[p].child ) { - p=_data[p].parent; - } - - if ( p!=-1 && _comp(value,_data[p].prio) ) { - cut(i,p); - if ( _comp(_data[_min].prio,value) ) { - fuse(_min,i); - } else { - fuse(i,_min); - _min=i; - } - } - } - - /// \brief Increase the priority of an item to the given value. - /// - /// This function increases the priority of an item to the given value. - /// \param item The item. - /// \param value The priority. - /// \pre \e item must be stored in the heap with priority at most \e value. - void increase (Item item, const Prio& value) { - erase(item); - push(item,value); - } - - /// \brief Return the state of an item. - /// - /// This method returns \c PRE_HEAP if the given item has never - /// been in the heap, \c IN_HEAP if it is in the heap at the moment, - /// and \c POST_HEAP otherwise. - /// In the latter case it is possible that the item will get back - /// to the heap again. - /// \param item The item. - State state(const Item &item) const { - int i=_iim[item]; - if( i>=0 ) { - if( _data[i].in ) i=0; - else i=-2; - } - return State(i); - } - - /// \brief Set the state of an item in the heap. - /// - /// This function sets the state of the given item in the heap. - /// It can be used to manually clear the heap when it is important - /// to achive better time complexity. - /// \param i The item. - /// \param st The state. It should not be \c IN_HEAP. - void state(const Item& i, State st) { - switch (st) { - case POST_HEAP: - case PRE_HEAP: - if (state(i) == IN_HEAP) erase(i); - _iim[i]=st; - break; - case IN_HEAP: - break; - } - } - - private: - - void cut(int a, int b) { - int child_a; - switch (_data[a].degree) { - case 2: - child_a = _data[_data[a].child].parent; - if( _data[a].left_child ) { - _data[child_a].left_child=true; - _data[b].child=child_a; - _data[child_a].parent=_data[a].parent; - } - else { - _data[child_a].left_child=false; - _data[child_a].parent=b; - if( a!=_data[b].child ) - _data[_data[b].child].parent=child_a; - else - _data[b].child=child_a; - } - --_data[a].degree; - _data[_data[a].child].parent=a; - break; - - case 1: - child_a = _data[a].child; - if( !_data[child_a].left_child ) { - --_data[a].degree; - if( _data[a].left_child ) { - _data[child_a].left_child=true; - _data[child_a].parent=_data[a].parent; - _data[b].child=child_a; - } - else { - _data[child_a].left_child=false; - _data[child_a].parent=b; - if( a!=_data[b].child ) - _data[_data[b].child].parent=child_a; - else - _data[b].child=child_a; - } - _data[a].child=-1; - } - else { - --_data[b].degree; - if( _data[a].left_child ) { - _data[b].child = - (1==_data[b].degree) ? _data[a].parent : -1; - } else { - if (1==_data[b].degree) - _data[_data[b].child].parent=b; - else - _data[b].child=-1; - } - } - break; - - case 0: - --_data[b].degree; - if( _data[a].left_child ) { - _data[b].child = - (0!=_data[b].degree) ? _data[a].parent : -1; - } else { - if( 0!=_data[b].degree ) - _data[_data[b].child].parent=b; - else - _data[b].child=-1; - } - break; - } - _data[a].parent=-1; - _data[a].left_child=false; - } - - void fuse(int a, int b) { - int child_a = _data[a].child; - int child_b = _data[b].child; - _data[a].child=b; - _data[b].parent=a; - _data[b].left_child=true; - - if( -1!=child_a ) { - _data[b].child=child_a; - _data[child_a].parent=b; - _data[child_a].left_child=false; - ++_data[b].degree; - - if( -1!=child_b ) { - _data[b].child=child_b; - _data[child_b].parent=child_a; - } - } - else { ++_data[a].degree; } - } - - class store { - friend class PairingHeap; - - Item name; - int parent; - int child; - bool left_child; - int degree; - bool in; - Prio prio; - - store() : parent(-1), child(-1), left_child(false), degree(0), in(true) {} - }; - }; - -} //namespace lemon - -#endif //LEMON_PAIRING_HEAP_H - Index: lemon/path.h =================================================================== --- lemon/path.h (revision 1000) +++ lemon/path.h (revision 990) @@ -3,5 +3,5 @@ * This file is a part of LEMON, a generic C++ optimization library. * - * Copyright (C) 2003-2010 + * Copyright (C) 2003-2009 * Egervary Jeno Kombinatorikus Optimalizalasi Kutatocsoport * (Egervary Research Group on Combinatorial Optimization, EGRES). @@ -44,5 +44,5 @@ /// /// In a sense, the path can be treated as a list of arcs. The - /// LEMON path type stores just this list. As a consequence, it + /// lemon path type stores just this list. As a consequence, it /// cannot enumerate the nodes of the path and the source node of /// a zero length path is undefined. @@ -149,5 +149,5 @@ void clear() { head.clear(); tail.clear(); } - /// \brief The n-th arc. + /// \brief The nth arc. /// /// \pre \c n is in the [0..length() - 1] range. @@ -157,5 +157,5 @@ } - /// \brief Initialize arc iterator to point to the n-th arc + /// \brief Initialize arc iterator to point to the nth arc /// /// \pre \c n is in the [0..length() - 1] range. @@ -245,5 +245,5 @@ /// /// In a sense, the path can be treated as a list of arcs. The - /// LEMON path type stores just this list. As a consequence it + /// lemon path type stores just this list. As a consequence it /// cannot enumerate the nodes in the path and the zero length paths /// cannot store the source. @@ -354,5 +354,5 @@ void clear() { data.clear(); } - /// \brief The n-th arc. + /// \brief The nth arc. /// /// \pre \c n is in the [0..length() - 1] range. @@ -361,5 +361,5 @@ } - /// \brief Initializes arc iterator to point to the n-th arc. + /// \brief Initializes arc iterator to point to the nth arc. ArcIt nthIt(int n) const { return ArcIt(*this, n); @@ -422,5 +422,5 @@ /// /// In a sense, the path can be treated as a list of arcs. The - /// LEMON path type stores just this list. As a consequence it + /// lemon path type stores just this list. As a consequence it /// cannot enumerate the nodes in the path and the zero length paths /// cannot store the source. @@ -544,7 +544,7 @@ }; - /// \brief The n-th arc. - /// - /// This function looks for the n-th arc in O(n) time. + /// \brief The nth arc. + /// + /// This function looks for the nth arc in O(n) time. /// \pre \c n is in the [0..length() - 1] range. const Arc& nth(int n) const { @@ -556,5 +556,5 @@ } - /// \brief Initializes arc iterator to point to the n-th arc. + /// \brief Initializes arc iterator to point to the nth arc. ArcIt nthIt(int n) const { Node *node = first; @@ -775,5 +775,5 @@ /// /// In a sense, the path can be treated as a list of arcs. The - /// LEMON path type stores just this list. As a consequence it + /// lemon path type stores just this list. As a consequence it /// cannot enumerate the nodes in the path and the source node of /// a zero length path is undefined. @@ -884,5 +884,5 @@ }; - /// \brief The n-th arc. + /// \brief The nth arc. /// /// \pre \c n is in the [0..length() - 1] range. @@ -891,5 +891,5 @@ } - /// \brief The arc iterator pointing to the n-th arc. + /// \brief The arc iterator pointing to the nth arc. ArcIt nthIt(int n) const { return ArcIt(*this, n); @@ -1019,5 +1019,5 @@ }; - + template ::value> @@ -1025,5 +1025,5 @@ static void copy(const From& from, To& to) { PathCopySelectorForward::copy(from, to); - } + } }; @@ -1032,5 +1032,5 @@ static void copy(const From& from, To& to) { PathCopySelectorBackward::copy(from, to); - } + } }; @@ -1095,5 +1095,5 @@ /// /// In a sense, the path can be treated as a list of arcs. The - /// LEMON path type stores only this list. As a consequence, it + /// lemon path type stores only this list. As a consequence, it /// cannot enumerate the nodes in the path and the zero length paths /// cannot have a source node. Index: mon/planarity.h =================================================================== --- lemon/planarity.h (revision 999) +++ (revision ) @@ -1,2754 +1,0 @@ -/* -*- mode: C++; indent-tabs-mode: nil; -*- - * - * This file is a part of LEMON, a generic C++ optimization library. - * - * Copyright (C) 2003-2010 - * Egervary Jeno Kombinatorikus Optimalizalasi Kutatocsoport - * (Egervary Research Group on Combinatorial Optimization, EGRES). - * - * Permission to use, modify and distribute this software is granted - * provided that this copyright notice appears in all copies. For - * precise terms see the accompanying LICENSE file. - * - * This software is provided "AS IS" with no warranty of any kind, - * express or implied, and with no claim as to its suitability for any - * purpose. - * - */ - -#ifndef LEMON_PLANARITY_H -#define LEMON_PLANARITY_H - -/// \ingroup planar -/// \file -/// \brief Planarity checking, embedding, drawing and coloring - -#include -#include - -#include -#include -#include -#include -#include -#include -#include -#include -#include -#include - -namespace lemon { - - namespace _planarity_bits { - - template - struct PlanarityVisitor : DfsVisitor { - - TEMPLATE_GRAPH_TYPEDEFS(Graph); - - typedef typename Graph::template NodeMap PredMap; - - typedef typename Graph::template EdgeMap TreeMap; - - typedef typename Graph::template NodeMap OrderMap; - typedef std::vector OrderList; - - typedef typename Graph::template NodeMap LowMap; - typedef typename Graph::template NodeMap AncestorMap; - - PlanarityVisitor(const Graph& graph, - PredMap& pred_map, TreeMap& tree_map, - OrderMap& order_map, OrderList& order_list, - AncestorMap& ancestor_map, LowMap& low_map) - : _graph(graph), _pred_map(pred_map), _tree_map(tree_map), - _order_map(order_map), _order_list(order_list), - _ancestor_map(ancestor_map), _low_map(low_map) {} - - void reach(const Node& node) { - _order_map[node] = _order_list.size(); - _low_map[node] = _order_list.size(); - _ancestor_map[node] = _order_list.size(); - _order_list.push_back(node); - } - - void discover(const Arc& arc) { - Node target = _graph.target(arc); - - _tree_map[arc] = true; - _pred_map[target] = arc; - } - - void examine(const Arc& arc) { - Node source = _graph.source(arc); - Node target = _graph.target(arc); - - if (_order_map[target] < _order_map[source] && !_tree_map[arc]) { - if (_low_map[source] > _order_map[target]) { - _low_map[source] = _order_map[target]; - } - if (_ancestor_map[source] > _order_map[target]) { - _ancestor_map[source] = _order_map[target]; - } - } - } - - void backtrack(const Arc& arc) { - Node source = _graph.source(arc); - Node target = _graph.target(arc); - - if (_low_map[source] > _low_map[target]) { - _low_map[source] = _low_map[target]; - } - } - - const Graph& _graph; - PredMap& _pred_map; - TreeMap& _tree_map; - OrderMap& _order_map; - OrderList& _order_list; - AncestorMap& _ancestor_map; - LowMap& _low_map; - }; - - template - struct NodeDataNode { - int prev, next; - int visited; - typename Graph::Arc first; - bool inverted; - }; - - template - struct NodeDataNode { - int prev, next; - int visited; - }; - - template - struct ChildListNode { - typedef typename Graph::Node Node; - Node first; - Node prev, next; - }; - - template - struct ArcListNode { - typename Graph::Arc prev, next; - }; - - template - class PlanarityChecking { - private: - - TEMPLATE_GRAPH_TYPEDEFS(Graph); - - const Graph& _graph; - - private: - - typedef typename Graph::template NodeMap PredMap; - - typedef typename Graph::template EdgeMap TreeMap; - - typedef typename Graph::template NodeMap OrderMap; - typedef std::vector OrderList; - - typedef typename Graph::template NodeMap LowMap; - typedef typename Graph::template NodeMap AncestorMap; - - typedef _planarity_bits::NodeDataNode NodeDataNode; - typedef std::vector NodeData; - - typedef _planarity_bits::ChildListNode ChildListNode; - typedef typename Graph::template NodeMap ChildLists; - - typedef typename Graph::template NodeMap > MergeRoots; - - typedef typename Graph::template NodeMap EmbedArc; - - public: - - PlanarityChecking(const Graph& graph) : _graph(graph) {} - - bool run() { - typedef _planarity_bits::PlanarityVisitor Visitor; - - PredMap pred_map(_graph, INVALID); - TreeMap tree_map(_graph, false); - - OrderMap order_map(_graph, -1); - OrderList order_list; - - AncestorMap ancestor_map(_graph, -1); - LowMap low_map(_graph, -1); - - Visitor visitor(_graph, pred_map, tree_map, - order_map, order_list, ancestor_map, low_map); - DfsVisit visit(_graph, visitor); - visit.run(); - - ChildLists child_lists(_graph); - createChildLists(tree_map, order_map, low_map, child_lists); - - NodeData node_data(2 * order_list.size()); - - EmbedArc embed_arc(_graph, false); - - MergeRoots merge_roots(_graph); - - for (int i = order_list.size() - 1; i >= 0; --i) { - - Node node = order_list[i]; - - Node source = node; - for (OutArcIt e(_graph, node); e != INVALID; ++e) { - Node target = _graph.target(e); - - if (order_map[source] < order_map[target] && tree_map[e]) { - initFace(target, node_data, order_map, order_list); - } - } - - for (OutArcIt e(_graph, node); e != INVALID; ++e) { - Node target = _graph.target(e); - - if (order_map[source] < order_map[target] && !tree_map[e]) { - embed_arc[target] = true; - walkUp(target, source, i, pred_map, low_map, - order_map, order_list, node_data, merge_roots); - } - } - - for (typename MergeRoots::Value::iterator it = - merge_roots[node].begin(); - it != merge_roots[node].end(); ++it) { - int rn = *it; - walkDown(rn, i, node_data, order_list, child_lists, - ancestor_map, low_map, embed_arc, merge_roots); - } - merge_roots[node].clear(); - - for (OutArcIt e(_graph, node); e != INVALID; ++e) { - Node target = _graph.target(e); - - if (order_map[source] < order_map[target] && !tree_map[e]) { - if (embed_arc[target]) { - return false; - } - } - } - } - - return true; - } - - private: - - void createChildLists(const TreeMap& tree_map, const OrderMap& order_map, - const LowMap& low_map, ChildLists& child_lists) { - - for (NodeIt n(_graph); n != INVALID; ++n) { - Node source = n; - - std::vector targets; - for (OutArcIt e(_graph, n); e != INVALID; ++e) { - Node target = _graph.target(e); - - if (order_map[source] < order_map[target] && tree_map[e]) { - targets.push_back(target); - } - } - - if (targets.size() == 0) { - child_lists[source].first = INVALID; - } else if (targets.size() == 1) { - child_lists[source].first = targets[0]; - child_lists[targets[0]].prev = INVALID; - child_lists[targets[0]].next = INVALID; - } else { - radixSort(targets.begin(), targets.end(), mapToFunctor(low_map)); - for (int i = 1; i < int(targets.size()); ++i) { - child_lists[targets[i]].prev = targets[i - 1]; - child_lists[targets[i - 1]].next = targets[i]; - } - child_lists[targets.back()].next = INVALID; - child_lists[targets.front()].prev = INVALID; - child_lists[source].first = targets.front(); - } - } - } - - void walkUp(const Node& node, Node root, int rorder, - const PredMap& pred_map, const LowMap& low_map, - const OrderMap& order_map, const OrderList& order_list, - NodeData& node_data, MergeRoots& merge_roots) { - - int na, nb; - bool da, db; - - na = nb = order_map[node]; - da = true; db = false; - - while (true) { - - if (node_data[na].visited == rorder) break; - if (node_data[nb].visited == rorder) break; - - node_data[na].visited = rorder; - node_data[nb].visited = rorder; - - int rn = -1; - - if (na >= int(order_list.size())) { - rn = na; - } else if (nb >= int(order_list.size())) { - rn = nb; - } - - if (rn == -1) { - int nn; - - nn = da ? node_data[na].prev : node_data[na].next; - da = node_data[nn].prev != na; - na = nn; - - nn = db ? node_data[nb].prev : node_data[nb].next; - db = node_data[nn].prev != nb; - nb = nn; - - } else { - - Node rep = order_list[rn - order_list.size()]; - Node parent = _graph.source(pred_map[rep]); - - if (low_map[rep] < rorder) { - merge_roots[parent].push_back(rn); - } else { - merge_roots[parent].push_front(rn); - } - - if (parent != root) { - na = nb = order_map[parent]; - da = true; db = false; - } else { - break; - } - } - } - } - - void walkDown(int rn, int rorder, NodeData& node_data, - OrderList& order_list, ChildLists& child_lists, - AncestorMap& ancestor_map, LowMap& low_map, - EmbedArc& embed_arc, MergeRoots& merge_roots) { - - std::vector > merge_stack; - - for (int di = 0; di < 2; ++di) { - bool rd = di == 0; - int pn = rn; - int n = rd ? node_data[rn].next : node_data[rn].prev; - - while (n != rn) { - - Node node = order_list[n]; - - if (embed_arc[node]) { - - // Merging components on the critical path - while (!merge_stack.empty()) { - - // Component root - int cn = merge_stack.back().first; - bool cd = merge_stack.back().second; - merge_stack.pop_back(); - - // Parent of component - int dn = merge_stack.back().first; - bool dd = merge_stack.back().second; - merge_stack.pop_back(); - - Node parent = order_list[dn]; - - // Erasing from merge_roots - merge_roots[parent].pop_front(); - - Node child = order_list[cn - order_list.size()]; - - // Erasing from child_lists - if (child_lists[child].prev != INVALID) { - child_lists[child_lists[child].prev].next = - child_lists[child].next; - } else { - child_lists[parent].first = child_lists[child].next; - } - - if (child_lists[child].next != INVALID) { - child_lists[child_lists[child].next].prev = - child_lists[child].prev; - } - - // Merging external faces - { - int en = cn; - cn = cd ? node_data[cn].prev : node_data[cn].next; - cd = node_data[cn].next == en; - - } - - if (cd) node_data[cn].next = dn; else node_data[cn].prev = dn; - if (dd) node_data[dn].prev = cn; else node_data[dn].next = cn; - - } - - bool d = pn == node_data[n].prev; - - if (node_data[n].prev == node_data[n].next && - node_data[n].inverted) { - d = !d; - } - - // Embedding arc into external face - if (rd) node_data[rn].next = n; else node_data[rn].prev = n; - if (d) node_data[n].prev = rn; else node_data[n].next = rn; - pn = rn; - - embed_arc[order_list[n]] = false; - } - - if (!merge_roots[node].empty()) { - - bool d = pn == node_data[n].prev; - - merge_stack.push_back(std::make_pair(n, d)); - - int rn = merge_roots[node].front(); - - int xn = node_data[rn].next; - Node xnode = order_list[xn]; - - int yn = node_data[rn].prev; - Node ynode = order_list[yn]; - - bool rd; - if (!external(xnode, rorder, child_lists, - ancestor_map, low_map)) { - rd = true; - } else if (!external(ynode, rorder, child_lists, - ancestor_map, low_map)) { - rd = false; - } else if (pertinent(xnode, embed_arc, merge_roots)) { - rd = true; - } else { - rd = false; - } - - merge_stack.push_back(std::make_pair(rn, rd)); - - pn = rn; - n = rd ? xn : yn; - - } else if (!external(node, rorder, child_lists, - ancestor_map, low_map)) { - int nn = (node_data[n].next != pn ? - node_data[n].next : node_data[n].prev); - - bool nd = n == node_data[nn].prev; - - if (nd) node_data[nn].prev = pn; - else node_data[nn].next = pn; - - if (n == node_data[pn].prev) node_data[pn].prev = nn; - else node_data[pn].next = nn; - - node_data[nn].inverted = - (node_data[nn].prev == node_data[nn].next && nd != rd); - - n = nn; - } - else break; - - } - - if (!merge_stack.empty() || n == rn) { - break; - } - } - } - - void initFace(const Node& node, NodeData& node_data, - const OrderMap& order_map, const OrderList& order_list) { - int n = order_map[node]; - int rn = n + order_list.size(); - - node_data[n].next = node_data[n].prev = rn; - node_data[rn].next = node_data[rn].prev = n; - - node_data[n].visited = order_list.size(); - node_data[rn].visited = order_list.size(); - - } - - bool external(const Node& node, int rorder, - ChildLists& child_lists, AncestorMap& ancestor_map, - LowMap& low_map) { - Node child = child_lists[node].first; - - if (child != INVALID) { - if (low_map[child] < rorder) return true; - } - - if (ancestor_map[node] < rorder) return true; - - return false; - } - - bool pertinent(const Node& node, const EmbedArc& embed_arc, - const MergeRoots& merge_roots) { - return !merge_roots[node].empty() || embed_arc[node]; - } - - }; - - } - - /// \ingroup planar - /// - /// \brief Planarity checking of an undirected simple graph - /// - /// This function implements the Boyer-Myrvold algorithm for - /// planarity checking of an undirected simple graph. It is a simplified - /// version of the PlanarEmbedding algorithm class because neither - /// the embedding nor the Kuratowski subdivisons are computed. - template - bool checkPlanarity(const GR& graph) { - _planarity_bits::PlanarityChecking pc(graph); - return pc.run(); - } - - /// \ingroup planar - /// - /// \brief Planar embedding of an undirected simple graph - /// - /// This class implements the Boyer-Myrvold algorithm for planar - /// embedding of an undirected simple graph. The planar embedding is an - /// ordering of the outgoing edges of the nodes, which is a possible - /// configuration to draw the graph in the plane. If there is not - /// such ordering then the graph contains a K5 (full graph - /// with 5 nodes) or a K3,3 (complete bipartite graph on - /// 3 Red and 3 Blue nodes) subdivision. - /// - /// The current implementation calculates either an embedding or a - /// Kuratowski subdivision. The running time of the algorithm is O(n). - /// - /// \see PlanarDrawing, checkPlanarity() - template - class PlanarEmbedding { - private: - - TEMPLATE_GRAPH_TYPEDEFS(Graph); - - const Graph& _graph; - typename Graph::template ArcMap _embedding; - - typename Graph::template EdgeMap _kuratowski; - - private: - - typedef typename Graph::template NodeMap PredMap; - - typedef typename Graph::template EdgeMap TreeMap; - - typedef typename Graph::template NodeMap OrderMap; - typedef std::vector OrderList; - - typedef typename Graph::template NodeMap LowMap; - typedef typename Graph::template NodeMap AncestorMap; - - typedef _planarity_bits::NodeDataNode NodeDataNode; - typedef std::vector NodeData; - - typedef _planarity_bits::ChildListNode ChildListNode; - typedef typename Graph::template NodeMap ChildLists; - - typedef typename Graph::template NodeMap > MergeRoots; - - typedef typename Graph::template NodeMap EmbedArc; - - typedef _planarity_bits::ArcListNode ArcListNode; - typedef typename Graph::template ArcMap ArcLists; - - typedef typename Graph::template NodeMap FlipMap; - - typedef typename Graph::template NodeMap TypeMap; - - enum IsolatorNodeType { - HIGHX = 6, LOWX = 7, - HIGHY = 8, LOWY = 9, - ROOT = 10, PERTINENT = 11, - INTERNAL = 12 - }; - - public: - - /// \brief The map type for storing the embedding - /// - /// The map type for storing the embedding. - /// \see embeddingMap() - typedef typename Graph::template ArcMap EmbeddingMap; - - /// \brief Constructor - /// - /// Constructor. - /// \pre The graph must be simple, i.e. it should not - /// contain parallel or loop arcs. - PlanarEmbedding(const Graph& graph) - : _graph(graph), _embedding(_graph), _kuratowski(graph, false) {} - - /// \brief Run the algorithm. - /// - /// This function runs the algorithm. - /// \param kuratowski If this parameter is set to \c false, then the - /// algorithm does not compute a Kuratowski subdivision. - /// \return \c true if the graph is planar. - bool run(bool kuratowski = true) { - typedef _planarity_bits::PlanarityVisitor Visitor; - - PredMap pred_map(_graph, INVALID); - TreeMap tree_map(_graph, false); - - OrderMap order_map(_graph, -1); - OrderList order_list; - - AncestorMap ancestor_map(_graph, -1); - LowMap low_map(_graph, -1); - - Visitor visitor(_graph, pred_map, tree_map, - order_map, order_list, ancestor_map, low_map); - DfsVisit visit(_graph, visitor); - visit.run(); - - ChildLists child_lists(_graph); - createChildLists(tree_map, order_map, low_map, child_lists); - - NodeData node_data(2 * order_list.size()); - - EmbedArc embed_arc(_graph, INVALID); - - MergeRoots merge_roots(_graph); - - ArcLists arc_lists(_graph); - - FlipMap flip_map(_graph, false); - - for (int i = order_list.size() - 1; i >= 0; --i) { - - Node node = order_list[i]; - - node_data[i].first = INVALID; - - Node source = node; - for (OutArcIt e(_graph, node); e != INVALID; ++e) { - Node target = _graph.target(e); - - if (order_map[source] < order_map[target] && tree_map[e]) { - initFace(target, arc_lists, node_data, - pred_map, order_map, order_list); - } - } - - for (OutArcIt e(_graph, node); e != INVALID; ++e) { - Node target = _graph.target(e); - - if (order_map[source] < order_map[target] && !tree_map[e]) { - embed_arc[target] = e; - walkUp(target, source, i, pred_map, low_map, - order_map, order_list, node_data, merge_roots); - } - } - - for (typename MergeRoots::Value::iterator it = - merge_roots[node].begin(); it != merge_roots[node].end(); ++it) { - int rn = *it; - walkDown(rn, i, node_data, arc_lists, flip_map, order_list, - child_lists, ancestor_map, low_map, embed_arc, merge_roots); - } - merge_roots[node].clear(); - - for (OutArcIt e(_graph, node); e != INVALID; ++e) { - Node target = _graph.target(e); - - if (order_map[source] < order_map[target] && !tree_map[e]) { - if (embed_arc[target] != INVALID) { - if (kuratowski) { - isolateKuratowski(e, node_data, arc_lists, flip_map, - order_map, order_list, pred_map, child_lists, - ancestor_map, low_map, - embed_arc, merge_roots); - } - return false; - } - } - } - } - - for (int i = 0; i < int(order_list.size()); ++i) { - - mergeRemainingFaces(order_list[i], node_data, order_list, order_map, - child_lists, arc_lists); - storeEmbedding(order_list[i], node_data, order_map, pred_map, - arc_lists, flip_map); - } - - return true; - } - - /// \brief Give back the successor of an arc - /// - /// This function gives back the successor of an arc. It makes - /// possible to query the cyclic order of the outgoing arcs from - /// a node. - Arc next(const Arc& arc) const { - return _embedding[arc]; - } - - /// \brief Give back the calculated embedding map - /// - /// This function gives back the calculated embedding map, which - /// contains the successor of each arc in the cyclic order of the - /// outgoing arcs of its source node. - const EmbeddingMap& embeddingMap() const { - return _embedding; - } - - /// \brief Give back \c true if the given edge is in the Kuratowski - /// subdivision - /// - /// This function gives back \c true if the given edge is in the found - /// Kuratowski subdivision. - /// \pre The \c run() function must be called with \c true parameter - /// before using this function. - bool kuratowski(const Edge& edge) const { - return _kuratowski[edge]; - } - - private: - - void createChildLists(const TreeMap& tree_map, const OrderMap& order_map, - const LowMap& low_map, ChildLists& child_lists) { - - for (NodeIt n(_graph); n != INVALID; ++n) { - Node source = n; - - std::vector targets; - for (OutArcIt e(_graph, n); e != INVALID; ++e) { - Node target = _graph.target(e); - - if (order_map[source] < order_map[target] && tree_map[e]) { - targets.push_back(target); - } - } - - if (targets.size() == 0) { - child_lists[source].first = INVALID; - } else if (targets.size() == 1) { - child_lists[source].first = targets[0]; - child_lists[targets[0]].prev = INVALID; - child_lists[targets[0]].next = INVALID; - } else { - radixSort(targets.begin(), targets.end(), mapToFunctor(low_map)); - for (int i = 1; i < int(targets.size()); ++i) { - child_lists[targets[i]].prev = targets[i - 1]; - child_lists[targets[i - 1]].next = targets[i]; - } - child_lists[targets.back()].next = INVALID; - child_lists[targets.front()].prev = INVALID; - child_lists[source].first = targets.front(); - } - } - } - - void walkUp(const Node& node, Node root, int rorder, - const PredMap& pred_map, const LowMap& low_map, - const OrderMap& order_map, const OrderList& order_list, - NodeData& node_data, MergeRoots& merge_roots) { - - int na, nb; - bool da, db; - - na = nb = order_map[node]; - da = true; db = false; - - while (true) { - - if (node_data[na].visited == rorder) break; - if (node_data[nb].visited == rorder) break; - - node_data[na].visited = rorder; - node_data[nb].visited = rorder; - - int rn = -1; - - if (na >= int(order_list.size())) { - rn = na; - } else if (nb >= int(order_list.size())) { - rn = nb; - } - - if (rn == -1) { - int nn; - - nn = da ? node_data[na].prev : node_data[na].next; - da = node_data[nn].prev != na; - na = nn; - - nn = db ? node_data[nb].prev : node_data[nb].next; - db = node_data[nn].prev != nb; - nb = nn; - - } else { - - Node rep = order_list[rn - order_list.size()]; - Node parent = _graph.source(pred_map[rep]); - - if (low_map[rep] < rorder) { - merge_roots[parent].push_back(rn); - } else { - merge_roots[parent].push_front(rn); - } - - if (parent != root) { - na = nb = order_map[parent]; - da = true; db = false; - } else { - break; - } - } - } - } - - void walkDown(int rn, int rorder, NodeData& node_data, - ArcLists& arc_lists, FlipMap& flip_map, - OrderList& order_list, ChildLists& child_lists, - AncestorMap& ancestor_map, LowMap& low_map, - EmbedArc& embed_arc, MergeRoots& merge_roots) { - - std::vector > merge_stack; - - for (int di = 0; di < 2; ++di) { - bool rd = di == 0; - int pn = rn; - int n = rd ? node_data[rn].next : node_data[rn].prev; - - while (n != rn) { - - Node node = order_list[n]; - - if (embed_arc[node] != INVALID) { - - // Merging components on the critical path - while (!merge_stack.empty()) { - - // Component root - int cn = merge_stack.back().first; - bool cd = merge_stack.back().second; - merge_stack.pop_back(); - - // Parent of component - int dn = merge_stack.back().first; - bool dd = merge_stack.back().second; - merge_stack.pop_back(); - - Node parent = order_list[dn]; - - // Erasing from merge_roots - merge_roots[parent].pop_front(); - - Node child = order_list[cn - order_list.size()]; - - // Erasing from child_lists - if (child_lists[child].prev != INVALID) { - child_lists[child_lists[child].prev].next = - child_lists[child].next; - } else { - child_lists[parent].first = child_lists[child].next; - } - - if (child_lists[child].next != INVALID) { - child_lists[child_lists[child].next].prev = - child_lists[child].prev; - } - - // Merging arcs + flipping - Arc de = node_data[dn].first; - Arc ce = node_data[cn].first; - - flip_map[order_list[cn - order_list.size()]] = cd != dd; - if (cd != dd) { - std::swap(arc_lists[ce].prev, arc_lists[ce].next); - ce = arc_lists[ce].prev; - std::swap(arc_lists[ce].prev, arc_lists[ce].next); - } - - { - Arc dne = arc_lists[de].next; - Arc cne = arc_lists[ce].next; - - arc_lists[de].next = cne; - arc_lists[ce].next = dne; - - arc_lists[dne].prev = ce; - arc_lists[cne].prev = de; - } - - if (dd) { - node_data[dn].first = ce; - } - - // Merging external faces - { - int en = cn; - cn = cd ? node_data[cn].prev : node_data[cn].next; - cd = node_data[cn].next == en; - - if (node_data[cn].prev == node_data[cn].next && - node_data[cn].inverted) { - cd = !cd; - } - } - - if (cd) node_data[cn].next = dn; else node_data[cn].prev = dn; - if (dd) node_data[dn].prev = cn; else node_data[dn].next = cn; - - } - - bool d = pn == node_data[n].prev; - - if (node_data[n].prev == node_data[n].next && - node_data[n].inverted) { - d = !d; - } - - // Add new arc - { - Arc arc = embed_arc[node]; - Arc re = node_data[rn].first; - - arc_lists[arc_lists[re].next].prev = arc; - arc_lists[arc].next = arc_lists[re].next; - arc_lists[arc].prev = re; - arc_lists[re].next = arc; - - if (!rd) { - node_data[rn].first = arc; - } - - Arc rev = _graph.oppositeArc(arc); - Arc e = node_data[n].first; - - arc_lists[arc_lists[e].next].prev = rev; - arc_lists[rev].next = arc_lists[e].next; - arc_lists[rev].prev = e; - arc_lists[e].next = rev; - - if (d) { - node_data[n].first = rev; - } - - } - - // Embedding arc into external face - if (rd) node_data[rn].next = n; else node_data[rn].prev = n; - if (d) node_data[n].prev = rn; else node_data[n].next = rn; - pn = rn; - - embed_arc[order_list[n]] = INVALID; - } - - if (!merge_roots[node].empty()) { - - bool d = pn == node_data[n].prev; - if (node_data[n].prev == node_data[n].next && - node_data[n].inverted) { - d = !d; - } - - merge_stack.push_back(std::make_pair(n, d)); - - int rn = merge_roots[node].front(); - - int xn = node_data[rn].next; - Node xnode = order_list[xn]; - - int yn = node_data[rn].prev; - Node ynode = order_list[yn]; - - bool rd; - if (!external(xnode, rorder, child_lists, ancestor_map, low_map)) { - rd = true; - } else if (!external(ynode, rorder, child_lists, - ancestor_map, low_map)) { - rd = false; - } else if (pertinent(xnode, embed_arc, merge_roots)) { - rd = true; - } else { - rd = false; - } - - merge_stack.push_back(std::make_pair(rn, rd)); - - pn = rn; - n = rd ? xn : yn; - - } else if (!external(node, rorder, child_lists, - ancestor_map, low_map)) { - int nn = (node_data[n].next != pn ? - node_data[n].next : node_data[n].prev); - - bool nd = n == node_data[nn].prev; - - if (nd) node_data[nn].prev = pn; - else node_data[nn].next = pn; - - if (n == node_data[pn].prev) node_data[pn].prev = nn; - else node_data[pn].next = nn; - - node_data[nn].inverted = - (node_data[nn].prev == node_data[nn].next && nd != rd); - - n = nn; - } - else break; - - } - - if (!merge_stack.empty() || n == rn) { - break; - } - } - } - - void initFace(const Node& node, ArcLists& arc_lists, - NodeData& node_data, const PredMap& pred_map, - const OrderMap& order_map, const OrderList& order_list) { - int n = order_map[node]; - int rn = n + order_list.size(); - - node_data[n].next = node_data[n].prev = rn; - node_data[rn].next = node_data[rn].prev = n; - - node_data[n].visited = order_list.size(); - node_data[rn].visited = order_list.size(); - - node_data[n].inverted = false; - node_data[rn].inverted = false; - - Arc arc = pred_map[node]; - Arc rev = _graph.oppositeArc(arc); - - node_data[rn].first = arc; - node_data[n].first = rev; - - arc_lists[arc].prev = arc; - arc_lists[arc].next = arc; - - arc_lists[rev].prev = rev; - arc_lists[rev].next = rev; - - } - - void mergeRemainingFaces(const Node& node, NodeData& node_data, - OrderList& order_list, OrderMap& order_map, - ChildLists& child_lists, ArcLists& arc_lists) { - while (child_lists[node].first != INVALID) { - int dd = order_map[node]; - Node child = child_lists[node].first; - int cd = order_map[child] + order_list.size(); - child_lists[node].first = child_lists[child].next; - - Arc de = node_data[dd].first; - Arc ce = node_data[cd].first; - - if (de != INVALID) { - Arc dne = arc_lists[de].next; - Arc cne = arc_lists[ce].next; - - arc_lists[de].next = cne; - arc_lists[ce].next = dne; - - arc_lists[dne].prev = ce; - arc_lists[cne].prev = de; - } - - node_data[dd].first = ce; - - } - } - - void storeEmbedding(const Node& node, NodeData& node_data, - OrderMap& order_map, PredMap& pred_map, - ArcLists& arc_lists, FlipMap& flip_map) { - - if (node_data[order_map[node]].first == INVALID) return; - - if (pred_map[node] != INVALID) { - Node source = _graph.source(pred_map[node]); - flip_map[node] = flip_map[node] != flip_map[source]; - } - - Arc first = node_data[order_map[node]].first; - Arc prev = first; - - Arc arc = flip_map[node] ? - arc_lists[prev].prev : arc_lists[prev].next; - - _embedding[prev] = arc; - - while (arc != first) { - Arc next = arc_lists[arc].prev == prev ? - arc_lists[arc].next : arc_lists[arc].prev; - prev = arc; arc = next; - _embedding[prev] = arc; - } - } - - - bool external(const Node& node, int rorder, - ChildLists& child_lists, AncestorMap& ancestor_map, - LowMap& low_map) { - Node child = child_lists[node].first; - - if (child != INVALID) { - if (low_map[child] < rorder) return true; - } - - if (ancestor_map[node] < rorder) return true; - - return false; - } - - bool pertinent(const Node& node, const EmbedArc& embed_arc, - const MergeRoots& merge_roots) { - return !merge_roots[node].empty() || embed_arc[node] != INVALID; - } - - int lowPoint(const Node& node, OrderMap& order_map, ChildLists& child_lists, - AncestorMap& ancestor_map, LowMap& low_map) { - int low_point; - - Node child = child_lists[node].first; - - if (child != INVALID) { - low_point = low_map[child]; - } else { - low_point = order_map[node]; - } - - if (low_point > ancestor_map[node]) { - low_point = ancestor_map[node]; - } - - return low_point; - } - - int findComponentRoot(Node root, Node node, ChildLists& child_lists, - OrderMap& order_map, OrderList& order_list) { - - int order = order_map[root]; - int norder = order_map[node]; - - Node child = child_lists[root].first; - while (child != INVALID) { - int corder = order_map[child]; - if (corder > order && corder < norder) { - order = corder; - } - child = child_lists[child].next; - } - return order + order_list.size(); - } - - Node findPertinent(Node node, OrderMap& order_map, NodeData& node_data, - EmbedArc& embed_arc, MergeRoots& merge_roots) { - Node wnode =_graph.target(node_data[order_map[node]].first); - while (!pertinent(wnode, embed_arc, merge_roots)) { - wnode = _graph.target(node_data[order_map[wnode]].first); - } - return wnode; - } - - - Node findExternal(Node node, int rorder, OrderMap& order_map, - ChildLists& child_lists, AncestorMap& ancestor_map, - LowMap& low_map, NodeData& node_data) { - Node wnode =_graph.target(node_data[order_map[node]].first); - while (!external(wnode, rorder, child_lists, ancestor_map, low_map)) { - wnode = _graph.target(node_data[order_map[wnode]].first); - } - return wnode; - } - - void markCommonPath(Node node, int rorder, Node& wnode, Node& znode, - OrderList& order_list, OrderMap& order_map, - NodeData& node_data, ArcLists& arc_lists, - EmbedArc& embed_arc, MergeRoots& merge_roots, - ChildLists& child_lists, AncestorMap& ancestor_map, - LowMap& low_map) { - - Node cnode = node; - Node pred = INVALID; - - while (true) { - - bool pert = pertinent(cnode, embed_arc, merge_roots); - bool ext = external(cnode, rorder, child_lists, ancestor_map, low_map); - - if (pert && ext) { - if (!merge_roots[cnode].empty()) { - int cn = merge_roots[cnode].back(); - - if (low_map[order_list[cn - order_list.size()]] < rorder) { - Arc arc = node_data[cn].first; - _kuratowski.set(arc, true); - - pred = cnode; - cnode = _graph.target(arc); - - continue; - } - } - wnode = znode = cnode; - return; - - } else if (pert) { - wnode = cnode; - - while (!external(cnode, rorder, child_lists, ancestor_map, low_map)) { - Arc arc = node_data[order_map[cnode]].first; - - if (_graph.target(arc) == pred) { - arc = arc_lists[arc].next; - } - _kuratowski.set(arc, true); - - Node next = _graph.target(arc); - pred = cnode; cnode = next; - } - - znode = cnode; - return; - - } else if (ext) { - znode = cnode; - - while (!pertinent(cnode, embed_arc, merge_roots)) { - Arc arc = node_data[order_map[cnode]].first; - - if (_graph.target(arc) == pred) { - arc = arc_lists[arc].next; - } - _kuratowski.set(arc, true); - - Node next = _graph.target(arc); - pred = cnode; cnode = next; - } - - wnode = cnode; - return; - - } else { - Arc arc = node_data[order_map[cnode]].first; - - if (_graph.target(arc) == pred) { - arc = arc_lists[arc].next; - } - _kuratowski.set(arc, true); - - Node next = _graph.target(arc); - pred = cnode; cnode = next; - } - - } - - } - - void orientComponent(Node root, int rn, OrderMap& order_map, - PredMap& pred_map, NodeData& node_data, - ArcLists& arc_lists, FlipMap& flip_map, - TypeMap& type_map) { - node_data[order_map[root]].first = node_data[rn].first; - type_map[root] = 1; - - std::vector st, qu; - - st.push_back(root); - while (!st.empty()) { - Node node = st.back(); - st.pop_back(); - qu.push_back(node); - - Arc arc = node_data[order_map[node]].first; - - if (type_map[_graph.target(arc)] == 0) { - st.push_back(_graph.target(arc)); - type_map[_graph.target(arc)] = 1; - } - - Arc last = arc, pred = arc; - arc = arc_lists[arc].next; - while (arc != last) { - - if (type_map[_graph.target(arc)] == 0) { - st.push_back(_graph.target(arc)); - type_map[_graph.target(arc)] = 1; - } - - Arc next = arc_lists[arc].next != pred ? - arc_lists[arc].next : arc_lists[arc].prev; - pred = arc; arc = next; - } - - } - - type_map[root] = 2; - flip_map[root] = false; - - for (int i = 1; i < int(qu.size()); ++i) { - - Node node = qu[i]; - - while (type_map[node] != 2) { - st.push_back(node); - type_map[node] = 2; - node = _graph.source(pred_map[node]); - } - - bool flip = flip_map[node]; - - while (!st.empty()) { - node = st.back(); - st.pop_back(); - - flip_map[node] = flip != flip_map[node]; - flip = flip_map[node]; - - if (flip) { - Arc arc = node_data[order_map[node]].first; - std::swap(arc_lists[arc].prev, arc_lists[arc].next); - arc = arc_lists[arc].prev; - std::swap(arc_lists[arc].prev, arc_lists[arc].next); - node_data[order_map[node]].first = arc; - } - } - } - - for (int i = 0; i < int(qu.size()); ++i) { - - Arc arc = node_data[order_map[qu[i]]].first; - Arc last = arc, pred = arc; - - arc = arc_lists[arc].next; - while (arc != last) { - - if (arc_lists[arc].next == pred) { - std::swap(arc_lists[arc].next, arc_lists[arc].prev); - } - pred = arc; arc = arc_lists[arc].next; - } - - } - } - - void setFaceFlags(Node root, Node wnode, Node ynode, Node xnode, - OrderMap& order_map, NodeData& node_data, - TypeMap& type_map) { - Node node = _graph.target(node_data[order_map[root]].first); - - while (node != ynode) { - type_map[node] = HIGHY; - node = _graph.target(node_data[order_map[node]].first); - } - - while (node != wnode) { - type_map[node] = LOWY; - node = _graph.target(node_data[order_map[node]].first); - } - - node = _graph.target(node_data[order_map[wnode]].first); - - while (node != xnode) { - type_map[node] = LOWX; - node = _graph.target(node_data[order_map[node]].first); - } - type_map[node] = LOWX; - - node = _graph.target(node_data[order_map[xnode]].first); - while (node != root) { - type_map[node] = HIGHX; - node = _graph.target(node_data[order_map[node]].first); - } - - type_map[wnode] = PERTINENT; - type_map[root] = ROOT; - } - - void findInternalPath(std::vector& ipath, - Node wnode, Node root, TypeMap& type_map, - OrderMap& order_map, NodeData& node_data, - ArcLists& arc_lists) { - std::vector st; - - Node node = wnode; - - while (node != root) { - Arc arc = arc_lists[node_data[order_map[node]].first].next; - st.push_back(arc); - node = _graph.target(arc); - } - - while (true) { - Arc arc = st.back(); - if (type_map[_graph.target(arc)] == LOWX || - type_map[_graph.target(arc)] == HIGHX) { - break; - } - if (type_map[_graph.target(arc)] == 2) { - type_map[_graph.target(arc)] = 3; - - arc = arc_lists[_graph.oppositeArc(arc)].next; - st.push_back(arc); - } else { - st.pop_back(); - arc = arc_lists[arc].next; - - while (_graph.oppositeArc(arc) == st.back()) { - arc = st.back(); - st.pop_back(); - arc = arc_lists[arc].next; - } - st.push_back(arc); - } - } - - for (int i = 0; i < int(st.size()); ++i) { - if (type_map[_graph.target(st[i])] != LOWY && - type_map[_graph.target(st[i])] != HIGHY) { - for (; i < int(st.size()); ++i) { - ipath.push_back(st[i]); - } - } - } - } - - void setInternalFlags(std::vector& ipath, TypeMap& type_map) { - for (int i = 1; i < int(ipath.size()); ++i) { - type_map[_graph.source(ipath[i])] = INTERNAL; - } - } - - void findPilePath(std::vector& ppath, - Node root, TypeMap& type_map, OrderMap& order_map, - NodeData& node_data, ArcLists& arc_lists) { - std::vector st; - - st.push_back(_graph.oppositeArc(node_data[order_map[root]].first)); - st.push_back(node_data[order_map[root]].first); - - while (st.size() > 1) { - Arc arc = st.back(); - if (type_map[_graph.target(arc)] == INTERNAL) { - break; - } - if (type_map[_graph.target(arc)] == 3) { - type_map[_graph.target(arc)] = 4; - - arc = arc_lists[_graph.oppositeArc(arc)].next; - st.push_back(arc); - } else { - st.pop_back(); - arc = arc_lists[arc].next; - - while (!st.empty() && _graph.oppositeArc(arc) == st.back()) { - arc = st.back(); - st.pop_back(); - arc = arc_lists[arc].next; - } - st.push_back(arc); - } - } - - for (int i = 1; i < int(st.size()); ++i) { - ppath.push_back(st[i]); - } - } - - - int markExternalPath(Node node, OrderMap& order_map, - ChildLists& child_lists, PredMap& pred_map, - AncestorMap& ancestor_map, LowMap& low_map) { - int lp = lowPoint(node, order_map, child_lists, - ancestor_map, low_map); - - if (ancestor_map[node] != lp) { - node = child_lists[node].first; - _kuratowski[pred_map[node]] = true; - - while (ancestor_map[node] != lp) { - for (OutArcIt e(_graph, node); e != INVALID; ++e) { - Node tnode = _graph.target(e); - if (order_map[tnode] > order_map[node] && low_map[tnode] == lp) { - node = tnode; - _kuratowski[e] = true; - break; - } - } - } - } - - for (OutArcIt e(_graph, node); e != INVALID; ++e) { - if (order_map[_graph.target(e)] == lp) { - _kuratowski[e] = true; - break; - } - } - - return lp; - } - - void markPertinentPath(Node node, OrderMap& order_map, - NodeData& node_data, ArcLists& arc_lists, - EmbedArc& embed_arc, MergeRoots& merge_roots) { - while (embed_arc[node] == INVALID) { - int n = merge_roots[node].front(); - Arc arc = node_data[n].first; - - _kuratowski.set(arc, true); - - Node pred = node; - node = _graph.target(arc); - while (!pertinent(node, embed_arc, merge_roots)) { - arc = node_data[order_map[node]].first; - if (_graph.target(arc) == pred) { - arc = arc_lists[arc].next; - } - _kuratowski.set(arc, true); - pred = node; - node = _graph.target(arc); - } - } - _kuratowski.set(embed_arc[node], true); - } - - void markPredPath(Node node, Node snode, PredMap& pred_map) { - while (node != snode) { - _kuratowski.set(pred_map[node], true); - node = _graph.source(pred_map[node]); - } - } - - void markFacePath(Node ynode, Node xnode, - OrderMap& order_map, NodeData& node_data) { - Arc arc = node_data[order_map[ynode]].first; - Node node = _graph.target(arc); - _kuratowski.set(arc, true); - - while (node != xnode) { - arc = node_data[order_map[node]].first; - _kuratowski.set(arc, true); - node = _graph.target(arc); - } - } - - void markInternalPath(std::vector& path) { - for (int i = 0; i < int(path.size()); ++i) { - _kuratowski.set(path[i], true); - } - } - - void markPilePath(std::vector& path) { - for (int i = 0; i < int(path.size()); ++i) { - _kuratowski.set(path[i], true); - } - } - - void isolateKuratowski(Arc arc, NodeData& node_data, - ArcLists& arc_lists, FlipMap& flip_map, - OrderMap& order_map, OrderList& order_list, - PredMap& pred_map, ChildLists& child_lists, - AncestorMap& ancestor_map, LowMap& low_map, - EmbedArc& embed_arc, MergeRoots& merge_roots) { - - Node root = _graph.source(arc); - Node enode = _graph.target(arc); - - int rorder = order_map[root]; - - TypeMap type_map(_graph, 0); - - int rn = findComponentRoot(root, enode, child_lists, - order_map, order_list); - - Node xnode = order_list[node_data[rn].next]; - Node ynode = order_list[node_data[rn].prev]; - - // Minor-A - { - while (!merge_roots[xnode].empty() || !merge_roots[ynode].empty()) { - - if (!merge_roots[xnode].empty()) { - root = xnode; - rn = merge_roots[xnode].front(); - } else { - root = ynode; - rn = merge_roots[ynode].front(); - } - - xnode = order_list[node_data[rn].next]; - ynode = order_list[node_data[rn].prev]; - } - - if (root != _graph.source(arc)) { - orientComponent(root, rn, order_map, pred_map, - node_data, arc_lists, flip_map, type_map); - markFacePath(root, root, order_map, node_data); - int xlp = markExternalPath(xnode, order_map, child_lists, - pred_map, ancestor_map, low_map); - int ylp = markExternalPath(ynode, order_map, child_lists, - pred_map, ancestor_map, low_map); - markPredPath(root, order_list[xlp < ylp ? xlp : ylp], pred_map); - Node lwnode = findPertinent(ynode, order_map, node_data, - embed_arc, merge_roots); - - markPertinentPath(lwnode, order_map, node_data, arc_lists, - embed_arc, merge_roots); - - return; - } - } - - orientComponent(root, rn, order_map, pred_map, - node_data, arc_lists, flip_map, type_map); - - Node wnode = findPertinent(ynode, order_map, node_data, - embed_arc, merge_roots); - setFaceFlags(root, wnode, ynode, xnode, order_map, node_data, type_map); - - - //Minor-B - if (!merge_roots[wnode].empty()) { - int cn = merge_roots[wnode].back(); - Node rep = order_list[cn - order_list.size()]; - if (low_map[rep] < rorder) { - markFacePath(root, root, order_map, node_data); - int xlp = markExternalPath(xnode, order_map, child_lists, - pred_map, ancestor_map, low_map); - int ylp = markExternalPath(ynode, order_map, child_lists, - pred_map, ancestor_map, low_map); - - Node lwnode, lznode; - markCommonPath(wnode, rorder, lwnode, lznode, order_list, - order_map, node_data, arc_lists, embed_arc, - merge_roots, child_lists, ancestor_map, low_map); - - markPertinentPath(lwnode, order_map, node_data, arc_lists, - embed_arc, merge_roots); - int zlp = markExternalPath(lznode, order_map, child_lists, - pred_map, ancestor_map, low_map); - - int minlp = xlp < ylp ? xlp : ylp; - if (zlp < minlp) minlp = zlp; - - int maxlp = xlp > ylp ? xlp : ylp; - if (zlp > maxlp) maxlp = zlp; - - markPredPath(order_list[maxlp], order_list[minlp], pred_map); - - return; - } - } - - Node pxnode, pynode; - std::vector ipath; - findInternalPath(ipath, wnode, root, type_map, order_map, - node_data, arc_lists); - setInternalFlags(ipath, type_map); - pynode = _graph.source(ipath.front()); - pxnode = _graph.target(ipath.back()); - - wnode = findPertinent(pynode, order_map, node_data, - embed_arc, merge_roots); - - // Minor-C - { - if (type_map[_graph.source(ipath.front())] == HIGHY) { - if (type_map[_graph.target(ipath.back())] == HIGHX) { - markFacePath(xnode, pxnode, order_map, node_data); - } - markFacePath(root, xnode, order_map, node_data); - markPertinentPath(wnode, order_map, node_data, arc_lists, - embed_arc, merge_roots); - markInternalPath(ipath); - int xlp = markExternalPath(xnode, order_map, child_lists, - pred_map, ancestor_map, low_map); - int ylp = markExternalPath(ynode, order_map, child_lists, - pred_map, ancestor_map, low_map); - markPredPath(root, order_list[xlp < ylp ? xlp : ylp], pred_map); - return; - } - - if (type_map[_graph.target(ipath.back())] == HIGHX) { - markFacePath(ynode, root, order_map, node_data); - markPertinentPath(wnode, order_map, node_data, arc_lists, - embed_arc, merge_roots); - markInternalPath(ipath); - int xlp = markExternalPath(xnode, order_map, child_lists, - pred_map, ancestor_map, low_map); - int ylp = markExternalPath(ynode, order_map, child_lists, - pred_map, ancestor_map, low_map); - markPredPath(root, order_list[xlp < ylp ? xlp : ylp], pred_map); - return; - } - } - - std::vector ppath; - findPilePath(ppath, root, type_map, order_map, node_data, arc_lists); - - // Minor-D - if (!ppath.empty()) { - markFacePath(ynode, xnode, order_map, node_data); - markPertinentPath(wnode, order_map, node_data, arc_lists, - embed_arc, merge_roots); - markPilePath(ppath); - markInternalPath(ipath); - int xlp = markExternalPath(xnode, order_map, child_lists, - pred_map, ancestor_map, low_map); - int ylp = markExternalPath(ynode, order_map, child_lists, - pred_map, ancestor_map, low_map); - markPredPath(root, order_list[xlp < ylp ? xlp : ylp], pred_map); - return; - } - - // Minor-E* - { - - if (!external(wnode, rorder, child_lists, ancestor_map, low_map)) { - Node znode = findExternal(pynode, rorder, order_map, - child_lists, ancestor_map, - low_map, node_data); - - if (type_map[znode] == LOWY) { - markFacePath(root, xnode, order_map, node_data); - markPertinentPath(wnode, order_map, node_data, arc_lists, - embed_arc, merge_roots); - markInternalPath(ipath); - int xlp = markExternalPath(xnode, order_map, child_lists, - pred_map, ancestor_map, low_map); - int zlp = markExternalPath(znode, order_map, child_lists, - pred_map, ancestor_map, low_map); - markPredPath(root, order_list[xlp < zlp ? xlp : zlp], pred_map); - } else { - markFacePath(ynode, root, order_map, node_data); - markPertinentPath(wnode, order_map, node_data, arc_lists, - embed_arc, merge_roots); - markInternalPath(ipath); - int ylp = markExternalPath(ynode, order_map, child_lists, - pred_map, ancestor_map, low_map); - int zlp = markExternalPath(znode, order_map, child_lists, - pred_map, ancestor_map, low_map); - markPredPath(root, order_list[ylp < zlp ? ylp : zlp], pred_map); - } - return; - } - - int xlp = markExternalPath(xnode, order_map, child_lists, - pred_map, ancestor_map, low_map); - int ylp = markExternalPath(ynode, order_map, child_lists, - pred_map, ancestor_map, low_map); - int wlp = markExternalPath(wnode, order_map, child_lists, - pred_map, ancestor_map, low_map); - - if (wlp > xlp && wlp > ylp) { - markFacePath(root, root, order_map, node_data); - markPredPath(root, order_list[xlp < ylp ? xlp : ylp], pred_map); - return; - } - - markInternalPath(ipath); - markPertinentPath(wnode, order_map, node_data, arc_lists, - embed_arc, merge_roots); - - if (xlp > ylp && xlp > wlp) { - markFacePath(root, pynode, order_map, node_data); - markFacePath(wnode, xnode, order_map, node_data); - markPredPath(root, order_list[ylp < wlp ? ylp : wlp], pred_map); - return; - } - - if (ylp > xlp && ylp > wlp) { - markFacePath(pxnode, root, order_map, node_data); - markFacePath(ynode, wnode, order_map, node_data); - markPredPath(root, order_list[xlp < wlp ? xlp : wlp], pred_map); - return; - } - - if (pynode != ynode) { - markFacePath(pxnode, wnode, order_map, node_data); - - int minlp = xlp < ylp ? xlp : ylp; - if (wlp < minlp) minlp = wlp; - - int maxlp = xlp > ylp ? xlp : ylp; - if (wlp > maxlp) maxlp = wlp; - - markPredPath(order_list[maxlp], order_list[minlp], pred_map); - return; - } - - if (pxnode != xnode) { - markFacePath(wnode, pynode, order_map, node_data); - - int minlp = xlp < ylp ? xlp : ylp; - if (wlp < minlp) minlp = wlp; - - int maxlp = xlp > ylp ? xlp : ylp; - if (wlp > maxlp) maxlp = wlp; - - markPredPath(order_list[maxlp], order_list[minlp], pred_map); - return; - } - - markFacePath(root, root, order_map, node_data); - int minlp = xlp < ylp ? xlp : ylp; - if (wlp < minlp) minlp = wlp; - markPredPath(root, order_list[minlp], pred_map); - return; - } - - } - - }; - - namespace _planarity_bits { - - template - void makeConnected(Graph& graph, EmbeddingMap& embedding) { - DfsVisitor null_visitor; - DfsVisit > dfs(graph, null_visitor); - dfs.init(); - - typename Graph::Node u = INVALID; - for (typename Graph::NodeIt n(graph); n != INVALID; ++n) { - if (!dfs.reached(n)) { - dfs.addSource(n); - dfs.start(); - if (u == INVALID) { - u = n; - } else { - typename Graph::Node v = n; - - typename Graph::Arc ue = typename Graph::OutArcIt(graph, u); - typename Graph::Arc ve = typename Graph::OutArcIt(graph, v); - - typename Graph::Arc e = graph.direct(graph.addEdge(u, v), true); - - if (ue != INVALID) { - embedding[e] = embedding[ue]; - embedding[ue] = e; - } else { - embedding[e] = e; - } - - if (ve != INVALID) { - embedding[graph.oppositeArc(e)] = embedding[ve]; - embedding[ve] = graph.oppositeArc(e); - } else { - embedding[graph.oppositeArc(e)] = graph.oppositeArc(e); - } - } - } - } - } - - template - void makeBiNodeConnected(Graph& graph, EmbeddingMap& embedding) { - typename Graph::template ArcMap processed(graph); - - std::vector arcs; - for (typename Graph::ArcIt e(graph); e != INVALID; ++e) { - arcs.push_back(e); - } - - IterableBoolMap visited(graph, false); - - for (int i = 0; i < int(arcs.size()); ++i) { - typename Graph::Arc pp = arcs[i]; - if (processed[pp]) continue; - - typename Graph::Arc e = embedding[graph.oppositeArc(pp)]; - processed[e] = true; - visited.set(graph.source(e), true); - - typename Graph::Arc p = e, l = e; - e = embedding[graph.oppositeArc(e)]; - - while (e != l) { - processed[e] = true; - - if (visited[graph.source(e)]) { - - typename Graph::Arc n = - graph.direct(graph.addEdge(graph.source(p), - graph.target(e)), true); - embedding[n] = p; - embedding[graph.oppositeArc(pp)] = n; - - embedding[graph.oppositeArc(n)] = - embedding[graph.oppositeArc(e)]; - embedding[graph.oppositeArc(e)] = - graph.oppositeArc(n); - - p = n; - e = embedding[graph.oppositeArc(n)]; - } else { - visited.set(graph.source(e), true); - pp = p; - p = e; - e = embedding[graph.oppositeArc(e)]; - } - } - visited.setAll(false); - } - } - - - template - void makeMaxPlanar(Graph& graph, EmbeddingMap& embedding) { - - typename Graph::template NodeMap degree(graph); - - for (typename Graph::NodeIt n(graph); n != INVALID; ++n) { - degree[n] = countIncEdges(graph, n); - } - - typename Graph::template ArcMap processed(graph); - IterableBoolMap visited(graph, false); - - std::vector arcs; - for (typename Graph::ArcIt e(graph); e != INVALID; ++e) { - arcs.push_back(e); - } - - for (int i = 0; i < int(arcs.size()); ++i) { - typename Graph::Arc e = arcs[i]; - - if (processed[e]) continue; - processed[e] = true; - - typename Graph::Arc mine = e; - int mind = degree[graph.source(e)]; - - int face_size = 1; - - typename Graph::Arc l = e; - e = embedding[graph.oppositeArc(e)]; - while (l != e) { - processed[e] = true; - - ++face_size; - - if (degree[graph.source(e)] < mind) { - mine = e; - mind = degree[graph.source(e)]; - } - - e = embedding[graph.oppositeArc(e)]; - } - - if (face_size < 4) { - continue; - } - - typename Graph::Node s = graph.source(mine); - for (typename Graph::OutArcIt e(graph, s); e != INVALID; ++e) { - visited.set(graph.target(e), true); - } - - typename Graph::Arc oppe = INVALID; - - e = embedding[graph.oppositeArc(mine)]; - e = embedding[graph.oppositeArc(e)]; - while (graph.target(e) != s) { - if (visited[graph.source(e)]) { - oppe = e; - break; - } - e = embedding[graph.oppositeArc(e)]; - } - visited.setAll(false); - - if (oppe == INVALID) { - - e = embedding[graph.oppositeArc(mine)]; - typename Graph::Arc pn = mine, p = e; - - e = embedding[graph.oppositeArc(e)]; - while (graph.target(e) != s) { - typename Graph::Arc n = - graph.direct(graph.addEdge(s, graph.source(e)), true); - - embedding[n] = pn; - embedding[graph.oppositeArc(n)] = e; - embedding[graph.oppositeArc(p)] = graph.oppositeArc(n); - - pn = n; - - p = e; - e = embedding[graph.oppositeArc(e)]; - } - - embedding[graph.oppositeArc(e)] = pn; - - } else { - - mine = embedding[graph.oppositeArc(mine)]; - s = graph.source(mine); - oppe = embedding[graph.oppositeArc(oppe)]; - typename Graph::Node t = graph.source(oppe); - - typename Graph::Arc ce = graph.direct(graph.addEdge(s, t), true); - embedding[ce] = mine; - embedding[graph.oppositeArc(ce)] = oppe; - - typename Graph::Arc pn = ce, p = oppe; - e = embedding[graph.oppositeArc(oppe)]; - while (graph.target(e) != s) { - typename Graph::Arc n = - graph.direct(graph.addEdge(s, graph.source(e)), true); - - embedding[n] = pn; - embedding[graph.oppositeArc(n)] = e; - embedding[graph.oppositeArc(p)] = graph.oppositeArc(n); - - pn = n; - - p = e; - e = embedding[graph.oppositeArc(e)]; - - } - embedding[graph.oppositeArc(e)] = pn; - - pn = graph.oppositeArc(ce), p = mine; - e = embedding[graph.oppositeArc(mine)]; - while (graph.target(e) != t) { - typename Graph::Arc n = - graph.direct(graph.addEdge(t, graph.source(e)), true); - - embedding[n] = pn; - embedding[graph.oppositeArc(n)] = e; - embedding[graph.oppositeArc(p)] = graph.oppositeArc(n); - - pn = n; - - p = e; - e = embedding[graph.oppositeArc(e)]; - - } - embedding[graph.oppositeArc(e)] = pn; - } - } - } - - } - - /// \ingroup planar - /// - /// \brief Schnyder's planar drawing algorithm - /// - /// The planar drawing algorithm calculates positions for the nodes - /// in the plane. These coordinates satisfy that if the edges are - /// represented with straight lines, then they will not intersect - /// each other. - /// - /// Scnyder's algorithm embeds the graph on an \c (n-2)x(n-2) size grid, - /// i.e. each node will be located in the \c [0..n-2]x[0..n-2] square. - /// The time complexity of the algorithm is O(n). - /// - /// \see PlanarEmbedding - template - class PlanarDrawing { - public: - - TEMPLATE_GRAPH_TYPEDEFS(Graph); - - /// \brief The point type for storing coordinates - typedef dim2::Point Point; - /// \brief The map type for storing the coordinates of the nodes - typedef typename Graph::template NodeMap PointMap; - - - /// \brief Constructor - /// - /// Constructor - /// \pre The graph must be simple, i.e. it should not - /// contain parallel or loop arcs. - PlanarDrawing(const Graph& graph) - : _graph(graph), _point_map(graph) {} - - private: - - template - void drawing(const AuxGraph& graph, - const AuxEmbeddingMap& next, - PointMap& point_map) { - TEMPLATE_GRAPH_TYPEDEFS(AuxGraph); - - typename AuxGraph::template ArcMap prev(graph); - - for (NodeIt n(graph); n != INVALID; ++n) { - Arc e = OutArcIt(graph, n); - - Arc p = e, l = e; - - e = next[e]; - while (e != l) { - prev[e] = p; - p = e; - e = next[e]; - } - prev[e] = p; - } - - Node anode, bnode, cnode; - - { - Arc e = ArcIt(graph); - anode = graph.source(e); - bnode = graph.target(e); - cnode = graph.target(next[graph.oppositeArc(e)]); - } - - IterableBoolMap proper(graph, false); - typename AuxGraph::template NodeMap conn(graph, -1); - - conn[anode] = conn[bnode] = -2; - { - for (OutArcIt e(graph, anode); e != INVALID; ++e) { - Node m = graph.target(e); - if (conn[m] == -1) { - conn[m] = 1; - } - } - conn[cnode] = 2; - - for (OutArcIt e(graph, bnode); e != INVALID; ++e) { - Node m = graph.target(e); - if (conn[m] == -1) { - conn[m] = 1; - } else if (conn[m] != -2) { - conn[m] += 1; - Arc pe = graph.oppositeArc(e); - if (conn[graph.target(next[pe])] == -2) { - conn[m] -= 1; - } - if (conn[graph.target(prev[pe])] == -2) { - conn[m] -= 1; - } - - proper.set(m, conn[m] == 1); - } - } - } - - - typename AuxGraph::template ArcMap angle(graph, -1); - - while (proper.trueNum() != 0) { - Node n = typename IterableBoolMap::TrueIt(proper); - proper.set(n, false); - conn[n] = -2; - - for (OutArcIt e(graph, n); e != INVALID; ++e) { - Node m = graph.target(e); - if (conn[m] == -1) { - conn[m] = 1; - } else if (conn[m] != -2) { - conn[m] += 1; - Arc pe = graph.oppositeArc(e); - if (conn[graph.target(next[pe])] == -2) { - conn[m] -= 1; - } - if (conn[graph.target(prev[pe])] == -2) { - conn[m] -= 1; - } - - proper.set(m, conn[m] == 1); - } - } - - { - Arc e = OutArcIt(graph, n); - Arc p = e, l = e; - - e = next[e]; - while (e != l) { - - if (conn[graph.target(e)] == -2 && conn[graph.target(p)] == -2) { - Arc f = e; - angle[f] = 0; - f = next[graph.oppositeArc(f)]; - angle[f] = 1; - f = next[graph.oppositeArc(f)]; - angle[f] = 2; - } - - p = e; - e = next[e]; - } - - if (conn[graph.target(e)] == -2 && conn[graph.target(p)] == -2) { - Arc f = e; - angle[f] = 0; - f = next[graph.oppositeArc(f)]; - angle[f] = 1; - f = next[graph.oppositeArc(f)]; - angle[f] = 2; - } - } - } - - typename AuxGraph::template NodeMap apred(graph, INVALID); - typename AuxGraph::template NodeMap bpred(graph, INVALID); - typename AuxGraph::template NodeMap cpred(graph, INVALID); - - typename AuxGraph::template NodeMap apredid(graph, -1); - typename AuxGraph::template NodeMap bpredid(graph, -1); - typename AuxGraph::template NodeMap cpredid(graph, -1); - - for (ArcIt e(graph); e != INVALID; ++e) { - if (angle[e] == angle[next[e]]) { - switch (angle[e]) { - case 2: - apred[graph.target(e)] = graph.source(e); - apredid[graph.target(e)] = graph.id(graph.source(e)); - break; - case 1: - bpred[graph.target(e)] = graph.source(e); - bpredid[graph.target(e)] = graph.id(graph.source(e)); - break; - case 0: - cpred[graph.target(e)] = graph.source(e); - cpredid[graph.target(e)] = graph.id(graph.source(e)); - break; - } - } - } - - cpred[anode] = INVALID; - cpred[bnode] = INVALID; - - std::vector aorder, border, corder; - - { - typename AuxGraph::template NodeMap processed(graph, false); - std::vector st; - for (NodeIt n(graph); n != INVALID; ++n) { - if (!processed[n] && n != bnode && n != cnode) { - st.push_back(n); - processed[n] = true; - Node m = apred[n]; - while (m != INVALID && !processed[m]) { - st.push_back(m); - processed[m] = true; - m = apred[m]; - } - while (!st.empty()) { - aorder.push_back(st.back()); - st.pop_back(); - } - } - } - } - - { - typename AuxGraph::template NodeMap processed(graph, false); - std::vector st; - for (NodeIt n(graph); n != INVALID; ++n) { - if (!processed[n] && n != cnode && n != anode) { - st.push_back(n); - processed[n] = true; - Node m = bpred[n]; - while (m != INVALID && !processed[m]) { - st.push_back(m); - processed[m] = true; - m = bpred[m]; - } - while (!st.empty()) { - border.push_back(st.back()); - st.pop_back(); - } - } - } - } - - { - typename AuxGraph::template NodeMap processed(graph, false); - std::vector st; - for (NodeIt n(graph); n != INVALID; ++n) { - if (!processed[n] && n != anode && n != bnode) { - st.push_back(n); - processed[n] = true; - Node m = cpred[n]; - while (m != INVALID && !processed[m]) { - st.push_back(m); - processed[m] = true; - m = cpred[m]; - } - while (!st.empty()) { - corder.push_back(st.back()); - st.pop_back(); - } - } - } - } - - typename AuxGraph::template NodeMap atree(graph, 0); - for (int i = aorder.size() - 1; i >= 0; --i) { - Node n = aorder[i]; - atree[n] = 1; - for (OutArcIt e(graph, n); e != INVALID; ++e) { - if (apred[graph.target(e)] == n) { - atree[n] += atree[graph.target(e)]; - } - } - } - - typename AuxGraph::template NodeMap btree(graph, 0); - for (int i = border.size() - 1; i >= 0; --i) { - Node n = border[i]; - btree[n] = 1; - for (OutArcIt e(graph, n); e != INVALID; ++e) { - if (bpred[graph.target(e)] == n) { - btree[n] += btree[graph.target(e)]; - } - } - } - - typename AuxGraph::template NodeMap apath(graph, 0); - apath[bnode] = apath[cnode] = 1; - typename AuxGraph::template NodeMap apath_btree(graph, 0); - apath_btree[bnode] = btree[bnode]; - for (int i = 1; i < int(aorder.size()); ++i) { - Node n = aorder[i]; - apath[n] = apath[apred[n]] + 1; - apath_btree[n] = btree[n] + apath_btree[apred[n]]; - } - - typename AuxGraph::template NodeMap bpath_atree(graph, 0); - bpath_atree[anode] = atree[anode]; - for (int i = 1; i < int(border.size()); ++i) { - Node n = border[i]; - bpath_atree[n] = atree[n] + bpath_atree[bpred[n]]; - } - - typename AuxGraph::template NodeMap cpath(graph, 0); - cpath[anode] = cpath[bnode] = 1; - typename AuxGraph::template NodeMap cpath_atree(graph, 0); - cpath_atree[anode] = atree[anode]; - typename AuxGraph::template NodeMap cpath_btree(graph, 0); - cpath_btree[bnode] = btree[bnode]; - for (int i = 1; i < int(corder.size()); ++i) { - Node n = corder[i]; - cpath[n] = cpath[cpred[n]] + 1; - cpath_atree[n] = atree[n] + cpath_atree[cpred[n]]; - cpath_btree[n] = btree[n] + cpath_btree[cpred[n]]; - } - - typename AuxGraph::template NodeMap third(graph); - for (NodeIt n(graph); n != INVALID; ++n) { - point_map[n].x = - bpath_atree[n] + cpath_atree[n] - atree[n] - cpath[n] + 1; - point_map[n].y = - cpath_btree[n] + apath_btree[n] - btree[n] - apath[n] + 1; - } - - } - - public: - - /// \brief Calculate the node positions - /// - /// This function calculates the node positions on the plane. - /// \return \c true if the graph is planar. - bool run() { - PlanarEmbedding pe(_graph); - if (!pe.run()) return false; - - run(pe); - return true; - } - - /// \brief Calculate the node positions according to a - /// combinatorical embedding - /// - /// This function calculates the node positions on the plane. - /// The given \c embedding map should contain a valid combinatorical - /// embedding, i.e. a valid cyclic order of the arcs. - /// It can be computed using PlanarEmbedding. - template - void run(const EmbeddingMap& embedding) { - typedef SmartEdgeSet AuxGraph; - - if (3 * countNodes(_graph) - 6 == countEdges(_graph)) { - drawing(_graph, embedding, _point_map); - return; - } - - AuxGraph aux_graph(_graph); - typename AuxGraph::template ArcMap - aux_embedding(aux_graph); - - { - - typename Graph::template EdgeMap - ref(_graph); - - for (EdgeIt e(_graph); e != INVALID; ++e) { - ref[e] = aux_graph.addEdge(_graph.u(e), _graph.v(e)); - } - - for (EdgeIt e(_graph); e != INVALID; ++e) { - Arc ee = embedding[_graph.direct(e, true)]; - aux_embedding[aux_graph.direct(ref[e], true)] = - aux_graph.direct(ref[ee], _graph.direction(ee)); - ee = embedding[_graph.direct(e, false)]; - aux_embedding[aux_graph.direct(ref[e], false)] = - aux_graph.direct(ref[ee], _graph.direction(ee)); - } - } - _planarity_bits::makeConnected(aux_graph, aux_embedding); - _planarity_bits::makeBiNodeConnected(aux_graph, aux_embedding); - _planarity_bits::makeMaxPlanar(aux_graph, aux_embedding); - drawing(aux_graph, aux_embedding, _point_map); - } - - /// \brief The coordinate of the given node - /// - /// This function returns the coordinate of the given node. - Point operator[](const Node& node) const { - return _point_map[node]; - } - - /// \brief Return the grid embedding in a node map - /// - /// This function returns the grid embedding in a node map of - /// \c dim2::Point coordinates. - const PointMap& coords() const { - return _point_map; - } - - private: - - const Graph& _graph; - PointMap _point_map; - - }; - - namespace _planarity_bits { - - template - class KempeFilter { - public: - typedef typename ColorMap::Key Key; - typedef bool Value; - - KempeFilter(const ColorMap& color_map, - const typename ColorMap::Value& first, - const typename ColorMap::Value& second) - : _color_map(color_map), _first(first), _second(second) {} - - Value operator[](const Key& key) const { - return _color_map[key] == _first || _color_map[key] == _second; - } - - private: - const ColorMap& _color_map; - typename ColorMap::Value _first, _second; - }; - } - - /// \ingroup planar - /// - /// \brief Coloring planar graphs - /// - /// The graph coloring problem is the coloring of the graph nodes - /// so that there are no adjacent nodes with the same color. The - /// planar graphs can always be colored with four colors, which is - /// proved by Appel and Haken. Their proofs provide a quadratic - /// time algorithm for four coloring, but it could not be used to - /// implement an efficient algorithm. The five and six coloring can be - /// made in linear time, but in this class, the five coloring has - /// quadratic worst case time complexity. The two coloring (if - /// possible) is solvable with a graph search algorithm and it is - /// implemented in \ref bipartitePartitions() function in LEMON. To - /// decide whether a planar graph is three colorable is NP-complete. - /// - /// This class contains member functions for calculate colorings - /// with five and six colors. The six coloring algorithm is a simple - /// greedy coloring on the backward minimum outgoing order of nodes. - /// This order can be computed by selecting the node with least - /// outgoing arcs to unprocessed nodes in each phase. This order - /// guarantees that when a node is chosen for coloring it has at - /// most five already colored adjacents. The five coloring algorithm - /// use the same method, but if the greedy approach fails to color - /// with five colors, i.e. the node has five already different - /// colored neighbours, it swaps the colors in one of the connected - /// two colored sets with the Kempe recoloring method. - template - class PlanarColoring { - public: - - TEMPLATE_GRAPH_TYPEDEFS(Graph); - - /// \brief The map type for storing color indices - typedef typename Graph::template NodeMap IndexMap; - /// \brief The map type for storing colors - /// - /// The map type for storing colors. - /// \see Palette, Color - typedef ComposeMap ColorMap; - - /// \brief Constructor - /// - /// Constructor. - /// \pre The graph must be simple, i.e. it should not - /// contain parallel or loop arcs. - PlanarColoring(const Graph& graph) - : _graph(graph), _color_map(graph), _palette(0) { - _palette.add(Color(1,0,0)); - _palette.add(Color(0,1,0)); - _palette.add(Color(0,0,1)); - _palette.add(Color(1,1,0)); - _palette.add(Color(1,0,1)); - _palette.add(Color(0,1,1)); - } - - /// \brief Return the node map of color indices - /// - /// This function returns the node map of color indices. The values are - /// in the range \c [0..4] or \c [0..5] according to the coloring method. - IndexMap colorIndexMap() const { - return _color_map; - } - - /// \brief Return the node map of colors - /// - /// This function returns the node map of colors. The values are among - /// five or six distinct \ref lemon::Color "colors". - ColorMap colorMap() const { - return composeMap(_palette, _color_map); - } - - /// \brief Return the color index of the node - /// - /// This function returns the color index of the given node. The value is - /// in the range \c [0..4] or \c [0..5] according to the coloring method. - int colorIndex(const Node& node) const { - return _color_map[node]; - } - - /// \brief Return the color of the node - /// - /// This function returns the color of the given node. The value is among - /// five or six distinct \ref lemon::Color "colors". - Color color(const Node& node) const { - return _palette[_color_map[node]]; - } - - - /// \brief Calculate a coloring with at most six colors - /// - /// This function calculates a coloring with at most six colors. The time - /// complexity of this variant is linear in the size of the graph. - /// \return \c true if the algorithm could color the graph with six colors. - /// If the algorithm fails, then the graph is not planar. - /// \note This function can return \c true if the graph is not - /// planar, but it can be colored with at most six colors. - bool runSixColoring() { - - typename Graph::template NodeMap heap_index(_graph, -1); - BucketHeap > heap(heap_index); - - for (NodeIt n(_graph); n != INVALID; ++n) { - _color_map[n] = -2; - heap.push(n, countOutArcs(_graph, n)); - } - - std::vector order; - - while (!heap.empty()) { - Node n = heap.top(); - heap.pop(); - _color_map[n] = -1; - order.push_back(n); - for (OutArcIt e(_graph, n); e != INVALID; ++e) { - Node t = _graph.runningNode(e); - if (_color_map[t] == -2) { - heap.decrease(t, heap[t] - 1); - } - } - } - - for (int i = order.size() - 1; i >= 0; --i) { - std::vector forbidden(6, false); - for (OutArcIt e(_graph, order[i]); e != INVALID; ++e) { - Node t = _graph.runningNode(e); - if (_color_map[t] != -1) { - forbidden[_color_map[t]] = true; - } - } - for (int k = 0; k < 6; ++k) { - if (!forbidden[k]) { - _color_map[order[i]] = k; - break; - } - } - if (_color_map[order[i]] == -1) { - return false; - } - } - return true; - } - - private: - - bool recolor(const Node& u, const Node& v) { - int ucolor = _color_map[u]; - int vcolor = _color_map[v]; - typedef _planarity_bits::KempeFilter KempeFilter; - KempeFilter filter(_color_map, ucolor, vcolor); - - typedef FilterNodes KempeGraph; - KempeGraph kempe_graph(_graph, filter); - - std::vector comp; - Bfs bfs(kempe_graph); - bfs.init(); - bfs.addSource(u); - while (!bfs.emptyQueue()) { - Node n = bfs.nextNode(); - if (n == v) return false; - comp.push_back(n); - bfs.processNextNode(); - } - - int scolor = ucolor + vcolor; - for (int i = 0; i < static_cast(comp.size()); ++i) { - _color_map[comp[i]] = scolor - _color_map[comp[i]]; - } - - return true; - } - - template - void kempeRecoloring(const Node& node, const EmbeddingMap& embedding) { - std::vector nodes; - nodes.reserve(4); - - for (Arc e = OutArcIt(_graph, node); e != INVALID; e = embedding[e]) { - Node t = _graph.target(e); - if (_color_map[t] != -1) { - nodes.push_back(t); - if (nodes.size() == 4) break; - } - } - - int color = _color_map[nodes[0]]; - if (recolor(nodes[0], nodes[2])) { - _color_map[node] = color; - } else { - color = _color_map[nodes[1]]; - recolor(nodes[1], nodes[3]); - _color_map[node] = color; - } - } - - public: - - /// \brief Calculate a coloring with at most five colors - /// - /// This function calculates a coloring with at most five - /// colors. The worst case time complexity of this variant is - /// quadratic in the size of the graph. - /// \param embedding This map should contain a valid combinatorical - /// embedding, i.e. a valid cyclic order of the arcs. - /// It can be computed using PlanarEmbedding. - template - void runFiveColoring(const EmbeddingMap& embedding) { - - typename Graph::template NodeMap heap_index(_graph, -1); - BucketHeap > heap(heap_index); - - for (NodeIt n(_graph); n != INVALID; ++n) { - _color_map[n] = -2; - heap.push(n, countOutArcs(_graph, n)); - } - - std::vector order; - - while (!heap.empty()) { - Node n = heap.top(); - heap.pop(); - _color_map[n] = -1; - order.push_back(n); - for (OutArcIt e(_graph, n); e != INVALID; ++e) { - Node t = _graph.runningNode(e); - if (_color_map[t] == -2) { - heap.decrease(t, heap[t] - 1); - } - } - } - - for (int i = order.size() - 1; i >= 0; --i) { - std::vector forbidden(5, false); - for (OutArcIt e(_graph, order[i]); e != INVALID; ++e) { - Node t = _graph.runningNode(e); - if (_color_map[t] != -1) { - forbidden[_color_map[t]] = true; - } - } - for (int k = 0; k < 5; ++k) { - if (!forbidden[k]) { - _color_map[order[i]] = k; - break; - } - } - if (_color_map[order[i]] == -1) { - kempeRecoloring(order[i], embedding); - } - } - } - - /// \brief Calculate a coloring with at most five colors - /// - /// This function calculates a coloring with at most five - /// colors. The worst case time complexity of this variant is - /// quadratic in the size of the graph. - /// \return \c true if the graph is planar. - bool runFiveColoring() { - PlanarEmbedding pe(_graph); - if (!pe.run()) return false; - - runFiveColoring(pe.embeddingMap()); - return true; - } - - private: - - const Graph& _graph; - IndexMap _color_map; - Palette _palette; - }; - -} - -#endif Index: lemon/preflow.h =================================================================== --- lemon/preflow.h (revision 966) +++ lemon/preflow.h (revision 923) @@ -3,5 +3,5 @@ * This file is a part of LEMON, a generic C++ optimization library. * - * Copyright (C) 2003-2010 + * Copyright (C) 2003-2009 * Egervary Jeno Kombinatorikus Optimalizalasi Kutatocsoport * (Egervary Research Group on Combinatorial Optimization, EGRES). @@ -53,9 +53,5 @@ /// The type of the map that stores the flow values. /// It must meet the \ref concepts::ReadWriteMap "ReadWriteMap" concept. -#ifdef DOXYGEN - typedef GR::ArcMap FlowMap; -#else typedef typename Digraph::template ArcMap FlowMap; -#endif /// \brief Instantiates a FlowMap. @@ -72,10 +68,7 @@ /// The elevator type used by Preflow algorithm. /// - /// \sa Elevator, LinkedElevator -#ifdef DOXYGEN - typedef lemon::Elevator Elevator; -#else - typedef lemon::Elevator Elevator; -#endif + /// \sa Elevator + /// \sa LinkedElevator + typedef LinkedElevator Elevator; /// \brief Instantiates an Elevator. @@ -103,8 +96,7 @@ /// This class provides an implementation of Goldberg-Tarjan's \e preflow /// \e push-relabel algorithm producing a \ref max_flow - /// "flow of maximum value" in a digraph \ref clrs01algorithms, - /// \ref amo93networkflows, \ref goldberg88newapproach. + /// "flow of maximum value" in a digraph. /// The preflow algorithms are the fastest known maximum - /// flow algorithms. The current implementation uses a mixture of the + /// flow algorithms. The current implementation use a mixture of the /// \e "highest label" and the \e "bound decrease" heuristics. /// The worst case time complexity of the algorithm is \f$O(n^2\sqrt{e})\f$. @@ -114,15 +106,7 @@ /// second phase constructs a feasible maximum flow on each arc. /// - /// \warning This implementation cannot handle infinite or very large - /// capacities (e.g. the maximum value of \c CAP::Value). - /// /// \tparam GR The type of the digraph the algorithm runs on. /// \tparam CAP The type of the capacity map. The default map /// type is \ref concepts::Digraph::ArcMap "GR::ArcMap". - /// \tparam TR The traits class that defines various types used by the - /// algorithm. By default, it is \ref PreflowDefaultTraits - /// "PreflowDefaultTraits". - /// In most cases, this parameter should not be set directly, - /// consider to use the named template parameters instead. #ifdef DOXYGEN template @@ -274,5 +258,5 @@ /// able to automatically created by the algorithm (i.e. the /// digraph and the maximum level should be passed to it). - /// However, an external elevator object could also be passed to the + /// However an external elevator object could also be passed to the /// algorithm with the \ref elevator(Elevator&) "elevator()" function /// before calling \ref run() or \ref init(). @@ -388,8 +372,7 @@ } - /// \brief Sets the tolerance used by the algorithm. - /// - /// Sets the tolerance object used by the algorithm. - /// \return (*this) + /// \brief Sets the tolerance used by algorithm. + /// + /// Sets the tolerance used by algorithm. Preflow& tolerance(const Tolerance& tolerance) { _tolerance = tolerance; @@ -399,6 +382,5 @@ /// \brief Returns a const reference to the tolerance. /// - /// Returns a const reference to the tolerance object used by - /// the algorithm. + /// Returns a const reference to the tolerance. const Tolerance& tolerance() const { return _tolerance; @@ -408,6 +390,6 @@ /// The simplest way to execute the preflow algorithm is to use /// \ref run() or \ref runMinCut().\n - /// If you need better control on the initial solution or the execution, - /// you have to call one of the \ref init() functions first, then + /// If you need more control on the initial solution or the execution, + /// first you have to call one of the \ref init() functions, then /// \ref startFirstPhase() and if you need it \ref startSecondPhase(). Index: mon/quad_heap.h =================================================================== --- lemon/quad_heap.h (revision 855) +++ (revision ) @@ -1,343 +1,0 @@ -/* -*- mode: C++; indent-tabs-mode: nil; -*- - * - * This file is a part of LEMON, a generic C++ optimization library. - * - * Copyright (C) 2003-2009 - * Egervary Jeno Kombinatorikus Optimalizalasi Kutatocsoport - * (Egervary Research Group on Combinatorial Optimization, EGRES). - * - * Permission to use, modify and distribute this software is granted - * provided that this copyright notice appears in all copies. For - * precise terms see the accompanying LICENSE file. - * - * This software is provided "AS IS" with no warranty of any kind, - * express or implied, and with no claim as to its suitability for any - * purpose. - * - */ - -#ifndef LEMON_QUAD_HEAP_H -#define LEMON_QUAD_HEAP_H - -///\ingroup heaps -///\file -///\brief Fourary (quaternary) heap implementation. - -#include -#include -#include - -namespace lemon { - - /// \ingroup heaps - /// - ///\brief Fourary (quaternary) heap data structure. - /// - /// This class implements the \e Fourary (\e quaternary) \e heap - /// data structure. - /// It fully conforms to the \ref concepts::Heap "heap concept". - /// - /// The fourary heap is a specialization of the \ref DHeap "D-ary heap" - /// for D=4. It is similar to the \ref BinHeap "binary heap", - /// but its nodes have at most four children, instead of two. - /// - /// \tparam PR Type of the priorities of the items. - /// \tparam IM A read-writable item map with \c int values, used - /// internally to handle the cross references. - /// \tparam CMP A functor class for comparing the priorities. - /// The default is \c std::less. - /// - ///\sa BinHeap - ///\sa DHeap -#ifdef DOXYGEN - template -#else - template > -#endif - class QuadHeap { - public: - /// Type of the item-int map. - typedef IM ItemIntMap; - /// Type of the priorities. - typedef PR Prio; - /// Type of the items stored in the heap. - typedef typename ItemIntMap::Key Item; - /// Type of the item-priority pairs. - typedef std::pair Pair; - /// Functor type for comparing the priorities. - typedef CMP Compare; - - /// \brief Type to represent the states of the items. - /// - /// Each item has a state associated to it. It can be "in heap", - /// "pre-heap" or "post-heap". The latter two are indifferent from the - /// heap's point of view, but may be useful to the user. - /// - /// The item-int map must be initialized in such way that it assigns - /// \c PRE_HEAP (-1) to any element to be put in the heap. - enum State { - IN_HEAP = 0, ///< = 0. - PRE_HEAP = -1, ///< = -1. - POST_HEAP = -2 ///< = -2. - }; - - private: - std::vector _data; - Compare _comp; - ItemIntMap &_iim; - - public: - /// \brief Constructor. - /// - /// Constructor. - /// \param map A map that assigns \c int values to the items. - /// It is used internally to handle the cross references. - /// The assigned value must be \c PRE_HEAP (-1) for each item. - explicit QuadHeap(ItemIntMap &map) : _iim(map) {} - - /// \brief Constructor. - /// - /// Constructor. - /// \param map A map that assigns \c int values to the items. - /// It is used internally to handle the cross references. - /// The assigned value must be \c PRE_HEAP (-1) for each item. - /// \param comp The function object used for comparing the priorities. - QuadHeap(ItemIntMap &map, const Compare &comp) - : _iim(map), _comp(comp) {} - - /// \brief The number of items stored in the heap. - /// - /// This function returns the number of items stored in the heap. - int size() const { return _data.size(); } - - /// \brief Check if the heap is empty. - /// - /// This function returns \c true if the heap is empty. - bool empty() const { return _data.empty(); } - - /// \brief Make the heap empty. - /// - /// This functon makes the heap empty. - /// It does not change the cross reference map. If you want to reuse - /// a heap that is not surely empty, you should first clear it and - /// then you should set the cross reference map to \c PRE_HEAP - /// for each item. - void clear() { _data.clear(); } - - private: - static int parent(int i) { return (i-1)/4; } - static int firstChild(int i) { return 4*i+1; } - - bool less(const Pair &p1, const Pair &p2) const { - return _comp(p1.second, p2.second); - } - - void bubbleUp(int hole, Pair p) { - int par = parent(hole); - while( hole>0 && less(p,_data[par]) ) { - move(_data[par],hole); - hole = par; - par = parent(hole); - } - move(p, hole); - } - - void bubbleDown(int hole, Pair p, int length) { - if( length>1 ) { - int child = firstChild(hole); - while( child+30) bubbleDown(0, _data[n], n); - _data.pop_back(); - } - - /// \brief Remove the given item from the heap. - /// - /// This function removes the given item from the heap if it is - /// already stored. - /// \param i The item to delete. - /// \pre \e i must be in the heap. - void erase(const Item &i) { - int h = _iim[i]; - int n = _data.size()-1; - _iim.set(_data[h].first, POST_HEAP); - if( h=0) s=0; - return State(s); - } - - /// \brief Set the state of an item in the heap. - /// - /// This function sets the state of the given item in the heap. - /// It can be used to manually clear the heap when it is important - /// to achive better time complexity. - /// \param i The item. - /// \param st The state. It should not be \c IN_HEAP. - void state(const Item& i, State st) { - switch (st) { - case POST_HEAP: - case PRE_HEAP: - if (state(i) == IN_HEAP) erase(i); - _iim[i] = st; - break; - case IN_HEAP: - break; - } - } - - /// \brief Replace an item in the heap. - /// - /// This function replaces item \c i with item \c j. - /// Item \c i must be in the heap, while \c j must be out of the heap. - /// After calling this method, item \c i will be out of the - /// heap and \c j will be in the heap with the same prioriority - /// as item \c i had before. - void replace(const Item& i, const Item& j) { - int idx = _iim[i]; - _iim.set(i, _iim[j]); - _iim.set(j, idx); - _data[idx].first = j; - } - - }; // class QuadHeap - -} // namespace lemon - -#endif // LEMON_FOURARY_HEAP_H Index: lemon/radix_heap.h =================================================================== --- lemon/radix_heap.h (revision 711) +++ lemon/radix_heap.h (revision 683) @@ -20,7 +20,7 @@ #define LEMON_RADIX_HEAP_H -///\ingroup heaps +///\ingroup auxdat ///\file -///\brief Radix heap implementation. +///\brief Radix Heap implementation. #include @@ -30,52 +30,54 @@ - /// \ingroup heaps + /// \ingroup auxdata /// - /// \brief Radix heap data structure. + /// \brief A Radix Heap implementation. /// - /// This class implements the \e radix \e heap data structure. - /// It practically conforms to the \ref concepts::Heap "heap concept", - /// but it has some limitations due its special implementation. - /// The type of the priorities must be \c int and the priority of an - /// item cannot be decreased under the priority of the last removed item. + /// This class implements the \e radix \e heap data structure. A \e heap + /// is a data structure for storing items with specified values called \e + /// priorities in such a way that finding the item with minimum priority is + /// efficient. This heap type can store only items with \e int priority. + /// In a heap one can change the priority of an item, add or erase an + /// item, but the priority cannot be decreased under the last removed + /// item's priority. /// - /// \tparam IM A read-writable item map with \c int values, used - /// internally to handle the cross references. + /// \param IM A read and writable Item int map, used internally + /// to handle the cross references. + /// + /// \see BinHeap + /// \see Dijkstra template class RadixHeap { public: - - /// Type of the item-int map. + typedef typename IM::Key Item; + typedef int Prio; typedef IM ItemIntMap; - /// Type of the priorities. - typedef int Prio; - /// Type of the items stored in the heap. - typedef typename ItemIntMap::Key Item; /// \brief Exception thrown by RadixHeap. /// - /// This exception is thrown when an item is inserted into a - /// RadixHeap with a priority smaller than the last erased one. + /// This Exception is thrown when a smaller priority + /// is inserted into the \e RadixHeap then the last time erased. /// \see RadixHeap - class PriorityUnderflowError : public Exception { + + class UnderFlowPriorityError : public Exception { public: virtual const char* what() const throw() { - return "lemon::RadixHeap::PriorityUnderflowError"; + return "lemon::RadixHeap::UnderFlowPriorityError"; } }; - /// \brief Type to represent the states of the items. - /// - /// Each item has a state associated to it. It can be "in heap", - /// "pre-heap" or "post-heap". The latter two are indifferent from the + /// \brief Type to represent the items states. + /// + /// Each Item element have a state associated to it. It may be "in heap", + /// "pre heap" or "post heap". The latter two are indifferent from the /// heap's point of view, but may be useful to the user. /// - /// The item-int map must be initialized in such way that it assigns - /// \c PRE_HEAP (-1) to any element to be put in the heap. + /// The ItemIntMap \e should be initialized in such way that it maps + /// PRE_HEAP (-1) to any element to be put in the heap... enum State { - IN_HEAP = 0, ///< = 0. - PRE_HEAP = -1, ///< = -1. - POST_HEAP = -2 ///< = -2. + IN_HEAP = 0, + PRE_HEAP = -1, + POST_HEAP = -2 }; @@ -95,53 +97,50 @@ }; - std::vector _data; - std::vector _boxes; + std::vector data; + std::vector boxes; ItemIntMap &_iim; + public: - - /// \brief Constructor. - /// - /// Constructor. - /// \param map A map that assigns \c int values to the items. - /// It is used internally to handle the cross references. - /// The assigned value must be \c PRE_HEAP (-1) for each item. - /// \param minimum The initial minimum value of the heap. - /// \param capacity The initial capacity of the heap. - RadixHeap(ItemIntMap &map, int minimum = 0, int capacity = 0) - : _iim(map) - { - _boxes.push_back(RadixBox(minimum, 1)); - _boxes.push_back(RadixBox(minimum + 1, 1)); - while (lower(_boxes.size() - 1, capacity + minimum - 1)) { + /// \brief The constructor. + /// + /// The constructor. + /// + /// \param map It should be given to the constructor, since it is used + /// internally to handle the cross references. The value of the map + /// should be PRE_HEAP (-1) for each element. + /// + /// \param minimal The initial minimal value of the heap. + /// \param capacity It determines the initial capacity of the heap. + RadixHeap(ItemIntMap &map, int minimal = 0, int capacity = 0) + : _iim(map) { + boxes.push_back(RadixBox(minimal, 1)); + boxes.push_back(RadixBox(minimal + 1, 1)); + while (lower(boxes.size() - 1, capacity + minimal - 1)) { extend(); } } - /// \brief The number of items stored in the heap. - /// - /// This function returns the number of items stored in the heap. - int size() const { return _data.size(); } - - /// \brief Check if the heap is empty. - /// - /// This function returns \c true if the heap is empty. - bool empty() const { return _data.empty(); } - - /// \brief Make the heap empty. - /// - /// This functon makes the heap empty. - /// It does not change the cross reference map. If you want to reuse - /// a heap that is not surely empty, you should first clear it and - /// then you should set the cross reference map to \c PRE_HEAP - /// for each item. - /// \param minimum The minimum value of the heap. - /// \param capacity The capacity of the heap. - void clear(int minimum = 0, int capacity = 0) { - _data.clear(); _boxes.clear(); - _boxes.push_back(RadixBox(minimum, 1)); - _boxes.push_back(RadixBox(minimum + 1, 1)); - while (lower(_boxes.size() - 1, capacity + minimum - 1)) { + /// The number of items stored in the heap. + /// + /// \brief Returns the number of items stored in the heap. + int size() const { return data.size(); } + /// \brief Checks if the heap stores no items. + /// + /// Returns \c true if and only if the heap stores no items. + bool empty() const { return data.empty(); } + + /// \brief Make empty this heap. + /// + /// Make empty this heap. It does not change the cross reference + /// map. If you want to reuse a heap what is not surely empty you + /// should first clear the heap and after that you should set the + /// cross reference map for each item to \c PRE_HEAP. + void clear(int minimal = 0, int capacity = 0) { + data.clear(); boxes.clear(); + boxes.push_back(RadixBox(minimal, 1)); + boxes.push_back(RadixBox(minimal + 1, 1)); + while (lower(boxes.size() - 1, capacity + minimal - 1)) { extend(); } @@ -151,56 +150,56 @@ bool upper(int box, Prio pr) { - return pr < _boxes[box].min; + return pr < boxes[box].min; } bool lower(int box, Prio pr) { - return pr >= _boxes[box].min + _boxes[box].size; - } - - // Remove item from the box list + return pr >= boxes[box].min + boxes[box].size; + } + + /// \brief Remove item from the box list. void remove(int index) { - if (_data[index].prev >= 0) { - _data[_data[index].prev].next = _data[index].next; + if (data[index].prev >= 0) { + data[data[index].prev].next = data[index].next; } else { - _boxes[_data[index].box].first = _data[index].next; - } - if (_data[index].next >= 0) { - _data[_data[index].next].prev = _data[index].prev; - } - } - - // Insert item into the box list + boxes[data[index].box].first = data[index].next; + } + if (data[index].next >= 0) { + data[data[index].next].prev = data[index].prev; + } + } + + /// \brief Insert item into the box list. void insert(int box, int index) { - if (_boxes[box].first == -1) { - _boxes[box].first = index; - _data[index].next = _data[index].prev = -1; + if (boxes[box].first == -1) { + boxes[box].first = index; + data[index].next = data[index].prev = -1; } else { - _data[index].next = _boxes[box].first; - _data[_boxes[box].first].prev = index; - _data[index].prev = -1; - _boxes[box].first = index; - } - _data[index].box = box; - } - - // Add a new box to the box list + data[index].next = boxes[box].first; + data[boxes[box].first].prev = index; + data[index].prev = -1; + boxes[box].first = index; + } + data[index].box = box; + } + + /// \brief Add a new box to the box list. void extend() { - int min = _boxes.back().min + _boxes.back().size; - int bs = 2 * _boxes.back().size; - _boxes.push_back(RadixBox(min, bs)); - } - - // Move an item up into the proper box. - void bubbleUp(int index) { - if (!lower(_data[index].box, _data[index].prio)) return; + int min = boxes.back().min + boxes.back().size; + int bs = 2 * boxes.back().size; + boxes.push_back(RadixBox(min, bs)); + } + + /// \brief Move an item up into the proper box. + void bubble_up(int index) { + if (!lower(data[index].box, data[index].prio)) return; remove(index); - int box = findUp(_data[index].box, _data[index].prio); + int box = findUp(data[index].box, data[index].prio); insert(box, index); } - // Find up the proper box for the item with the given priority + /// \brief Find up the proper box for the item with the given prio. int findUp(int start, int pr) { while (lower(start, pr)) { - if (++start == int(_boxes.size())) { + if (++start == int(boxes.size())) { extend(); } @@ -209,37 +208,38 @@ } - // Move an item down into the proper box - void bubbleDown(int index) { - if (!upper(_data[index].box, _data[index].prio)) return; + /// \brief Move an item down into the proper box. + void bubble_down(int index) { + if (!upper(data[index].box, data[index].prio)) return; remove(index); - int box = findDown(_data[index].box, _data[index].prio); + int box = findDown(data[index].box, data[index].prio); insert(box, index); } - // Find down the proper box for the item with the given priority + /// \brief Find up the proper box for the item with the given prio. int findDown(int start, int pr) { while (upper(start, pr)) { - if (--start < 0) throw PriorityUnderflowError(); + if (--start < 0) throw UnderFlowPriorityError(); } return start; } - // Find the first non-empty box + /// \brief Find the first not empty box. int findFirst() { int first = 0; - while (_boxes[first].first == -1) ++first; + while (boxes[first].first == -1) ++first; return first; } - // Gives back the minimum priority of the given box + /// \brief Gives back the minimal prio of the box. int minValue(int box) { - int min = _data[_boxes[box].first].prio; - for (int k = _boxes[box].first; k != -1; k = _data[k].next) { - if (_data[k].prio < min) min = _data[k].prio; + int min = data[boxes[box].first].prio; + for (int k = boxes[box].first; k != -1; k = data[k].next) { + if (data[k].prio < min) min = data[k].prio; } return min; } - // Rearrange the items of the heap and make the first box non-empty + /// \brief Rearrange the items of the heap and makes the + /// first box not empty. void moveDown() { int box = findFirst(); @@ -247,29 +247,29 @@ int min = minValue(box); for (int i = 0; i <= box; ++i) { - _boxes[i].min = min; - min += _boxes[i].size; - } - int curr = _boxes[box].first, next; + boxes[i].min = min; + min += boxes[i].size; + } + int curr = boxes[box].first, next; while (curr != -1) { - next = _data[curr].next; - bubbleDown(curr); + next = data[curr].next; + bubble_down(curr); curr = next; } } - void relocateLast(int index) { - if (index != int(_data.size()) - 1) { - _data[index] = _data.back(); - if (_data[index].prev != -1) { - _data[_data[index].prev].next = index; + void relocate_last(int index) { + if (index != int(data.size()) - 1) { + data[index] = data.back(); + if (data[index].prev != -1) { + data[data[index].prev].next = index; } else { - _boxes[_data[index].box].first = index; + boxes[data[index].box].first = index; } - if (_data[index].next != -1) { - _data[_data[index].next].prev = index; + if (data[index].next != -1) { + data[data[index].next].prev = index; } - _iim[_data[index].item] = index; - } - _data.pop_back(); + _iim[data[index].item] = index; + } + data.pop_back(); } @@ -278,84 +278,78 @@ /// \brief Insert an item into the heap with the given priority. /// - /// This function inserts the given item into the heap with the - /// given priority. + /// Adds \c i to the heap with priority \c p. /// \param i The item to insert. /// \param p The priority of the item. - /// \pre \e i must not be stored in the heap. - /// \warning This method may throw an \c UnderFlowPriorityException. void push(const Item &i, const Prio &p) { - int n = _data.size(); + int n = data.size(); _iim.set(i, n); - _data.push_back(RadixItem(i, p)); - while (lower(_boxes.size() - 1, p)) { + data.push_back(RadixItem(i, p)); + while (lower(boxes.size() - 1, p)) { extend(); } - int box = findDown(_boxes.size() - 1, p); + int box = findDown(boxes.size() - 1, p); insert(box, n); } - /// \brief Return the item having minimum priority. - /// - /// This function returns the item having minimum priority. - /// \pre The heap must be non-empty. + /// \brief Returns the item with minimum priority. + /// + /// This method returns the item with minimum priority. + /// \pre The heap must be nonempty. Item top() const { const_cast&>(*this).moveDown(); - return _data[_boxes[0].first].item; - } - - /// \brief The minimum priority. - /// - /// This function returns the minimum priority. - /// \pre The heap must be non-empty. + return data[boxes[0].first].item; + } + + /// \brief Returns the minimum priority. + /// + /// It returns the minimum priority. + /// \pre The heap must be nonempty. Prio prio() const { const_cast&>(*this).moveDown(); - return _data[_boxes[0].first].prio; + return data[boxes[0].first].prio; } - /// \brief Remove the item having minimum priority. - /// - /// This function removes the item having minimum priority. + /// \brief Deletes the item with minimum priority. + /// + /// This method deletes the item with minimum priority. /// \pre The heap must be non-empty. void pop() { moveDown(); - int index = _boxes[0].first; - _iim[_data[index].item] = POST_HEAP; + int index = boxes[0].first; + _iim[data[index].item] = POST_HEAP; remove(index); - relocateLast(index); - } - - /// \brief Remove the given item from the heap. - /// - /// This function removes the given item from the heap if it is - /// already stored. - /// \param i The item to delete. - /// \pre \e i must be in the heap. + relocate_last(index); + } + + /// \brief Deletes \c i from the heap. + /// + /// This method deletes item \c i from the heap, if \c i was + /// already stored in the heap. + /// \param i The item to erase. void erase(const Item &i) { int index = _iim[i]; _iim[i] = POST_HEAP; remove(index); - relocateLast(index); + relocate_last(index); } - /// \brief The priority of the given item. - /// - /// This function returns the priority of the given item. - /// \param i The item. - /// \pre \e i must be in the heap. + /// \brief Returns the priority of \c i. + /// + /// This function returns the priority of item \c i. + /// \pre \c i must be in the heap. + /// \param i The item. Prio operator[](const Item &i) const { int idx = _iim[i]; - return _data[idx].prio; - } - - /// \brief Set the priority of an item or insert it, if it is - /// not stored in the heap. - /// - /// This method sets the priority of the given item if it is - /// already stored in the heap. Otherwise it inserts the given - /// item into the heap with the given priority. + return data[idx].prio; + } + + /// \brief \c i gets to the heap with priority \c p independently + /// if \c i was already there. + /// + /// This method calls \ref push(\c i, \c p) if \c i is not stored + /// in the heap and sets the priority of \c i to \c p otherwise. + /// It may throw an \e UnderFlowPriorityException. /// \param i The item. /// \param p The priority. - /// \pre \e i must be in the heap. - /// \warning This method may throw an \c UnderFlowPriorityException. void set(const Item &i, const Prio &p) { int idx = _iim[i]; @@ -363,45 +357,46 @@ push(i, p); } - else if( p >= _data[idx].prio ) { - _data[idx].prio = p; - bubbleUp(idx); + else if( p >= data[idx].prio ) { + data[idx].prio = p; + bubble_up(idx); } else { - _data[idx].prio = p; - bubbleDown(idx); - } - } - - /// \brief Decrease the priority of an item to the given value. - /// - /// This function decreases the priority of an item to the given value. + data[idx].prio = p; + bubble_down(idx); + } + } + + + /// \brief Decreases the priority of \c i to \c p. + /// + /// This method decreases the priority of item \c i to \c p. + /// \pre \c i must be stored in the heap with priority at least \c p, and + /// \c should be greater or equal to the last removed item's priority. /// \param i The item. /// \param p The priority. - /// \pre \e i must be stored in the heap with priority at least \e p. - /// \warning This method may throw an \c UnderFlowPriorityException. void decrease(const Item &i, const Prio &p) { int idx = _iim[i]; - _data[idx].prio = p; - bubbleDown(idx); - } - - /// \brief Increase the priority of an item to the given value. - /// - /// This function increases the priority of an item to the given value. + data[idx].prio = p; + bubble_down(idx); + } + + /// \brief Increases the priority of \c i to \c p. + /// + /// This method sets the priority of item \c i to \c p. + /// \pre \c i must be stored in the heap with priority at most \c p /// \param i The item. /// \param p The priority. - /// \pre \e i must be stored in the heap with priority at most \e p. void increase(const Item &i, const Prio &p) { int idx = _iim[i]; - _data[idx].prio = p; - bubbleUp(idx); - } - - /// \brief Return the state of an item. - /// - /// This method returns \c PRE_HEAP if the given item has never - /// been in the heap, \c IN_HEAP if it is in the heap at the moment, - /// and \c POST_HEAP otherwise. - /// In the latter case it is possible that the item will get back - /// to the heap again. + data[idx].prio = p; + bubble_up(idx); + } + + /// \brief Returns if \c item is in, has already been in, or has + /// never been in the heap. + /// + /// This method returns PRE_HEAP if \c item has never been in the + /// heap, IN_HEAP if it is in the heap at the moment, and POST_HEAP + /// otherwise. In the latter case it is possible that \c item will + /// get back to the heap again. /// \param i The item. State state(const Item &i) const { @@ -411,9 +406,9 @@ } - /// \brief Set the state of an item in the heap. - /// - /// This function sets the state of the given item in the heap. - /// It can be used to manually clear the heap when it is important - /// to achive better time complexity. + /// \brief Sets the state of the \c item in the heap. + /// + /// Sets the state of the \c item in the heap. It can be used to + /// manually clear the heap when it is important to achive the + /// better time complexity. /// \param i The item. /// \param st The state. It should not be \c IN_HEAP. Index: lemon/smart_graph.h =================================================================== --- lemon/smart_graph.h (revision 877) +++ lemon/smart_graph.h (revision 617) @@ -3,5 +3,5 @@ * This file is a part of LEMON, a generic C++ optimization library. * - * Copyright (C) 2003-2010 + * Copyright (C) 2003-2009 * Egervary Jeno Kombinatorikus Optimalizalasi Kutatocsoport * (Egervary Research Group on Combinatorial Optimization, EGRES). @@ -33,5 +33,8 @@ class SmartDigraph; - + ///Base of SmartDigraph + + ///Base of SmartDigraph + /// class SmartDigraphBase { protected: @@ -185,26 +188,26 @@ ///\brief A smart directed graph class. /// - ///\ref SmartDigraph is a simple and fast digraph implementation. - ///It is also quite memory efficient but at the price - ///that it does not support node and arc deletion - ///(except for the Snapshot feature). + ///This is a simple and fast digraph implementation. + ///It is also quite memory efficient, but at the price + ///that it does support only limited (only stack-like) + ///node and arc deletions. + ///It fully conforms to the \ref concepts::Digraph "Digraph concept". /// - ///This type fully conforms to the \ref concepts::Digraph "Digraph concept" - ///and it also provides some additional functionalities. - ///Most of its member functions and nested classes are documented - ///only in the concept class. - /// - ///This class provides constant time counting for nodes and arcs. - /// - ///\sa concepts::Digraph - ///\sa SmartGraph + ///\sa concepts::Digraph. class SmartDigraph : public ExtendedSmartDigraphBase { typedef ExtendedSmartDigraphBase Parent; private: - /// Digraphs are \e not copy constructible. Use DigraphCopy instead. + + ///SmartDigraph is \e not copy constructible. Use DigraphCopy() instead. + + ///SmartDigraph is \e not copy constructible. Use DigraphCopy() instead. + /// SmartDigraph(const SmartDigraph &) : ExtendedSmartDigraphBase() {}; - /// \brief Assignment of a digraph to another one is \e not allowed. - /// Use DigraphCopy instead. + ///\brief Assignment of SmartDigraph to another one is \e not allowed. + ///Use DigraphCopy() instead. + + ///Assignment of SmartDigraph to another one is \e not allowed. + ///Use DigraphCopy() instead. void operator=(const SmartDigraph &) {} @@ -219,47 +222,77 @@ ///Add a new node to the digraph. - ///This function adds a new node to the digraph. - ///\return The new node. + /// Add a new node to the digraph. + /// \return The new node. Node addNode() { return Parent::addNode(); } ///Add a new arc to the digraph. - ///This function adds a new arc to the digraph with source node \c s + ///Add a new arc to the digraph with source node \c s ///and target node \c t. ///\return The new arc. - Arc addArc(Node s, Node t) { + Arc addArc(const Node& s, const Node& t) { return Parent::addArc(s, t); } + /// \brief Using this it is possible to avoid the superfluous memory + /// allocation. + + /// Using this it is possible to avoid the superfluous memory + /// allocation: if you know that the digraph you want to build will + /// be very large (e.g. it will contain millions of nodes and/or arcs) + /// then it is worth reserving space for this amount before starting + /// to build the digraph. + /// \sa reserveArc + void reserveNode(int n) { nodes.reserve(n); }; + + /// \brief Using this it is possible to avoid the superfluous memory + /// allocation. + + /// Using this it is possible to avoid the superfluous memory + /// allocation: if you know that the digraph you want to build will + /// be very large (e.g. it will contain millions of nodes and/or arcs) + /// then it is worth reserving space for this amount before starting + /// to build the digraph. + /// \sa reserveNode + void reserveArc(int m) { arcs.reserve(m); }; + /// \brief Node validity check /// - /// This function gives back \c true if the given node is valid, - /// i.e. it is a real node of the digraph. + /// This function gives back true if the given node is valid, + /// ie. it is a real node of the graph. /// /// \warning A removed node (using Snapshot) could become valid again - /// if new nodes are added to the digraph. + /// when new nodes are added to the graph. bool valid(Node n) const { return Parent::valid(n); } /// \brief Arc validity check /// - /// This function gives back \c true if the given arc is valid, - /// i.e. it is a real arc of the digraph. + /// This function gives back true if the given arc is valid, + /// ie. it is a real arc of the graph. /// /// \warning A removed arc (using Snapshot) could become valid again - /// if new arcs are added to the graph. + /// when new arcs are added to the graph. bool valid(Arc a) const { return Parent::valid(a); } + ///Clear the digraph. + + ///Erase all the nodes and arcs from the digraph. + /// + void clear() { + Parent::clear(); + } + ///Split a node. - ///This function splits the given node. First, a new node is added - ///to the digraph, then the source of each outgoing arc of node \c n - ///is moved to this new node. - ///If the second parameter \c connect is \c true (this is the default - ///value), then a new arc from node \c n to the newly created node - ///is also added. + ///This function splits a node. First a new node is added to the digraph, + ///then the source of each outgoing arc of \c n is moved to this new node. + ///If \c connect is \c true (this is the default value), then a new arc + ///from \c n to the newly created node is also added. ///\return The newly created node. /// - ///\note All iterators remain valid. - /// + ///\note The Arcs + ///referencing a moved arc remain + ///valid. However InArc's and OutArc's + ///may be invalidated. ///\warning This functionality cannot be used together with the Snapshot ///feature. @@ -276,32 +309,4 @@ } - ///Clear the digraph. - - ///This function erases all nodes and arcs from the digraph. - /// - void clear() { - Parent::clear(); - } - - /// Reserve memory for nodes. - - /// Using this function, it is possible to avoid superfluous memory - /// allocation: if you know that the digraph you want to build will - /// be large (e.g. it will contain millions of nodes and/or arcs), - /// then it is worth reserving space for this amount before starting - /// to build the digraph. - /// \sa reserveArc() - void reserveNode(int n) { nodes.reserve(n); }; - - /// Reserve memory for arcs. - - /// Using this function, it is possible to avoid superfluous memory - /// allocation: if you know that the digraph you want to build will - /// be large (e.g. it will contain millions of nodes and/or arcs), - /// then it is worth reserving space for this amount before starting - /// to build the digraph. - /// \sa reserveNode() - void reserveArc(int m) { arcs.reserve(m); }; - public: @@ -328,21 +333,18 @@ public: - ///Class to make a snapshot of the digraph and to restore it later. - - ///Class to make a snapshot of the digraph and to restore it later. + ///Class to make a snapshot of the digraph and to restrore to it later. + + ///Class to make a snapshot of the digraph and to restrore to it later. /// ///The newly added nodes and arcs can be removed using the - ///restore() function. This is the only way for deleting nodes and/or - ///arcs from a SmartDigraph structure. - /// - ///\note After a state is restored, you cannot restore a later state, - ///i.e. you cannot add the removed nodes and arcs again using - ///another Snapshot instance. - /// - ///\warning Node splitting cannot be restored. - ///\warning The validity of the snapshot is not stored due to - ///performance reasons. If you do not use the snapshot correctly, - ///it can cause broken program, invalid or not restored state of - ///the digraph or no change. + ///restore() function. + ///\note After you restore a state, you cannot restore + ///a later state, in other word you cannot add again the arcs deleted + ///by restore() using another one Snapshot instance. + /// + ///\warning If you do not use correctly the snapshot that can cause + ///either broken program, invalid state of the digraph, valid but + ///not the restored digraph or no change. Because the runtime performance + ///the validity of the snapshot is not stored. class Snapshot { @@ -356,11 +358,12 @@ ///Default constructor. - ///You have to call save() to actually make a snapshot. + ///To actually make a snapshot you must call save(). + /// Snapshot() : _graph(0) {} ///Constructor that immediately makes a snapshot - ///This constructor immediately makes a snapshot of the given digraph. - /// - Snapshot(SmartDigraph &gr) : _graph(&gr) { + ///This constructor immediately makes a snapshot of the digraph. + ///\param graph The digraph we make a snapshot of. + Snapshot(SmartDigraph &graph) : _graph(&graph) { node_num=_graph->nodes.size(); arc_num=_graph->arcs.size(); @@ -369,9 +372,12 @@ ///Make a snapshot. - ///This function makes a snapshot of the given digraph. - ///It can be called more than once. In case of a repeated + ///Make a snapshot of the digraph. + /// + ///This function can be called more than once. In case of a repeated ///call, the previous snapshot gets lost. - void save(SmartDigraph &gr) { - _graph=&gr; + ///\param graph The digraph we make the snapshot of. + void save(SmartDigraph &graph) + { + _graph=&graph; node_num=_graph->nodes.size(); arc_num=_graph->arcs.size(); @@ -380,6 +386,9 @@ ///Undo the changes until a snapshot. - ///This function undos the changes until the last snapshot - ///created by save() or Snapshot(SmartDigraph&). + ///Undo the changes until a snapshot created by save(). + /// + ///\note After you restored a state, you cannot restore + ///a later state, in other word you cannot add again the arcs deleted + ///by restore(). void restore() { @@ -500,5 +509,5 @@ } - static void next(Node& node) { + void next(Node& node) const { --node._id; } @@ -508,5 +517,5 @@ } - static void next(Arc& arc) { + void next(Arc& arc) const { --arc._id; } @@ -516,5 +525,5 @@ } - static void next(Edge& arc) { + void next(Edge& arc) const { --arc._id; } @@ -613,26 +622,27 @@ /// \brief A smart undirected graph class. /// - /// \ref SmartGraph is a simple and fast graph implementation. - /// It is also quite memory efficient but at the price - /// that it does not support node and edge deletion - /// (except for the Snapshot feature). + /// This is a simple and fast graph implementation. + /// It is also quite memory efficient, but at the price + /// that it does support only limited (only stack-like) + /// node and arc deletions. + /// It fully conforms to the \ref concepts::Graph "Graph concept". /// - /// This type fully conforms to the \ref concepts::Graph "Graph concept" - /// and it also provides some additional functionalities. - /// Most of its member functions and nested classes are documented - /// only in the concept class. - /// - /// This class provides constant time counting for nodes, edges and arcs. - /// - /// \sa concepts::Graph - /// \sa SmartDigraph + /// \sa concepts::Graph. class SmartGraph : public ExtendedSmartGraphBase { typedef ExtendedSmartGraphBase Parent; private: - /// Graphs are \e not copy constructible. Use GraphCopy instead. + + ///SmartGraph is \e not copy constructible. Use GraphCopy() instead. + + ///SmartGraph is \e not copy constructible. Use GraphCopy() instead. + /// SmartGraph(const SmartGraph &) : ExtendedSmartGraphBase() {}; - /// \brief Assignment of a graph to another one is \e not allowed. - /// Use GraphCopy instead. + + ///\brief Assignment of SmartGraph to another one is \e not allowed. + ///Use GraphCopy() instead. + + ///Assignment of SmartGraph to another one is \e not allowed. + ///Use GraphCopy() instead. void operator=(const SmartGraph &) {} @@ -645,74 +655,53 @@ SmartGraph() {} - /// \brief Add a new node to the graph. - /// - /// This function adds a new node to the graph. + ///Add a new node to the graph. + + /// Add a new node to the graph. /// \return The new node. Node addNode() { return Parent::addNode(); } - /// \brief Add a new edge to the graph. - /// - /// This function adds a new edge to the graph between nodes - /// \c u and \c v with inherent orientation from node \c u to - /// node \c v. - /// \return The new edge. - Edge addEdge(Node u, Node v) { - return Parent::addEdge(u, v); + ///Add a new edge to the graph. + + ///Add a new edge to the graph with node \c s + ///and \c t. + ///\return The new edge. + Edge addEdge(const Node& s, const Node& t) { + return Parent::addEdge(s, t); } /// \brief Node validity check /// - /// This function gives back \c true if the given node is valid, - /// i.e. it is a real node of the graph. + /// This function gives back true if the given node is valid, + /// ie. it is a real node of the graph. /// /// \warning A removed node (using Snapshot) could become valid again - /// if new nodes are added to the graph. + /// when new nodes are added to the graph. bool valid(Node n) const { return Parent::valid(n); } + /// \brief Arc validity check + /// + /// This function gives back true if the given arc is valid, + /// ie. it is a real arc of the graph. + /// + /// \warning A removed arc (using Snapshot) could become valid again + /// when new edges are added to the graph. + bool valid(Arc a) const { return Parent::valid(a); } + /// \brief Edge validity check /// - /// This function gives back \c true if the given edge is valid, - /// i.e. it is a real edge of the graph. + /// This function gives back true if the given edge is valid, + /// ie. it is a real edge of the graph. /// /// \warning A removed edge (using Snapshot) could become valid again - /// if new edges are added to the graph. + /// when new edges are added to the graph. bool valid(Edge e) const { return Parent::valid(e); } - /// \brief Arc validity check - /// - /// This function gives back \c true if the given arc is valid, - /// i.e. it is a real arc of the graph. - /// - /// \warning A removed arc (using Snapshot) could become valid again - /// if new edges are added to the graph. - bool valid(Arc a) const { return Parent::valid(a); } - ///Clear the graph. - ///This function erases all nodes and arcs from the graph. + ///Erase all the nodes and edges from the graph. /// void clear() { Parent::clear(); } - - /// Reserve memory for nodes. - - /// Using this function, it is possible to avoid superfluous memory - /// allocation: if you know that the graph you want to build will - /// be large (e.g. it will contain millions of nodes and/or edges), - /// then it is worth reserving space for this amount before starting - /// to build the graph. - /// \sa reserveEdge() - void reserveNode(int n) { nodes.reserve(n); }; - - /// Reserve memory for edges. - - /// Using this function, it is possible to avoid superfluous memory - /// allocation: if you know that the graph you want to build will - /// be large (e.g. it will contain millions of nodes and/or edges), - /// then it is worth reserving space for this amount before starting - /// to build the graph. - /// \sa reserveNode() - void reserveEdge(int m) { arcs.reserve(2 * m); }; public: @@ -754,20 +743,19 @@ public: - ///Class to make a snapshot of the graph and to restore it later. - - ///Class to make a snapshot of the graph and to restore it later. - /// - ///The newly added nodes and edges can be removed using the - ///restore() function. This is the only way for deleting nodes and/or - ///edges from a SmartGraph structure. - /// - ///\note After a state is restored, you cannot restore a later state, - ///i.e. you cannot add the removed nodes and edges again using - ///another Snapshot instance. - /// - ///\warning The validity of the snapshot is not stored due to - ///performance reasons. If you do not use the snapshot correctly, - ///it can cause broken program, invalid or not restored state of - ///the graph or no change. + ///Class to make a snapshot of the digraph and to restrore to it later. + + ///Class to make a snapshot of the digraph and to restrore to it later. + /// + ///The newly added nodes and arcs can be removed using the + ///restore() function. + /// + ///\note After you restore a state, you cannot restore + ///a later state, in other word you cannot add again the arcs deleted + ///by restore() using another one Snapshot instance. + /// + ///\warning If you do not use correctly the snapshot that can cause + ///either broken program, invalid state of the digraph, valid but + ///not the restored digraph or no change. Because the runtime performance + ///the validity of the snapshot is not stored. class Snapshot { @@ -781,28 +769,34 @@ ///Default constructor. - ///You have to call save() to actually make a snapshot. + ///To actually make a snapshot you must call save(). + /// Snapshot() : _graph(0) {} ///Constructor that immediately makes a snapshot - /// This constructor immediately makes a snapshot of the given graph. + ///This constructor immediately makes a snapshot of the digraph. + ///\param graph The digraph we make a snapshot of. + Snapshot(SmartGraph &graph) { + graph.saveSnapshot(*this); + } + + ///Make a snapshot. + + ///Make a snapshot of the graph. /// - Snapshot(SmartGraph &gr) { - gr.saveSnapshot(*this); - } - - ///Make a snapshot. - - ///This function makes a snapshot of the given graph. - ///It can be called more than once. In case of a repeated + ///This function can be called more than once. In case of a repeated ///call, the previous snapshot gets lost. - void save(SmartGraph &gr) + ///\param graph The digraph we make the snapshot of. + void save(SmartGraph &graph) { - gr.saveSnapshot(*this); - } - - ///Undo the changes until the last snapshot. - - ///This function undos the changes until the last snapshot - ///created by save() or Snapshot(SmartGraph&). + graph.saveSnapshot(*this); + } + + ///Undo the changes until a snapshot. + + ///Undo the changes until a snapshot created by save(). + /// + ///\note After you restored a state, you cannot restore + ///a later state, in other word you cannot add again the arcs deleted + ///by restore(). void restore() { Index: lemon/soplex.cc =================================================================== --- lemon/soplex.cc (revision 877) +++ lemon/soplex.cc (revision 576) @@ -3,5 +3,5 @@ * This file is a part of LEMON, a generic C++ optimization library. * - * Copyright (C) 2003-2010 + * Copyright (C) 2003-2008 * Egervary Jeno Kombinatorikus Optimalizalasi Kutatocsoport * (Egervary Research Group on Combinatorial Optimization, EGRES). @@ -92,17 +92,4 @@ } - int SoplexLp::_addRow(Value l, ExprIterator b, ExprIterator e, Value u) { - soplex::DSVector v; - for (ExprIterator it = b; it != e; ++it) { - v.add(it->first, it->second); - } - soplex::LPRow r(l, v, u); - soplex->addRow(r); - - _row_names.push_back(std::string()); - - return soplex->nRows() - 1; - } - void SoplexLp::_eraseCol(int i) { @@ -288,5 +275,5 @@ _clear_temporals(); - + _applyMessageLevel(); Index: lemon/soplex.h =================================================================== --- lemon/soplex.h (revision 877) +++ lemon/soplex.h (revision 576) @@ -3,5 +3,5 @@ * This file is a part of LEMON, a generic C++ optimization library. * - * Copyright (C) 2003-2010 + * Copyright (C) 2003-2008 * Egervary Jeno Kombinatorikus Optimalizalasi Kutatocsoport * (Egervary Research Group on Combinatorial Optimization, EGRES). @@ -85,5 +85,4 @@ virtual int _addCol(); virtual int _addRow(); - virtual int _addRow(Value l, ExprIterator b, ExprIterator e, Value u); virtual void _eraseCol(int i); Index: mon/static_graph.h =================================================================== --- lemon/static_graph.h (revision 877) +++ (revision ) @@ -1,476 +1,0 @@ -/* -*- mode: C++; indent-tabs-mode: nil; -*- - * - * This file is a part of LEMON, a generic C++ optimization library. - * - * Copyright (C) 2003-2010 - * Egervary Jeno Kombinatorikus Optimalizalasi Kutatocsoport - * (Egervary Research Group on Combinatorial Optimization, EGRES). - * - * Permission to use, modify and distribute this software is granted - * provided that this copyright notice appears in all copies. For - * precise terms see the accompanying LICENSE file. - * - * This software is provided "AS IS" with no warranty of any kind, - * express or implied, and with no claim as to its suitability for any - * purpose. - * - */ - -#ifndef LEMON_STATIC_GRAPH_H -#define LEMON_STATIC_GRAPH_H - -///\ingroup graphs -///\file -///\brief StaticDigraph class. - -#include -#include - -namespace lemon { - - class StaticDigraphBase { - public: - - StaticDigraphBase() - : built(false), node_num(0), arc_num(0), - node_first_out(NULL), node_first_in(NULL), - arc_source(NULL), arc_target(NULL), - arc_next_in(NULL), arc_next_out(NULL) {} - - ~StaticDigraphBase() { - if (built) { - delete[] node_first_out; - delete[] node_first_in; - delete[] arc_source; - delete[] arc_target; - delete[] arc_next_out; - delete[] arc_next_in; - } - } - - class Node { - friend class StaticDigraphBase; - protected: - int id; - Node(int _id) : id(_id) {} - public: - Node() {} - Node (Invalid) : id(-1) {} - bool operator==(const Node& node) const { return id == node.id; } - bool operator!=(const Node& node) const { return id != node.id; } - bool operator<(const Node& node) const { return id < node.id; } - }; - - class Arc { - friend class StaticDigraphBase; - protected: - int id; - Arc(int _id) : id(_id) {} - public: - Arc() { } - Arc (Invalid) : id(-1) {} - bool operator==(const Arc& arc) const { return id == arc.id; } - bool operator!=(const Arc& arc) const { return id != arc.id; } - bool operator<(const Arc& arc) const { return id < arc.id; } - }; - - Node source(const Arc& e) const { return Node(arc_source[e.id]); } - Node target(const Arc& e) const { return Node(arc_target[e.id]); } - - void first(Node& n) const { n.id = node_num - 1; } - static void next(Node& n) { --n.id; } - - void first(Arc& e) const { e.id = arc_num - 1; } - static void next(Arc& e) { --e.id; } - - void firstOut(Arc& e, const Node& n) const { - e.id = node_first_out[n.id] != node_first_out[n.id + 1] ? - node_first_out[n.id] : -1; - } - void nextOut(Arc& e) const { e.id = arc_next_out[e.id]; } - - void firstIn(Arc& e, const Node& n) const { e.id = node_first_in[n.id]; } - void nextIn(Arc& e) const { e.id = arc_next_in[e.id]; } - - static int id(const Node& n) { return n.id; } - static Node nodeFromId(int id) { return Node(id); } - int maxNodeId() const { return node_num - 1; } - - static int id(const Arc& e) { return e.id; } - static Arc arcFromId(int id) { return Arc(id); } - int maxArcId() const { return arc_num - 1; } - - typedef True NodeNumTag; - typedef True ArcNumTag; - - int nodeNum() const { return node_num; } - int arcNum() const { return arc_num; } - - private: - - template - class ArcLess { - public: - typedef typename Digraph::Arc Arc; - - ArcLess(const Digraph &_graph, const NodeRefMap& _nodeRef) - : digraph(_graph), nodeRef(_nodeRef) {} - - bool operator()(const Arc& left, const Arc& right) const { - return nodeRef[digraph.target(left)] < nodeRef[digraph.target(right)]; - } - private: - const Digraph& digraph; - const NodeRefMap& nodeRef; - }; - - public: - - typedef True BuildTag; - - void clear() { - if (built) { - delete[] node_first_out; - delete[] node_first_in; - delete[] arc_source; - delete[] arc_target; - delete[] arc_next_out; - delete[] arc_next_in; - } - built = false; - node_num = 0; - arc_num = 0; - } - - template - void build(const Digraph& digraph, NodeRefMap& nodeRef, ArcRefMap& arcRef) { - typedef typename Digraph::Node GNode; - typedef typename Digraph::Arc GArc; - - built = true; - - node_num = countNodes(digraph); - arc_num = countArcs(digraph); - - node_first_out = new int[node_num + 1]; - node_first_in = new int[node_num]; - - arc_source = new int[arc_num]; - arc_target = new int[arc_num]; - arc_next_out = new int[arc_num]; - arc_next_in = new int[arc_num]; - - int node_index = 0; - for (typename Digraph::NodeIt n(digraph); n != INVALID; ++n) { - nodeRef[n] = Node(node_index); - node_first_in[node_index] = -1; - ++node_index; - } - - ArcLess arcLess(digraph, nodeRef); - - int arc_index = 0; - for (typename Digraph::NodeIt n(digraph); n != INVALID; ++n) { - int source = nodeRef[n].id; - std::vector arcs; - for (typename Digraph::OutArcIt e(digraph, n); e != INVALID; ++e) { - arcs.push_back(e); - } - if (!arcs.empty()) { - node_first_out[source] = arc_index; - std::sort(arcs.begin(), arcs.end(), arcLess); - for (typename std::vector::iterator it = arcs.begin(); - it != arcs.end(); ++it) { - int target = nodeRef[digraph.target(*it)].id; - arcRef[*it] = Arc(arc_index); - arc_source[arc_index] = source; - arc_target[arc_index] = target; - arc_next_in[arc_index] = node_first_in[target]; - node_first_in[target] = arc_index; - arc_next_out[arc_index] = arc_index + 1; - ++arc_index; - } - arc_next_out[arc_index - 1] = -1; - } else { - node_first_out[source] = arc_index; - } - } - node_first_out[node_num] = arc_num; - } - - template - void build(int n, ArcListIterator first, ArcListIterator last) { - built = true; - - node_num = n; - arc_num = std::distance(first, last); - - node_first_out = new int[node_num + 1]; - node_first_in = new int[node_num]; - - arc_source = new int[arc_num]; - arc_target = new int[arc_num]; - arc_next_out = new int[arc_num]; - arc_next_in = new int[arc_num]; - - for (int i = 0; i != node_num; ++i) { - node_first_in[i] = -1; - } - - int arc_index = 0; - for (int i = 0; i != node_num; ++i) { - node_first_out[i] = arc_index; - for ( ; first != last && (*first).first == i; ++first) { - int j = (*first).second; - LEMON_ASSERT(j >= 0 && j < node_num, - "Wrong arc list for StaticDigraph::build()"); - arc_source[arc_index] = i; - arc_target[arc_index] = j; - arc_next_in[arc_index] = node_first_in[j]; - node_first_in[j] = arc_index; - arc_next_out[arc_index] = arc_index + 1; - ++arc_index; - } - if (arc_index > node_first_out[i]) - arc_next_out[arc_index - 1] = -1; - } - LEMON_ASSERT(first == last, - "Wrong arc list for StaticDigraph::build()"); - node_first_out[node_num] = arc_num; - } - - protected: - - void fastFirstOut(Arc& e, const Node& n) const { - e.id = node_first_out[n.id]; - } - - static void fastNextOut(Arc& e) { - ++e.id; - } - void fastLastOut(Arc& e, const Node& n) const { - e.id = node_first_out[n.id + 1]; - } - - protected: - bool built; - int node_num; - int arc_num; - int *node_first_out; - int *node_first_in; - int *arc_source; - int *arc_target; - int *arc_next_in; - int *arc_next_out; - }; - - typedef DigraphExtender ExtendedStaticDigraphBase; - - - /// \ingroup graphs - /// - /// \brief A static directed graph class. - /// - /// \ref StaticDigraph is a highly efficient digraph implementation, - /// but it is fully static. - /// It stores only two \c int values for each node and only four \c int - /// values for each arc. Moreover it provides faster item iteration than - /// \ref ListDigraph and \ref SmartDigraph, especially using \c OutArcIt - /// iterators, since its arcs are stored in an appropriate order. - /// However it only provides build() and clear() functions and does not - /// support any other modification of the digraph. - /// - /// Since this digraph structure is completely static, its nodes and arcs - /// can be indexed with integers from the ranges [0..nodeNum()-1] - /// and [0..arcNum()-1], respectively. - /// The index of an item is the same as its ID, it can be obtained - /// using the corresponding \ref index() or \ref concepts::Digraph::id() - /// "id()" function. A node or arc with a certain index can be obtained - /// using node() or arc(). - /// - /// This type fully conforms to the \ref concepts::Digraph "Digraph concept". - /// Most of its member functions and nested classes are documented - /// only in the concept class. - /// - /// This class provides constant time counting for nodes and arcs. - /// - /// \sa concepts::Digraph - class StaticDigraph : public ExtendedStaticDigraphBase { - public: - - typedef ExtendedStaticDigraphBase Parent; - - public: - - /// \brief Constructor - /// - /// Default constructor. - StaticDigraph() : Parent() {} - - /// \brief The node with the given index. - /// - /// This function returns the node with the given index. - /// \sa index() - static Node node(int ix) { return Parent::nodeFromId(ix); } - - /// \brief The arc with the given index. - /// - /// This function returns the arc with the given index. - /// \sa index() - static Arc arc(int ix) { return Parent::arcFromId(ix); } - - /// \brief The index of the given node. - /// - /// This function returns the index of the the given node. - /// \sa node() - static int index(Node node) { return Parent::id(node); } - - /// \brief The index of the given arc. - /// - /// This function returns the index of the the given arc. - /// \sa arc() - static int index(Arc arc) { return Parent::id(arc); } - - /// \brief Number of nodes. - /// - /// This function returns the number of nodes. - int nodeNum() const { return node_num; } - - /// \brief Number of arcs. - /// - /// This function returns the number of arcs. - int arcNum() const { return arc_num; } - - /// \brief Build the digraph copying another digraph. - /// - /// This function builds the digraph copying another digraph of any - /// kind. It can be called more than once, but in such case, the whole - /// structure and all maps will be cleared and rebuilt. - /// - /// This method also makes possible to copy a digraph to a StaticDigraph - /// structure using \ref DigraphCopy. - /// - /// \param digraph An existing digraph to be copied. - /// \param nodeRef The node references will be copied into this map. - /// Its key type must be \c Digraph::Node and its value type must be - /// \c StaticDigraph::Node. - /// It must conform to the \ref concepts::ReadWriteMap "ReadWriteMap" - /// concept. - /// \param arcRef The arc references will be copied into this map. - /// Its key type must be \c Digraph::Arc and its value type must be - /// \c StaticDigraph::Arc. - /// It must conform to the \ref concepts::WriteMap "WriteMap" concept. - /// - /// \note If you do not need the arc references, then you could use - /// \ref NullMap for the last parameter. However the node references - /// are required by the function itself, thus they must be readable - /// from the map. - template - void build(const Digraph& digraph, NodeRefMap& nodeRef, ArcRefMap& arcRef) { - if (built) Parent::clear(); - Parent::build(digraph, nodeRef, arcRef); - } - - /// \brief Build the digraph from an arc list. - /// - /// This function builds the digraph from the given arc list. - /// It can be called more than once, but in such case, the whole - /// structure and all maps will be cleared and rebuilt. - /// - /// The list of the arcs must be given in the range [begin, end) - /// specified by STL compatible itartors whose \c value_type must be - /// std::pair. - /// Each arc must be specified by a pair of integer indices - /// from the range [0..n-1]. The pairs must be in a - /// non-decreasing order with respect to their first values. - /// If the k-th pair in the list is (i,j), then - /// arc(k-1) will connect node(i) to node(j). - /// - /// \param n The number of nodes. - /// \param begin An iterator pointing to the beginning of the arc list. - /// \param end An iterator pointing to the end of the arc list. - /// - /// For example, a simple digraph can be constructed like this. - /// \code - /// std::vector > arcs; - /// arcs.push_back(std::make_pair(0,1)); - /// arcs.push_back(std::make_pair(0,2)); - /// arcs.push_back(std::make_pair(1,3)); - /// arcs.push_back(std::make_pair(1,2)); - /// arcs.push_back(std::make_pair(3,0)); - /// StaticDigraph gr; - /// gr.build(4, arcs.begin(), arcs.end()); - /// \endcode - template - void build(int n, ArcListIterator begin, ArcListIterator end) { - if (built) Parent::clear(); - StaticDigraphBase::build(n, begin, end); - notifier(Node()).build(); - notifier(Arc()).build(); - } - - /// \brief Clear the digraph. - /// - /// This function erases all nodes and arcs from the digraph. - void clear() { - Parent::clear(); - } - - protected: - - using Parent::fastFirstOut; - using Parent::fastNextOut; - using Parent::fastLastOut; - - public: - - class OutArcIt : public Arc { - public: - - OutArcIt() { } - - OutArcIt(Invalid i) : Arc(i) { } - - OutArcIt(const StaticDigraph& digraph, const Node& node) { - digraph.fastFirstOut(*this, node); - digraph.fastLastOut(last, node); - if (last == *this) *this = INVALID; - } - - OutArcIt(const StaticDigraph& digraph, const Arc& arc) : Arc(arc) { - if (arc != INVALID) { - digraph.fastLastOut(last, digraph.source(arc)); - } - } - - OutArcIt& operator++() { - StaticDigraph::fastNextOut(*this); - if (last == *this) *this = INVALID; - return *this; - } - - private: - Arc last; - }; - - Node baseNode(const OutArcIt &arc) const { - return Parent::source(static_cast(arc)); - } - - Node runningNode(const OutArcIt &arc) const { - return Parent::target(static_cast(arc)); - } - - Node baseNode(const InArcIt &arc) const { - return Parent::target(static_cast(arc)); - } - - Node runningNode(const InArcIt &arc) const { - return Parent::source(static_cast(arc)); - } - - }; - -} - -#endif Index: lemon/suurballe.h =================================================================== --- lemon/suurballe.h (revision 877) +++ lemon/suurballe.h (revision 852) @@ -3,5 +3,5 @@ * This file is a part of LEMON, a generic C++ optimization library. * - * Copyright (C) 2003-2010 + * Copyright (C) 2003-2009 * Egervary Jeno Kombinatorikus Optimalizalasi Kutatocsoport * (Egervary Research Group on Combinatorial Optimization, EGRES). @@ -30,51 +30,7 @@ #include #include -#include #include 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 GR::ArcMap. -#ifdef DOXYGEN - template -#else - template < typename GR, - typename LEN = typename GR::template ArcMap > -#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 FlowMap; - /// The type of the potential map. - typedef typename GR::template NodeMap 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 Path; - - /// The cross reference type used for the heap. - typedef typename GR::template NodeMap 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 Heap; - }; /// \addtogroup shortest_path @@ -91,5 +47,5 @@ /// "minimum cost flow problem". This implementation is actually an /// efficient specialized version of the \ref CapacityScaling - /// "successive shortest path" algorithm directly for this problem. + /// "Successive Shortest Path" algorithm directly for this problem. /// Therefore this class provides query functions for flow values and /// node potentials (the dual solution) just like the minimum cost flow @@ -102,12 +58,11 @@ /// \warning Length values should be \e non-negative. /// - /// \note For finding \e node-disjoint paths, this algorithm can be used + /// \note For finding node-disjoint paths this algorithm can be used /// along with the \ref SplitNodes adaptor. #ifdef DOXYGEN - template + template #else template < typename GR, - typename LEN = typename GR::template ArcMap, - typename TR = SuurballeDefaultTraits > + typename LEN = typename GR::template ArcMap > #endif class Suurballe @@ -120,24 +75,24 @@ public: - /// The type of the digraph. - typedef typename TR::Digraph Digraph; + /// The type of the digraph the algorithm runs on. + typedef GR Digraph; /// The type of the length map. - typedef typename TR::LengthMap LengthMap; + typedef LEN LengthMap; /// The type of the lengths. - typedef typename TR::Length Length; - + typedef typename LengthMap::Value Length; +#ifdef DOXYGEN /// The type of the flow map. - typedef typename TR::FlowMap FlowMap; + typedef GR::ArcMap FlowMap; /// The type of the potential map. - typedef typename TR::PotentialMap PotentialMap; + typedef GR::NodeMap PotentialMap; +#else + /// The type of the flow map. + typedef typename Digraph::template ArcMap FlowMap; + /// The type of the potential map. + typedef typename Digraph::template NodeMap PotentialMap; +#endif + /// The type of the path structures. - typedef typename TR::Path Path; - /// The cross reference type used for the heap. - typedef typename TR::HeapCrossRef HeapCrossRef; - /// The heap type used for internal Dijkstra computations. - typedef typename TR::Heap Heap; - - /// The \ref SuurballeDefaultTraits "traits class" of the algorithm. - typedef TR Traits; + typedef SimplePath Path; private: @@ -150,36 +105,42 @@ class ResidualDijkstra { + typedef typename Digraph::template NodeMap HeapCrossRef; + typedef BinHeap Heap; + private: + // The digraph the algorithm runs on const Digraph &_graph; + + // The main maps + const FlowMap &_flow; const LengthMap &_length; - const FlowMap &_flow; - PotentialMap &_pi; + PotentialMap &_potential; + + // The distance map + PotentialMap _dist; + // The pred arc map PredMap &_pred; + // The processed (i.e. permanently labeled) nodes + std::vector _proc_nodes; + Node _s; Node _t; - PotentialMap _dist; - std::vector _proc_nodes; - public: - // Constructor - ResidualDijkstra(Suurballe &srb) : - _graph(srb._graph), _length(srb._length), - _flow(*srb._flow), _pi(*srb._potential), _pred(srb._pred), - _s(srb._s), _t(srb._t), _dist(_graph) {} - - // Run the algorithm and return true if a path is found - // from the source node to the target node. - bool run(int cnt) { - return cnt == 0 ? startFirst() : start(); - } - - private: - - // Execute the algorithm for the first time (the flow and potential - // functions have to be identically zero). - bool startFirst() { + /// Constructor. + ResidualDijkstra( const Digraph &graph, + const FlowMap &flow, + const LengthMap &length, + PotentialMap &potential, + PredMap &pred, + Node s, Node t ) : + _graph(graph), _flow(flow), _length(length), _potential(potential), + _dist(graph), _pred(pred), _s(s), _t(t) {} + + /// \brief Run the algorithm. It returns \c true if a path is found + /// from the source node to the target node. + bool run() { HeapCrossRef heap_cross_ref(_graph, Heap::PRE_HEAP); Heap heap(heap_cross_ref); @@ -191,21 +152,22 @@ while (!heap.empty() && heap.top() != _t) { Node u = heap.top(), v; - Length d = heap.prio(), dn; + Length d = heap.prio() + _potential[u], nd; _dist[u] = heap.prio(); + heap.pop(); _proc_nodes.push_back(u); - heap.pop(); // Traverse outgoing arcs for (OutArcIt e(_graph, u); e != INVALID; ++e) { - v = _graph.target(e); - switch(heap.state(v)) { + if (_flow[e] == 0) { + v = _graph.target(e); + switch(heap.state(v)) { case Heap::PRE_HEAP: - heap.push(v, d + _length[e]); + heap.push(v, d + _length[e] - _potential[v]); _pred[v] = e; break; case Heap::IN_HEAP: - dn = d + _length[e]; - if (dn < heap[v]) { - heap.decrease(v, dn); + nd = d + _length[e] - _potential[v]; + if (nd < heap[v]) { + heap.decrease(v, nd); _pred[v] = e; } @@ -213,50 +175,4 @@ case Heap::POST_HEAP: break; - } - } - } - if (heap.empty()) return false; - - // Update potentials of processed nodes - Length t_dist = heap.prio(); - for (int i = 0; i < int(_proc_nodes.size()); ++i) - _pi[_proc_nodes[i]] = _dist[_proc_nodes[i]] - t_dist; - return true; - } - - // Execute the algorithm. - bool start() { - HeapCrossRef heap_cross_ref(_graph, Heap::PRE_HEAP); - Heap heap(heap_cross_ref); - heap.push(_s, 0); - _pred[_s] = INVALID; - _proc_nodes.clear(); - - // Process nodes - while (!heap.empty() && heap.top() != _t) { - Node u = heap.top(), v; - Length d = heap.prio() + _pi[u], dn; - _dist[u] = heap.prio(); - _proc_nodes.push_back(u); - heap.pop(); - - // Traverse outgoing arcs - for (OutArcIt e(_graph, u); e != INVALID; ++e) { - if (_flow[e] == 0) { - v = _graph.target(e); - switch(heap.state(v)) { - case Heap::PRE_HEAP: - heap.push(v, d + _length[e] - _pi[v]); - _pred[v] = e; - break; - case Heap::IN_HEAP: - dn = d + _length[e] - _pi[v]; - if (dn < heap[v]) { - heap.decrease(v, dn); - _pred[v] = e; - } - break; - case Heap::POST_HEAP: - break; } } @@ -268,17 +184,17 @@ v = _graph.source(e); switch(heap.state(v)) { - case Heap::PRE_HEAP: - heap.push(v, d - _length[e] - _pi[v]); + case Heap::PRE_HEAP: + heap.push(v, d - _length[e] - _potential[v]); + _pred[v] = e; + break; + case Heap::IN_HEAP: + nd = d - _length[e] - _potential[v]; + if (nd < heap[v]) { + heap.decrease(v, nd); _pred[v] = e; - break; - case Heap::IN_HEAP: - dn = d - _length[e] - _pi[v]; - if (dn < heap[v]) { - heap.decrease(v, dn); - _pred[v] = e; - } - break; - case Heap::POST_HEAP: - break; + } + break; + case Heap::POST_HEAP: + break; } } @@ -290,86 +206,9 @@ Length t_dist = heap.prio(); for (int i = 0; i < int(_proc_nodes.size()); ++i) - _pi[_proc_nodes[i]] += _dist[_proc_nodes[i]] - t_dist; + _potential[_proc_nodes[i]] += _dist[_proc_nodes[i]] - t_dist; return true; } }; //class ResidualDijkstra - - public: - - /// \name Named Template Parameters - /// @{ - - template - 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 - struct SetFlowMap - : public Suurballe > { - typedef Suurballe > Create; - }; - - template - 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 - struct SetPotentialMap - : public Suurballe > { - typedef Suurballe > Create; - }; - - template - 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 - struct SetPath - : public Suurballe > { - typedef Suurballe > Create; - }; - - template - 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 > - struct SetHeap - : public Suurballe > { - typedef Suurballe > Create; - }; - - /// @} private: @@ -388,23 +227,17 @@ // The source node - Node _s; + Node _source; // The target node - Node _t; + Node _target; // Container to store the found paths - std::vector _paths; + std::vector< SimplePath > paths; int _path_num; // The pred arc map PredMap _pred; - - // Data for full init - PotentialMap *_init_dist; - PredMap *_init_pred; - bool _full_init; - - protected: - - Suurballe() {} + // Implementation of the Dijkstra algorithm for finding augmenting + // shortest paths in the residual network + ResidualDijkstra *_dijkstra; public: @@ -419,6 +252,5 @@ const LengthMap &length ) : _graph(graph), _length(length), _flow(0), _local_flow(false), - _potential(0), _local_potential(false), _pred(graph), - _init_dist(0), _init_pred(0) + _potential(0), _local_potential(false), _pred(graph) {} @@ -427,6 +259,5 @@ if (_local_flow) delete _flow; if (_local_potential) delete _potential; - delete _init_dist; - delete _init_pred; + delete _dijkstra; } @@ -473,11 +304,8 @@ /// \name Execution Control /// The simplest way to execute the algorithm is to call the run() - /// function.\n - /// If you need to execute the algorithm many times using the same - /// source node, then you may call fullInit() once and start() - /// for each target node.\n + /// function. + /// \n /// If you only need the flow that is the union of the found - /// arc-disjoint paths, then you may call findFlow() instead of - /// start(). + /// arc-disjoint paths, you may call init() and findFlow(). /// @{ @@ -499,9 +327,11 @@ /// \code /// s.init(s); - /// s.start(t, k); + /// s.findFlow(t, k); + /// s.findPaths(); /// \endcode int run(const Node& s, const Node& t, int k = 2) { init(s); - start(t, k); + findFlow(t, k); + findPaths(); return _path_num; } @@ -509,9 +339,9 @@ /// \brief Initialize the algorithm. /// - /// This function initializes the algorithm with the given source node. + /// This function initializes the algorithm. /// /// \param s The source node. void init(const Node& s) { - _s = s; + _source = s; // Initialize maps @@ -524,61 +354,6 @@ _local_potential = true; } - _full_init = false; - } - - /// \brief Initialize the algorithm and perform Dijkstra. - /// - /// This function initializes the algorithm and performs a full - /// Dijkstra search from the given source node. It makes consecutive - /// executions of \ref start() "start(t, k)" faster, since they - /// have to perform %Dijkstra only k-1 times. - /// - /// This initialization is usually worth using instead of \ref init() - /// if the algorithm is executed many times using the same source node. - /// - /// \param s The source node. - void fullInit(const Node& s) { - // Initialize maps - init(s); - if (!_init_dist) { - _init_dist = new PotentialMap(_graph); - } - if (!_init_pred) { - _init_pred = new PredMap(_graph); - } - - // Run a full Dijkstra - typename Dijkstra - ::template SetStandardHeap - ::template SetDistMap - ::template SetPredMap - ::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, s.start(t, k) is - /// just a shortcut of the following code. - /// \code - /// s.findFlow(t, k); - /// s.findPaths(); - /// \endcode - int start(const Node& t, int k = 2) { - findFlow(t, k); - findPaths(); - return _path_num; + for (ArcIt e(_graph); e != INVALID; ++e) (*_flow)[e] = 0; + for (NodeIt n(_graph); n != INVALID; ++n) (*_potential)[n] = 0; } @@ -598,37 +373,18 @@ /// \pre \ref init() must be called before using this function. int findFlow(const Node& t, int k = 2) { - _t = t; - ResidualDijkstra dijkstra(*this); - - // Initialization - for (ArcIt e(_graph); e != INVALID; ++e) { - (*_flow)[e] = 0; - } - if (_full_init) { - for (NodeIt n(_graph); n != INVALID; ++n) { - (*_potential)[n] = (*_init_dist)[n]; - } - Node u = _t; - Arc e; - while ((e = (*_init_pred)[u]) != INVALID) { - (*_flow)[e] = 1; - u = _graph.source(e); - } - _path_num = 1; - } else { - for (NodeIt n(_graph); n != INVALID; ++n) { - (*_potential)[n] = 0; - } - _path_num = 0; - } + _target = t; + _dijkstra = + new ResidualDijkstra( _graph, *_flow, _length, *_potential, _pred, + _source, _target ); // Find shortest paths + _path_num = 0; while (_path_num < k) { // Run Dijkstra - if (!dijkstra.run(_path_num)) break; + if (!_dijkstra->run()) break; ++_path_num; // Set the flow along the found shortest path - Node u = _t; + Node u = _target; Arc e; while ((e = _pred[u]) != INVALID) { @@ -647,6 +403,6 @@ /// \brief Compute the paths from the flow. /// - /// This function computes arc-disjoint paths from the found minimum - /// cost flow, which is the union of them. + /// This function computes the paths from the found minimum cost flow, + /// which is the union of some arc-disjoint paths. /// /// \pre \ref init() and \ref findFlow() must be called before using @@ -656,13 +412,13 @@ for(ArcIt a(_graph); a != INVALID; ++a) res_flow[a] = (*_flow)[a]; - _paths.clear(); - _paths.resize(_path_num); + paths.clear(); + paths.resize(_path_num); for (int i = 0; i < _path_num; ++i) { - Node n = _s; - while (n != _t) { + Node n = _source; + while (n != _target) { OutArcIt e(_graph, n); for ( ; res_flow[e] == 0; ++e) ; n = _graph.target(e); - _paths[i].addBack(e); + paths[i].addBack(e); res_flow[e] = 0; } @@ -763,5 +519,5 @@ /// this function. const Path& path(int i) const { - return _paths[i]; + return paths[i]; } Index: lemon/time_measure.h =================================================================== --- lemon/time_measure.h (revision 786) +++ lemon/time_measure.h (revision 584) @@ -376,5 +376,5 @@ ///This function returns the number of stop() exections that is ///necessary to really stop the timer. - ///For example, the timer + ///For example the timer ///is running if and only if the return value is \c true ///(i.e. greater than Index: lemon/unionfind.h =================================================================== --- lemon/unionfind.h (revision 877) +++ lemon/unionfind.h (revision 867) @@ -3,5 +3,5 @@ * This file is a part of LEMON, a generic C++ optimization library. * - * Copyright (C) 2003-2010 + * Copyright (C) 2003-2009 * Egervary Jeno Kombinatorikus Optimalizalasi Kutatocsoport * (Egervary Research Group on Combinatorial Optimization, EGRES). @@ -44,5 +44,5 @@ /// This is a very simple but efficient implementation, providing /// only four methods: join (union), find, insert and size. - /// For more features, see the \ref UnionFindEnum class. + /// For more features see the \ref UnionFindEnum class. /// /// It is primarily used in Kruskal algorithm for finding minimal Index: m4/lx_check_coin.m4 =================================================================== --- m4/lx_check_coin.m4 (revision 749) +++ m4/lx_check_coin.m4 (revision 749) @@ -0,0 +1,136 @@ +AC_DEFUN([LX_CHECK_COIN], +[ + AC_ARG_WITH([coin], +AS_HELP_STRING([--with-coin@<:@=PREFIX@:>@], [search for CLP under PREFIX or under the default search paths if PREFIX is not given @<:@default@:>@]) +AS_HELP_STRING([--without-coin], [disable checking for CLP]), + [], [with_coin=yes]) + + AC_ARG_WITH([coin-includedir], +AS_HELP_STRING([--with-coin-includedir=DIR], [search for CLP headers in DIR]), + [], [with_coin_includedir=no]) + + AC_ARG_WITH([coin-libdir], +AS_HELP_STRING([--with-coin-libdir=DIR], [search for CLP libraries in DIR]), + [], [with_coin_libdir=no]) + + lx_clp_found=no + if test x"$with_coin" != x"no"; then + AC_MSG_CHECKING([for CLP]) + + if test x"$with_coin_includedir" != x"no"; then + CLP_CXXFLAGS="-I$with_coin_includedir" + elif test x"$with_coin" != x"yes"; then + CLP_CXXFLAGS="-I$with_coin/include" + fi + + if test x"$with_coin_libdir" != x"no"; then + CLP_LDFLAGS="-L$with_coin_libdir" + elif test x"$with_coin" != x"yes"; then + CLP_LDFLAGS="-L$with_coin/lib" + fi + CLP_LIBS="-lClp -lCoinUtils -lm" + + lx_save_cxxflags="$CXXFLAGS" + lx_save_ldflags="$LDFLAGS" + lx_save_libs="$LIBS" + CXXFLAGS="$CLP_CXXFLAGS" + LDFLAGS="$CLP_LDFLAGS" + LIBS="$CLP_LIBS" + + lx_clp_test_prog=' + #include + + int main(int argc, char** argv) + { + ClpModel clp; + return 0; + }' + + AC_LANG_PUSH(C++) + AC_LINK_IFELSE([$lx_clp_test_prog], [lx_clp_found=yes], [lx_clp_found=no]) + AC_LANG_POP(C++) + + CXXFLAGS="$lx_save_cxxflags" + LDFLAGS="$lx_save_ldflags" + LIBS="$lx_save_libs" + + if test x"$lx_clp_found" = x"yes"; then + AC_DEFINE([LEMON_HAVE_CLP], [1], [Define to 1 if you have CLP.]) + lx_lp_found=yes + AC_DEFINE([LEMON_HAVE_LP], [1], [Define to 1 if you have any LP solver.]) + AC_MSG_RESULT([yes]) + else + CLP_CXXFLAGS="" + CLP_LDFLAGS="" + CLP_LIBS="" + AC_MSG_RESULT([no]) + fi + fi + CLP_LIBS="$CLP_LDFLAGS $CLP_LIBS" + AC_SUBST(CLP_CXXFLAGS) + AC_SUBST(CLP_LIBS) + AM_CONDITIONAL([HAVE_CLP], [test x"$lx_clp_found" = x"yes"]) + + + lx_cbc_found=no + if test x"$lx_clp_found" = x"yes"; then + if test x"$with_coin" != x"no"; then + AC_MSG_CHECKING([for CBC]) + + if test x"$with_coin_includedir" != x"no"; then + CBC_CXXFLAGS="-I$with_coin_includedir" + elif test x"$with_coin" != x"yes"; then + CBC_CXXFLAGS="-I$with_coin/include" + fi + + if test x"$with_coin_libdir" != x"no"; then + CBC_LDFLAGS="-L$with_coin_libdir" + elif test x"$with_coin" != x"yes"; then + CBC_LDFLAGS="-L$with_coin/lib" + fi + CBC_LIBS="-lOsi -lCbc -lCbcSolver -lClp -lOsiClp -lCoinUtils -lVol -lOsiVol -lCgl -lm -llapack -lblas" + + lx_save_cxxflags="$CXXFLAGS" + lx_save_ldflags="$LDFLAGS" + lx_save_libs="$LIBS" + CXXFLAGS="$CBC_CXXFLAGS" + LDFLAGS="$CBC_LDFLAGS" + LIBS="$CBC_LIBS" + + lx_cbc_test_prog=' + #include + + int main(int argc, char** argv) + { + CbcModel cbc; + return 0; + }' + + AC_LANG_PUSH(C++) + AC_LINK_IFELSE([$lx_cbc_test_prog], [lx_cbc_found=yes], [lx_cbc_found=no]) + AC_LANG_POP(C++) + + CXXFLAGS="$lx_save_cxxflags" + LDFLAGS="$lx_save_ldflags" + LIBS="$lx_save_libs" + + if test x"$lx_cbc_found" = x"yes"; then + AC_DEFINE([LEMON_HAVE_CBC], [1], [Define to 1 if you have CBC.]) + lx_lp_found=yes + AC_DEFINE([LEMON_HAVE_LP], [1], [Define to 1 if you have any LP solver.]) + lx_mip_found=yes + AC_DEFINE([LEMON_HAVE_MIP], [1], [Define to 1 if you have any MIP solver.]) + AC_MSG_RESULT([yes]) + else + CBC_CXXFLAGS="" + CBC_LDFLAGS="" + CBC_LIBS="" + AC_MSG_RESULT([no]) + fi + fi + fi + CBC_LIBS="$CBC_LDFLAGS $CBC_LIBS" + AC_SUBST(CBC_CXXFLAGS) + AC_SUBST(CBC_LIBS) + AM_CONDITIONAL([HAVE_CBC], [test x"$lx_cbc_found" = x"yes"]) +]) Index: m4/lx_check_cplex.m4 =================================================================== --- m4/lx_check_cplex.m4 (revision 627) +++ m4/lx_check_cplex.m4 (revision 627) @@ -0,0 +1,81 @@ +AC_DEFUN([LX_CHECK_CPLEX], +[ + AC_ARG_WITH([cplex], +AS_HELP_STRING([--with-cplex@<:@=PREFIX@:>@], [search for CPLEX under PREFIX or under the default search paths if PREFIX is not given @<:@default@:>@]) +AS_HELP_STRING([--without-cplex], [disable checking for CPLEX]), + [], [with_cplex=yes]) + + AC_ARG_WITH([cplex-includedir], +AS_HELP_STRING([--with-cplex-includedir=DIR], [search for CPLEX headers in DIR]), + [], [with_cplex_includedir=no]) + + AC_ARG_WITH([cplex-libdir], +AS_HELP_STRING([--with-cplex-libdir=DIR], [search for CPLEX libraries in DIR]), + [], [with_cplex_libdir=no]) + + lx_cplex_found=no + if test x"$with_cplex" != x"no"; then + AC_MSG_CHECKING([for CPLEX]) + + if test x"$with_cplex_includedir" != x"no"; then + CPLEX_CFLAGS="-I$with_cplex_includedir" + elif test x"$with_cplex" != x"yes"; then + CPLEX_CFLAGS="-I$with_cplex/include" + elif test x"$CPLEX_INCLUDEDIR" != x; then + CPLEX_CFLAGS="-I$CPLEX_INCLUDEDIR" + fi + + if test x"$with_cplex_libdir" != x"no"; then + CPLEX_LDFLAGS="-L$with_cplex_libdir" + elif test x"$with_cplex" != x"yes"; then + CPLEX_LDFLAGS="-L$with_cplex/lib" + elif test x"$CPLEX_LIBDIR" != x; then + CPLEX_LDFLAGS="-L$CPLEX_LIBDIR" + fi + CPLEX_LIBS="-lcplex -lm -lpthread" + + lx_save_cxxflags="$CXXFLAGS" + lx_save_ldflags="$LDFLAGS" + lx_save_libs="$LIBS" + CXXFLAGS="$CPLEX_CFLAGS" + LDFLAGS="$CPLEX_LDFLAGS" + LIBS="$CPLEX_LIBS" + + lx_cplex_test_prog=' + extern "C" { + #include + } + + int main(int argc, char** argv) + { + CPXENVptr env = NULL; + return 0; + }' + + AC_LANG_PUSH(C++) + AC_LINK_IFELSE([$lx_cplex_test_prog], [lx_cplex_found=yes], [lx_cplex_found=no]) + AC_LANG_POP(C++) + + CXXFLAGS="$lx_save_cxxflags" + LDFLAGS="$lx_save_ldflags" + LIBS="$lx_save_libs" + + if test x"$lx_cplex_found" = x"yes"; then + AC_DEFINE([LEMON_HAVE_CPLEX], [1], [Define to 1 if you have CPLEX.]) + lx_lp_found=yes + AC_DEFINE([LEMON_HAVE_LP], [1], [Define to 1 if you have any LP solver.]) + lx_mip_found=yes + AC_DEFINE([LEMON_HAVE_MIP], [1], [Define to 1 if you have any MIP solver.]) + AC_MSG_RESULT([yes]) + else + CPLEX_CFLAGS="" + CPLEX_LDFLAGS="" + CPLEX_LIBS="" + AC_MSG_RESULT([no]) + fi + fi + CPLEX_LIBS="$CPLEX_LDFLAGS $CPLEX_LIBS" + AC_SUBST(CPLEX_CFLAGS) + AC_SUBST(CPLEX_LIBS) + AM_CONDITIONAL([HAVE_CPLEX], [test x"$lx_cplex_found" = x"yes"]) +]) Index: m4/lx_check_glpk.m4 =================================================================== --- m4/lx_check_glpk.m4 (revision 627) +++ m4/lx_check_glpk.m4 (revision 627) @@ -0,0 +1,84 @@ +AC_DEFUN([LX_CHECK_GLPK], +[ + AC_ARG_WITH([glpk], +AS_HELP_STRING([--with-glpk@<:@=PREFIX@:>@], [search for GLPK under PREFIX or under the default search paths if PREFIX is not given @<:@default@:>@]) +AS_HELP_STRING([--without-glpk], [disable checking for GLPK]), + [], [with_glpk=yes]) + + AC_ARG_WITH([glpk-includedir], +AS_HELP_STRING([--with-glpk-includedir=DIR], [search for GLPK headers in DIR]), + [], [with_glpk_includedir=no]) + + AC_ARG_WITH([glpk-libdir], +AS_HELP_STRING([--with-glpk-libdir=DIR], [search for GLPK libraries in DIR]), + [], [with_glpk_libdir=no]) + + lx_glpk_found=no + if test x"$with_glpk" != x"no"; then + AC_MSG_CHECKING([for GLPK]) + + if test x"$with_glpk_includedir" != x"no"; then + GLPK_CFLAGS="-I$with_glpk_includedir" + elif test x"$with_glpk" != x"yes"; then + GLPK_CFLAGS="-I$with_glpk/include" + fi + + if test x"$with_glpk_libdir" != x"no"; then + GLPK_LDFLAGS="-L$with_glpk_libdir" + elif test x"$with_glpk" != x"yes"; then + GLPK_LDFLAGS="-L$with_glpk/lib" + fi + GLPK_LIBS="-lglpk" + + lx_save_cxxflags="$CXXFLAGS" + lx_save_ldflags="$LDFLAGS" + lx_save_libs="$LIBS" + CXXFLAGS="$GLPK_CFLAGS" + LDFLAGS="$GLPK_LDFLAGS" + LIBS="$GLPK_LIBS" + + lx_glpk_test_prog=' + extern "C" { + #include + } + + #if (GLP_MAJOR_VERSION < 4) \ + || (GLP_MAJOR_VERSION == 4 && GLP_MINOR_VERSION < 33) + #error Supported GLPK versions: 4.33 or above + #endif + + int main(int argc, char** argv) + { + LPX *lp; + lp = lpx_create_prob(); + lpx_delete_prob(lp); + return 0; + }' + + AC_LANG_PUSH(C++) + AC_LINK_IFELSE([$lx_glpk_test_prog], [lx_glpk_found=yes], [lx_glpk_found=no]) + AC_LANG_POP(C++) + + CXXFLAGS="$lx_save_cxxflags" + LDFLAGS="$lx_save_ldflags" + LIBS="$lx_save_libs" + + if test x"$lx_glpk_found" = x"yes"; then + AC_DEFINE([LEMON_HAVE_GLPK], [1], [Define to 1 if you have GLPK.]) + lx_lp_found=yes + AC_DEFINE([LEMON_HAVE_LP], [1], [Define to 1 if you have any LP solver.]) + lx_mip_found=yes + AC_DEFINE([LEMON_HAVE_MIP], [1], [Define to 1 if you have any MIP solver.]) + AC_MSG_RESULT([yes]) + else + GLPK_CFLAGS="" + GLPK_LDFLAGS="" + GLPK_LIBS="" + AC_MSG_RESULT([no]) + fi + fi + GLPK_LIBS="$GLPK_LDFLAGS $GLPK_LIBS" + AC_SUBST(GLPK_CFLAGS) + AC_SUBST(GLPK_LIBS) + AM_CONDITIONAL([HAVE_GLPK], [test x"$lx_glpk_found" = x"yes"]) +]) Index: m4/lx_check_soplex.m4 =================================================================== --- m4/lx_check_soplex.m4 (revision 627) +++ m4/lx_check_soplex.m4 (revision 627) @@ -0,0 +1,73 @@ +AC_DEFUN([LX_CHECK_SOPLEX], +[ + AC_ARG_WITH([soplex], +AS_HELP_STRING([--with-soplex@<:@=PREFIX@:>@], [search for SOPLEX under PREFIX or under the default search paths if PREFIX is not given @<:@default@:>@]) +AS_HELP_STRING([--without-soplex], [disable checking for SOPLEX]), + [], [with_soplex=yes]) + + AC_ARG_WITH([soplex-includedir], +AS_HELP_STRING([--with-soplex-includedir=DIR], [search for SOPLEX headers in DIR]), + [], [with_soplex_includedir=no]) + + AC_ARG_WITH([soplex-libdir], +AS_HELP_STRING([--with-soplex-libdir=DIR], [search for SOPLEX libraries in DIR]), + [], [with_soplex_libdir=no]) + + lx_soplex_found=no + if test x"$with_soplex" != x"no"; then + AC_MSG_CHECKING([for SOPLEX]) + + if test x"$with_soplex_includedir" != x"no"; then + SOPLEX_CXXFLAGS="-I$with_soplex_includedir" + elif test x"$with_soplex" != x"yes"; then + SOPLEX_CXXFLAGS="-I$with_soplex/src" + fi + + if test x"$with_soplex_libdir" != x"no"; then + SOPLEX_LDFLAGS="-L$with_soplex_libdir" + elif test x"$with_soplex" != x"yes"; then + SOPLEX_LDFLAGS="-L$with_soplex/lib" + fi + SOPLEX_LIBS="-lsoplex -lz" + + lx_save_cxxflags="$CXXFLAGS" + lx_save_ldflags="$LDFLAGS" + lx_save_libs="$LIBS" + CXXFLAGS="$SOPLEX_CXXFLAGS" + LDFLAGS="$SOPLEX_LDFLAGS" + LIBS="$SOPLEX_LIBS" + + lx_soplex_test_prog=' + #include + + int main(int argc, char** argv) + { + soplex::SoPlex soplex; + return 0; + }' + + AC_LANG_PUSH(C++) + AC_LINK_IFELSE([$lx_soplex_test_prog], [lx_soplex_found=yes], [lx_soplex_found=no]) + AC_LANG_POP(C++) + + CXXFLAGS="$lx_save_cxxflags" + LDFLAGS="$lx_save_ldflags" + LIBS="$lx_save_libs" + + if test x"$lx_soplex_found" = x"yes"; then + AC_DEFINE([LEMON_HAVE_SOPLEX], [1], [Define to 1 if you have SOPLEX.]) + lx_lp_found=yes + AC_DEFINE([LEMON_HAVE_LP], [1], [Define to 1 if you have any LP solver.]) + AC_MSG_RESULT([yes]) + else + SOPLEX_CXXFLAGS="" + SOPLEX_LDFLAGS="" + SOPLEX_LIBS="" + AC_MSG_RESULT([no]) + fi + fi + SOPLEX_LIBS="$SOPLEX_LDFLAGS $SOPLEX_LIBS" + AC_SUBST(SOPLEX_CXXFLAGS) + AC_SUBST(SOPLEX_LIBS) + AM_CONDITIONAL([HAVE_SOPLEX], [test x"$lx_soplex_found" = x"yes"]) +]) Index: ripts/bib2dox.py =================================================================== --- scripts/bib2dox.py (revision 836) +++ (revision ) @@ -1,816 +1,0 @@ -#! /usr/bin/env python -""" - BibTeX to Doxygen converter - Usage: python bib2dox.py bibfile.bib > bibfile.dox - - This file is a part of LEMON, a generic C++ optimization library. - - ********************************************************************** - - This code is the modification of the BibTeX to XML converter - by Vidar Bronken Gundersen et al. - See the original copyright notices below. - - ********************************************************************** - - Decoder for bibliographic data, BibTeX - Usage: python bibtex2xml.py bibfile.bib > bibfile.xml - - v.8 - (c)2002-06-23 Vidar Bronken Gundersen - http://bibtexml.sf.net/ - Reuse approved as long as this notification is kept. - Licence: GPL. - - Contributions/thanks to: - Egon Willighagen, http://sf.net/projects/jreferences/ - Richard Mahoney (for providing a test case) - - Editted by Sara Sprenkle to be more robust and handle more bibtex features. - (c) 2003-01-15 - - 1. Changed bibtex: tags to bibxml: tags. - 2. Use xmlns:bibxml="http://bibtexml.sf.net/" - 3. Allow spaces between @type and first { - 4. "author" fields with multiple authors split by " and " - are put in separate xml "bibxml:author" tags. - 5. Option for Titles: words are capitalized - only if first letter in title or capitalized inside braces - 6. Removes braces from within field values - 7. Ignores comments in bibtex file (including @comment{ or % ) - 8. Replaces some special latex tags, e.g., replaces ~ with ' ' - 9. Handles bibtex @string abbreviations - --> includes bibtex's default abbreviations for months - --> does concatenation of abbr # " more " and " more " # abbr - 10. Handles @type( ... ) or @type{ ... } - 11. The keywords field is split on , or ; and put into separate xml - "bibxml:keywords" tags - 12. Ignores @preamble - - Known Limitations - 1. Does not transform Latex encoding like math mode and special - latex symbols. - 2. Does not parse author fields into first and last names. - E.g., It does not do anything special to an author whose name is - in the form LAST_NAME, FIRST_NAME - In "author" tag, will show up as - LAST_NAME, FIRST_NAME - 3. Does not handle "crossref" fields other than to print - ... - 4. Does not inform user of the input's format errors. You just won't - be able to transform the file later with XSL - - You will have to manually edit the XML output if you need to handle - these (and unknown) limitations. - -""" - -import string, re - -# set of valid name characters -valid_name_chars = '[\w\-:]' - -# -# define global regular expression variables -# -author_rex = re.compile('\s+and\s+') -rembraces_rex = re.compile('[{}]') -capitalize_rex = re.compile('({[^}]*})') - -# used by bibtexkeywords(data) -keywords_rex = re.compile('[,;]') - -# used by concat_line(line) -concatsplit_rex = re.compile('\s*#\s*') - -# split on {, }, or " in verify_out_of_braces -delimiter_rex = re.compile('([{}"])',re.I) - -field_rex = re.compile('\s*(\w*)\s*=\s*(.*)') -data_rex = re.compile('\s*(\w*)\s*=\s*([^,]*),?') - -url_rex = re.compile('\\\url\{([^}]*)\}') - -# -# styles for html formatting -# -divstyle = 'margin-top: -4ex; margin-left: 8em;' - -# -# return the string parameter without braces -# -def transformurls(str): - return url_rex.sub(r'\1', str) - -# -# return the string parameter without braces -# -def removebraces(str): - return rembraces_rex.sub('', str) - -# -# latex-specific replacements -# (do this after braces were removed) -# -def latexreplacements(line): - line = string.replace(line, '~', ' ') - line = string.replace(line, '\\\'a', 'á') - line = string.replace(line, '\\"a', 'ä') - line = string.replace(line, '\\\'e', 'é') - line = string.replace(line, '\\"e', 'ë') - line = string.replace(line, '\\\'i', 'í') - line = string.replace(line, '\\"i', 'ï') - line = string.replace(line, '\\\'o', 'ó') - line = string.replace(line, '\\"o', 'ö') - line = string.replace(line, '\\\'u', 'ú') - line = string.replace(line, '\\"u', 'ü') - line = string.replace(line, '\\H o', 'õ') - line = string.replace(line, '\\H u', 'ü') # ũ does not exist - line = string.replace(line, '\\\'A', 'Á') - line = string.replace(line, '\\"A', 'Ä') - line = string.replace(line, '\\\'E', 'É') - line = string.replace(line, '\\"E', 'Ë') - line = string.replace(line, '\\\'I', 'Í') - line = string.replace(line, '\\"I', 'Ï') - line = string.replace(line, '\\\'O', 'Ó') - line = string.replace(line, '\\"O', 'Ö') - line = string.replace(line, '\\\'U', 'Ú') - line = string.replace(line, '\\"U', 'Ü') - line = string.replace(line, '\\H O', 'Õ') - line = string.replace(line, '\\H U', 'Ü') # Ũ does not exist - - return line - -# -# copy characters form a string decoding html expressions (&xyz;) -# -def copychars(str, ifrom, count): - result = '' - i = ifrom - c = 0 - html_spec = False - while (i < len(str)) and (c < count): - if str[i] == '&': - html_spec = True; - if i+1 < len(str): - result += str[i+1] - c += 1 - i += 2 - else: - if not html_spec: - if ((str[i] >= 'A') and (str[i] <= 'Z')) or \ - ((str[i] >= 'a') and (str[i] <= 'z')): - result += str[i] - c += 1 - elif str[i] == ';': - html_spec = False; - i += 1 - - return result - - -# -# Handle a list of authors (separated by 'and'). -# It gives back an array of the follwing values: -# - num: the number of authors, -# - list: the list of the author names, -# - text: the bibtex text (separated by commas and/or 'and') -# - abbrev: abbreviation that can be used for indicate the -# bibliography entries -# -def bibtexauthor(data): - result = {} - bibtex = '' - result['list'] = author_rex.split(data) - result['num'] = len(result['list']) - for i, author in enumerate(result['list']): - # general transformations - author = latexreplacements(removebraces(author.strip())) - # transform "Xyz, A. B." to "A. B. Xyz" - pos = author.find(',') - if pos != -1: - author = author[pos+1:].strip() + ' ' + author[:pos].strip() - result['list'][i] = author - bibtex += author + '#' - bibtex = bibtex[:-1] - if result['num'] > 1: - ix = bibtex.rfind('#') - if result['num'] == 2: - bibtex = bibtex[:ix] + ' and ' + bibtex[ix+1:] - else: - bibtex = bibtex[:ix] + ', and ' + bibtex[ix+1:] - bibtex = bibtex.replace('#', ', ') - result['text'] = bibtex - - result['abbrev'] = '' - for author in result['list']: - pos = author.rfind(' ') + 1 - count = 1 - if result['num'] == 1: - count = 3 - result['abbrev'] += copychars(author, pos, count) - - return result - - -# -# data = title string -# @return the capitalized title (first letter is capitalized), rest are capitalized -# only if capitalized inside braces -# -def capitalizetitle(data): - title_list = capitalize_rex.split(data) - title = '' - count = 0 - for phrase in title_list: - check = string.lstrip(phrase) - - # keep phrase's capitalization the same - if check.find('{') == 0: - title += removebraces(phrase) - else: - # first word --> capitalize first letter (after spaces) - if count == 0: - title += check.capitalize() - else: - title += phrase.lower() - count = count + 1 - - return title - - -# -# @return the bibtex for the title -# @param data --> title string -# braces are removed from title -# -def bibtextitle(data, entrytype): - if entrytype in ('book', 'inbook'): - title = removebraces(data.strip()) - else: - title = removebraces(capitalizetitle(data.strip())) - bibtex = title - return bibtex - - -# -# function to compare entry lists -# -def entry_cmp(x, y): - return cmp(x[0], y[0]) - - -# -# print the XML for the transformed "filecont_source" -# -def bibtexdecoder(filecont_source): - filecont = [] - file = [] - - # want @{, - pubtype_rex = re.compile('@(\w*)\s*{\s*(.*),') - endtype_rex = re.compile('}\s*$') - endtag_rex = re.compile('^\s*}\s*$') - - bracefield_rex = re.compile('\s*(\w*)\s*=\s*(.*)') - bracedata_rex = re.compile('\s*(\w*)\s*=\s*{(.*)},?') - - quotefield_rex = re.compile('\s*(\w*)\s*=\s*(.*)') - quotedata_rex = re.compile('\s*(\w*)\s*=\s*"(.*)",?') - - for line in filecont_source: - line = line[:-1] - - # encode character entities - line = string.replace(line, '&', '&') - line = string.replace(line, '<', '<') - line = string.replace(line, '>', '>') - - # start entry: publication type (store for later use) - if pubtype_rex.match(line): - # want @{, - entrycont = {} - entry = [] - entrytype = pubtype_rex.sub('\g<1>',line) - entrytype = string.lower(entrytype) - entryid = pubtype_rex.sub('\g<2>', line) - - # end entry if just a } - elif endtype_rex.match(line): - # generate doxygen code for the entry - - # enty type related formattings - if entrytype in ('book', 'inbook'): - entrycont['title'] = '' + entrycont['title'] + '' - if not entrycont.has_key('author'): - entrycont['author'] = entrycont['editor'] - entrycont['author']['text'] += ', editors' - elif entrytype == 'article': - entrycont['journal'] = '' + entrycont['journal'] + '' - elif entrytype in ('inproceedings', 'incollection', 'conference'): - entrycont['booktitle'] = '' + entrycont['booktitle'] + '' - elif entrytype == 'techreport': - if not entrycont.has_key('type'): - entrycont['type'] = 'Technical report' - elif entrytype == 'mastersthesis': - entrycont['type'] = 'Master\'s thesis' - elif entrytype == 'phdthesis': - entrycont['type'] = 'PhD thesis' - - for eline in entrycont: - if eline != '': - eline = latexreplacements(eline) - - if entrycont.has_key('pages') and (entrycont['pages'] != ''): - entrycont['pages'] = string.replace(entrycont['pages'], '--', '-') - - if entrycont.has_key('author') and (entrycont['author'] != ''): - entry.append(entrycont['author']['text'] + '.') - if entrycont.has_key('title') and (entrycont['title'] != ''): - entry.append(entrycont['title'] + '.') - if entrycont.has_key('journal') and (entrycont['journal'] != ''): - entry.append(entrycont['journal'] + ',') - if entrycont.has_key('booktitle') and (entrycont['booktitle'] != ''): - entry.append('In ' + entrycont['booktitle'] + ',') - if entrycont.has_key('type') and (entrycont['type'] != ''): - eline = entrycont['type'] - if entrycont.has_key('number') and (entrycont['number'] != ''): - eline += ' ' + entrycont['number'] - eline += ',' - entry.append(eline) - if entrycont.has_key('institution') and (entrycont['institution'] != ''): - entry.append(entrycont['institution'] + ',') - if entrycont.has_key('publisher') and (entrycont['publisher'] != ''): - entry.append(entrycont['publisher'] + ',') - if entrycont.has_key('school') and (entrycont['school'] != ''): - entry.append(entrycont['school'] + ',') - if entrycont.has_key('address') and (entrycont['address'] != ''): - entry.append(entrycont['address'] + ',') - if entrycont.has_key('edition') and (entrycont['edition'] != ''): - entry.append(entrycont['edition'] + ' edition,') - if entrycont.has_key('howpublished') and (entrycont['howpublished'] != ''): - entry.append(entrycont['howpublished'] + ',') - if entrycont.has_key('volume') and (entrycont['volume'] != ''): - eline = entrycont['volume']; - if entrycont.has_key('number') and (entrycont['number'] != ''): - eline += '(' + entrycont['number'] + ')' - if entrycont.has_key('pages') and (entrycont['pages'] != ''): - eline += ':' + entrycont['pages'] - eline += ',' - entry.append(eline) - else: - if entrycont.has_key('pages') and (entrycont['pages'] != ''): - entry.append('pages ' + entrycont['pages'] + ',') - if entrycont.has_key('year') and (entrycont['year'] != ''): - if entrycont.has_key('month') and (entrycont['month'] != ''): - entry.append(entrycont['month'] + ' ' + entrycont['year'] + '.') - else: - entry.append(entrycont['year'] + '.') - if entrycont.has_key('note') and (entrycont['note'] != ''): - entry.append(entrycont['note'] + '.') - if entrycont.has_key('url') and (entrycont['url'] != ''): - entry.append(entrycont['url'] + '.') - - # generate keys for sorting and for the output - sortkey = '' - bibkey = '' - if entrycont.has_key('author'): - for author in entrycont['author']['list']: - sortkey += copychars(author, author.rfind(' ')+1, len(author)) - bibkey = entrycont['author']['abbrev'] - else: - bibkey = 'x' - if entrycont.has_key('year'): - sortkey += entrycont['year'] - bibkey += entrycont['year'][-2:] - if entrycont.has_key('title'): - sortkey += entrycont['title'] - if entrycont.has_key('key'): - sortkey = entrycont['key'] + sortkey - bibkey = entrycont['key'] - entry.insert(0, sortkey) - entry.insert(1, bibkey) - entry.insert(2, entryid) - - # add the entry to the file contents - filecont.append(entry) - - else: - # field, publication info - field = '' - data = '' - - # field = {data} entries - if bracedata_rex.match(line): - field = bracefield_rex.sub('\g<1>', line) - field = string.lower(field) - data = bracedata_rex.sub('\g<2>', line) - - # field = "data" entries - elif quotedata_rex.match(line): - field = quotefield_rex.sub('\g<1>', line) - field = string.lower(field) - data = quotedata_rex.sub('\g<2>', line) - - # field = data entries - elif data_rex.match(line): - field = field_rex.sub('\g<1>', line) - field = string.lower(field) - data = data_rex.sub('\g<2>', line) - - if field == 'url': - data = '\\url{' + data.strip() + '}' - - if field in ('author', 'editor'): - entrycont[field] = bibtexauthor(data) - line = '' - elif field == 'title': - line = bibtextitle(data, entrytype) - elif field != '': - line = removebraces(transformurls(data.strip())) - - if line != '': - line = latexreplacements(line) - entrycont[field] = line - - - # sort entries - filecont.sort(entry_cmp) - - # count the bibtex keys - keytable = {} - counttable = {} - for entry in filecont: - bibkey = entry[1] - if not keytable.has_key(bibkey): - keytable[bibkey] = 1 - else: - keytable[bibkey] += 1 - - for bibkey in keytable.keys(): - counttable[bibkey] = 0 - - # generate output - for entry in filecont: - # generate output key form the bibtex key - bibkey = entry[1] - entryid = entry[2] - if keytable[bibkey] == 1: - outkey = bibkey - else: - outkey = bibkey + chr(97 + counttable[bibkey]) - counttable[bibkey] += 1 - - # append the entry code to the output - file.append('\\section ' + entryid + ' [' + outkey + ']') - file.append('
') - for line in entry[3:]: - file.append(line) - file.append('
') - file.append('') - - return file - - -# -# return 1 iff abbr is in line but not inside braces or quotes -# assumes that abbr appears only once on the line (out of braces and quotes) -# -def verify_out_of_braces(line, abbr): - - phrase_split = delimiter_rex.split(line) - - abbr_rex = re.compile( '\\b' + abbr + '\\b', re.I) - - open_brace = 0 - open_quote = 0 - - for phrase in phrase_split: - if phrase == "{": - open_brace = open_brace + 1 - elif phrase == "}": - open_brace = open_brace - 1 - elif phrase == '"': - if open_quote == 1: - open_quote = 0 - else: - open_quote = 1 - elif abbr_rex.search(phrase): - if open_brace == 0 and open_quote == 0: - return 1 - - return 0 - - -# -# a line in the form phrase1 # phrase2 # ... # phrasen -# is returned as phrase1 phrase2 ... phrasen -# with the correct punctuation -# Bug: Doesn't always work with multiple abbreviations plugged in -# -def concat_line(line): - # only look at part after equals - field = field_rex.sub('\g<1>',line) - rest = field_rex.sub('\g<2>',line) - - concat_line = field + ' =' - - pound_split = concatsplit_rex.split(rest) - - phrase_count = 0 - length = len(pound_split) - - for phrase in pound_split: - phrase = phrase.strip() - if phrase_count != 0: - if phrase.startswith('"') or phrase.startswith('{'): - phrase = phrase[1:] - elif phrase.startswith('"'): - phrase = phrase.replace('"','{',1) - - if phrase_count != length-1: - if phrase.endswith('"') or phrase.endswith('}'): - phrase = phrase[:-1] - else: - if phrase.endswith('"'): - phrase = phrase[:-1] - phrase = phrase + "}" - elif phrase.endswith('",'): - phrase = phrase[:-2] - phrase = phrase + "}," - - # if phrase did have \#, add the \# back - if phrase.endswith('\\'): - phrase = phrase + "#" - concat_line = concat_line + ' ' + phrase - - phrase_count = phrase_count + 1 - - return concat_line - - -# -# substitute abbreviations into filecont -# @param filecont_source - string of data from file -# -def bibtex_replace_abbreviations(filecont_source): - filecont = filecont_source.splitlines() - - # These are defined in bibtex, so we'll define them too - abbr_list = ['jan','feb','mar','apr','may','jun', - 'jul','aug','sep','oct','nov','dec'] - value_list = ['January','February','March','April', - 'May','June','July','August','September', - 'October','November','December'] - - abbr_rex = [] - total_abbr_count = 0 - - front = '\\b' - back = '(,?)\\b' - - for x in abbr_list: - abbr_rex.append( re.compile( front + abbr_list[total_abbr_count] + back, re.I ) ) - total_abbr_count = total_abbr_count + 1 - - - abbrdef_rex = re.compile('\s*@string\s*{\s*('+ valid_name_chars +'*)\s*=(.*)', - re.I) - - comment_rex = re.compile('@comment\s*{',re.I) - preamble_rex = re.compile('@preamble\s*{',re.I) - - waiting_for_end_string = 0 - i = 0 - filecont2 = '' - - for line in filecont: - if line == ' ' or line == '': - continue - - if waiting_for_end_string: - if re.search('}',line): - waiting_for_end_string = 0 - continue - - if abbrdef_rex.search(line): - abbr = abbrdef_rex.sub('\g<1>', line) - - if abbr_list.count(abbr) == 0: - val = abbrdef_rex.sub('\g<2>', line) - abbr_list.append(abbr) - value_list.append(string.strip(val)) - abbr_rex.append( re.compile( front + abbr_list[total_abbr_count] + back, re.I ) ) - total_abbr_count = total_abbr_count + 1 - waiting_for_end_string = 1 - continue - - if comment_rex.search(line): - waiting_for_end_string = 1 - continue - - if preamble_rex.search(line): - waiting_for_end_string = 1 - continue - - - # replace subsequent abbreviations with the value - abbr_count = 0 - - for x in abbr_list: - - if abbr_rex[abbr_count].search(line): - if verify_out_of_braces(line,abbr_list[abbr_count]) == 1: - line = abbr_rex[abbr_count].sub( value_list[abbr_count] + '\g<1>', line) - # Check for # concatenations - if concatsplit_rex.search(line): - line = concat_line(line) - abbr_count = abbr_count + 1 - - - filecont2 = filecont2 + line + '\n' - i = i+1 - - - # Do one final pass over file - - # make sure that didn't end up with {" or }" after the substitution - filecont2 = filecont2.replace('{"','{{') - filecont2 = filecont2.replace('"}','}}') - - afterquotevalue_rex = re.compile('"\s*,\s*') - afterbrace_rex = re.compile('"\s*}') - afterbracevalue_rex = re.compile('(=\s*{[^=]*)},\s*') - - # add new lines to data that changed because of abbreviation substitutions - filecont2 = afterquotevalue_rex.sub('",\n', filecont2) - filecont2 = afterbrace_rex.sub('"\n}', filecont2) - filecont2 = afterbracevalue_rex.sub('\g<1>},\n', filecont2) - - return filecont2 - -# -# convert @type( ... ) to @type{ ... } -# -def no_outer_parens(filecont): - - # do checking for open parens - # will convert to braces - paren_split = re.split('([(){}])',filecont) - - open_paren_count = 0 - open_type = 0 - look_next = 0 - - # rebuild filecont - filecont = '' - - at_rex = re.compile('@\w*') - - for phrase in paren_split: - if look_next == 1: - if phrase == '(': - phrase = '{' - open_paren_count = open_paren_count + 1 - else: - open_type = 0 - look_next = 0 - - if phrase == '(': - open_paren_count = open_paren_count + 1 - - elif phrase == ')': - open_paren_count = open_paren_count - 1 - if open_type == 1 and open_paren_count == 0: - phrase = '}' - open_type = 0 - - elif at_rex.search( phrase ): - open_type = 1 - look_next = 1 - - filecont = filecont + phrase - - return filecont - - -# -# make all whitespace into just one space -# format the bibtex file into a usable form. -# -def bibtexwasher(filecont_source): - - space_rex = re.compile('\s+') - comment_rex = re.compile('\s*%') - - filecont = [] - - # remove trailing and excessive whitespace - # ignore comments - for line in filecont_source: - line = string.strip(line) - line = space_rex.sub(' ', line) - # ignore comments - if not comment_rex.match(line) and line != '': - filecont.append(' '+ line) - - filecont = string.join(filecont, '') - - # the file is in one long string - - filecont = no_outer_parens(filecont) - - # - # split lines according to preferred syntax scheme - # - filecont = re.sub('(=\s*{[^=]*)},', '\g<1>},\n', filecont) - - # add new lines after commas that are after values - filecont = re.sub('"\s*,', '",\n', filecont) - filecont = re.sub('=\s*([\w\d]+)\s*,', '= \g<1>,\n', filecont) - filecont = re.sub('(@\w*)\s*({(\s*)[^,\s]*)\s*,', - '\n\n\g<1>\g<2>,\n', filecont) - - # add new lines after } - filecont = re.sub('"\s*}','"\n}\n', filecont) - filecont = re.sub('}\s*,','},\n', filecont) - - - filecont = re.sub('@(\w*)', '\n@\g<1>', filecont) - - # character encoding, reserved latex characters - filecont = re.sub('{\\\&}', '&', filecont) - filecont = re.sub('\\\&', '&', filecont) - - # do checking for open braces to get format correct - open_brace_count = 0 - brace_split = re.split('([{}])',filecont) - - # rebuild filecont - filecont = '' - - for phrase in brace_split: - if phrase == '{': - open_brace_count = open_brace_count + 1 - elif phrase == '}': - open_brace_count = open_brace_count - 1 - if open_brace_count == 0: - filecont = filecont + '\n' - - filecont = filecont + phrase - - filecont2 = bibtex_replace_abbreviations(filecont) - - # gather - filecont = filecont2.splitlines() - i=0 - j=0 # count the number of blank lines - for line in filecont: - # ignore blank lines - if line == '' or line == ' ': - j = j+1 - continue - filecont[i] = line + '\n' - i = i+1 - - # get rid of the extra stuff at the end of the array - # (The extra stuff are duplicates that are in the array because - # blank lines were removed.) - length = len( filecont) - filecont[length-j:length] = [] - - return filecont - - -def filehandler(filepath): - try: - fd = open(filepath, 'r') - filecont_source = fd.readlines() - fd.close() - except: - print 'Could not open file:', filepath - washeddata = bibtexwasher(filecont_source) - outdata = bibtexdecoder(washeddata) - print '/**' - print '\page references References' - print - for line in outdata: - print line - print '*/' - - -# main program - -def main(): - import sys - if sys.argv[1:]: - filepath = sys.argv[1] - else: - print "No input file" - sys.exit() - filehandler(filepath) - -if __name__ == "__main__": main() - - -# end python script Index: scripts/chg-len.py =================================================================== --- scripts/chg-len.py (revision 422) +++ scripts/chg-len.py (revision 422) @@ -0,0 +1,32 @@ +#! /usr/bin/env python + +import sys + +from mercurial import ui, hg +from mercurial import util + +util.rcpath = lambda : [] + +if len(sys.argv)>1 and sys.argv[1] in ["-h","--help"]: + print """ +This utility just prints the length of the longest path +in the revision graph from revison 0 to the current one. +""" + exit(0) + +u = ui.ui() +r = hg.repository(u, ".") +N = r.changectx(".").rev() +lengths=[0]*(N+1) +for i in range(N+1): + p=r.changectx(i).parents() + if p[0]: + p0=lengths[p[0].rev()] + else: + p0=-1 + if len(p)>1 and p[1]: + p1=lengths[p[1].rev()] + else: + p1=-1 + lengths[i]=max(p0,p1)+1 +print lengths[N] Index: scripts/mk-release.sh =================================================================== --- scripts/mk-release.sh (revision 564) +++ scripts/mk-release.sh (revision 564) @@ -0,0 +1,35 @@ +#!/bin/bash + +set -e + +if [ $# = 0 ]; then + echo "Usage: $0 release-id" + exit 1 +else + export LEMON_VERSION=$1 +fi + +echo '*****************************************************************' +echo ' Start making release tarballs for version '${LEMON_VERSION} +echo '*****************************************************************' + +autoreconf -vif +./configure + +make +make html +make distcheck +tar xf lemon-${LEMON_VERSION}.tar.gz +zip -r lemon-${LEMON_VERSION}.zip lemon-${LEMON_VERSION} +mv lemon-${LEMON_VERSION}/doc/html lemon-doc-${LEMON_VERSION} +tar czf lemon-doc-${LEMON_VERSION}.tar.gz lemon-doc-${LEMON_VERSION} +zip -r lemon-doc-${LEMON_VERSION}.zip lemon-doc-${LEMON_VERSION} +tar czf lemon-nodoc-${LEMON_VERSION}.tar.gz lemon-${LEMON_VERSION} +zip -r lemon-nodoc-${LEMON_VERSION}.zip lemon-${LEMON_VERSION} +hg tag -m 'LEMON '${LEMON_VERSION}' released ('$(hg par --template="{node|short}")' tagged as r'${LEMON_VERSION}')' r${LEMON_VERSION} + +rm -rf lemon-${LEMON_VERSION} lemon-doc-${LEMON_VERSION} + +echo '*****************************************************************' +echo ' Release '${LEMON_VERSION}' has been created' +echo '*****************************************************************' Index: scripts/unify-sources.sh =================================================================== --- scripts/unify-sources.sh (revision 733) +++ scripts/unify-sources.sh (revision 655) @@ -1,17 +1,3 @@ #!/bin/bash -# -# This file is a part of LEMON, a generic C++ optimization library. -# -# Copyright (C) 2003-2009 -# Egervary Jeno Kombinatorikus Optimalizalasi Kutatocsoport -# (Egervary Research Group on Combinatorial Optimization, EGRES). -# -# Permission to use, modify and distribute this software is granted -# provided that this copyright notice appears in all copies. For -# precise terms see the accompanying LICENSE file. -# -# This software is provided "AS IS" with no warranty of any kind, -# express or implied, and with no claim as to its suitability for any -# purpose. YEAR=`date +%Y` Index: ripts/valgrind-wrapper.sh =================================================================== --- scripts/valgrind-wrapper.sh (revision 793) +++ (revision ) @@ -1,22 +1,0 @@ -#!/bin/sh - -# Run in valgrind, with leak checking enabled - -valgrind -q --leak-check=full "$@" 2> .valgrind-log - -# Save the test result - -result="$?" - -# Valgrind should generate no error messages - -log_contents="`cat .valgrind-log`" - -if [ "$log_contents" != "" ]; then - cat .valgrind-log >&2 - result=1 -fi - -rm -f .valgrind-log - -exit $result Index: test/CMakeLists.txt =================================================================== --- test/CMakeLists.txt (revision 1000) +++ test/CMakeLists.txt (revision 993) @@ -15,5 +15,4 @@ adaptors_test arc_look_up_test - bellman_ford_test bfs_test circulation_test @@ -27,5 +26,4 @@ error_test euler_test - fractional_matching_test gomory_hu_test graph_copy_test @@ -38,12 +36,7 @@ maps_test matching_test - max_cardinality_search_test - max_clique_test min_cost_arborescence_test min_cost_flow_test - min_mean_cycle_test - nagamochi_ibaraki_test path_test - planarity_test preflow_test radix_sort_test Index: test/Makefile.am =================================================================== --- test/Makefile.am (revision 959) +++ test/Makefile.am (revision 959) @@ -0,0 +1,89 @@ +EXTRA_DIST += \ + test/CMakeLists.txt + +noinst_HEADERS += \ + test/graph_test.h \ + test/test_tools.h + +check_PROGRAMS += \ + test/adaptors_test \ + test/bfs_test \ + test/circulation_test \ + test/connectivity_test \ + test/counter_test \ + test/dfs_test \ + test/digraph_test \ + test/dijkstra_test \ + test/dim_test \ + test/edge_set_test \ + test/error_test \ + test/euler_test \ + test/gomory_hu_test \ + test/graph_copy_test \ + test/graph_test \ + test/graph_utils_test \ + test/hao_orlin_test \ + test/heap_test \ + test/kruskal_test \ + test/lgf_test \ + test/maps_test \ + test/matching_test \ + test/min_cost_arborescence_test \ + test/min_cost_flow_test \ + test/path_test \ + test/preflow_test \ + test/radix_sort_test \ + test/random_test \ + test/suurballe_test \ + test/test_tools_fail \ + test/test_tools_pass \ + test/time_measure_test \ + test/unionfind_test + +test_test_tools_pass_DEPENDENCIES = demo + +if HAVE_LP +check_PROGRAMS += test/lp_test +endif HAVE_LP +if HAVE_MIP +check_PROGRAMS += test/mip_test +endif HAVE_MIP + +TESTS += $(check_PROGRAMS) +XFAIL_TESTS += test/test_tools_fail$(EXEEXT) + +test_adaptors_test_SOURCES = test/adaptors_test.cc +test_bfs_test_SOURCES = test/bfs_test.cc +test_circulation_test_SOURCES = test/circulation_test.cc +test_counter_test_SOURCES = test/counter_test.cc +test_connectivity_test_SOURCES = test/connectivity_test.cc +test_dfs_test_SOURCES = test/dfs_test.cc +test_digraph_test_SOURCES = test/digraph_test.cc +test_dijkstra_test_SOURCES = test/dijkstra_test.cc +test_dim_test_SOURCES = test/dim_test.cc +test_edge_set_test_SOURCES = test/edge_set_test.cc +test_error_test_SOURCES = test/error_test.cc +test_euler_test_SOURCES = test/euler_test.cc +test_gomory_hu_test_SOURCES = test/gomory_hu_test.cc +test_graph_copy_test_SOURCES = test/graph_copy_test.cc +test_graph_test_SOURCES = test/graph_test.cc +test_graph_utils_test_SOURCES = test/graph_utils_test.cc +test_heap_test_SOURCES = test/heap_test.cc +test_kruskal_test_SOURCES = test/kruskal_test.cc +test_hao_orlin_test_SOURCES = test/hao_orlin_test.cc +test_lgf_test_SOURCES = test/lgf_test.cc +test_lp_test_SOURCES = test/lp_test.cc +test_maps_test_SOURCES = test/maps_test.cc +test_mip_test_SOURCES = test/mip_test.cc +test_matching_test_SOURCES = test/matching_test.cc +test_min_cost_arborescence_test_SOURCES = test/min_cost_arborescence_test.cc +test_min_cost_flow_test_SOURCES = test/min_cost_flow_test.cc +test_path_test_SOURCES = test/path_test.cc +test_preflow_test_SOURCES = test/preflow_test.cc +test_radix_sort_test_SOURCES = test/radix_sort_test.cc +test_suurballe_test_SOURCES = test/suurballe_test.cc +test_random_test_SOURCES = test/random_test.cc +test_test_tools_fail_SOURCES = test/test_tools_fail.cc +test_test_tools_pass_SOURCES = test/test_tools_pass.cc +test_time_measure_test_SOURCES = test/time_measure_test.cc +test_unionfind_test_SOURCES = test/unionfind_test.cc Index: test/adaptors_test.cc =================================================================== --- test/adaptors_test.cc (revision 998) +++ test/adaptors_test.cc (revision 997) @@ -1375,20 +1375,26 @@ GridGraph::EdgeMap dir_map(graph); - dir_map[graph.right(n1)] = graph.u(graph.right(n1)) != n1; - dir_map[graph.up(n1)] = graph.u(graph.up(n1)) == n1; - dir_map[graph.left(n4)] = graph.u(graph.left(n4)) == n4; - dir_map[graph.down(n4)] = graph.u(graph.down(n4)) == n4; + dir_map[graph.right(n1)] = graph.u(graph.right(n1)) == n1; + dir_map[graph.up(n1)] = graph.u(graph.up(n1)) != n1; + dir_map[graph.left(n4)] = graph.u(graph.left(n4)) != n4; + dir_map[graph.down(n4)] = graph.u(graph.down(n4)) != n4; // Apply several adaptors on the grid graph - typedef Orienter< const GridGraph, GridGraph::EdgeMap > - OrientedGridGraph; - typedef SplitNodes SplitGridGraph; + typedef SplitNodes< ReverseDigraph< const Orienter< + const GridGraph, GridGraph::EdgeMap > > > + RevSplitGridGraph; + typedef ReverseDigraph SplitGridGraph; typedef Undirector USplitGridGraph; + typedef Undirector UUSplitGridGraph; + checkConcept(); checkConcept(); checkConcept(); - - OrientedGridGraph oadaptor = orienter(graph, dir_map); - SplitGridGraph adaptor = splitNodes(oadaptor); + checkConcept(); + + RevSplitGridGraph rev_adaptor = + splitNodes(reverseDigraph(orienter(graph, dir_map))); + SplitGridGraph adaptor = reverseDigraph(rev_adaptor); USplitGridGraph uadaptor = undirector(adaptor); + UUSplitGridGraph uuadaptor = undirector(uadaptor); // Check adaptor @@ -1397,21 +1403,21 @@ checkGraphConArcList(adaptor, 8); - checkGraphOutArcList(adaptor, adaptor.inNode(n1), 1); - checkGraphOutArcList(adaptor, adaptor.outNode(n1), 1); - checkGraphOutArcList(adaptor, adaptor.inNode(n2), 1); - checkGraphOutArcList(adaptor, adaptor.outNode(n2), 0); - checkGraphOutArcList(adaptor, adaptor.inNode(n3), 1); - checkGraphOutArcList(adaptor, adaptor.outNode(n3), 1); - checkGraphOutArcList(adaptor, adaptor.inNode(n4), 1); - checkGraphOutArcList(adaptor, adaptor.outNode(n4), 2); - - checkGraphInArcList(adaptor, adaptor.inNode(n1), 1); - checkGraphInArcList(adaptor, adaptor.outNode(n1), 1); - checkGraphInArcList(adaptor, adaptor.inNode(n2), 2); - checkGraphInArcList(adaptor, adaptor.outNode(n2), 1); - checkGraphInArcList(adaptor, adaptor.inNode(n3), 1); - checkGraphInArcList(adaptor, adaptor.outNode(n3), 1); - checkGraphInArcList(adaptor, adaptor.inNode(n4), 0); - checkGraphInArcList(adaptor, adaptor.outNode(n4), 1); + checkGraphOutArcList(adaptor, rev_adaptor.inNode(n1), 1); + checkGraphOutArcList(adaptor, rev_adaptor.outNode(n1), 1); + checkGraphOutArcList(adaptor, rev_adaptor.inNode(n2), 2); + checkGraphOutArcList(adaptor, rev_adaptor.outNode(n2), 1); + checkGraphOutArcList(adaptor, rev_adaptor.inNode(n3), 1); + checkGraphOutArcList(adaptor, rev_adaptor.outNode(n3), 1); + checkGraphOutArcList(adaptor, rev_adaptor.inNode(n4), 0); + checkGraphOutArcList(adaptor, rev_adaptor.outNode(n4), 1); + + checkGraphInArcList(adaptor, rev_adaptor.inNode(n1), 1); + checkGraphInArcList(adaptor, rev_adaptor.outNode(n1), 1); + checkGraphInArcList(adaptor, rev_adaptor.inNode(n2), 1); + checkGraphInArcList(adaptor, rev_adaptor.outNode(n2), 0); + checkGraphInArcList(adaptor, rev_adaptor.inNode(n3), 1); + checkGraphInArcList(adaptor, rev_adaptor.outNode(n3), 1); + checkGraphInArcList(adaptor, rev_adaptor.inNode(n4), 1); + checkGraphInArcList(adaptor, rev_adaptor.outNode(n4), 2); checkNodeIds(adaptor); @@ -1436,12 +1442,27 @@ checkGraphArcMap(uadaptor); - checkGraphIncEdgeArcLists(uadaptor, adaptor.inNode(n1), 2); - checkGraphIncEdgeArcLists(uadaptor, adaptor.outNode(n1), 2); - checkGraphIncEdgeArcLists(uadaptor, adaptor.inNode(n2), 3); - checkGraphIncEdgeArcLists(uadaptor, adaptor.outNode(n2), 1); - checkGraphIncEdgeArcLists(uadaptor, adaptor.inNode(n3), 2); - checkGraphIncEdgeArcLists(uadaptor, adaptor.outNode(n3), 2); - checkGraphIncEdgeArcLists(uadaptor, adaptor.inNode(n4), 1); - checkGraphIncEdgeArcLists(uadaptor, adaptor.outNode(n4), 3); + checkGraphIncEdgeArcLists(uadaptor, rev_adaptor.inNode(n1), 2); + checkGraphIncEdgeArcLists(uadaptor, rev_adaptor.outNode(n1), 2); + checkGraphIncEdgeArcLists(uadaptor, rev_adaptor.inNode(n2), 3); + checkGraphIncEdgeArcLists(uadaptor, rev_adaptor.outNode(n2), 1); + checkGraphIncEdgeArcLists(uadaptor, rev_adaptor.inNode(n3), 2); + checkGraphIncEdgeArcLists(uadaptor, rev_adaptor.outNode(n3), 2); + checkGraphIncEdgeArcLists(uadaptor, rev_adaptor.inNode(n4), 1); + checkGraphIncEdgeArcLists(uadaptor, rev_adaptor.outNode(n4), 3); + + // Check uuadaptor + checkGraphNodeList(uuadaptor, 8); + checkGraphEdgeList(uuadaptor, 16); + checkGraphArcList(uuadaptor, 32); + checkGraphConEdgeList(uuadaptor, 16); + checkGraphConArcList(uuadaptor, 32); + + checkNodeIds(uuadaptor); + checkEdgeIds(uuadaptor); + checkArcIds(uuadaptor); + + checkGraphNodeMap(uuadaptor); + checkGraphEdgeMap(uuadaptor); + checkGraphArcMap(uuadaptor); } Index: st/bellman_ford_test.cc =================================================================== --- test/bellman_ford_test.cc (revision 999) +++ (revision ) @@ -1,285 +1,0 @@ -/* -*- mode: C++; indent-tabs-mode: nil; -*- - * - * This file is a part of LEMON, a generic C++ optimization library. - * - * Copyright (C) 2003-2010 - * Egervary Jeno Kombinatorikus Optimalizalasi Kutatocsoport - * (Egervary Research Group on Combinatorial Optimization, EGRES). - * - * Permission to use, modify and distribute this software is granted - * provided that this copyright notice appears in all copies. For - * precise terms see the accompanying LICENSE file. - * - * This software is provided "AS IS" with no warranty of any kind, - * express or implied, and with no claim as to its suitability for any - * purpose. - * - */ - -#include -#include -#include -#include -#include -#include - -#include "graph_test.h" -#include "test_tools.h" - -using namespace lemon; - -char test_lgf[] = - "@nodes\n" - "label\n" - "0\n" - "1\n" - "2\n" - "3\n" - "4\n" - "@arcs\n" - " length\n" - "0 1 3\n" - "1 2 -3\n" - "1 2 -5\n" - "1 3 -2\n" - "0 2 -1\n" - "1 2 -4\n" - "0 3 2\n" - "4 2 -5\n" - "2 3 1\n" - "@attributes\n" - "source 0\n" - "target 3\n"; - - -void checkBellmanFordCompile() -{ - typedef int Value; - typedef concepts::Digraph Digraph; - typedef concepts::ReadMap LengthMap; - typedef BellmanFord BF; - typedef Digraph::Node Node; - typedef Digraph::Arc Arc; - - Digraph gr; - Node s, t, n; - Arc e; - Value l; - int k=3; - bool b; - BF::DistMap d(gr); - BF::PredMap p(gr); - LengthMap length; - concepts::Path pp; - - { - BF bf_test(gr,length); - const BF& const_bf_test = bf_test; - - bf_test.run(s); - bf_test.run(s,k); - - bf_test.init(); - bf_test.addSource(s); - bf_test.addSource(s, 1); - b = bf_test.processNextRound(); - b = bf_test.processNextWeakRound(); - - bf_test.start(); - bf_test.checkedStart(); - bf_test.limitedStart(k); - - l = const_bf_test.dist(t); - e = const_bf_test.predArc(t); - s = const_bf_test.predNode(t); - b = const_bf_test.reached(t); - d = const_bf_test.distMap(); - p = const_bf_test.predMap(); - pp = const_bf_test.path(t); - pp = const_bf_test.negativeCycle(); - - for (BF::ActiveIt it(const_bf_test); it != INVALID; ++it) {} - } - { - BF::SetPredMap > - ::SetDistMap > - ::SetOperationTraits > - ::Create bf_test(gr,length); - - LengthMap length_map; - concepts::ReadWriteMap pred_map; - concepts::ReadWriteMap dist_map; - - bf_test - .lengthMap(length_map) - .predMap(pred_map) - .distMap(dist_map); - - bf_test.run(s); - bf_test.run(s,k); - - bf_test.init(); - bf_test.addSource(s); - bf_test.addSource(s, 1); - b = bf_test.processNextRound(); - b = bf_test.processNextWeakRound(); - - bf_test.start(); - bf_test.checkedStart(); - bf_test.limitedStart(k); - - l = bf_test.dist(t); - e = bf_test.predArc(t); - s = bf_test.predNode(t); - b = bf_test.reached(t); - pp = bf_test.path(t); - pp = bf_test.negativeCycle(); - } -} - -void checkBellmanFordFunctionCompile() -{ - typedef int Value; - typedef concepts::Digraph Digraph; - typedef Digraph::Arc Arc; - typedef Digraph::Node Node; - typedef concepts::ReadMap LengthMap; - - Digraph g; - bool b; - bellmanFord(g,LengthMap()).run(Node()); - b = bellmanFord(g,LengthMap()).run(Node(),Node()); - bellmanFord(g,LengthMap()) - .predMap(concepts::ReadWriteMap()) - .distMap(concepts::ReadWriteMap()) - .run(Node()); - b=bellmanFord(g,LengthMap()) - .predMap(concepts::ReadWriteMap()) - .distMap(concepts::ReadWriteMap()) - .path(concepts::Path()) - .dist(Value()) - .run(Node(),Node()); -} - - -template -void checkBellmanFord() { - TEMPLATE_DIGRAPH_TYPEDEFS(Digraph); - typedef typename Digraph::template ArcMap LengthMap; - - Digraph gr; - Node s, t; - LengthMap length(gr); - - std::istringstream input(test_lgf); - digraphReader(gr, input). - arcMap("length", length). - node("source", s). - node("target", t). - run(); - - BellmanFord - bf(gr, length); - bf.run(s); - Path p = bf.path(t); - - check(bf.reached(t) && bf.dist(t) == -1, "Bellman-Ford found a wrong path."); - check(p.length() == 3, "path() found a wrong path."); - check(checkPath(gr, p), "path() found a wrong path."); - check(pathSource(gr, p) == s, "path() found a wrong path."); - check(pathTarget(gr, p) == t, "path() found a wrong path."); - - ListPath path; - Value dist = 0; - bool reached = bellmanFord(gr,length).path(path).dist(dist).run(s,t); - - check(reached && dist == -1, "Bellman-Ford found a wrong path."); - check(path.length() == 3, "path() found a wrong path."); - check(checkPath(gr, path), "path() found a wrong path."); - check(pathSource(gr, path) == s, "path() found a wrong path."); - check(pathTarget(gr, path) == t, "path() found a wrong path."); - - for(ArcIt e(gr); e!=INVALID; ++e) { - Node u=gr.source(e); - Node v=gr.target(e); - check(!bf.reached(u) || (bf.dist(v) - bf.dist(u) <= length[e]), - "Wrong output. dist(target)-dist(source)-arc_length=" << - bf.dist(v) - bf.dist(u) - length[e]); - } - - for(NodeIt v(gr); v!=INVALID; ++v) { - if (bf.reached(v)) { - check(v==s || bf.predArc(v)!=INVALID, "Wrong tree."); - if (bf.predArc(v)!=INVALID ) { - Arc e=bf.predArc(v); - Node u=gr.source(e); - check(u==bf.predNode(v),"Wrong tree."); - check(bf.dist(v) - bf.dist(u) == length[e], - "Wrong distance! Difference: " << - bf.dist(v) - bf.dist(u) - length[e]); - } - } - } -} - -void checkBellmanFordNegativeCycle() { - DIGRAPH_TYPEDEFS(SmartDigraph); - - SmartDigraph gr; - IntArcMap length(gr); - - Node n1 = gr.addNode(); - Node n2 = gr.addNode(); - Node n3 = gr.addNode(); - Node n4 = gr.addNode(); - - Arc a1 = gr.addArc(n1, n2); - Arc a2 = gr.addArc(n2, n2); - - length[a1] = 2; - length[a2] = -1; - - { - BellmanFord bf(gr, length); - bf.run(n1); - StaticPath p = bf.negativeCycle(); - check(p.length() == 1 && p.front() == p.back() && p.front() == a2, - "Wrong negative cycle."); - } - - length[a2] = 0; - - { - BellmanFord bf(gr, length); - bf.run(n1); - check(bf.negativeCycle().empty(), - "Negative cycle should not be found."); - } - - length[gr.addArc(n1, n3)] = 5; - length[gr.addArc(n4, n3)] = 1; - length[gr.addArc(n2, n4)] = 2; - length[gr.addArc(n3, n2)] = -4; - - { - BellmanFord bf(gr, length); - bf.init(); - bf.addSource(n1); - for (int i = 0; i < 4; ++i) { - check(bf.negativeCycle().empty(), - "Negative cycle should not be found."); - bf.processNextRound(); - } - StaticPath p = bf.negativeCycle(); - check(p.length() == 3, "Wrong negative cycle."); - check(length[p.nth(0)] + length[p.nth(1)] + length[p.nth(2)] == -1, - "Wrong negative cycle."); - } -} - -int main() { - checkBellmanFord(); - checkBellmanFord(); - checkBellmanFordNegativeCycle(); - return 0; -} Index: test/bfs_test.cc =================================================================== --- test/bfs_test.cc (revision 877) +++ test/bfs_test.cc (revision 1007) @@ -3,5 +3,5 @@ * This file is a part of LEMON, a generic C++ optimization library. * - * Copyright (C) 2003-2010 + * Copyright (C) 2003-2009 * Egervary Jeno Kombinatorikus Optimalizalasi Kutatocsoport * (Egervary Research Group on Combinatorial Optimization, EGRES). @@ -62,4 +62,5 @@ Arc e; int l, i; + ignore_unused_variable_warning(l,i); bool b; BType::DistMap d(G); @@ -84,5 +85,5 @@ b = const_bfs_test.emptyQueue(); i = const_bfs_test.queueSize(); - + bfs_test.start(); bfs_test.start(t); @@ -105,10 +106,10 @@ ::SetProcessedMap > ::Create bfs_test(G); - + concepts::ReadWriteMap pred_map; concepts::ReadWriteMap dist_map; concepts::ReadWriteMap reached_map; concepts::WriteMap processed_map; - + bfs_test .predMap(pred_map) @@ -120,5 +121,5 @@ bfs_test.run(s,t); bfs_test.run(); - + bfs_test.init(); bfs_test.addSource(s); @@ -129,5 +130,5 @@ b = bfs_test.emptyQueue(); i = bfs_test.queueSize(); - + bfs_test.start(); bfs_test.start(t); @@ -151,4 +152,6 @@ Digraph g; bool b; + ignore_unused_variable_warning(b); + bfs(g).run(Node()); b=bfs(g).run(Node(),Node()); Index: test/circulation_test.cc =================================================================== --- test/circulation_test.cc (revision 877) +++ test/circulation_test.cc (revision 1007) @@ -3,5 +3,5 @@ * This file is a part of LEMON, a generic C++ optimization library. * - * Copyright (C) 2003-2010 + * Copyright (C) 2003-2009 * Egervary Jeno Kombinatorikus Optimalizalasi Kutatocsoport * (Egervary Research Group on Combinatorial Optimization, EGRES). @@ -74,4 +74,5 @@ VType v; bool b; + ignore_unused_variable_warning(v,b); typedef Circulation @@ -82,5 +83,5 @@ CirculationType circ_test(g, lcap, ucap, supply); const CirculationType& const_circ_test = circ_test; - + circ_test .lowerMap(lcap) @@ -88,9 +89,4 @@ .supplyMap(supply) .flowMap(flow); - - const CirculationType::Elevator& elev = const_circ_test.elevator(); - circ_test.elevator(const_cast(elev)); - CirculationType::Tolerance tol = const_circ_test.tolerance(); - circ_test.tolerance(tol); circ_test.init(); @@ -103,5 +99,5 @@ b = const_circ_test.barrier(n); const_circ_test.barrierMap(bar); - + ignore_unused_variable_warning(fm); } Index: test/connectivity_test.cc =================================================================== --- test/connectivity_test.cc (revision 998) +++ test/connectivity_test.cc (revision 997) @@ -3,5 +3,5 @@ * This file is a part of LEMON, a generic C++ optimization library. * - * Copyright (C) 2003-2010 + * Copyright (C) 2003-2009 * Egervary Jeno Kombinatorikus Optimalizalasi Kutatocsoport * (Egervary Research Group on Combinatorial Optimization, EGRES). @@ -30,10 +30,10 @@ typedef ListDigraph Digraph; typedef Undirector Graph; - - { - Digraph d; - Digraph::NodeMap order(d); - Graph g(d); - + + { + Digraph d; + Digraph::NodeMap order(d); + Graph g(d); + check(stronglyConnected(d), "The empty digraph is strongly connected"); check(countStronglyConnectedComponents(d) == 0, @@ -49,5 +49,5 @@ check(countBiEdgeConnectedComponents(g) == 0, "The empty graph has 0 bi-edge-connected component"); - + check(dag(d), "The empty digraph is DAG."); check(checkedTopologicalSort(d, order), "The empty digraph is DAG."); @@ -84,5 +84,5 @@ check(countBiEdgeConnectedComponents(g) == 1, "This graph has 1 bi-edge-connected component"); - + check(dag(d), "This digraph is DAG."); check(checkedTopologicalSort(d, order), "This digraph is DAG."); @@ -103,5 +103,5 @@ Digraph::NodeMap order(d); Graph g(d); - + Digraph::Node n1 = d.addNode(); Digraph::Node n2 = d.addNode(); @@ -110,5 +110,5 @@ Digraph::Node n5 = d.addNode(); Digraph::Node n6 = d.addNode(); - + d.addArc(n1, n3); d.addArc(n3, n2); @@ -138,21 +138,21 @@ check(!parallelFree(g), "This graph is not parallel-free."); check(!simpleGraph(g), "This graph is not simple."); - + d.addArc(n3, n3); - + check(!loopFree(d), "This digraph is not loop-free."); check(!loopFree(g), "This graph is not loop-free."); check(!simpleGraph(d), "This digraph is not simple."); - + d.addArc(n3, n2); - + check(!parallelFree(d), "This digraph is not parallel-free."); } - + { Digraph d; Digraph::ArcMap cutarcs(d, false); Graph g(d); - + Digraph::Node n1 = d.addNode(); Digraph::Node n2 = d.addNode(); @@ -174,5 +174,5 @@ d.addArc(n6, n7); d.addArc(n7, n6); - + check(!stronglyConnected(d), "This digraph is not strongly connected"); check(countStronglyConnectedComponents(d) == 3, @@ -237,5 +237,5 @@ Digraph d; Digraph::NodeMap order(d); - + Digraph::Node belt = d.addNode(); Digraph::Node trousers = d.addNode(); @@ -258,5 +258,5 @@ d.addArc(shirt, necktie); d.addArc(necktie, coat); - + check(dag(d), "This digraph is DAG."); topologicalSort(d, order); @@ -270,5 +270,5 @@ ListGraph g; ListGraph::NodeMap map(g); - + ListGraph::Node n1 = g.addNode(); ListGraph::Node n2 = g.addNode(); @@ -286,8 +286,8 @@ g.addEdge(n4, n7); g.addEdge(n5, n7); - + check(bipartite(g), "This graph is bipartite"); check(bipartitePartitions(g, map), "This graph is bipartite"); - + check(map[n1] == map[n2] && map[n1] == map[n6] && map[n1] == map[n7], "Wrong bipartitePartitions()"); Index: test/dfs_test.cc =================================================================== --- test/dfs_test.cc (revision 966) +++ test/dfs_test.cc (revision 1007) @@ -3,5 +3,5 @@ * This file is a part of LEMON, a generic C++ optimization library. * - * Copyright (C) 2003-2010 + * Copyright (C) 2003-2009 * Egervary Jeno Kombinatorikus Optimalizalasi Kutatocsoport * (Egervary Research Group on Combinatorial Optimization, EGRES). @@ -68,4 +68,6 @@ int l, i; bool b; + ignore_unused_variable_warning(l,i,b); + DType::DistMap d(G); DType::PredMap p(G); @@ -87,5 +89,5 @@ b = const_dfs_test.emptyQueue(); i = const_dfs_test.queueSize(); - + dfs_test.start(); dfs_test.start(t); @@ -113,5 +115,5 @@ concepts::ReadWriteMap reached_map; concepts::WriteMap processed_map; - + dfs_test .predMap(pred_map) @@ -130,5 +132,5 @@ b = dfs_test.emptyQueue(); i = dfs_test.queueSize(); - + dfs_test.start(); dfs_test.start(t); @@ -152,4 +154,6 @@ Digraph g; bool b; + ignore_unused_variable_warning(b); + dfs(g).run(Node()); b=dfs(g).run(Node(),Node()); Index: test/digraph_test.cc =================================================================== --- test/digraph_test.cc (revision 999) +++ test/digraph_test.cc (revision 997) @@ -3,5 +3,5 @@ * This file is a part of LEMON, a generic C++ optimization library. * - * Copyright (C) 2003-2010 + * Copyright (C) 2003-2009 * Egervary Jeno Kombinatorikus Optimalizalasi Kutatocsoport * (Egervary Research Group on Combinatorial Optimization, EGRES). @@ -20,5 +20,4 @@ #include #include -#include #include @@ -36,7 +35,4 @@ checkGraphNodeList(G, 0); checkGraphArcList(G, 0); - - G.reserveNode(3); - G.reserveArc(4); Node @@ -293,12 +289,4 @@ snapshot.restore(); - snapshot.save(G); - - checkGraphNodeList(G, 4); - checkGraphArcList(G, 4); - - G.addArc(G.addNode(), G.addNode()); - - snapshot.restore(); checkGraphNodeList(G, 4); @@ -335,8 +323,4 @@ checkConcept, SmartDigraph>(); } - { // Checking StaticDigraph - checkConcept(); - checkConcept, StaticDigraph>(); - } { // Checking FullDigraph checkConcept(); @@ -395,121 +379,8 @@ } -void checkStaticDigraph() { - SmartDigraph g; - SmartDigraph::NodeMap nref(g); - SmartDigraph::ArcMap aref(g); - - StaticDigraph G; - - checkGraphNodeList(G, 0); - checkGraphArcList(G, 0); - - G.build(g, nref, aref); - - checkGraphNodeList(G, 0); - checkGraphArcList(G, 0); - - SmartDigraph::Node - n1 = g.addNode(), - n2 = g.addNode(), - n3 = g.addNode(); - - G.build(g, nref, aref); - - checkGraphNodeList(G, 3); - checkGraphArcList(G, 0); - - SmartDigraph::Arc a1 = g.addArc(n1, n2); - - G.build(g, nref, aref); - - check(G.source(aref[a1]) == nref[n1] && G.target(aref[a1]) == nref[n2], - "Wrong arc or wrong references"); - checkGraphNodeList(G, 3); - checkGraphArcList(G, 1); - - checkGraphOutArcList(G, nref[n1], 1); - checkGraphOutArcList(G, nref[n2], 0); - checkGraphOutArcList(G, nref[n3], 0); - - checkGraphInArcList(G, nref[n1], 0); - checkGraphInArcList(G, nref[n2], 1); - checkGraphInArcList(G, nref[n3], 0); - - checkGraphConArcList(G, 1); - - SmartDigraph::Arc - a2 = g.addArc(n2, n1), - a3 = g.addArc(n2, n3), - a4 = g.addArc(n2, n3); - ignore_unused_variable_warning(a2,a3,a4); - - digraphCopy(g, G).nodeRef(nref).run(); - - checkGraphNodeList(G, 3); - checkGraphArcList(G, 4); - - checkGraphOutArcList(G, nref[n1], 1); - checkGraphOutArcList(G, nref[n2], 3); - checkGraphOutArcList(G, nref[n3], 0); - - checkGraphInArcList(G, nref[n1], 1); - checkGraphInArcList(G, nref[n2], 1); - checkGraphInArcList(G, nref[n3], 2); - - checkGraphConArcList(G, 4); - - std::vector > arcs; - arcs.push_back(std::make_pair(0,1)); - arcs.push_back(std::make_pair(0,2)); - arcs.push_back(std::make_pair(1,3)); - arcs.push_back(std::make_pair(1,2)); - arcs.push_back(std::make_pair(3,0)); - arcs.push_back(std::make_pair(3,3)); - arcs.push_back(std::make_pair(4,2)); - arcs.push_back(std::make_pair(4,3)); - arcs.push_back(std::make_pair(4,1)); - - G.build(6, arcs.begin(), arcs.end()); - - checkGraphNodeList(G, 6); - checkGraphArcList(G, 9); - - checkGraphOutArcList(G, G.node(0), 2); - checkGraphOutArcList(G, G.node(1), 2); - checkGraphOutArcList(G, G.node(2), 0); - checkGraphOutArcList(G, G.node(3), 2); - checkGraphOutArcList(G, G.node(4), 3); - checkGraphOutArcList(G, G.node(5), 0); - - checkGraphInArcList(G, G.node(0), 1); - checkGraphInArcList(G, G.node(1), 2); - checkGraphInArcList(G, G.node(2), 3); - checkGraphInArcList(G, G.node(3), 3); - checkGraphInArcList(G, G.node(4), 0); - checkGraphInArcList(G, G.node(5), 0); - - checkGraphConArcList(G, 9); - - checkNodeIds(G); - checkArcIds(G); - checkGraphNodeMap(G); - checkGraphArcMap(G); - - int n = G.nodeNum(); - int m = G.arcNum(); - check(G.index(G.node(n-1)) == n-1, "Wrong index."); - check(G.index(G.arc(m-1)) == m-1, "Wrong index."); -} - void checkFullDigraph(int num) { typedef FullDigraph Digraph; DIGRAPH_TYPEDEFS(Digraph); - Digraph G(num); - check(G.nodeNum() == num && G.arcNum() == num * num, "Wrong size"); - - G.resize(num); - check(G.nodeNum() == num && G.arcNum() == num * num, "Wrong size"); checkGraphNodeList(G, num); @@ -555,7 +426,4 @@ checkDigraphValidity(); } - { // Checking StaticDigraph - checkStaticDigraph(); - } { // Checking FullDigraph checkFullDigraph(8); Index: test/dijkstra_test.cc =================================================================== --- test/dijkstra_test.cc (revision 877) +++ test/dijkstra_test.cc (revision 1007) @@ -3,5 +3,5 @@ * This file is a part of LEMON, a generic C++ optimization library. * - * Copyright (C) 2003-2010 + * Copyright (C) 2003-2009 * Egervary Jeno Kombinatorikus Optimalizalasi Kutatocsoport * (Egervary Research Group on Combinatorial Optimization, EGRES). @@ -66,4 +66,6 @@ int i; bool b; + ignore_unused_variable_warning(l,i,b); + DType::DistMap d(G); DType::PredMap p(G); @@ -86,5 +88,5 @@ b = const_dijkstra_test.emptyQueue(); i = const_dijkstra_test.queueSize(); - + dijkstra_test.start(); dijkstra_test.start(t); @@ -110,5 +112,5 @@ ::SetHeap > > ::SetStandardHeap > > - ::SetHeap >, + ::SetHeap >, concepts::ReadWriteMap > ::Create dijkstra_test(G,length); @@ -120,5 +122,5 @@ concepts::ReadWriteMap heap_cross_ref; BinHeap > heap(heap_cross_ref); - + dijkstra_test .lengthMap(length_map) @@ -137,5 +139,5 @@ b = dijkstra_test.emptyQueue(); i = dijkstra_test.queueSize(); - + dijkstra_test.start(); dijkstra_test.start(t); @@ -163,4 +165,6 @@ Digraph g; bool b; + ignore_unused_variable_warning(b); + dijkstra(g,LengthMap()).run(Node()); b=dijkstra(g,LengthMap()).run(Node(),Node()); Index: test/edge_set_test.cc =================================================================== --- test/edge_set_test.cc (revision 998) +++ test/edge_set_test.cc (revision 997) @@ -3,5 +3,5 @@ * This file is a part of LEMON, a generic C++ optimization library. * - * Copyright (C) 2003-2010 + * Copyright (C) 2003-2008 * Egervary Jeno Kombinatorikus Optimalizalasi Kutatocsoport * (Egervary Research Group on Combinatorial Optimization, EGRES). Index: test/euler_test.cc =================================================================== --- test/euler_test.cc (revision 998) +++ test/euler_test.cc (revision 997) @@ -3,5 +3,5 @@ * This file is a part of LEMON, a generic C++ optimization library. * - * Copyright (C) 2003-2010 + * Copyright (C) 2003-2009 * Egervary Jeno Kombinatorikus Optimalizalasi Kutatocsoport * (Egervary Research Group on Combinatorial Optimization, EGRES). @@ -86,9 +86,9 @@ typedef ListDigraph Digraph; typedef Undirector Graph; - - { - Digraph d; - Graph g(d); - + + { + Digraph d; + Graph g(d); + checkDiEulerIt(d); checkDiEulerIt(g); @@ -130,5 +130,5 @@ Digraph::Node n2 = d.addNode(); Digraph::Node n3 = d.addNode(); - + d.addArc(n1, n2); d.addArc(n2, n1); @@ -155,5 +155,5 @@ Digraph::Node n5 = d.addNode(); Digraph::Node n6 = d.addNode(); - + d.addArc(n1, n2); d.addArc(n2, n4); @@ -214,5 +214,5 @@ Digraph::Node n2 = d.addNode(); Digraph::Node n3 = d.addNode(); - + d.addArc(n1, n2); d.addArc(n2, n3); Index: st/fractional_matching_test.cc =================================================================== --- test/fractional_matching_test.cc (revision 999) +++ (revision ) @@ -1,527 +1,0 @@ -/* -*- mode: C++; indent-tabs-mode: nil; -*- - * - * This file is a part of LEMON, a generic C++ optimization library. - * - * Copyright (C) 2003-2010 - * Egervary Jeno Kombinatorikus Optimalizalasi Kutatocsoport - * (Egervary Research Group on Combinatorial Optimization, EGRES). - * - * Permission to use, modify and distribute this software is granted - * provided that this copyright notice appears in all copies. For - * precise terms see the accompanying LICENSE file. - * - * This software is provided "AS IS" with no warranty of any kind, - * express or implied, and with no claim as to its suitability for any - * purpose. - * - */ - -#include -#include -#include -#include -#include - -#include -#include -#include -#include -#include -#include - -#include "test_tools.h" - -using namespace std; -using namespace lemon; - -GRAPH_TYPEDEFS(SmartGraph); - - -const int lgfn = 4; -const std::string lgf[lgfn] = { - "@nodes\n" - "label\n" - "0\n" - "1\n" - "2\n" - "3\n" - "4\n" - "5\n" - "6\n" - "7\n" - "@edges\n" - " label weight\n" - "7 4 0 984\n" - "0 7 1 73\n" - "7 1 2 204\n" - "2 3 3 583\n" - "2 7 4 565\n" - "2 1 5 582\n" - "0 4 6 551\n" - "2 5 7 385\n" - "1 5 8 561\n" - "5 3 9 484\n" - "7 5 10 904\n" - "3 6 11 47\n" - "7 6 12 888\n" - "3 0 13 747\n" - "6 1 14 310\n", - - "@nodes\n" - "label\n" - "0\n" - "1\n" - "2\n" - "3\n" - "4\n" - "5\n" - "6\n" - "7\n" - "@edges\n" - " label weight\n" - "2 5 0 710\n" - "0 5 1 241\n" - "2 4 2 856\n" - "2 6 3 762\n" - "4 1 4 747\n" - "6 1 5 962\n" - "4 7 6 723\n" - "1 7 7 661\n" - "2 3 8 376\n" - "1 0 9 416\n" - "6 7 10 391\n", - - "@nodes\n" - "label\n" - "0\n" - "1\n" - "2\n" - "3\n" - "4\n" - "5\n" - "6\n" - "7\n" - "@edges\n" - " label weight\n" - "6 2 0 553\n" - "0 7 1 653\n" - "6 3 2 22\n" - "4 7 3 846\n" - "7 2 4 981\n" - "7 6 5 250\n" - "5 2 6 539\n", - - "@nodes\n" - "label\n" - "0\n" - "@edges\n" - " label weight\n" - "0 0 0 100\n" -}; - -void checkMaxFractionalMatchingCompile() -{ - typedef concepts::Graph Graph; - typedef Graph::Node Node; - typedef Graph::Edge Edge; - - Graph g; - Node n; - Edge e; - - MaxFractionalMatching mat_test(g); - const MaxFractionalMatching& - const_mat_test = mat_test; - - mat_test.init(); - mat_test.start(); - mat_test.start(true); - mat_test.startPerfect(); - mat_test.startPerfect(true); - mat_test.run(); - mat_test.run(true); - mat_test.runPerfect(); - mat_test.runPerfect(true); - - const_mat_test.matchingSize(); - const_mat_test.matching(e); - const_mat_test.matching(n); - const MaxFractionalMatching::MatchingMap& mmap = - const_mat_test.matchingMap(); - e = mmap[n]; - - const_mat_test.barrier(n); -} - -void checkMaxWeightedFractionalMatchingCompile() -{ - typedef concepts::Graph Graph; - typedef Graph::Node Node; - typedef Graph::Edge Edge; - typedef Graph::EdgeMap WeightMap; - - Graph g; - Node n; - Edge e; - WeightMap w(g); - - MaxWeightedFractionalMatching mat_test(g, w); - const MaxWeightedFractionalMatching& - const_mat_test = mat_test; - - mat_test.init(); - mat_test.start(); - mat_test.run(); - - const_mat_test.matchingWeight(); - const_mat_test.matchingSize(); - const_mat_test.matching(e); - const_mat_test.matching(n); - const MaxWeightedFractionalMatching::MatchingMap& mmap = - const_mat_test.matchingMap(); - e = mmap[n]; - - const_mat_test.dualValue(); - const_mat_test.nodeValue(n); -} - -void checkMaxWeightedPerfectFractionalMatchingCompile() -{ - typedef concepts::Graph Graph; - typedef Graph::Node Node; - typedef Graph::Edge Edge; - typedef Graph::EdgeMap WeightMap; - - Graph g; - Node n; - Edge e; - WeightMap w(g); - - MaxWeightedPerfectFractionalMatching mat_test(g, w); - const MaxWeightedPerfectFractionalMatching& - const_mat_test = mat_test; - - mat_test.init(); - mat_test.start(); - mat_test.run(); - - const_mat_test.matchingWeight(); - const_mat_test.matching(e); - const_mat_test.matching(n); - const MaxWeightedPerfectFractionalMatching::MatchingMap& mmap = - const_mat_test.matchingMap(); - e = mmap[n]; - - const_mat_test.dualValue(); - const_mat_test.nodeValue(n); -} - -void checkFractionalMatching(const SmartGraph& graph, - const MaxFractionalMatching& mfm, - bool allow_loops = true) { - int pv = 0; - for (SmartGraph::NodeIt n(graph); n != INVALID; ++n) { - int indeg = 0; - for (InArcIt a(graph, n); a != INVALID; ++a) { - if (mfm.matching(graph.source(a)) == a) { - ++indeg; - } - } - if (mfm.matching(n) != INVALID) { - check(indeg == 1, "Invalid matching"); - ++pv; - } else { - check(indeg == 0, "Invalid matching"); - } - } - check(pv == mfm.matchingSize(), "Wrong matching size"); - - for (SmartGraph::EdgeIt e(graph); e != INVALID; ++e) { - check((e == mfm.matching(graph.u(e)) ? 1 : 0) + - (e == mfm.matching(graph.v(e)) ? 1 : 0) == - mfm.matching(e), "Invalid matching"); - } - - SmartGraph::NodeMap processed(graph, false); - for (SmartGraph::NodeIt n(graph); n != INVALID; ++n) { - if (processed[n]) continue; - processed[n] = true; - if (mfm.matching(n) == INVALID) continue; - int num = 1; - Node v = graph.target(mfm.matching(n)); - while (v != n) { - processed[v] = true; - ++num; - v = graph.target(mfm.matching(v)); - } - check(num == 2 || num % 2 == 1, "Wrong cycle size"); - check(allow_loops || num != 1, "Wrong cycle size"); - } - - int anum = 0, bnum = 0; - SmartGraph::NodeMap neighbours(graph, false); - for (SmartGraph::NodeIt n(graph); n != INVALID; ++n) { - if (!mfm.barrier(n)) continue; - ++anum; - for (SmartGraph::InArcIt a(graph, n); a != INVALID; ++a) { - Node u = graph.source(a); - if (!allow_loops && u == n) continue; - if (!neighbours[u]) { - neighbours[u] = true; - ++bnum; - } - } - } - check(anum - bnum + mfm.matchingSize() == countNodes(graph), - "Wrong barrier"); -} - -void checkPerfectFractionalMatching(const SmartGraph& graph, - const MaxFractionalMatching& mfm, - bool perfect, bool allow_loops = true) { - if (perfect) { - for (SmartGraph::NodeIt n(graph); n != INVALID; ++n) { - int indeg = 0; - for (InArcIt a(graph, n); a != INVALID; ++a) { - if (mfm.matching(graph.source(a)) == a) { - ++indeg; - } - } - check(mfm.matching(n) != INVALID, "Invalid matching"); - check(indeg == 1, "Invalid matching"); - } - for (SmartGraph::EdgeIt e(graph); e != INVALID; ++e) { - check((e == mfm.matching(graph.u(e)) ? 1 : 0) + - (e == mfm.matching(graph.v(e)) ? 1 : 0) == - mfm.matching(e), "Invalid matching"); - } - } else { - int anum = 0, bnum = 0; - SmartGraph::NodeMap neighbours(graph, false); - for (SmartGraph::NodeIt n(graph); n != INVALID; ++n) { - if (!mfm.barrier(n)) continue; - ++anum; - for (SmartGraph::InArcIt a(graph, n); a != INVALID; ++a) { - Node u = graph.source(a); - if (!allow_loops && u == n) continue; - if (!neighbours[u]) { - neighbours[u] = true; - ++bnum; - } - } - } - check(anum - bnum > 0, "Wrong barrier"); - } -} - -void checkWeightedFractionalMatching(const SmartGraph& graph, - const SmartGraph::EdgeMap& weight, - const MaxWeightedFractionalMatching& mwfm, - bool allow_loops = true) { - for (SmartGraph::EdgeIt e(graph); e != INVALID; ++e) { - if (graph.u(e) == graph.v(e) && !allow_loops) continue; - int rw = mwfm.nodeValue(graph.u(e)) + mwfm.nodeValue(graph.v(e)) - - weight[e] * mwfm.dualScale; - - check(rw >= 0, "Negative reduced weight"); - check(rw == 0 || !mwfm.matching(e), - "Non-zero reduced weight on matching edge"); - } - - int pv = 0; - for (SmartGraph::NodeIt n(graph); n != INVALID; ++n) { - int indeg = 0; - for (InArcIt a(graph, n); a != INVALID; ++a) { - if (mwfm.matching(graph.source(a)) == a) { - ++indeg; - } - } - check(indeg <= 1, "Invalid matching"); - if (mwfm.matching(n) != INVALID) { - check(mwfm.nodeValue(n) >= 0, "Invalid node value"); - check(indeg == 1, "Invalid matching"); - pv += weight[mwfm.matching(n)]; - SmartGraph::Node o = graph.target(mwfm.matching(n)); - ignore_unused_variable_warning(o); - } else { - check(mwfm.nodeValue(n) == 0, "Invalid matching"); - check(indeg == 0, "Invalid matching"); - } - } - - for (SmartGraph::EdgeIt e(graph); e != INVALID; ++e) { - check((e == mwfm.matching(graph.u(e)) ? 1 : 0) + - (e == mwfm.matching(graph.v(e)) ? 1 : 0) == - mwfm.matching(e), "Invalid matching"); - } - - int dv = 0; - for (SmartGraph::NodeIt n(graph); n != INVALID; ++n) { - dv += mwfm.nodeValue(n); - } - - check(pv * mwfm.dualScale == dv * 2, "Wrong duality"); - - SmartGraph::NodeMap processed(graph, false); - for (SmartGraph::NodeIt n(graph); n != INVALID; ++n) { - if (processed[n]) continue; - processed[n] = true; - if (mwfm.matching(n) == INVALID) continue; - int num = 1; - Node v = graph.target(mwfm.matching(n)); - while (v != n) { - processed[v] = true; - ++num; - v = graph.target(mwfm.matching(v)); - } - check(num == 2 || num % 2 == 1, "Wrong cycle size"); - check(allow_loops || num != 1, "Wrong cycle size"); - } - - return; -} - -void checkWeightedPerfectFractionalMatching(const SmartGraph& graph, - const SmartGraph::EdgeMap& weight, - const MaxWeightedPerfectFractionalMatching& mwpfm, - bool allow_loops = true) { - for (SmartGraph::EdgeIt e(graph); e != INVALID; ++e) { - if (graph.u(e) == graph.v(e) && !allow_loops) continue; - int rw = mwpfm.nodeValue(graph.u(e)) + mwpfm.nodeValue(graph.v(e)) - - weight[e] * mwpfm.dualScale; - - check(rw >= 0, "Negative reduced weight"); - check(rw == 0 || !mwpfm.matching(e), - "Non-zero reduced weight on matching edge"); - } - - int pv = 0; - for (SmartGraph::NodeIt n(graph); n != INVALID; ++n) { - int indeg = 0; - for (InArcIt a(graph, n); a != INVALID; ++a) { - if (mwpfm.matching(graph.source(a)) == a) { - ++indeg; - } - } - check(mwpfm.matching(n) != INVALID, "Invalid perfect matching"); - check(indeg == 1, "Invalid perfect matching"); - pv += weight[mwpfm.matching(n)]; - SmartGraph::Node o = graph.target(mwpfm.matching(n)); - ignore_unused_variable_warning(o); - } - - for (SmartGraph::EdgeIt e(graph); e != INVALID; ++e) { - check((e == mwpfm.matching(graph.u(e)) ? 1 : 0) + - (e == mwpfm.matching(graph.v(e)) ? 1 : 0) == - mwpfm.matching(e), "Invalid matching"); - } - - int dv = 0; - for (SmartGraph::NodeIt n(graph); n != INVALID; ++n) { - dv += mwpfm.nodeValue(n); - } - - check(pv * mwpfm.dualScale == dv * 2, "Wrong duality"); - - SmartGraph::NodeMap processed(graph, false); - for (SmartGraph::NodeIt n(graph); n != INVALID; ++n) { - if (processed[n]) continue; - processed[n] = true; - if (mwpfm.matching(n) == INVALID) continue; - int num = 1; - Node v = graph.target(mwpfm.matching(n)); - while (v != n) { - processed[v] = true; - ++num; - v = graph.target(mwpfm.matching(v)); - } - check(num == 2 || num % 2 == 1, "Wrong cycle size"); - check(allow_loops || num != 1, "Wrong cycle size"); - } - - return; -} - - -int main() { - - for (int i = 0; i < lgfn; ++i) { - SmartGraph graph; - SmartGraph::EdgeMap weight(graph); - - istringstream lgfs(lgf[i]); - graphReader(graph, lgfs). - edgeMap("weight", weight).run(); - - bool perfect_with_loops; - { - MaxFractionalMatching mfm(graph, true); - mfm.run(); - checkFractionalMatching(graph, mfm, true); - perfect_with_loops = mfm.matchingSize() == countNodes(graph); - } - - bool perfect_without_loops; - { - MaxFractionalMatching mfm(graph, false); - mfm.run(); - checkFractionalMatching(graph, mfm, false); - perfect_without_loops = mfm.matchingSize() == countNodes(graph); - } - - { - MaxFractionalMatching mfm(graph, true); - bool result = mfm.runPerfect(); - checkPerfectFractionalMatching(graph, mfm, result, true); - check(result == perfect_with_loops, "Wrong perfect matching"); - } - - { - MaxFractionalMatching mfm(graph, false); - bool result = mfm.runPerfect(); - checkPerfectFractionalMatching(graph, mfm, result, false); - check(result == perfect_without_loops, "Wrong perfect matching"); - } - - { - MaxWeightedFractionalMatching mwfm(graph, weight, true); - mwfm.run(); - checkWeightedFractionalMatching(graph, weight, mwfm, true); - } - - { - MaxWeightedFractionalMatching mwfm(graph, weight, false); - mwfm.run(); - checkWeightedFractionalMatching(graph, weight, mwfm, false); - } - - { - MaxWeightedPerfectFractionalMatching mwpfm(graph, weight, - true); - bool perfect = mwpfm.run(); - check(perfect == (mwpfm.matchingSize() == countNodes(graph)), - "Perfect matching found"); - check(perfect == perfect_with_loops, "Wrong perfect matching"); - - if (perfect) { - checkWeightedPerfectFractionalMatching(graph, weight, mwpfm, true); - } - } - - { - MaxWeightedPerfectFractionalMatching mwpfm(graph, weight, - false); - bool perfect = mwpfm.run(); - check(perfect == (mwpfm.matchingSize() == countNodes(graph)), - "Perfect matching found"); - check(perfect == perfect_without_loops, "Wrong perfect matching"); - - if (perfect) { - checkWeightedPerfectFractionalMatching(graph, weight, mwpfm, false); - } - } - - } - - return 0; -} Index: test/gomory_hu_test.cc =================================================================== --- test/gomory_hu_test.cc (revision 877) +++ test/gomory_hu_test.cc (revision 1007) @@ -1,20 +1,2 @@ -/* -*- mode: C++; indent-tabs-mode: nil; -*- - * - * This file is a part of LEMON, a generic C++ optimization library. - * - * Copyright (C) 2003-2010 - * Egervary Jeno Kombinatorikus Optimalizalasi Kutatocsoport - * (Egervary Research Group on Combinatorial Optimization, EGRES). - * - * Permission to use, modify and distribute this software is granted - * provided that this copyright notice appears in all copies. For - * precise terms see the accompanying LICENSE file. - * - * This software is provided "AS IS" with no warranty of any kind, - * express or implied, and with no claim as to its suitability for any - * purpose. - * - */ - #include @@ -52,5 +34,5 @@ "source 0\n" "target 3\n"; - + void checkGomoryHuCompile() { @@ -69,4 +51,5 @@ Value v; int d; + ignore_unused_variable_warning(v,d); GomoryHu gh_test(g, cap); @@ -88,5 +71,5 @@ int cutValue(const Graph& graph, const BoolNodeMap& cut, - const IntEdgeMap& capacity) { + const IntEdgeMap& capacity) { int sum = 0; @@ -126,5 +109,5 @@ int sum=0; for(GomoryHu::MinCutEdgeIt a(ght, u, v);a!=INVALID;++a) - sum+=capacity[a]; + sum+=capacity[a]; check(sum == ght.minCutValue(u, v), "Problem with MinCutEdgeIt"); @@ -137,5 +120,5 @@ } } - + return 0; } Index: test/graph_copy_test.cc =================================================================== --- test/graph_copy_test.cc (revision 894) +++ test/graph_copy_test.cc (revision 893) @@ -19,5 +19,4 @@ #include #include -#include #include #include @@ -28,5 +27,4 @@ using namespace lemon; -template void digraph_copy_test() { const int nn = 10; @@ -54,17 +52,17 @@ } } - + // Test digraph copy - GR to; - typename GR::template NodeMap tnm(to); - typename GR::template ArcMap tam(to); - typename GR::Node tn; - typename GR::Arc ta; - - SmartDigraph::NodeMap nr(from); - SmartDigraph::ArcMap er(from); - - typename GR::template NodeMap ncr(to); - typename GR::template ArcMap ecr(to); + ListDigraph to; + ListDigraph::NodeMap tnm(to); + ListDigraph::ArcMap tam(to); + ListDigraph::Node tn; + ListDigraph::Arc ta; + + SmartDigraph::NodeMap nr(from); + SmartDigraph::ArcMap er(from); + + ListDigraph::NodeMap ncr(to); + ListDigraph::ArcMap ecr(to); digraphCopy(from, to). @@ -89,9 +87,9 @@ } - for (typename GR::NodeIt it(to); it != INVALID; ++it) { + for (ListDigraph::NodeIt it(to); it != INVALID; ++it) { check(nr[ncr[it]] == it, "Wrong copy."); } - for (typename GR::ArcIt it(to); it != INVALID; ++it) { + for (ListDigraph::ArcIt it(to); it != INVALID; ++it) { check(er[ecr[it]] == it, "Wrong copy."); } @@ -106,5 +104,4 @@ } -template void graph_copy_test() { const int nn = 10; @@ -139,19 +136,19 @@ // Test graph copy - GR to; - typename GR::template NodeMap tnm(to); - typename GR::template ArcMap tam(to); - typename GR::template EdgeMap tem(to); - typename GR::Node tn; - typename GR::Arc ta; - typename GR::Edge te; - - SmartGraph::NodeMap nr(from); - SmartGraph::ArcMap ar(from); - SmartGraph::EdgeMap er(from); - - typename GR::template NodeMap ncr(to); - typename GR::template ArcMap acr(to); - typename GR::template EdgeMap ecr(to); + ListGraph to; + ListGraph::NodeMap tnm(to); + ListGraph::ArcMap tam(to); + ListGraph::EdgeMap tem(to); + ListGraph::Node tn; + ListGraph::Arc ta; + ListGraph::Edge te; + + SmartGraph::NodeMap nr(from); + SmartGraph::ArcMap ar(from); + SmartGraph::EdgeMap er(from); + + ListGraph::NodeMap ncr(to); + ListGraph::ArcMap acr(to); + ListGraph::EdgeMap ecr(to); graphCopy(from, to). @@ -188,12 +185,12 @@ } - for (typename GR::NodeIt it(to); it != INVALID; ++it) { + for (ListGraph::NodeIt it(to); it != INVALID; ++it) { check(nr[ncr[it]] == it, "Wrong copy."); } - for (typename GR::ArcIt it(to); it != INVALID; ++it) { + for (ListGraph::ArcIt it(to); it != INVALID; ++it) { check(ar[acr[it]] == it, "Wrong copy."); } - for (typename GR::EdgeIt it(to); it != INVALID; ++it) { + for (ListGraph::EdgeIt it(to); it != INVALID; ++it) { check(er[ecr[it]] == it, "Wrong copy."); } @@ -212,9 +209,6 @@ int main() { - digraph_copy_test(); - digraph_copy_test(); - digraph_copy_test(); - graph_copy_test(); - graph_copy_test(); + digraph_copy_test(); + graph_copy_test(); return 0; Index: test/graph_test.cc =================================================================== --- test/graph_test.cc (revision 998) +++ test/graph_test.cc (revision 997) @@ -3,5 +3,5 @@ * This file is a part of LEMON, a generic C++ optimization library. * - * Copyright (C) 2003-2010 + * Copyright (C) 2003-2009 * Egervary Jeno Kombinatorikus Optimalizalasi Kutatocsoport * (Egervary Research Group on Combinatorial Optimization, EGRES). @@ -39,7 +39,4 @@ checkGraphArcList(G, 0); - G.reserveNode(3); - G.reserveEdge(3); - Node n1 = G.addNode(), @@ -264,17 +261,8 @@ snapshot.restore(); - snapshot.save(G); checkGraphNodeList(G, 4); checkGraphEdgeList(G, 3); checkGraphArcList(G, 6); - - G.addEdge(G.addNode(), G.addNode()); - - snapshot.restore(); - - checkGraphNodeList(G, 4); - checkGraphEdgeList(G, 3); - checkGraphArcList(G, 6); } @@ -284,11 +272,4 @@ Graph G(num); - check(G.nodeNum() == num && G.edgeNum() == num * (num - 1) / 2, - "Wrong size"); - - G.resize(num); - check(G.nodeNum() == num && G.edgeNum() == num * (num - 1) / 2, - "Wrong size"); - checkGraphNodeList(G, num); checkGraphEdgeList(G, num * (num - 1) / 2); @@ -436,8 +417,4 @@ check(G.height() == height, "Wrong row number"); - G.resize(width, height); - check(G.width() == width, "Wrong column number"); - check(G.height() == height, "Wrong row number"); - for (int i = 0; i < width; ++i) { for (int j = 0; j < height; ++j) { @@ -515,9 +492,4 @@ HypercubeGraph G(dim); - check(G.dimension() == dim, "Wrong dimension"); - - G.resize(dim); - check(G.dimension() == dim, "Wrong dimension"); - checkGraphNodeList(G, 1 << dim); checkGraphEdgeList(G, dim * (1 << (dim-1))); Index: test/hao_orlin_test.cc =================================================================== --- test/hao_orlin_test.cc (revision 877) +++ test/hao_orlin_test.cc (revision 1007) @@ -3,5 +3,5 @@ * This file is a part of LEMON, a generic C++ optimization library. * - * Copyright (C) 2003-2010 + * Copyright (C) 2003-2009 * Egervary Jeno Kombinatorikus Optimalizalasi Kutatocsoport * (Egervary Research Group on Combinatorial Optimization, EGRES). @@ -67,4 +67,5 @@ CutMap cut; Value v; + ignore_unused_variable_warning(v); HaoOrlin ho_test(g, cap); @@ -84,5 +85,5 @@ template -typename CapMap::Value +typename CapMap::Value cutValue(const Graph& graph, const CapMap& cap, const CutMap& cut) { @@ -111,5 +112,5 @@ ho.run(); ho.minCutMap(cut); - + check(ho.minCutValue() == 1, "Wrong cut value"); check(ho.minCutValue() == cutValue(graph, cap1, cut), "Wrong cut value"); @@ -127,17 +128,17 @@ ho.run(); ho.minCutMap(cut); - + check(ho.minCutValue() == 1, "Wrong cut value"); check(ho.minCutValue() == cutValue(graph, cap3, cut), "Wrong cut value"); } - + typedef Undirector UGraph; UGraph ugraph(graph); - + { HaoOrlin > ho(ugraph, cap1); ho.run(); ho.minCutMap(cut); - + check(ho.minCutValue() == 2, "Wrong cut value"); check(ho.minCutValue() == cutValue(ugraph, cap1, cut), "Wrong cut value"); @@ -147,5 +148,5 @@ ho.run(); ho.minCutMap(cut); - + check(ho.minCutValue() == 5, "Wrong cut value"); check(ho.minCutValue() == cutValue(ugraph, cap2, cut), "Wrong cut value"); @@ -155,5 +156,5 @@ ho.run(); ho.minCutMap(cut); - + check(ho.minCutValue() == 5, "Wrong cut value"); check(ho.minCutValue() == cutValue(ugraph, cap3, cut), "Wrong cut value"); Index: test/heap_test.cc =================================================================== --- test/heap_test.cc (revision 948) +++ test/heap_test.cc (revision 681) @@ -26,4 +26,5 @@ #include + #include #include @@ -31,10 +32,6 @@ #include -#include -#include #include -#include #include -#include #include @@ -93,7 +90,9 @@ void heapSortTest() { RangeMap map(test_len, -1); + Heap heap(map); std::vector v(test_len); + for (int i = 0; i < test_len; ++i) { v[i] = test_seq[i]; @@ -102,5 +101,5 @@ std::sort(v.begin(), v.end()); for (int i = 0; i < test_len; ++i) { - check(v[i] == heap.prio(), "Wrong order in heap sort."); + check(v[i] == heap.prio() ,"Wrong order in heap sort."); heap.pop(); } @@ -114,4 +113,5 @@ std::vector v(test_len); + for (int i = 0; i < test_len; ++i) { v[i] = test_seq[i]; @@ -124,8 +124,10 @@ std::sort(v.begin(), v.end()); for (int i = 0; i < test_len; ++i) { - check(v[i] == heap.prio(), "Wrong order in heap increase test."); + check(v[i] == heap.prio() ,"Wrong order in heap increase test."); heap.pop(); } } + + template @@ -143,5 +145,5 @@ if (dijkstra.reached(s)) { check( dijkstra.dist(t) - dijkstra.dist(s) <= length[a], - "Error in shortest path tree."); + "Error in a shortest path tree!"); } } @@ -152,5 +154,5 @@ Node s = digraph.source(a); check( dijkstra.dist(n) - dijkstra.dist(s) == length[a], - "Error in shortest path tree."); + "Error in a shortest path tree!"); } } @@ -174,5 +176,4 @@ run(); - // BinHeap { typedef BinHeap IntHeap; @@ -186,29 +187,4 @@ } - // QuadHeap - { - typedef QuadHeap IntHeap; - checkConcept, IntHeap>(); - heapSortTest(); - heapIncreaseTest(); - - typedef QuadHeap NodeHeap; - checkConcept, NodeHeap>(); - dijkstraHeapTest(digraph, length, source); - } - - // DHeap - { - typedef DHeap IntHeap; - checkConcept, IntHeap>(); - heapSortTest(); - heapIncreaseTest(); - - typedef DHeap NodeHeap; - checkConcept, NodeHeap>(); - dijkstraHeapTest(digraph, length, source); - } - - // FibHeap { typedef FibHeap IntHeap; @@ -222,17 +198,4 @@ } - // PairingHeap - { - typedef PairingHeap IntHeap; - checkConcept, IntHeap>(); - heapSortTest(); - heapIncreaseTest(); - - typedef PairingHeap NodeHeap; - checkConcept, NodeHeap>(); - dijkstraHeapTest(digraph, length, source); - } - - // RadixHeap { typedef RadixHeap IntHeap; @@ -246,17 +209,4 @@ } - // BinomialHeap - { - typedef BinomialHeap IntHeap; - checkConcept, IntHeap>(); - heapSortTest(); - heapIncreaseTest(); - - typedef BinomialHeap NodeHeap; - checkConcept, NodeHeap>(); - dijkstraHeapTest(digraph, length, source); - } - - // BucketHeap, SimpleBucketHeap { typedef BucketHeap IntHeap; @@ -268,40 +218,4 @@ checkConcept, NodeHeap>(); dijkstraHeapTest(digraph, length, source); - - typedef SimpleBucketHeap SimpleIntHeap; - heapSortTest(); - } - - { - typedef FibHeap IntHeap; - checkConcept, IntHeap>(); - heapSortTest(); - heapIncreaseTest(); - - typedef FibHeap NodeHeap; - checkConcept, NodeHeap>(); - dijkstraHeapTest(digraph, length, source); - } - - { - typedef RadixHeap IntHeap; - checkConcept, IntHeap>(); - heapSortTest(); - heapIncreaseTest(); - - typedef RadixHeap NodeHeap; - checkConcept, NodeHeap>(); - dijkstraHeapTest(digraph, length, source); - } - - { - typedef BucketHeap IntHeap; - checkConcept, IntHeap>(); - heapSortTest(); - heapIncreaseTest(); - - typedef BucketHeap NodeHeap; - checkConcept, NodeHeap>(); - dijkstraHeapTest(digraph, length, source); } Index: test/maps_test.cc =================================================================== --- test/maps_test.cc (revision 998) +++ test/maps_test.cc (revision 997) @@ -3,5 +3,5 @@ * This file is a part of LEMON, a generic C++ optimization library. * - * Copyright (C) 2003-2010 + * Copyright (C) 2003-2009 * Egervary Jeno Kombinatorikus Optimalizalasi Kutatocsoport * (Egervary Research Group on Combinatorial Optimization, EGRES). @@ -24,8 +24,4 @@ #include #include -#include -#include -#include -#include #include "test_tools.h" @@ -39,20 +35,7 @@ class C { - int _x; + int x; public: - C(int x) : _x(x) {} - int get() const { return _x; } -}; -inline bool operator<(C c1, C c2) { return c1.get() < c2.get(); } -inline bool operator==(C c1, C c2) { return c1.get() == c2.get(); } - -C createC(int x) { return C(x); } - -template -class Less { - T _t; -public: - Less(T t): _t(t) {} - bool operator()(const T& t) const { return t < _t; } + C(int _x) : x(_x) {} }; @@ -70,12 +53,4 @@ int binc(int a, B) { return a+1; } - -template -class Sum { - T& _sum; -public: - Sum(T& sum) : _sum(sum) {} - void operator()(const T& t) { _sum += t; } -}; typedef ReadMap DoubleMap; @@ -374,8 +349,4 @@ { typedef std::vector vec; - checkConcept, LoggerBoolMap >(); - checkConcept, - LoggerBoolMap > >(); - vec v1; vec v2(10); @@ -397,208 +368,27 @@ it != map2.end(); ++it ) check(v1[i++] == *it, "Something is wrong with LoggerBoolMap"); - + } + + // CrossRefMap + { typedef ListDigraph Graph; DIGRAPH_TYPEDEFS(Graph); + + checkConcept, + CrossRefMap >(); + Graph gr; - + typedef CrossRefMap CRMap; + typedef CRMap::ValueIterator ValueIt; + CRMap map(gr); + Node n0 = gr.addNode(); Node n1 = gr.addNode(); Node n2 = gr.addNode(); - Node n3 = gr.addNode(); - - gr.addArc(n3, n0); - gr.addArc(n3, n2); - gr.addArc(n0, n2); - gr.addArc(n2, n1); - gr.addArc(n0, n1); - - { - std::vector v; - dfs(gr).processedMap(loggerBoolMap(std::back_inserter(v))).run(); - - check(v.size()==4 && v[0]==n1 && v[1]==n2 && v[2]==n0 && v[3]==n3, - "Something is wrong with LoggerBoolMap"); - } - { - std::vector v(countNodes(gr)); - dfs(gr).processedMap(loggerBoolMap(v.begin())).run(); - - check(v.size()==4 && v[0]==n1 && v[1]==n2 && v[2]==n0 && v[3]==n3, - "Something is wrong with LoggerBoolMap"); - } - } - - // IdMap, RangeIdMap - { - typedef ListDigraph Graph; - DIGRAPH_TYPEDEFS(Graph); - - checkConcept, IdMap >(); - checkConcept, IdMap >(); - checkConcept, RangeIdMap >(); - checkConcept, RangeIdMap >(); - - Graph gr; - IdMap nmap(gr); - IdMap amap(gr); - RangeIdMap nrmap(gr); - RangeIdMap armap(gr); - - Node n0 = gr.addNode(); - Node n1 = gr.addNode(); - Node n2 = gr.addNode(); - - Arc a0 = gr.addArc(n0, n1); - Arc a1 = gr.addArc(n0, n2); - Arc a2 = gr.addArc(n2, n1); - Arc a3 = gr.addArc(n2, n0); - - check(nmap[n0] == gr.id(n0) && nmap(gr.id(n0)) == n0, "Wrong IdMap"); - check(nmap[n1] == gr.id(n1) && nmap(gr.id(n1)) == n1, "Wrong IdMap"); - check(nmap[n2] == gr.id(n2) && nmap(gr.id(n2)) == n2, "Wrong IdMap"); - - check(amap[a0] == gr.id(a0) && amap(gr.id(a0)) == a0, "Wrong IdMap"); - check(amap[a1] == gr.id(a1) && amap(gr.id(a1)) == a1, "Wrong IdMap"); - check(amap[a2] == gr.id(a2) && amap(gr.id(a2)) == a2, "Wrong IdMap"); - check(amap[a3] == gr.id(a3) && amap(gr.id(a3)) == a3, "Wrong IdMap"); - - check(nmap.inverse()[gr.id(n0)] == n0, "Wrong IdMap::InverseMap"); - check(amap.inverse()[gr.id(a0)] == a0, "Wrong IdMap::InverseMap"); - - check(nrmap.size() == 3 && armap.size() == 4, - "Wrong RangeIdMap::size()"); - - check(nrmap[n0] == 0 && nrmap(0) == n0, "Wrong RangeIdMap"); - check(nrmap[n1] == 1 && nrmap(1) == n1, "Wrong RangeIdMap"); - check(nrmap[n2] == 2 && nrmap(2) == n2, "Wrong RangeIdMap"); - - check(armap[a0] == 0 && armap(0) == a0, "Wrong RangeIdMap"); - check(armap[a1] == 1 && armap(1) == a1, "Wrong RangeIdMap"); - check(armap[a2] == 2 && armap(2) == a2, "Wrong RangeIdMap"); - check(armap[a3] == 3 && armap(3) == a3, "Wrong RangeIdMap"); - - check(nrmap.inverse()[0] == n0, "Wrong RangeIdMap::InverseMap"); - check(armap.inverse()[0] == a0, "Wrong RangeIdMap::InverseMap"); - - gr.erase(n1); - - if (nrmap[n0] == 1) nrmap.swap(n0, n2); - nrmap.swap(n2, n0); - if (armap[a1] == 1) armap.swap(a1, a3); - armap.swap(a3, a1); - - check(nrmap.size() == 2 && armap.size() == 2, - "Wrong RangeIdMap::size()"); - - check(nrmap[n0] == 1 && nrmap(1) == n0, "Wrong RangeIdMap"); - check(nrmap[n2] == 0 && nrmap(0) == n2, "Wrong RangeIdMap"); - - check(armap[a1] == 1 && armap(1) == a1, "Wrong RangeIdMap"); - check(armap[a3] == 0 && armap(0) == a3, "Wrong RangeIdMap"); - - check(nrmap.inverse()[0] == n2, "Wrong RangeIdMap::InverseMap"); - check(armap.inverse()[0] == a3, "Wrong RangeIdMap::InverseMap"); - } - - // SourceMap, TargetMap, ForwardMap, BackwardMap, InDegMap, OutDegMap - { - typedef ListGraph Graph; - GRAPH_TYPEDEFS(Graph); - - checkConcept, SourceMap >(); - checkConcept, TargetMap >(); - checkConcept, ForwardMap >(); - checkConcept, BackwardMap >(); - checkConcept, InDegMap >(); - checkConcept, OutDegMap >(); - - Graph gr; - Node n0 = gr.addNode(); - Node n1 = gr.addNode(); - Node n2 = gr.addNode(); - - gr.addEdge(n0,n1); - gr.addEdge(n1,n2); - gr.addEdge(n0,n2); - gr.addEdge(n2,n1); - gr.addEdge(n1,n2); - gr.addEdge(n0,n1); - - for (EdgeIt e(gr); e != INVALID; ++e) { - check(forwardMap(gr)[e] == gr.direct(e, true), "Wrong ForwardMap"); - check(backwardMap(gr)[e] == gr.direct(e, false), "Wrong BackwardMap"); - } - - check(mapCompare(gr, - sourceMap(orienter(gr, constMap(true))), - targetMap(orienter(gr, constMap(false)))), - "Wrong SourceMap or TargetMap"); - - typedef Orienter > Digraph; - Digraph dgr(gr, constMap(true)); - OutDegMap odm(dgr); - InDegMap idm(dgr); - - check(odm[n0] == 3 && odm[n1] == 2 && odm[n2] == 1, "Wrong OutDegMap"); - check(idm[n0] == 0 && idm[n1] == 3 && idm[n2] == 3, "Wrong InDegMap"); - - gr.addEdge(n2, n0); - - check(odm[n0] == 3 && odm[n1] == 2 && odm[n2] == 2, "Wrong OutDegMap"); - check(idm[n0] == 1 && idm[n1] == 3 && idm[n2] == 3, "Wrong InDegMap"); - } - - // CrossRefMap - { - typedef ListDigraph Graph; - DIGRAPH_TYPEDEFS(Graph); - - checkConcept, - CrossRefMap >(); - checkConcept, - CrossRefMap >(); - checkConcept, - CrossRefMap >(); - - Graph gr; - typedef CrossRefMap CRMap; - CRMap map(gr); - - Node n0 = gr.addNode(); - Node n1 = gr.addNode(); - Node n2 = gr.addNode(); - + map.set(n0, 'A'); map.set(n1, 'B'); map.set(n2, 'C'); - - check(map[n0] == 'A' && map('A') == n0 && map.inverse()['A'] == n0, - "Wrong CrossRefMap"); - check(map[n1] == 'B' && map('B') == n1 && map.inverse()['B'] == n1, - "Wrong CrossRefMap"); - check(map[n2] == 'C' && map('C') == n2 && map.inverse()['C'] == n2, - "Wrong CrossRefMap"); - check(map.count('A') == 1 && map.count('B') == 1 && map.count('C') == 1, - "Wrong CrossRefMap::count()"); - - CRMap::ValueIt it = map.beginValue(); - check(*it++ == 'A' && *it++ == 'B' && *it++ == 'C' && - it == map.endValue(), "Wrong value iterator"); - map.set(n2, 'A'); - - check(map[n0] == 'A' && map[n1] == 'B' && map[n2] == 'A', - "Wrong CrossRefMap"); - check(map('A') == n0 && map.inverse()['A'] == n0, "Wrong CrossRefMap"); - check(map('B') == n1 && map.inverse()['B'] == n1, "Wrong CrossRefMap"); - check(map('C') == INVALID && map.inverse()['C'] == INVALID, - "Wrong CrossRefMap"); - check(map.count('A') == 2 && map.count('B') == 1 && map.count('C') == 0, - "Wrong CrossRefMap::count()"); - - it = map.beginValue(); - check(*it++ == 'A' && *it++ == 'A' && *it++ == 'B' && - it == map.endValue(), "Wrong value iterator"); - map.set(n0, 'C'); @@ -608,40 +398,4 @@ check(map('B') == n1 && map.inverse()['B'] == n1, "Wrong CrossRefMap"); check(map('C') == n0 && map.inverse()['C'] == n0, "Wrong CrossRefMap"); - check(map.count('A') == 1 && map.count('B') == 1 && map.count('C') == 1, - "Wrong CrossRefMap::count()"); - - it = map.beginValue(); - check(*it++ == 'A' && *it++ == 'B' && *it++ == 'C' && - it == map.endValue(), "Wrong value iterator"); - } - - // CrossRefMap - { - typedef SmartDigraph Graph; - DIGRAPH_TYPEDEFS(Graph); - - checkConcept, - CrossRefMap >(); - - Graph gr; - typedef CrossRefMap CRMap; - typedef CRMap::ValueIterator ValueIt; - CRMap map(gr); - - Node n0 = gr.addNode(); - Node n1 = gr.addNode(); - Node n2 = gr.addNode(); - - map.set(n0, 'A'); - map.set(n1, 'B'); - map.set(n2, 'C'); - map.set(n2, 'A'); - map.set(n0, 'C'); - - check(map[n0] == 'C' && map[n1] == 'B' && map[n2] == 'A', - "Wrong CrossRefMap"); - check(map('A') == n2 && map.inverse()['A'] == n2, "Wrong CrossRefMap"); - check(map('B') == n1 && map.inverse()['B'] == n1, "Wrong CrossRefMap"); - check(map('C') == n0 && map.inverse()['C'] == n0, "Wrong CrossRefMap"); ValueIt it = map.beginValue(); @@ -650,372 +404,4 @@ } - // Iterable bool map - { - typedef SmartGraph Graph; - typedef SmartGraph::Node Item; - - typedef IterableBoolMap Ibm; - checkConcept, Ibm>(); - - const int num = 10; - Graph g; - Ibm map0(g, true); - std::vector items; - for (int i = 0; i < num; ++i) { - items.push_back(g.addNode()); - } - - Ibm map1(g, true); - int n = 0; - for (Ibm::TrueIt it(map1); it != INVALID; ++it) { - check(map1[static_cast(it)], "Wrong TrueIt"); - ++n; - } - check(n == num, "Wrong number"); - - n = 0; - for (Ibm::ItemIt it(map1, true); it != INVALID; ++it) { - check(map1[static_cast(it)], "Wrong ItemIt for true"); - ++n; - } - check(n == num, "Wrong number"); - check(Ibm::FalseIt(map1) == INVALID, "Wrong FalseIt"); - check(Ibm::ItemIt(map1, false) == INVALID, "Wrong ItemIt for false"); - - map1[items[5]] = true; - - n = 0; - for (Ibm::ItemIt it(map1, true); it != INVALID; ++it) { - check(map1[static_cast(it)], "Wrong ItemIt for true"); - ++n; - } - check(n == num, "Wrong number"); - - map1[items[num / 2]] = false; - check(map1[items[num / 2]] == false, "Wrong map value"); - - n = 0; - for (Ibm::TrueIt it(map1); it != INVALID; ++it) { - check(map1[static_cast(it)], "Wrong TrueIt for true"); - ++n; - } - check(n == num - 1, "Wrong number"); - - n = 0; - for (Ibm::FalseIt it(map1); it != INVALID; ++it) { - check(!map1[static_cast(it)], "Wrong FalseIt for true"); - ++n; - } - check(n == 1, "Wrong number"); - - map1[items[0]] = false; - check(map1[items[0]] == false, "Wrong map value"); - - map1[items[num - 1]] = false; - check(map1[items[num - 1]] == false, "Wrong map value"); - - n = 0; - for (Ibm::TrueIt it(map1); it != INVALID; ++it) { - check(map1[static_cast(it)], "Wrong TrueIt for true"); - ++n; - } - check(n == num - 3, "Wrong number"); - check(map1.trueNum() == num - 3, "Wrong number"); - - n = 0; - for (Ibm::FalseIt it(map1); it != INVALID; ++it) { - check(!map1[static_cast(it)], "Wrong FalseIt for true"); - ++n; - } - check(n == 3, "Wrong number"); - check(map1.falseNum() == 3, "Wrong number"); - } - - // Iterable int map - { - typedef SmartGraph Graph; - typedef SmartGraph::Node Item; - typedef IterableIntMap Iim; - - checkConcept, Iim>(); - - const int num = 10; - Graph g; - Iim map0(g, 0); - std::vector items; - for (int i = 0; i < num; ++i) { - items.push_back(g.addNode()); - } - - Iim map1(g); - check(map1.size() == 0, "Wrong size"); - - for (int i = 0; i < num; ++i) { - map1[items[i]] = i; - } - check(map1.size() == num, "Wrong size"); - - for (int i = 0; i < num; ++i) { - Iim::ItemIt it(map1, i); - check(static_cast(it) == items[i], "Wrong value"); - ++it; - check(static_cast(it) == INVALID, "Wrong value"); - } - - for (int i = 0; i < num; ++i) { - map1[items[i]] = i % 2; - } - check(map1.size() == 2, "Wrong size"); - - int n = 0; - for (Iim::ItemIt it(map1, 0); it != INVALID; ++it) { - check(map1[static_cast(it)] == 0, "Wrong value"); - ++n; - } - check(n == (num + 1) / 2, "Wrong number"); - - for (Iim::ItemIt it(map1, 1); it != INVALID; ++it) { - check(map1[static_cast(it)] == 1, "Wrong value"); - ++n; - } - check(n == num, "Wrong number"); - - } - - // Iterable value map - { - typedef SmartGraph Graph; - typedef SmartGraph::Node Item; - typedef IterableValueMap Ivm; - - checkConcept, Ivm>(); - - const int num = 10; - Graph g; - Ivm map0(g, 0.0); - std::vector items; - for (int i = 0; i < num; ++i) { - items.push_back(g.addNode()); - } - - Ivm map1(g, 0.0); - check(distance(map1.beginValue(), map1.endValue()) == 1, "Wrong size"); - check(*map1.beginValue() == 0.0, "Wrong value"); - - for (int i = 0; i < num; ++i) { - map1.set(items[i], static_cast(i)); - } - check(distance(map1.beginValue(), map1.endValue()) == num, "Wrong size"); - - for (int i = 0; i < num; ++i) { - Ivm::ItemIt it(map1, static_cast(i)); - check(static_cast(it) == items[i], "Wrong value"); - ++it; - check(static_cast(it) == INVALID, "Wrong value"); - } - - for (Ivm::ValueIt vit = map1.beginValue(); - vit != map1.endValue(); ++vit) { - check(map1[static_cast(Ivm::ItemIt(map1, *vit))] == *vit, - "Wrong ValueIt"); - } - - for (int i = 0; i < num; ++i) { - map1.set(items[i], static_cast(i % 2)); - } - check(distance(map1.beginValue(), map1.endValue()) == 2, "Wrong size"); - - int n = 0; - for (Ivm::ItemIt it(map1, 0.0); it != INVALID; ++it) { - check(map1[static_cast(it)] == 0.0, "Wrong value"); - ++n; - } - check(n == (num + 1) / 2, "Wrong number"); - - for (Ivm::ItemIt it(map1, 1.0); it != INVALID; ++it) { - check(map1[static_cast(it)] == 1.0, "Wrong value"); - ++n; - } - check(n == num, "Wrong number"); - - } - - // Graph map utilities: - // mapMin(), mapMax(), mapMinValue(), mapMaxValue() - // mapFind(), mapFindIf(), mapCount(), mapCountIf() - // mapCopy(), mapCompare(), mapFill() - { - DIGRAPH_TYPEDEFS(SmartDigraph); - - SmartDigraph g; - Node n1 = g.addNode(); - Node n2 = g.addNode(); - Node n3 = g.addNode(); - - SmartDigraph::NodeMap map1(g); - SmartDigraph::ArcMap map2(g); - ConstMap cmap1 = A(); - ConstMap cmap2 = C(0); - - map1[n1] = 10; - map1[n2] = 5; - map1[n3] = 12; - - // mapMin(), mapMax(), mapMinValue(), mapMaxValue() - check(mapMin(g, map1) == n2, "Wrong mapMin()"); - check(mapMax(g, map1) == n3, "Wrong mapMax()"); - check(mapMin(g, map1, std::greater()) == n3, "Wrong mapMin()"); - check(mapMax(g, map1, std::greater()) == n2, "Wrong mapMax()"); - check(mapMinValue(g, map1) == 5, "Wrong mapMinValue()"); - check(mapMaxValue(g, map1) == 12, "Wrong mapMaxValue()"); - - check(mapMin(g, map2) == INVALID, "Wrong mapMin()"); - check(mapMax(g, map2) == INVALID, "Wrong mapMax()"); - - check(mapMin(g, cmap1) != INVALID, "Wrong mapMin()"); - check(mapMax(g, cmap2) == INVALID, "Wrong mapMax()"); - - Arc a1 = g.addArc(n1, n2); - Arc a2 = g.addArc(n1, n3); - Arc a3 = g.addArc(n2, n3); - Arc a4 = g.addArc(n3, n1); - - map2[a1] = 'b'; - map2[a2] = 'a'; - map2[a3] = 'b'; - map2[a4] = 'c'; - - // mapMin(), mapMax(), mapMinValue(), mapMaxValue() - check(mapMin(g, map2) == a2, "Wrong mapMin()"); - check(mapMax(g, map2) == a4, "Wrong mapMax()"); - check(mapMin(g, map2, std::greater()) == a4, "Wrong mapMin()"); - check(mapMax(g, map2, std::greater()) == a2, "Wrong mapMax()"); - check(mapMinValue(g, map2, std::greater()) == 'c', - "Wrong mapMinValue()"); - check(mapMaxValue(g, map2, std::greater()) == 'a', - "Wrong mapMaxValue()"); - - check(mapMin(g, cmap1) != INVALID, "Wrong mapMin()"); - check(mapMax(g, cmap2) != INVALID, "Wrong mapMax()"); - check(mapMaxValue(g, cmap2) == C(0), "Wrong mapMaxValue()"); - - check(mapMin(g, composeMap(functorToMap(&createC), map2)) == a2, - "Wrong mapMin()"); - check(mapMax(g, composeMap(functorToMap(&createC), map2)) == a4, - "Wrong mapMax()"); - check(mapMinValue(g, composeMap(functorToMap(&createC), map2)) == C('a'), - "Wrong mapMinValue()"); - check(mapMaxValue(g, composeMap(functorToMap(&createC), map2)) == C('c'), - "Wrong mapMaxValue()"); - - // mapFind(), mapFindIf() - check(mapFind(g, map1, 5) == n2, "Wrong mapFind()"); - check(mapFind(g, map1, 6) == INVALID, "Wrong mapFind()"); - check(mapFind(g, map2, 'a') == a2, "Wrong mapFind()"); - check(mapFind(g, map2, 'e') == INVALID, "Wrong mapFind()"); - check(mapFind(g, cmap2, C(0)) == ArcIt(g), "Wrong mapFind()"); - check(mapFind(g, cmap2, C(1)) == INVALID, "Wrong mapFind()"); - - check(mapFindIf(g, map1, Less(7)) == n2, - "Wrong mapFindIf()"); - check(mapFindIf(g, map1, Less(5)) == INVALID, - "Wrong mapFindIf()"); - check(mapFindIf(g, map2, Less('d')) == ArcIt(g), - "Wrong mapFindIf()"); - check(mapFindIf(g, map2, Less('a')) == INVALID, - "Wrong mapFindIf()"); - - // mapCount(), mapCountIf() - check(mapCount(g, map1, 5) == 1, "Wrong mapCount()"); - check(mapCount(g, map1, 6) == 0, "Wrong mapCount()"); - check(mapCount(g, map2, 'a') == 1, "Wrong mapCount()"); - check(mapCount(g, map2, 'b') == 2, "Wrong mapCount()"); - check(mapCount(g, map2, 'e') == 0, "Wrong mapCount()"); - check(mapCount(g, cmap2, C(0)) == 4, "Wrong mapCount()"); - check(mapCount(g, cmap2, C(1)) == 0, "Wrong mapCount()"); - - check(mapCountIf(g, map1, Less(11)) == 2, - "Wrong mapCountIf()"); - check(mapCountIf(g, map1, Less(13)) == 3, - "Wrong mapCountIf()"); - check(mapCountIf(g, map1, Less(5)) == 0, - "Wrong mapCountIf()"); - check(mapCountIf(g, map2, Less('d')) == 4, - "Wrong mapCountIf()"); - check(mapCountIf(g, map2, Less('c')) == 3, - "Wrong mapCountIf()"); - check(mapCountIf(g, map2, Less('a')) == 0, - "Wrong mapCountIf()"); - - // MapIt, ConstMapIt -/* -These tests can be used after applying bugfix #330 - typedef SmartDigraph::NodeMap::MapIt MapIt; - typedef SmartDigraph::NodeMap::ConstMapIt ConstMapIt; - check(*std::min_element(MapIt(map1), MapIt(INVALID)) == 5, - "Wrong NodeMap<>::MapIt"); - check(*std::max_element(ConstMapIt(map1), ConstMapIt(INVALID)) == 12, - "Wrong NodeMap<>::MapIt"); - - int sum = 0; - std::for_each(MapIt(map1), MapIt(INVALID), Sum(sum)); - check(sum == 27, "Wrong NodeMap<>::MapIt"); - std::for_each(ConstMapIt(map1), ConstMapIt(INVALID), Sum(sum)); - check(sum == 54, "Wrong NodeMap<>::ConstMapIt"); -*/ - - // mapCopy(), mapCompare(), mapFill() - check(mapCompare(g, map1, map1), "Wrong mapCompare()"); - check(mapCompare(g, cmap2, cmap2), "Wrong mapCompare()"); - check(mapCompare(g, map1, shiftMap(map1, 0)), "Wrong mapCompare()"); - check(mapCompare(g, map2, scaleMap(map2, 1)), "Wrong mapCompare()"); - check(!mapCompare(g, map1, shiftMap(map1, 1)), "Wrong mapCompare()"); - - SmartDigraph::NodeMap map3(g, 0); - SmartDigraph::ArcMap map4(g, 'a'); - - check(!mapCompare(g, map1, map3), "Wrong mapCompare()"); - check(!mapCompare(g, map2, map4), "Wrong mapCompare()"); - - mapCopy(g, map1, map3); - mapCopy(g, map2, map4); - - check(mapCompare(g, map1, map3), "Wrong mapCompare() or mapCopy()"); - check(mapCompare(g, map2, map4), "Wrong mapCompare() or mapCopy()"); - - Undirector ug(g); - Undirector::EdgeMap umap1(ug, 'x'); - Undirector::ArcMap umap2(ug, 3.14); - - check(!mapCompare(g, map2, umap1), "Wrong mapCompare() or mapCopy()"); - check(!mapCompare(g, umap1, map2), "Wrong mapCompare() or mapCopy()"); - check(!mapCompare(ug, map2, umap1), "Wrong mapCompare() or mapCopy()"); - check(!mapCompare(ug, umap1, map2), "Wrong mapCompare() or mapCopy()"); - - mapCopy(g, map2, umap1); - - check(mapCompare(g, map2, umap1), "Wrong mapCompare() or mapCopy()"); - check(mapCompare(g, umap1, map2), "Wrong mapCompare() or mapCopy()"); - check(mapCompare(ug, map2, umap1), "Wrong mapCompare() or mapCopy()"); - check(mapCompare(ug, umap1, map2), "Wrong mapCompare() or mapCopy()"); - - mapCopy(g, map2, umap1); - mapCopy(g, umap1, map2); - mapCopy(ug, map2, umap1); - mapCopy(ug, umap1, map2); - - check(!mapCompare(ug, umap1, umap2), "Wrong mapCompare() or mapCopy()"); - mapCopy(ug, umap1, umap2); - check(mapCompare(ug, umap1, umap2), "Wrong mapCompare() or mapCopy()"); - - check(!mapCompare(g, map1, constMap(2)), "Wrong mapCompare()"); - mapFill(g, map1, 2); - check(mapCompare(g, constMap(2), map1), "Wrong mapFill()"); - - check(!mapCompare(g, map2, constMap('z')), "Wrong mapCompare()"); - mapCopy(g, constMap('z'), map2); - check(mapCompare(g, constMap('z'), map2), "Wrong mapCopy()"); - } - return 0; } Index: test/matching_test.cc =================================================================== --- test/matching_test.cc (revision 877) +++ test/matching_test.cc (revision 1007) @@ -3,5 +3,5 @@ * This file is a part of LEMON, a generic C++ optimization library. * - * Copyright (C) 2003-2010 + * Copyright (C) 2003-2009 * Egervary Jeno Kombinatorikus Optimalizalasi Kutatocsoport * (Egervary Research Group on Combinatorial Optimization, EGRES). @@ -135,5 +135,5 @@ mat_test.startDense(); mat_test.run(); - + const_mat_test.matchingSize(); const_mat_test.matching(e); @@ -144,6 +144,7 @@ const_mat_test.mate(n); - MaxMatching::Status stat = + MaxMatching::Status stat = const_mat_test.status(n); + ignore_unused_variable_warning(stat); const MaxMatching::StatusMap& smap = const_mat_test.statusMap(); @@ -171,5 +172,5 @@ mat_test.start(); mat_test.run(); - + const_mat_test.matchingWeight(); const_mat_test.matchingSize(); @@ -180,5 +181,5 @@ e = mmap[n]; const_mat_test.mate(n); - + int k = 0; const_mat_test.dualValue(); @@ -208,5 +209,5 @@ mat_test.start(); mat_test.run(); - + const_mat_test.matchingWeight(); const_mat_test.matching(e); @@ -216,5 +217,5 @@ e = mmap[n]; const_mat_test.mate(n); - + int k = 0; const_mat_test.dualValue(); @@ -402,44 +403,20 @@ edgeMap("weight", weight).run(); - bool perfect; - { - MaxMatching mm(graph); - mm.run(); - checkMatching(graph, mm); - perfect = 2 * mm.matchingSize() == countNodes(graph); - } - - { - MaxWeightedMatching mwm(graph, weight); - mwm.run(); - checkWeightedMatching(graph, weight, mwm); - } - - { - MaxWeightedMatching mwm(graph, weight); - mwm.init(); - mwm.start(); - checkWeightedMatching(graph, weight, mwm); - } - - { - MaxWeightedPerfectMatching mwpm(graph, weight); - bool result = mwpm.run(); - - check(result == perfect, "Perfect matching found"); - if (perfect) { - checkWeightedPerfectMatching(graph, weight, mwpm); - } - } - - { - MaxWeightedPerfectMatching mwpm(graph, weight); - mwpm.init(); - bool result = mwpm.start(); - - check(result == perfect, "Perfect matching found"); - if (perfect) { - checkWeightedPerfectMatching(graph, weight, mwpm); - } + MaxMatching mm(graph); + mm.run(); + checkMatching(graph, mm); + + MaxWeightedMatching mwm(graph, weight); + mwm.run(); + checkWeightedMatching(graph, weight, mwm); + + MaxWeightedPerfectMatching mwpm(graph, weight); + bool perfect = mwpm.run(); + + check(perfect == (mm.matchingSize() * 2 == countNodes(graph)), + "Perfect matching found"); + + if (perfect) { + checkWeightedPerfectMatching(graph, weight, mwpm); } } Index: st/max_cardinality_search_test.cc =================================================================== --- test/max_cardinality_search_test.cc (revision 955) +++ (revision ) @@ -1,162 +1,0 @@ -/* -*- mode: C++; indent-tabs-mode: nil; -*- - * - * This file is a part of LEMON, a generic C++ optimization library. - * - * Copyright (C) 2003-2010 - * Egervary Jeno Kombinatorikus Optimalizalasi Kutatocsoport - * (Egervary Research Group on Combinatorial Optimization, EGRES). - * - * Permission to use, modify and distribute this software is granted - * provided that this copyright notice appears in all copies. For - * precise terms see the accompanying LICENSE file. - * - * This software is provided "AS IS" with no warranty of any kind, - * express or implied, and with no claim as to its suitability for any - * purpose. - * - */ - -#include - -#include "test_tools.h" -#include -#include -#include -#include -#include -#include - -using namespace lemon; -using namespace std; - -char test_lgf[] = - "@nodes\n" - "label\n" - "0\n" - "1\n" - "2\n" - "3\n" - "@arcs\n" - " label capacity\n" - "0 1 0 2\n" - "1 0 1 2\n" - "2 1 2 1\n" - "2 3 3 3\n" - "3 2 4 3\n" - "3 1 5 5\n" - "@attributes\n" - "s 0\n" - "x 1\n" - "y 2\n" - "z 3\n"; - -void checkMaxCardSearchCompile() { - - typedef concepts::Digraph Digraph; - typedef int Value; - typedef Digraph::Node Node; - typedef Digraph::Arc Arc; - typedef concepts::ReadMap CapMap; - typedef concepts::ReadWriteMap CardMap; - typedef concepts::ReadWriteMap ProcMap; - typedef Digraph::NodeMap HeapCrossRef; - - Digraph g; - Node n,s; - CapMap cap; - CardMap card; - ProcMap proc; - HeapCrossRef crossref(g); - - typedef MaxCardinalitySearch - ::SetCapacityMap - ::SetCardinalityMap - ::SetProcessedMap - ::SetStandardHeap > - ::Create MaxCardType; - - MaxCardType maxcard(g,cap); - const MaxCardType& const_maxcard = maxcard; - - const MaxCardType::Heap& heap_const = const_maxcard.heap(); - MaxCardType::Heap& heap = const_cast(heap_const); - maxcard.heap(heap,crossref); - - maxcard.capacityMap(cap).cardinalityMap(card).processedMap(proc); - - maxcard.init(); - maxcard.addSource(s); - n = maxcard.nextNode(); - maxcard.processNextNode(); - maxcard.start(); - maxcard.run(s); - maxcard.run(); - } - - void checkWithIntMap( std::istringstream& input) - { - typedef SmartDigraph Digraph; - typedef Digraph::Node Node; - typedef Digraph::ArcMap CapMap; - - Digraph g; - Node s,x,y,z,a; - CapMap cap(g); - - DigraphReader(g,input). - arcMap("capacity", cap). - node("s",s). - node("x",x). - node("y",y). - node("z",z). - run(); - - MaxCardinalitySearch maxcard(g,cap); - - maxcard.init(); - maxcard.addSource(s); - maxcard.start(x); - - check(maxcard.processed(s) && !maxcard.processed(x) && - !maxcard.processed(y), "Wrong processed()!"); - - a=maxcard.nextNode(); - check(maxcard.processNextNode()==a, - "Wrong nextNode() or processNextNode() return value!"); - - check(maxcard.processed(a), "Wrong processNextNode()!"); - - maxcard.start(); - check(maxcard.cardinality(x)==2 && maxcard.cardinality(y)>=4, - "Wrong cardinalities!"); - } - - void checkWithConst1Map(std::istringstream &input) { - typedef SmartDigraph Digraph; - typedef Digraph::Node Node; - - Digraph g; - Node s,x,y,z; - - DigraphReader(g,input). - node("s",s). - node("x",x). - node("y",y). - node("z",z). - run(); - - MaxCardinalitySearch maxcard(g); - maxcard.run(s); - check(maxcard.cardinality(x)==1 && - maxcard.cardinality(y)+maxcard.cardinality(z)==3, - "Wrong cardinalities!"); -} - -int main() { - - std::istringstream input1(test_lgf); - checkWithIntMap(input1); - - std::istringstream input2(test_lgf); - checkWithConst1Map(input2); -} Index: st/max_clique_test.cc =================================================================== --- test/max_clique_test.cc (revision 918) +++ (revision ) @@ -1,188 +1,0 @@ -/* -*- mode: C++; indent-tabs-mode: nil; -*- - * - * This file is a part of LEMON, a generic C++ optimization library. - * - * Copyright (C) 2003-2010 - * Egervary Jeno Kombinatorikus Optimalizalasi Kutatocsoport - * (Egervary Research Group on Combinatorial Optimization, EGRES). - * - * Permission to use, modify and distribute this software is granted - * provided that this copyright notice appears in all copies. For - * precise terms see the accompanying LICENSE file. - * - * This software is provided "AS IS" with no warranty of any kind, - * express or implied, and with no claim as to its suitability for any - * purpose. - * - */ - -#include -#include -#include -#include -#include -#include - -#include "test_tools.h" - -using namespace lemon; - -char test_lgf[] = - "@nodes\n" - "label max_clique\n" - "1 0\n" - "2 0\n" - "3 0\n" - "4 1\n" - "5 1\n" - "6 1\n" - "7 1\n" - "@edges\n" - " label\n" - "1 2 1\n" - "1 3 2\n" - "1 4 3\n" - "1 6 4\n" - "2 3 5\n" - "2 5 6\n" - "2 7 7\n" - "3 4 8\n" - "3 5 9\n" - "4 5 10\n" - "4 6 11\n" - "4 7 12\n" - "5 6 13\n" - "5 7 14\n" - "6 7 15\n"; - - -// Check with general graphs -template -void checkMaxCliqueGeneral(Param rule) { - typedef ListGraph GR; - typedef GrossoLocatelliPullanMc McAlg; - typedef McAlg::CliqueNodeIt CliqueIt; - - // Basic tests - { - GR g; - GR::NodeMap map(g); - McAlg mc(g); - mc.iterationLimit(50); - check(mc.run(rule) == McAlg::SIZE_LIMIT, "Wrong termination cause"); - check(mc.cliqueSize() == 0, "Wrong clique size"); - check(CliqueIt(mc) == INVALID, "Wrong CliqueNodeIt"); - - GR::Node u = g.addNode(); - check(mc.run(rule) == McAlg::SIZE_LIMIT, "Wrong termination cause"); - check(mc.cliqueSize() == 1, "Wrong clique size"); - mc.cliqueMap(map); - check(map[u], "Wrong clique map"); - CliqueIt it1(mc); - check(static_cast(it1) == u && ++it1 == INVALID, - "Wrong CliqueNodeIt"); - - GR::Node v = g.addNode(); - check(mc.run(rule) == McAlg::ITERATION_LIMIT, "Wrong termination cause"); - check(mc.cliqueSize() == 1, "Wrong clique size"); - mc.cliqueMap(map); - check((map[u] && !map[v]) || (map[v] && !map[u]), "Wrong clique map"); - CliqueIt it2(mc); - check(it2 != INVALID && ++it2 == INVALID, "Wrong CliqueNodeIt"); - - g.addEdge(u, v); - check(mc.run(rule) == McAlg::SIZE_LIMIT, "Wrong termination cause"); - check(mc.cliqueSize() == 2, "Wrong clique size"); - mc.cliqueMap(map); - check(map[u] && map[v], "Wrong clique map"); - CliqueIt it3(mc); - check(it3 != INVALID && ++it3 != INVALID && ++it3 == INVALID, - "Wrong CliqueNodeIt"); - } - - // Test graph - { - GR g; - GR::NodeMap max_clique(g); - GR::NodeMap map(g); - std::istringstream input(test_lgf); - graphReader(g, input) - .nodeMap("max_clique", max_clique) - .run(); - - McAlg mc(g); - mc.iterationLimit(50); - check(mc.run(rule) == McAlg::ITERATION_LIMIT, "Wrong termination cause"); - check(mc.cliqueSize() == 4, "Wrong clique size"); - mc.cliqueMap(map); - for (GR::NodeIt n(g); n != INVALID; ++n) { - check(map[n] == max_clique[n], "Wrong clique map"); - } - int cnt = 0; - for (CliqueIt n(mc); n != INVALID; ++n) { - cnt++; - check(map[n] && max_clique[n], "Wrong CliqueNodeIt"); - } - check(cnt == 4, "Wrong CliqueNodeIt"); - } -} - -// Check with full graphs -template -void checkMaxCliqueFullGraph(Param rule) { - typedef FullGraph GR; - typedef GrossoLocatelliPullanMc McAlg; - typedef McAlg::CliqueNodeIt CliqueIt; - - for (int size = 0; size <= 40; size = size * 3 + 1) { - GR g(size); - GR::NodeMap map(g); - McAlg mc(g); - check(mc.run(rule) == McAlg::SIZE_LIMIT, "Wrong termination cause"); - check(mc.cliqueSize() == size, "Wrong clique size"); - mc.cliqueMap(map); - for (GR::NodeIt n(g); n != INVALID; ++n) { - check(map[n], "Wrong clique map"); - } - int cnt = 0; - for (CliqueIt n(mc); n != INVALID; ++n) cnt++; - check(cnt == size, "Wrong CliqueNodeIt"); - } -} - -// Check with grid graphs -template -void checkMaxCliqueGridGraph(Param rule) { - GridGraph g(5, 7); - GridGraph::NodeMap map(g); - GrossoLocatelliPullanMc mc(g); - - mc.iterationLimit(100); - check(mc.run(rule) == mc.ITERATION_LIMIT, "Wrong termination cause"); - check(mc.cliqueSize() == 2, "Wrong clique size"); - - mc.stepLimit(100); - check(mc.run(rule) == mc.STEP_LIMIT, "Wrong termination cause"); - check(mc.cliqueSize() == 2, "Wrong clique size"); - - mc.sizeLimit(2); - check(mc.run(rule) == mc.SIZE_LIMIT, "Wrong termination cause"); - check(mc.cliqueSize() == 2, "Wrong clique size"); -} - - -int main() { - checkMaxCliqueGeneral(GrossoLocatelliPullanMc::RANDOM); - checkMaxCliqueGeneral(GrossoLocatelliPullanMc::DEGREE_BASED); - checkMaxCliqueGeneral(GrossoLocatelliPullanMc::PENALTY_BASED); - - checkMaxCliqueFullGraph(GrossoLocatelliPullanMc::RANDOM); - checkMaxCliqueFullGraph(GrossoLocatelliPullanMc::DEGREE_BASED); - checkMaxCliqueFullGraph(GrossoLocatelliPullanMc::PENALTY_BASED); - - checkMaxCliqueGridGraph(GrossoLocatelliPullanMc::RANDOM); - checkMaxCliqueGridGraph(GrossoLocatelliPullanMc::DEGREE_BASED); - checkMaxCliqueGridGraph(GrossoLocatelliPullanMc::PENALTY_BASED); - - return 0; -} Index: test/min_cost_arborescence_test.cc =================================================================== --- test/min_cost_arborescence_test.cc (revision 877) +++ test/min_cost_arborescence_test.cc (revision 1007) @@ -3,5 +3,5 @@ * This file is a part of LEMON, a generic C++ optimization library. * - * Copyright (C) 2003-2010 + * Copyright (C) 2003-2008 * Egervary Jeno Kombinatorikus Optimalizalasi Kutatocsoport * (Egervary Research Group on Combinatorial Optimization, EGRES). @@ -92,4 +92,5 @@ VType c; bool b; + ignore_unused_variable_warning(c,b); int i; CostMap cost; @@ -111,5 +112,5 @@ b = const_mcarb_test.emptyQueue(); i = const_mcarb_test.queueSize(); - + c = const_mcarb_test.arborescenceCost(); b = const_mcarb_test.arborescence(e); @@ -121,10 +122,10 @@ b = const_mcarb_test.reached(n); b = const_mcarb_test.processed(n); - + i = const_mcarb_test.dualNum(); c = const_mcarb_test.dualValue(); i = const_mcarb_test.dualSize(i); c = const_mcarb_test.dualValue(i); - + ignore_unused_variable_warning(am); ignore_unused_variable_warning(pm); Index: test/min_cost_flow_test.cc =================================================================== --- test/min_cost_flow_test.cc (revision 877) +++ test/min_cost_flow_test.cc (revision 669) @@ -3,5 +3,5 @@ * This file is a part of LEMON, a generic C++ optimization library. * - * Copyright (C) 2003-2010 + * Copyright (C) 2003-2009 * Egervary Jeno Kombinatorikus Optimalizalasi Kutatocsoport * (Egervary Research Group on Combinatorial Optimization, EGRES). @@ -25,10 +25,6 @@ #include -#include -#include -#include #include -#include #include @@ -37,5 +33,4 @@ using namespace lemon; -// Test networks char test_lgf[] = "@nodes\n" @@ -53,5 +48,5 @@ " 11 0 0 0 0 -10 0\n" " 12 -20 -27 0 -30 -30 -20\n" - "\n" + "\n" "@arcs\n" " cost cap low1 low2 low3\n" @@ -82,56 +77,4 @@ "target 12\n"; -char test_neg1_lgf[] = - "@nodes\n" - "label sup\n" - " 1 100\n" - " 2 0\n" - " 3 0\n" - " 4 -100\n" - " 5 0\n" - " 6 0\n" - " 7 0\n" - "@arcs\n" - " cost low1 low2\n" - "1 2 100 0 0\n" - "1 3 30 0 0\n" - "2 4 20 0 0\n" - "3 4 80 0 0\n" - "3 2 50 0 0\n" - "5 3 10 0 0\n" - "5 6 80 0 1000\n" - "6 7 30 0 -1000\n" - "7 5 -120 0 0\n"; - -char test_neg2_lgf[] = - "@nodes\n" - "label sup\n" - " 1 100\n" - " 2 -300\n" - "@arcs\n" - " cost\n" - "1 2 -1\n"; - - -// Test data -typedef ListDigraph Digraph; -DIGRAPH_TYPEDEFS(ListDigraph); - -Digraph gr; -Digraph::ArcMap c(gr), l1(gr), l2(gr), l3(gr), u(gr); -Digraph::NodeMap s1(gr), s2(gr), s3(gr), s4(gr), s5(gr), s6(gr); -ConstMap cc(1), cu(std::numeric_limits::max()); -Node v, w; - -Digraph neg1_gr; -Digraph::ArcMap neg1_c(neg1_gr), neg1_l1(neg1_gr), neg1_l2(neg1_gr); -ConstMap neg1_u1(std::numeric_limits::max()), neg1_u2(5000); -Digraph::NodeMap neg1_s(neg1_gr); - -Digraph neg2_gr; -Digraph::ArcMap neg2_c(neg2_gr); -ConstMap neg2_l(0), neg2_u(1000); -Digraph::NodeMap neg2_s(neg2_gr); - enum SupplyType { @@ -141,5 +84,4 @@ }; - // Check the interface of an MCF algorithm template @@ -152,5 +94,5 @@ void constraints() { checkConcept(); - + const Constraints& me = *this; @@ -158,5 +100,5 @@ const MCF& const_mcf = mcf; - b = mcf.reset().resetParams() + b = mcf.reset() .lowerMap(me.lower) .upperMap(me.upper) @@ -181,5 +123,5 @@ typedef concepts::WriteMap FlowMap; typedef concepts::WriteMap PotMap; - + GR g; VAM lower; @@ -235,5 +177,5 @@ typename CM, typename SM, typename FM, typename PM > bool checkPotential( const GR& gr, const LM& lower, const UM& upper, - const CM& cost, const SM& supply, const FM& flow, + const CM& cost, const SM& supply, const FM& flow, const PM& pi, SupplyType type ) { @@ -248,5 +190,5 @@ (red_cost < 0 && flow[e] == upper[e]); } - + for (NodeIt n(gr); opt && n != INVALID; ++n) { typename SM::Value sum = 0; @@ -261,5 +203,5 @@ } } - + return opt; } @@ -286,5 +228,5 @@ } } - + for (NodeIt n(gr); n != INVALID; ++n) { dual_cost -= red_supply[n] * pi[n]; @@ -295,5 +237,5 @@ dual_cost -= (upper[a] - lower[a]) * std::max(-red_cost, 0); } - + return dual_cost == total; } @@ -327,97 +269,28 @@ } -template < typename MCF, typename Param > -void runMcfGeqTests( Param param, - const std::string &test_str = "", - bool full_neg_cost_support = false ) -{ - MCF mcf1(gr), mcf2(neg1_gr), mcf3(neg2_gr); - - // Basic tests - mcf1.upperMap(u).costMap(c).supplyMap(s1); - checkMcf(mcf1, mcf1.run(param), gr, l1, u, c, s1, - mcf1.OPTIMAL, true, 5240, test_str + "-1"); - mcf1.stSupply(v, w, 27); - checkMcf(mcf1, mcf1.run(param), gr, l1, u, c, s2, - mcf1.OPTIMAL, true, 7620, test_str + "-2"); - mcf1.lowerMap(l2).supplyMap(s1); - checkMcf(mcf1, mcf1.run(param), gr, l2, u, c, s1, - mcf1.OPTIMAL, true, 5970, test_str + "-3"); - mcf1.stSupply(v, w, 27); - checkMcf(mcf1, mcf1.run(param), gr, l2, u, c, s2, - mcf1.OPTIMAL, true, 8010, test_str + "-4"); - mcf1.resetParams().supplyMap(s1); - checkMcf(mcf1, mcf1.run(param), gr, l1, cu, cc, s1, - mcf1.OPTIMAL, true, 74, test_str + "-5"); - mcf1.lowerMap(l2).stSupply(v, w, 27); - checkMcf(mcf1, mcf1.run(param), gr, l2, cu, cc, s2, - mcf1.OPTIMAL, true, 94, test_str + "-6"); - mcf1.reset(); - checkMcf(mcf1, mcf1.run(param), gr, l1, cu, cc, s3, - mcf1.OPTIMAL, true, 0, test_str + "-7"); - mcf1.lowerMap(l2).upperMap(u); - checkMcf(mcf1, mcf1.run(param), gr, l2, u, cc, s3, - mcf1.INFEASIBLE, false, 0, test_str + "-8"); - mcf1.lowerMap(l3).upperMap(u).costMap(c).supplyMap(s4); - checkMcf(mcf1, mcf1.run(param), gr, l3, u, c, s4, - mcf1.OPTIMAL, true, 6360, test_str + "-9"); - - // Tests for the GEQ form - mcf1.resetParams().upperMap(u).costMap(c).supplyMap(s5); - checkMcf(mcf1, mcf1.run(param), gr, l1, u, c, s5, - mcf1.OPTIMAL, true, 3530, test_str + "-10", GEQ); - mcf1.lowerMap(l2); - checkMcf(mcf1, mcf1.run(param), gr, l2, u, c, s5, - mcf1.OPTIMAL, true, 4540, test_str + "-11", GEQ); - mcf1.supplyMap(s6); - checkMcf(mcf1, mcf1.run(param), gr, l2, u, c, s6, - mcf1.INFEASIBLE, false, 0, test_str + "-12", GEQ); - - // Tests with negative costs - mcf2.lowerMap(neg1_l1).costMap(neg1_c).supplyMap(neg1_s); - checkMcf(mcf2, mcf2.run(param), neg1_gr, neg1_l1, neg1_u1, neg1_c, neg1_s, - mcf2.UNBOUNDED, false, 0, test_str + "-13"); - mcf2.upperMap(neg1_u2); - checkMcf(mcf2, mcf2.run(param), neg1_gr, neg1_l1, neg1_u2, neg1_c, neg1_s, - mcf2.OPTIMAL, true, -40000, test_str + "-14"); - mcf2.resetParams().lowerMap(neg1_l2).costMap(neg1_c).supplyMap(neg1_s); - checkMcf(mcf2, mcf2.run(param), neg1_gr, neg1_l2, neg1_u1, neg1_c, neg1_s, - mcf2.UNBOUNDED, false, 0, test_str + "-15"); - - mcf3.costMap(neg2_c).supplyMap(neg2_s); - if (full_neg_cost_support) { - checkMcf(mcf3, mcf3.run(param), neg2_gr, neg2_l, neg2_u, neg2_c, neg2_s, - mcf3.OPTIMAL, true, -300, test_str + "-16", GEQ); - } else { - checkMcf(mcf3, mcf3.run(param), neg2_gr, neg2_l, neg2_u, neg2_c, neg2_s, - mcf3.UNBOUNDED, false, 0, test_str + "-17", GEQ); - } - mcf3.upperMap(neg2_u); - checkMcf(mcf3, mcf3.run(param), neg2_gr, neg2_l, neg2_u, neg2_c, neg2_s, - mcf3.OPTIMAL, true, -300, test_str + "-18", GEQ); -} - -template < typename MCF, typename Param > -void runMcfLeqTests( Param param, - const std::string &test_str = "" ) -{ - // Tests for the LEQ form - MCF mcf1(gr); - mcf1.supplyType(mcf1.LEQ); - mcf1.upperMap(u).costMap(c).supplyMap(s6); - checkMcf(mcf1, mcf1.run(param), gr, l1, u, c, s6, - mcf1.OPTIMAL, true, 5080, test_str + "-19", LEQ); - mcf1.lowerMap(l2); - checkMcf(mcf1, mcf1.run(param), gr, l2, u, c, s6, - mcf1.OPTIMAL, true, 5930, test_str + "-20", LEQ); - mcf1.supplyMap(s5); - checkMcf(mcf1, mcf1.run(param), gr, l2, u, c, s5, - mcf1.INFEASIBLE, false, 0, test_str + "-21", LEQ); -} - - int main() { - // Read the test networks + // Check the interfaces + { + typedef concepts::Digraph GR; + checkConcept< McfClassConcept, + NetworkSimplex >(); + checkConcept< McfClassConcept, + NetworkSimplex >(); + checkConcept< McfClassConcept, + NetworkSimplex >(); + } + + // Run various MCF tests + typedef ListDigraph Digraph; + DIGRAPH_TYPEDEFS(ListDigraph); + + // Read the test digraph + Digraph gr; + Digraph::ArcMap c(gr), l1(gr), l2(gr), l3(gr), u(gr); + Digraph::NodeMap s1(gr), s2(gr), s3(gr), s4(gr), s5(gr), s6(gr); + ConstMap cc(1), cu(std::numeric_limits::max()); + Node v, w; + std::istringstream input(test_lgf); DigraphReader(gr, input) @@ -436,105 +309,140 @@ .node("target", w) .run(); - - std::istringstream neg_inp1(test_neg1_lgf); - DigraphReader(neg1_gr, neg_inp1) - .arcMap("cost", neg1_c) - .arcMap("low1", neg1_l1) - .arcMap("low2", neg1_l2) - .nodeMap("sup", neg1_s) - .run(); - - std::istringstream neg_inp2(test_neg2_lgf); - DigraphReader(neg2_gr, neg_inp2) - .arcMap("cost", neg2_c) - .nodeMap("sup", neg2_s) - .run(); - - // Check the interface of NetworkSimplex + + // Build test digraphs with negative costs + Digraph neg_gr; + Node n1 = neg_gr.addNode(); + Node n2 = neg_gr.addNode(); + Node n3 = neg_gr.addNode(); + Node n4 = neg_gr.addNode(); + Node n5 = neg_gr.addNode(); + Node n6 = neg_gr.addNode(); + Node n7 = neg_gr.addNode(); + + Arc a1 = neg_gr.addArc(n1, n2); + Arc a2 = neg_gr.addArc(n1, n3); + Arc a3 = neg_gr.addArc(n2, n4); + Arc a4 = neg_gr.addArc(n3, n4); + Arc a5 = neg_gr.addArc(n3, n2); + Arc a6 = neg_gr.addArc(n5, n3); + Arc a7 = neg_gr.addArc(n5, n6); + Arc a8 = neg_gr.addArc(n6, n7); + Arc a9 = neg_gr.addArc(n7, n5); + + Digraph::ArcMap neg_c(neg_gr), neg_l1(neg_gr, 0), neg_l2(neg_gr, 0); + ConstMap neg_u1(std::numeric_limits::max()), neg_u2(5000); + Digraph::NodeMap neg_s(neg_gr, 0); + + neg_l2[a7] = 1000; + neg_l2[a8] = -1000; + + neg_s[n1] = 100; + neg_s[n4] = -100; + + neg_c[a1] = 100; + neg_c[a2] = 30; + neg_c[a3] = 20; + neg_c[a4] = 80; + neg_c[a5] = 50; + neg_c[a6] = 10; + neg_c[a7] = 80; + neg_c[a8] = 30; + neg_c[a9] = -120; + + Digraph negs_gr; + Digraph::NodeMap negs_s(negs_gr); + Digraph::ArcMap negs_c(negs_gr); + ConstMap negs_l(0), negs_u(1000); + n1 = negs_gr.addNode(); + n2 = negs_gr.addNode(); + negs_s[n1] = 100; + negs_s[n2] = -300; + negs_c[negs_gr.addArc(n1, n2)] = -1; + + + // A. Test NetworkSimplex with the default pivot rule { - typedef concepts::Digraph GR; - checkConcept< McfClassConcept, - NetworkSimplex >(); - checkConcept< McfClassConcept, - NetworkSimplex >(); - checkConcept< McfClassConcept, - NetworkSimplex >(); - } - - // Check the interface of CapacityScaling + NetworkSimplex mcf(gr); + + // Check the equality form + mcf.upperMap(u).costMap(c); + checkMcf(mcf, mcf.supplyMap(s1).run(), + gr, l1, u, c, s1, mcf.OPTIMAL, true, 5240, "#A1"); + checkMcf(mcf, mcf.stSupply(v, w, 27).run(), + gr, l1, u, c, s2, mcf.OPTIMAL, true, 7620, "#A2"); + mcf.lowerMap(l2); + checkMcf(mcf, mcf.supplyMap(s1).run(), + gr, l2, u, c, s1, mcf.OPTIMAL, true, 5970, "#A3"); + checkMcf(mcf, mcf.stSupply(v, w, 27).run(), + gr, l2, u, c, s2, mcf.OPTIMAL, true, 8010, "#A4"); + mcf.reset(); + checkMcf(mcf, mcf.supplyMap(s1).run(), + gr, l1, cu, cc, s1, mcf.OPTIMAL, true, 74, "#A5"); + checkMcf(mcf, mcf.lowerMap(l2).stSupply(v, w, 27).run(), + gr, l2, cu, cc, s2, mcf.OPTIMAL, true, 94, "#A6"); + mcf.reset(); + checkMcf(mcf, mcf.run(), + gr, l1, cu, cc, s3, mcf.OPTIMAL, true, 0, "#A7"); + checkMcf(mcf, mcf.lowerMap(l2).upperMap(u).run(), + gr, l2, u, cc, s3, mcf.INFEASIBLE, false, 0, "#A8"); + mcf.reset().lowerMap(l3).upperMap(u).costMap(c).supplyMap(s4); + checkMcf(mcf, mcf.run(), + gr, l3, u, c, s4, mcf.OPTIMAL, true, 6360, "#A9"); + + // Check the GEQ form + mcf.reset().upperMap(u).costMap(c).supplyMap(s5); + checkMcf(mcf, mcf.run(), + gr, l1, u, c, s5, mcf.OPTIMAL, true, 3530, "#A10", GEQ); + mcf.supplyType(mcf.GEQ); + checkMcf(mcf, mcf.lowerMap(l2).run(), + gr, l2, u, c, s5, mcf.OPTIMAL, true, 4540, "#A11", GEQ); + mcf.supplyMap(s6); + checkMcf(mcf, mcf.run(), + gr, l2, u, c, s6, mcf.INFEASIBLE, false, 0, "#A12", GEQ); + + // Check the LEQ form + mcf.reset().supplyType(mcf.LEQ); + mcf.upperMap(u).costMap(c).supplyMap(s6); + checkMcf(mcf, mcf.run(), + gr, l1, u, c, s6, mcf.OPTIMAL, true, 5080, "#A13", LEQ); + checkMcf(mcf, mcf.lowerMap(l2).run(), + gr, l2, u, c, s6, mcf.OPTIMAL, true, 5930, "#A14", LEQ); + mcf.supplyMap(s5); + checkMcf(mcf, mcf.run(), + gr, l2, u, c, s5, mcf.INFEASIBLE, false, 0, "#A15", LEQ); + + // Check negative costs + NetworkSimplex neg_mcf(neg_gr); + neg_mcf.lowerMap(neg_l1).costMap(neg_c).supplyMap(neg_s); + checkMcf(neg_mcf, neg_mcf.run(), neg_gr, neg_l1, neg_u1, + neg_c, neg_s, neg_mcf.UNBOUNDED, false, 0, "#A16"); + neg_mcf.upperMap(neg_u2); + checkMcf(neg_mcf, neg_mcf.run(), neg_gr, neg_l1, neg_u2, + neg_c, neg_s, neg_mcf.OPTIMAL, true, -40000, "#A17"); + neg_mcf.reset().lowerMap(neg_l2).costMap(neg_c).supplyMap(neg_s); + checkMcf(neg_mcf, neg_mcf.run(), neg_gr, neg_l2, neg_u1, + neg_c, neg_s, neg_mcf.UNBOUNDED, false, 0, "#A18"); + + NetworkSimplex negs_mcf(negs_gr); + negs_mcf.costMap(negs_c).supplyMap(negs_s); + checkMcf(negs_mcf, negs_mcf.run(), negs_gr, negs_l, negs_u, + negs_c, negs_s, negs_mcf.OPTIMAL, true, -300, "#A19", GEQ); + } + + // B. Test NetworkSimplex with each pivot rule { - typedef concepts::Digraph GR; - checkConcept< McfClassConcept, - CapacityScaling >(); - checkConcept< McfClassConcept, - CapacityScaling >(); - checkConcept< McfClassConcept, - CapacityScaling >(); - typedef CapacityScaling:: - SetHeap > >::Create CAS; - checkConcept< McfClassConcept, CAS >(); - } - - // Check the interface of CostScaling - { - typedef concepts::Digraph GR; - checkConcept< McfClassConcept, - CostScaling >(); - checkConcept< McfClassConcept, - CostScaling >(); - checkConcept< McfClassConcept, - CostScaling >(); - typedef CostScaling:: - SetLargeCost::Create COS; - checkConcept< McfClassConcept, COS >(); - } - - // Check the interface of CycleCanceling - { - typedef concepts::Digraph GR; - checkConcept< McfClassConcept, - CycleCanceling >(); - checkConcept< McfClassConcept, - CycleCanceling >(); - checkConcept< McfClassConcept, - CycleCanceling >(); - } - - // Test NetworkSimplex - { - typedef NetworkSimplex MCF; - runMcfGeqTests(MCF::FIRST_ELIGIBLE, "NS-FE", true); - runMcfLeqTests(MCF::FIRST_ELIGIBLE, "NS-FE"); - runMcfGeqTests(MCF::BEST_ELIGIBLE, "NS-BE", true); - runMcfLeqTests(MCF::BEST_ELIGIBLE, "NS-BE"); - runMcfGeqTests(MCF::BLOCK_SEARCH, "NS-BS", true); - runMcfLeqTests(MCF::BLOCK_SEARCH, "NS-BS"); - runMcfGeqTests(MCF::CANDIDATE_LIST, "NS-CL", true); - runMcfLeqTests(MCF::CANDIDATE_LIST, "NS-CL"); - runMcfGeqTests(MCF::ALTERING_LIST, "NS-AL", true); - runMcfLeqTests(MCF::ALTERING_LIST, "NS-AL"); - } - - // Test CapacityScaling - { - typedef CapacityScaling MCF; - runMcfGeqTests(0, "SSP"); - runMcfGeqTests(2, "CAS"); - } - - // Test CostScaling - { - typedef CostScaling MCF; - runMcfGeqTests(MCF::PUSH, "COS-PR"); - runMcfGeqTests(MCF::AUGMENT, "COS-AR"); - runMcfGeqTests(MCF::PARTIAL_AUGMENT, "COS-PAR"); - } - - // Test CycleCanceling - { - typedef CycleCanceling MCF; - runMcfGeqTests(MCF::SIMPLE_CYCLE_CANCELING, "SCC"); - runMcfGeqTests(MCF::MINIMUM_MEAN_CYCLE_CANCELING, "MMCC"); - runMcfGeqTests(MCF::CANCEL_AND_TIGHTEN, "CAT"); + NetworkSimplex mcf(gr); + mcf.supplyMap(s1).costMap(c).upperMap(u).lowerMap(l2); + + checkMcf(mcf, mcf.run(NetworkSimplex::FIRST_ELIGIBLE), + gr, l2, u, c, s1, mcf.OPTIMAL, true, 5970, "#B1"); + checkMcf(mcf, mcf.run(NetworkSimplex::BEST_ELIGIBLE), + gr, l2, u, c, s1, mcf.OPTIMAL, true, 5970, "#B2"); + checkMcf(mcf, mcf.run(NetworkSimplex::BLOCK_SEARCH), + gr, l2, u, c, s1, mcf.OPTIMAL, true, 5970, "#B3"); + checkMcf(mcf, mcf.run(NetworkSimplex::CANDIDATE_LIST), + gr, l2, u, c, s1, mcf.OPTIMAL, true, 5970, "#B4"); + checkMcf(mcf, mcf.run(NetworkSimplex::ALTERING_LIST), + gr, l2, u, c, s1, mcf.OPTIMAL, true, 5970, "#B5"); } Index: st/min_mean_cycle_test.cc =================================================================== --- test/min_mean_cycle_test.cc (revision 877) +++ (revision ) @@ -1,216 +1,0 @@ -/* -*- mode: C++; indent-tabs-mode: nil; -*- - * - * This file is a part of LEMON, a generic C++ optimization library. - * - * Copyright (C) 2003-2010 - * Egervary Jeno Kombinatorikus Optimalizalasi Kutatocsoport - * (Egervary Research Group on Combinatorial Optimization, EGRES). - * - * Permission to use, modify and distribute this software is granted - * provided that this copyright notice appears in all copies. For - * precise terms see the accompanying LICENSE file. - * - * This software is provided "AS IS" with no warranty of any kind, - * express or implied, and with no claim as to its suitability for any - * purpose. - * - */ - -#include -#include - -#include -#include -#include -#include -#include - -#include -#include -#include - -#include "test_tools.h" - -using namespace lemon; - -char test_lgf[] = - "@nodes\n" - "label\n" - "1\n" - "2\n" - "3\n" - "4\n" - "5\n" - "6\n" - "7\n" - "@arcs\n" - " len1 len2 len3 len4 c1 c2 c3 c4\n" - "1 2 1 1 1 1 0 0 0 0\n" - "2 4 5 5 5 5 1 0 0 0\n" - "2 3 8 8 8 8 0 0 0 0\n" - "3 2 -2 0 0 0 1 0 0 0\n" - "3 4 4 4 4 4 0 0 0 0\n" - "3 7 -4 -4 -4 -4 0 0 0 0\n" - "4 1 2 2 2 2 0 0 0 0\n" - "4 3 3 3 3 3 1 0 0 0\n" - "4 4 3 3 0 0 0 0 1 0\n" - "5 2 4 4 4 4 0 0 0 0\n" - "5 6 3 3 3 3 0 1 0 0\n" - "6 5 2 2 2 2 0 1 0 0\n" - "6 4 -1 -1 -1 -1 0 0 0 0\n" - "6 7 1 1 1 1 0 0 0 0\n" - "7 7 4 4 4 -1 0 0 0 1\n"; - - -// Check the interface of an MMC algorithm -template -struct MmcClassConcept -{ - template - struct Constraints { - void constraints() { - const Constraints& me = *this; - - typedef typename MMC - ::template SetPath > - ::template SetLargeCost - ::Create MmcAlg; - MmcAlg mmc(me.g, me.cost); - const MmcAlg& const_mmc = mmc; - - typename MmcAlg::Tolerance tol = const_mmc.tolerance(); - mmc.tolerance(tol); - - b = mmc.cycle(p).run(); - b = mmc.findCycleMean(); - b = mmc.findCycle(); - - v = const_mmc.cycleCost(); - i = const_mmc.cycleSize(); - d = const_mmc.cycleMean(); - p = const_mmc.cycle(); - } - - typedef concepts::ReadMap CM; - - GR g; - CM cost; - ListPath p; - Cost v; - int i; - double d; - bool b; - }; -}; - -// Perform a test with the given parameters -template -void checkMmcAlg(const SmartDigraph& gr, - const SmartDigraph::ArcMap& lm, - const SmartDigraph::ArcMap& cm, - int cost, int size) { - MMC alg(gr, lm); - alg.findCycleMean(); - check(alg.cycleMean() == static_cast(cost) / size, - "Wrong cycle mean"); - alg.findCycle(); - check(alg.cycleCost() == cost && alg.cycleSize() == size, - "Wrong path"); - SmartDigraph::ArcMap cycle(gr, 0); - for (typename MMC::Path::ArcIt a(alg.cycle()); a != INVALID; ++a) { - ++cycle[a]; - } - for (SmartDigraph::ArcIt a(gr); a != INVALID; ++a) { - check(cm[a] == cycle[a], "Wrong path"); - } -} - -// Class for comparing types -template -struct IsSameType { - static const int result = 0; -}; - -template -struct IsSameType { - static const int result = 1; -}; - - -int main() { - #ifdef LEMON_HAVE_LONG_LONG - typedef long long long_int; - #else - typedef long long_int; - #endif - - // Check the interface - { - typedef concepts::Digraph GR; - - // KarpMmc - checkConcept< MmcClassConcept, - KarpMmc > >(); - checkConcept< MmcClassConcept, - KarpMmc > >(); - - // HartmannOrlinMmc - checkConcept< MmcClassConcept, - HartmannOrlinMmc > >(); - checkConcept< MmcClassConcept, - HartmannOrlinMmc > >(); - - // HowardMmc - checkConcept< MmcClassConcept, - HowardMmc > >(); - checkConcept< MmcClassConcept, - HowardMmc > >(); - - check((IsSameType > - ::LargeCost, long_int>::result == 1), "Wrong LargeCost type"); - check((IsSameType > - ::LargeCost, double>::result == 1), "Wrong LargeCost type"); - } - - // Run various tests - { - typedef SmartDigraph GR; - DIGRAPH_TYPEDEFS(GR); - - GR gr; - IntArcMap l1(gr), l2(gr), l3(gr), l4(gr); - IntArcMap c1(gr), c2(gr), c3(gr), c4(gr); - - std::istringstream input(test_lgf); - digraphReader(gr, input). - arcMap("len1", l1). - arcMap("len2", l2). - arcMap("len3", l3). - arcMap("len4", l4). - arcMap("c1", c1). - arcMap("c2", c2). - arcMap("c3", c3). - arcMap("c4", c4). - run(); - - // Karp - checkMmcAlg >(gr, l1, c1, 6, 3); - checkMmcAlg >(gr, l2, c2, 5, 2); - checkMmcAlg >(gr, l3, c3, 0, 1); - checkMmcAlg >(gr, l4, c4, -1, 1); - - // HartmannOrlin - checkMmcAlg >(gr, l1, c1, 6, 3); - checkMmcAlg >(gr, l2, c2, 5, 2); - checkMmcAlg >(gr, l3, c3, 0, 1); - checkMmcAlg >(gr, l4, c4, -1, 1); - - // Howard - checkMmcAlg >(gr, l1, c1, 6, 3); - checkMmcAlg >(gr, l2, c2, 5, 2); - checkMmcAlg >(gr, l3, c3, 0, 1); - checkMmcAlg >(gr, l4, c4, -1, 1); - } - - return 0; -} Index: st/nagamochi_ibaraki_test.cc =================================================================== --- test/nagamochi_ibaraki_test.cc (revision 913) +++ (revision ) @@ -1,141 +1,0 @@ -/* -*- mode: C++; indent-tabs-mode: nil; -*- - * - * This file is a part of LEMON, a generic C++ optimization library. - * - * Copyright (C) 2003-2010 - * Egervary Jeno Kombinatorikus Optimalizalasi Kutatocsoport - * (Egervary Research Group on Combinatorial Optimization, EGRES). - * - * Permission to use, modify and distribute this software is granted - * provided that this copyright notice appears in all copies. For - * precise terms see the accompanying LICENSE file. - * - * This software is provided "AS IS" with no warranty of any kind, - * express or implied, and with no claim as to its suitability for any - * purpose. - * - */ - -#include - -#include -#include -#include -#include -#include -#include - -#include "test_tools.h" - -using namespace lemon; -using namespace std; - -const std::string lgf = - "@nodes\n" - "label\n" - "0\n" - "1\n" - "2\n" - "3\n" - "4\n" - "5\n" - "@edges\n" - " cap1 cap2 cap3\n" - "0 1 1 1 1 \n" - "0 2 2 2 4 \n" - "1 2 4 4 4 \n" - "3 4 1 1 1 \n" - "3 5 2 2 4 \n" - "4 5 4 4 4 \n" - "2 3 1 6 6 \n"; - -void checkNagamochiIbarakiCompile() -{ - typedef int Value; - typedef concepts::Graph Graph; - - typedef Graph::Node Node; - typedef Graph::Edge Edge; - typedef concepts::ReadMap CapMap; - typedef concepts::WriteMap CutMap; - - Graph g; - Node n; - CapMap cap; - CutMap cut; - Value v; - bool b; - - NagamochiIbaraki ni_test(g, cap); - const NagamochiIbaraki& const_ni_test = ni_test; - - ni_test.init(); - ni_test.start(); - b = ni_test.processNextPhase(); - ni_test.run(); - - v = const_ni_test.minCutValue(); - v = const_ni_test.minCutMap(cut); -} - -template -typename CapMap::Value - cutValue(const Graph& graph, const CapMap& cap, const CutMap& cut) -{ - typename CapMap::Value sum = 0; - for (typename Graph::EdgeIt e(graph); e != INVALID; ++e) { - if (cut[graph.u(e)] != cut[graph.v(e)]) { - sum += cap[e]; - } - } - return sum; -} - -int main() { - SmartGraph graph; - SmartGraph::EdgeMap cap1(graph), cap2(graph), cap3(graph); - SmartGraph::NodeMap cut(graph); - - istringstream input(lgf); - graphReader(graph, input) - .edgeMap("cap1", cap1) - .edgeMap("cap2", cap2) - .edgeMap("cap3", cap3) - .run(); - - { - NagamochiIbaraki ni(graph, cap1); - ni.run(); - ni.minCutMap(cut); - - check(ni.minCutValue() == 1, "Wrong cut value"); - check(ni.minCutValue() == cutValue(graph, cap1, cut), "Wrong cut value"); - } - { - NagamochiIbaraki ni(graph, cap2); - ni.run(); - ni.minCutMap(cut); - - check(ni.minCutValue() == 3, "Wrong cut value"); - check(ni.minCutValue() == cutValue(graph, cap2, cut), "Wrong cut value"); - } - { - NagamochiIbaraki ni(graph, cap3); - ni.run(); - ni.minCutMap(cut); - - check(ni.minCutValue() == 5, "Wrong cut value"); - check(ni.minCutValue() == cutValue(graph, cap3, cut), "Wrong cut value"); - } - { - NagamochiIbaraki::SetUnitCapacity::Create ni(graph); - ni.run(); - ni.minCutMap(cut); - - ConstMap cap4(1); - check(ni.minCutValue() == 1, "Wrong cut value"); - check(ni.minCutValue() == cutValue(graph, cap4, cut), "Wrong cut value"); - } - - return 0; -} Index: st/planarity_test.cc =================================================================== --- test/planarity_test.cc (revision 798) +++ (revision ) @@ -1,262 +1,0 @@ -/* -*- mode: C++; indent-tabs-mode: nil; -*- - * - * This file is a part of LEMON, a generic C++ optimization library. - * - * Copyright (C) 2003-2009 - * Egervary Jeno Kombinatorikus Optimalizalasi Kutatocsoport - * (Egervary Research Group on Combinatorial Optimization, EGRES). - * - * Permission to use, modify and distribute this software is granted - * provided that this copyright notice appears in all copies. For - * precise terms see the accompanying LICENSE file. - * - * This software is provided "AS IS" with no warranty of any kind, - * express or implied, and with no claim as to its suitability for any - * purpose. - * - */ - -#include - -#include - -#include -#include -#include -#include - -#include "test_tools.h" - -using namespace lemon; -using namespace lemon::dim2; - -const int lgfn = 4; -const std::string lgf[lgfn] = { - "@nodes\n" - "label\n" - "0\n" - "1\n" - "2\n" - "3\n" - "4\n" - "@edges\n" - " label\n" - "0 1 0\n" - "0 2 0\n" - "0 3 0\n" - "0 4 0\n" - "1 2 0\n" - "1 3 0\n" - "1 4 0\n" - "2 3 0\n" - "2 4 0\n" - "3 4 0\n", - - "@nodes\n" - "label\n" - "0\n" - "1\n" - "2\n" - "3\n" - "4\n" - "@edges\n" - " label\n" - "0 1 0\n" - "0 2 0\n" - "0 3 0\n" - "0 4 0\n" - "1 2 0\n" - "1 3 0\n" - "2 3 0\n" - "2 4 0\n" - "3 4 0\n", - - "@nodes\n" - "label\n" - "0\n" - "1\n" - "2\n" - "3\n" - "4\n" - "5\n" - "@edges\n" - " label\n" - "0 3 0\n" - "0 4 0\n" - "0 5 0\n" - "1 3 0\n" - "1 4 0\n" - "1 5 0\n" - "2 3 0\n" - "2 4 0\n" - "2 5 0\n", - - "@nodes\n" - "label\n" - "0\n" - "1\n" - "2\n" - "3\n" - "4\n" - "5\n" - "@edges\n" - " label\n" - "0 3 0\n" - "0 4 0\n" - "0 5 0\n" - "1 3 0\n" - "1 4 0\n" - "1 5 0\n" - "2 3 0\n" - "2 5 0\n" -}; - - - -typedef SmartGraph Graph; -GRAPH_TYPEDEFS(Graph); - -typedef PlanarEmbedding PE; -typedef PlanarDrawing PD; -typedef PlanarColoring PC; - -void checkEmbedding(const Graph& graph, PE& pe) { - int face_num = 0; - - Graph::ArcMap face(graph, -1); - - for (ArcIt a(graph); a != INVALID; ++a) { - if (face[a] == -1) { - Arc b = a; - while (face[b] == -1) { - face[b] = face_num; - b = pe.next(graph.oppositeArc(b)); - } - check(face[b] == face_num, "Wrong face"); - ++face_num; - } - } - check(face_num + countNodes(graph) - countConnectedComponents(graph) == - countEdges(graph) + 1, "Euler test does not passed"); -} - -void checkKuratowski(const Graph& graph, PE& pe) { - std::map degs; - for (NodeIt n(graph); n != INVALID; ++n) { - int deg = 0; - for (IncEdgeIt e(graph, n); e != INVALID; ++e) { - if (pe.kuratowski(e)) { - ++deg; - } - } - ++degs[deg]; - } - for (std::map::iterator it = degs.begin(); it != degs.end(); ++it) { - check(it->first == 0 || it->first == 2 || - (it->first == 3 && it->second == 6) || - (it->first == 4 && it->second == 5), - "Wrong degree in Kuratowski graph"); - } - - // Not full test - check((degs[3] == 0) != (degs[4] == 0), "Wrong Kuratowski graph"); -} - -bool intersect(Point e1, Point e2, Point f1, Point f2) { - int l, r; - if (std::min(e1.x, e2.x) > std::max(f1.x, f2.x)) return false; - if (std::max(e1.x, e2.x) < std::min(f1.x, f2.x)) return false; - if (std::min(e1.y, e2.y) > std::max(f1.y, f2.y)) return false; - if (std::max(e1.y, e2.y) < std::min(f1.y, f2.y)) return false; - - l = (e2.x - e1.x) * (f1.y - e1.y) - (e2.y - e1.y) * (f1.x - e1.x); - r = (e2.x - e1.x) * (f2.y - e1.y) - (e2.y - e1.y) * (f2.x - e1.x); - if (!((l >= 0 && r <= 0) || (l <= 0 && r >= 0))) return false; - l = (f2.x - f1.x) * (e1.y - f1.y) - (f2.y - f1.y) * (e1.x - f1.x); - r = (f2.x - f1.x) * (e2.y - f1.y) - (f2.y - f1.y) * (e2.x - f1.x); - if (!((l >= 0 && r <= 0) || (l <= 0 && r >= 0))) return false; - return true; -} - -bool collinear(Point p, Point q, Point r) { - int v; - v = (q.x - p.x) * (r.y - p.y) - (q.y - p.y) * (r.x - p.x); - if (v != 0) return false; - v = (q.x - p.x) * (r.x - p.x) + (q.y - p.y) * (r.y - p.y); - if (v < 0) return false; - return true; -} - -void checkDrawing(const Graph& graph, PD& pd) { - for (Graph::NodeIt n(graph); n != INVALID; ++n) { - Graph::NodeIt m(n); - for (++m; m != INVALID; ++m) { - check(pd[m] != pd[n], "Two nodes with identical coordinates"); - } - } - - for (Graph::EdgeIt e(graph); e != INVALID; ++e) { - for (Graph::EdgeIt f(e); f != e; ++f) { - Point e1 = pd[graph.u(e)]; - Point e2 = pd[graph.v(e)]; - Point f1 = pd[graph.u(f)]; - Point f2 = pd[graph.v(f)]; - - if (graph.u(e) == graph.u(f)) { - check(!collinear(e1, e2, f2), "Wrong drawing"); - } else if (graph.u(e) == graph.v(f)) { - check(!collinear(e1, e2, f1), "Wrong drawing"); - } else if (graph.v(e) == graph.u(f)) { - check(!collinear(e2, e1, f2), "Wrong drawing"); - } else if (graph.v(e) == graph.v(f)) { - check(!collinear(e2, e1, f1), "Wrong drawing"); - } else { - check(!intersect(e1, e2, f1, f2), "Wrong drawing"); - } - } - } -} - -void checkColoring(const Graph& graph, PC& pc, int num) { - for (NodeIt n(graph); n != INVALID; ++n) { - check(pc.colorIndex(n) >= 0 && pc.colorIndex(n) < num, - "Wrong coloring"); - } - for (EdgeIt e(graph); e != INVALID; ++e) { - check(pc.colorIndex(graph.u(e)) != pc.colorIndex(graph.v(e)), - "Wrong coloring"); - } -} - -int main() { - - for (int i = 0; i < lgfn; ++i) { - std::istringstream lgfs(lgf[i]); - - SmartGraph graph; - graphReader(graph, lgfs).run(); - - check(simpleGraph(graph), "Test graphs must be simple"); - - PE pe(graph); - bool planar = pe.run(); - check(checkPlanarity(graph) == planar, "Planarity checking failed"); - - if (planar) { - checkEmbedding(graph, pe); - - PlanarDrawing pd(graph); - pd.run(pe.embeddingMap()); - checkDrawing(graph, pd); - - PlanarColoring pc(graph); - pc.runFiveColoring(pe.embeddingMap()); - checkColoring(graph, pc, 5); - - } else { - checkKuratowski(graph, pe); - } - } - - return 0; -} Index: test/preflow_test.cc =================================================================== --- test/preflow_test.cc (revision 924) +++ test/preflow_test.cc (revision 1007) @@ -3,5 +3,5 @@ * This file is a part of LEMON, a generic C++ optimization library. * - * Copyright (C) 2003-2010 + * Copyright (C) 2003-2009 * Egervary Jeno Kombinatorikus Optimalizalasi Kutatocsoport * (Egervary Research Group on Combinatorial Optimization, EGRES). @@ -87,4 +87,5 @@ VType v; bool b; + ignore_unused_variable_warning(v,b); typedef Preflow @@ -96,9 +97,4 @@ const PreflowType& const_preflow_test = preflow_test; - const PreflowType::Elevator& elev = const_preflow_test.elevator(); - preflow_test.elevator(const_cast(elev)); - PreflowType::Tolerance tol = const_preflow_test.tolerance(); - preflow_test.tolerance(tol); - preflow_test .capacityMap(cap) @@ -119,5 +115,5 @@ b = const_preflow_test.minCut(n); const_preflow_test.minCutMap(cut); - + ignore_unused_variable_warning(fm); } Index: test/suurballe_test.cc =================================================================== --- test/suurballe_test.cc (revision 877) +++ test/suurballe_test.cc (revision 1007) @@ -3,5 +3,5 @@ * This file is a part of LEMON, a generic C++ optimization library. * - * Copyright (C) 2003-2010 + * Copyright (C) 2003-2009 * Egervary Jeno Kombinatorikus Optimalizalasi Kutatocsoport * (Egervary Research Group on Combinatorial Optimization, EGRES). @@ -24,5 +24,4 @@ #include #include -#include #include "test_tools.h" @@ -82,12 +81,6 @@ typedef Digraph::Arc Arc; typedef concepts::ReadMap LengthMap; - - typedef Suurballe ST; - typedef Suurballe - ::SetFlowMap - ::SetPotentialMap - ::SetPath > - ::SetHeap > > - ::Create SuurballeType; + + typedef Suurballe SuurballeType; Digraph g; @@ -109,13 +102,12 @@ 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; + ignore_unused_variable_warning(f,c); + c = const_suurb_test.totalLength(); f = const_suurb_test.flow(e); @@ -127,5 +119,5 @@ k = const_suurb_test.pathNum(); Path p = const_suurb_test.path(k); - + ignore_unused_variable_warning(fm); ignore_unused_variable_warning(pm); @@ -206,9 +198,7 @@ run(); - // Check run() + // Find 2 paths { Suurballe suurballe(digraph, length); - - // Find 2 paths check(suurballe.run(s, t) == 2, "Wrong number of paths"); check(checkFlow(digraph, suurballe.flowMap(), s, t, 2), @@ -220,6 +210,9 @@ for (int i = 0; i < suurballe.pathNum(); ++i) check(checkPath(digraph, suurballe.path(i), s, t), "Wrong path"); - - // Find 3 paths + } + + // Find 3 paths + { + Suurballe suurballe(digraph, length); check(suurballe.run(s, t, 3) == 3, "Wrong number of paths"); check(checkFlow(digraph, suurballe.flowMap(), s, t, 3), @@ -231,6 +224,9 @@ for (int i = 0; i < suurballe.pathNum(); ++i) check(checkPath(digraph, suurballe.path(i), s, t), "Wrong path"); - - // Find 5 paths (only 3 can be found) + } + + // Find 5 paths (only 3 can be found) + { + Suurballe suurballe(digraph, length); check(suurballe.run(s, t, 5) == 3, "Wrong number of paths"); check(checkFlow(digraph, suurballe.flowMap(), s, t, 3), @@ -244,22 +240,4 @@ } - // Check fullInit() + start() - { - Suurballe suurballe(digraph, length); - suurballe.fullInit(s); - - // Find 2 paths - check(suurballe.start(t) == 2, "Wrong number of paths"); - check(suurballe.totalLength() == 510, "The flow is not optimal"); - - // Find 3 paths - check(suurballe.start(t, 3) == 3, "Wrong number of paths"); - check(suurballe.totalLength() == 1040, "The flow is not optimal"); - - // Find 5 paths (only 3 can be found) - check(suurballe.start(t, 5) == 3, "Wrong number of paths"); - check(suurballe.totalLength() == 1040, "The flow is not optimal"); - } - return 0; } Index: test/test_tools.h =================================================================== --- test/test_tools.h (revision 877) +++ test/test_tools.h (revision 440) @@ -3,5 +3,5 @@ * This file is a part of LEMON, a generic C++ optimization library. * - * Copyright (C) 2003-2010 + * Copyright (C) 2003-2009 * Egervary Jeno Kombinatorikus Optimalizalasi Kutatocsoport * (Egervary Research Group on Combinatorial Optimization, EGRES). @@ -38,13 +38,9 @@ ///print something like this (and then exits). ///\verbatim file_name.cc:123: error: This is obviously false. \endverbatim -#define check(rc, msg) \ - { \ - if(!(rc)) { \ - std::cerr << __FILE__ ":" << __LINE__ << ": error: " \ - << msg << std::endl; \ - abort(); \ - } else { } \ - } \ - +#define check(rc, msg) \ + if(!(rc)) { \ + std::cerr << __FILE__ ":" << __LINE__ << ": error: " << msg << std::endl; \ + abort(); \ + } else { } \ #endif Index: tools/Makefile.am =================================================================== --- tools/Makefile.am (revision 674) +++ tools/Makefile.am (revision 674) @@ -0,0 +1,17 @@ +EXTRA_DIST += \ + tools/CMakeLists.txt + +if WANT_TOOLS + +bin_PROGRAMS += \ + tools/dimacs-solver \ + tools/dimacs-to-lgf \ + tools/lgf-gen + +dist_bin_SCRIPTS += tools/lemon-0.x-to-1.x.sh + +endif WANT_TOOLS + +tools_dimacs_solver_SOURCES = tools/dimacs-solver.cc +tools_dimacs_to_lgf_SOURCES = tools/dimacs-to-lgf.cc +tools_lgf_gen_SOURCES = tools/lgf-gen.cc Index: tools/dimacs-solver.cc =================================================================== --- tools/dimacs-solver.cc (revision 1006) +++ tools/dimacs-solver.cc (revision 1005) @@ -3,5 +3,5 @@ * This file is a part of LEMON, a generic C++ optimization library. * - * Copyright (C) 2003-2010 + * Copyright (C) 2003-2009 * Egervary Jeno Kombinatorikus Optimalizalasi Kutatocsoport * (Egervary Research Group on Combinatorial Optimization, EGRES). @@ -89,8 +89,8 @@ pre.run(); if(report) std::cerr << "Run Preflow: " << ti << '\n'; - if(report) std::cerr << "\nMax flow value: " << pre.flowValue() << '\n'; -} - -template + if(report) std::cerr << "\nMax flow value: " << pre.flowValue() << '\n'; +} + +template void solve_min(ArgParser &ap, std::istream &is, std::ostream &, Value infty, DimacsDescriptor &desc) @@ -129,6 +129,5 @@ std::cerr << "Run NetworkSimplex: " << ti << "\n\n"; std::cerr << "Feasible flow: " << (res == MCF::OPTIMAL ? "found" : "not found") << '\n'; - if (res) std::cerr << "Min flow cost: " - << ns.template totalCost() << '\n'; + if (res) std::cerr << "Min flow cost: " << ns.totalCost() << '\n'; } } @@ -150,9 +149,9 @@ if(report) std::cerr << "Run MaxMatching: " << ti << '\n'; if(report) std::cerr << "\nCardinality of max matching: " - << mat.matchingSize() << '\n'; -} - - -template + << mat.matchingSize() << '\n'; +} + + +template void solve(ArgParser &ap, std::istream &is, std::ostream &os, DimacsDescriptor &desc) @@ -168,9 +167,9 @@ exit(1); } - + switch(desc.type) { case DimacsDescriptor::MIN: - solve_min(ap,is,os,infty,desc); + solve_min(ap,is,os,infty,desc); break; case DimacsDescriptor::MAX: @@ -237,5 +236,5 @@ DimacsDescriptor desc = dimacsType(is); - + if(!ap.given("q")) { @@ -262,16 +261,14 @@ std::cout << "\n\n"; } - + if(ap.given("double")) - solve(ap,is,os,desc); + solve(ap,is,os,desc); else if(ap.given("ldouble")) - solve(ap,is,os,desc); + solve(ap,is,os,desc); #ifdef LEMON_HAVE_LONG_LONG else if(ap.given("long")) - solve(ap,is,os,desc); - else solve(ap,is,os,desc); -#else - else solve(ap,is,os,desc); + solve(ap,is,os,desc); #endif + else solve(ap,is,os,desc); return 0; Index: tools/lemon-0.x-to-1.x.sh =================================================================== --- tools/lemon-0.x-to-1.x.sh (revision 691) +++ tools/lemon-0.x-to-1.x.sh (revision 574) @@ -36,8 +36,8 @@ -e "s/Edge\>/_Ar_c_label_/g"\ -e "s/\/_ar_c_label_/g"\ - -e "s/_edge\>/__ar_c_label_/g"\ + -e "s/_edge\>/_ar_c_label_/g"\ -e "s/Edges\>/_Ar_c_label_s/g"\ -e "s/\/_ar_c_label_s/g"\ - -e "s/_edges\>/__ar_c_label_s/g"\ + -e "s/_edges\>/_ar_c_label_s/g"\ -e "s/\([Ee]\)dge\([a-z]\)/_\1d_ge_label_\2/g"\ -e "s/\([a-z]\)edge/\1_ed_ge_label_/g"\ @@ -69,9 +69,4 @@ -e "s/_GR_APH_TY_PEDE_FS_label_/GRAPH_TYPEDEFS/g"\ -e "s/_DIGR_APH_TY_PEDE_FS_label_/DIGRAPH_TYPEDEFS/g"\ - -e "s/\/adaptors.h/g"\ - -e "s/\/core.h/g"\ - -e "s/\/lgf_reader.h/g"\ - -e "s/\/lgf_writer.h/g"\ - -e "s/\/connectivity.h/g"\ -e "s/DigraphToEps/GraphToEps/g"\ -e "s/digraphToEps/graphToEps/g"\