# HG changeset patch # User Alpar Juttner # Date 1257432481 -3600 # Node ID ef88c0a30f8592e11001a23f7ab29bd9482d8988 # Parent c35afa9e89e78a559f59aa1a5cc71f317561b1c1# Parent ceb2756dea2a20543c70f82004c9a35dd3d48dc7 Merge #293 diff -r c35afa9e89e7 -r ef88c0a30f85 .hgignore --- a/.hgignore Mon Jan 12 23:11:39 2009 +0100 +++ b/.hgignore Thu Nov 05 15:48:01 2009 +0100 @@ -22,6 +22,7 @@ lemon/libemon.la lemon/stamp-h2 doc/Doxyfile +cmake/version.cmake .dirstamp .libs/* .deps/* @@ -39,11 +40,11 @@ ^doc/.*\.tag ^autom4te.cache/.* ^build-aux/.* -^objs.*/.* +^.*objs.*/.* ^test/[a-z_]*$ ^tools/[a-z-_]*$ ^demo/.*_demo$ -^build/.* +^.*build.*/.* ^doc/gen-images/.* CMakeFiles DartTestfile.txt diff -r c35afa9e89e7 -r ef88c0a30f85 CMakeLists.txt --- a/CMakeLists.txt Mon Jan 12 23:11:39 2009 +0100 +++ b/CMakeLists.txt Thu Nov 05 15:48:01 2009 +0100 @@ -1,34 +1,75 @@ CMAKE_MINIMUM_REQUIRED(VERSION 2.6) SET(PROJECT_NAME "LEMON") -SET(PROJECT_VERSION "hg-tip" CACHE STRING "The version string.") - PROJECT(${PROJECT_NAME}) -SET(CMAKE_MODULE_PATH ${CMAKE_SOURCE_DIR}/cmake) +IF(EXISTS ${PROJECT_SOURCE_DIR}/cmake/version.cmake) + INCLUDE(${PROJECT_SOURCE_DIR}/cmake/version.cmake) +ELSEIF(DEFINED ENV{LEMON_VERSION}) + SET(LEMON_VERSION $ENV{LEMON_VERSION} CACHE STRING "LEMON version string.") +ELSE() + EXECUTE_PROCESS( + COMMAND hg id -i + WORKING_DIRECTORY ${PROJECT_SOURCE_DIR} + OUTPUT_VARIABLE HG_REVISION + ERROR_QUIET + OUTPUT_STRIP_TRAILING_WHITESPACE + ) + IF(HG_REVISION STREQUAL "") + SET(HG_REVISION "hg-tip") + ENDIF() + SET(LEMON_VERSION ${HG_REVISION} CACHE STRING "LEMON version string.") +ENDIF() -INCLUDE(FindDoxygen) -INCLUDE(FindGhostscript) +SET(PROJECT_VERSION ${LEMON_VERSION}) + +SET(CMAKE_MODULE_PATH ${PROJECT_SOURCE_DIR}/cmake) + +FIND_PACKAGE(Doxygen) +FIND_PACKAGE(Ghostscript) +FIND_PACKAGE(GLPK 4.33) +FIND_PACKAGE(CPLEX) +FIND_PACKAGE(COIN) + +INCLUDE(CheckTypeSize) +CHECK_TYPE_SIZE("long long" LONG_LONG) +SET(LEMON_HAVE_LONG_LONG ${HAVE_LONG_LONG}) + +INCLUDE(FindPythonInterp) ENABLE_TESTING() ADD_SUBDIRECTORY(lemon) -ADD_SUBDIRECTORY(demo) -ADD_SUBDIRECTORY(doc) -ADD_SUBDIRECTORY(test) +IF(${CMAKE_SOURCE_DIR} STREQUAL ${PROJECT_SOURCE_DIR}) + ADD_SUBDIRECTORY(demo) + ADD_SUBDIRECTORY(tools) + ADD_SUBDIRECTORY(doc) + ADD_SUBDIRECTORY(test) +ENDIF() -IF(WIN32) - INSTALL(FILES ${CMAKE_SOURCE_DIR}/cmake/nsis/lemon.ico - DESTINATION bin) -ENDIF(WIN32) +CONFIGURE_FILE( + ${PROJECT_SOURCE_DIR}/cmake/LEMONConfig.cmake.in + ${PROJECT_BINARY_DIR}/cmake/LEMONConfig.cmake + @ONLY +) +IF(UNIX) + INSTALL( + FILES ${PROJECT_BINARY_DIR}/cmake/LEMONConfig.cmake + DESTINATION share/lemon/cmake + ) +ELSEIF(WIN32) + INSTALL( + FILES ${PROJECT_BINARY_DIR}/cmake/LEMONConfig.cmake + DESTINATION cmake + ) +ENDIF() -IF(WIN32) +IF(${CMAKE_SOURCE_DIR} STREQUAL ${PROJECT_SOURCE_DIR} AND WIN32) SET(CPACK_PACKAGE_NAME ${PROJECT_NAME}) - SET(CPACK_PACKAGE_VENDOR - "EGRES - Egervary Research Group on Combinatorial Optimization") + SET(CPACK_PACKAGE_VENDOR "EGRES") SET(CPACK_PACKAGE_DESCRIPTION_SUMMARY - "LEMON - Library of Efficient Models and Optimization in Networks") - SET(CPACK_RESOURCE_FILE_LICENSE "${CMAKE_SOURCE_DIR}/LICENSE") + "LEMON - Library for Efficient Modeling and Optimization in Networks") + SET(CPACK_RESOURCE_FILE_LICENSE "${PROJECT_SOURCE_DIR}/LICENSE") SET(CPACK_PACKAGE_VERSION ${PROJECT_VERSION}) @@ -37,48 +78,50 @@ SET(CPACK_PACKAGE_INSTALL_REGISTRY_KEY "${PROJECT_NAME} ${PROJECT_VERSION}") - # Variables to generate a component-based installer. - #SET(CPACK_COMPONENTS_ALL headers library html_documentation) + SET(CPACK_COMPONENTS_ALL headers library html_documentation bin) - #SET(CPACK_COMPONENT_HEADERS_DISPLAY_NAME "C++ headers") - #SET(CPACK_COMPONENT_LIBRARY_DISPLAY_NAME "Static library") - #SET(CPACK_COMPONENT_HTML_DOCUMENTATION_DISPLAY_NAME "HTML documentation") + SET(CPACK_COMPONENT_HEADERS_DISPLAY_NAME "C++ headers") + SET(CPACK_COMPONENT_LIBRARY_DISPLAY_NAME "Dynamic-link library") + SET(CPACK_COMPONENT_BIN_DISPLAY_NAME "Command line utilities") + SET(CPACK_COMPONENT_HTML_DOCUMENTATION_DISPLAY_NAME "HTML documentation") - #SET(CPACK_COMPONENT_HEADERS_DESCRIPTION - # "C++ header files for use with the LEMON library") - #SET(CPACK_COMPONENT_LIBRARY_DESCRIPTION - # "Static library used to build programs with LEMON") - #SET(CPACK_COMPONENT_HTML_DOCUMENTATION_DESCRIPTION - # "Doxygen generated documentation") + SET(CPACK_COMPONENT_HEADERS_DESCRIPTION + "C++ header files") + SET(CPACK_COMPONENT_LIBRARY_DESCRIPTION + "DLL and import library") + SET(CPACK_COMPONENT_BIN_DESCRIPTION + "Command line utilities") + SET(CPACK_COMPONENT_HTML_DOCUMENTATION_DESCRIPTION + "Doxygen generated documentation") - #SET(CPACK_COMPONENT_HEADERS_DEPENDS library) + SET(CPACK_COMPONENT_HEADERS_DEPENDS library) - #SET(CPACK_COMPONENT_HEADERS_GROUP "Development") - #SET(CPACK_COMPONENT_LIBRARY_GROUP "Development") - #SET(CPACK_COMPONENT_HTML_DOCUMENTATION_GROUP "Documentation") + SET(CPACK_COMPONENT_HEADERS_GROUP "Development") + SET(CPACK_COMPONENT_LIBRARY_GROUP "Development") + SET(CPACK_COMPONENT_HTML_DOCUMENTATION_GROUP "Documentation") - #SET(CPACK_COMPONENT_GROUP_DEVELOPMENT_DESCRIPTION - # "Components needed to develop software using LEMON") - #SET(CPACK_COMPONENT_GROUP_DOCUMENTATION_DESCRIPTION - # "Documentation of LEMON") + SET(CPACK_COMPONENT_GROUP_DEVELOPMENT_DESCRIPTION + "Components needed to develop software using LEMON") + SET(CPACK_COMPONENT_GROUP_DOCUMENTATION_DESCRIPTION + "Documentation of LEMON") - #SET(CPACK_ALL_INSTALL_TYPES Full Developer) + SET(CPACK_ALL_INSTALL_TYPES Full Developer) - #SET(CPACK_COMPONENT_HEADERS_INSTALL_TYPES Developer Full) - #SET(CPACK_COMPONENT_LIBRARY_INSTALL_TYPES Developer Full) - #SET(CPACK_COMPONENT_HTML_DOCUMENTATION_INSTALL_TYPES Full) + SET(CPACK_COMPONENT_HEADERS_INSTALL_TYPES Developer Full) + SET(CPACK_COMPONENT_LIBRARY_INSTALL_TYPES Developer Full) + SET(CPACK_COMPONENT_HTML_DOCUMENTATION_INSTALL_TYPES Full) SET(CPACK_GENERATOR "NSIS") - SET(CPACK_NSIS_MUI_ICON "${CMAKE_SOURCE_DIR}/cmake/nsis/lemon.ico") - SET(CPACK_NSIS_MUI_UNIICON "${CMAKE_SOURCE_DIR}/cmake/nsis/uninstall.ico") - #SET(CPACK_PACKAGE_ICON "${CMAKE_SOURCE_DIR}/cmake/nsis\\\\installer.bmp") + SET(CPACK_NSIS_MUI_ICON "${PROJECT_SOURCE_DIR}/cmake/nsis/lemon.ico") + SET(CPACK_NSIS_MUI_UNIICON "${PROJECT_SOURCE_DIR}/cmake/nsis/uninstall.ico") + #SET(CPACK_PACKAGE_ICON "${PROJECT_SOURCE_DIR}/cmake/nsis\\\\installer.bmp") SET(CPACK_NSIS_INSTALLED_ICON_NAME "bin\\\\lemon.ico") SET(CPACK_NSIS_DISPLAY_NAME "${CPACK_PACKAGE_INSTALL_DIRECTORY} ${PROJECT_NAME}") SET(CPACK_NSIS_HELP_LINK "http:\\\\\\\\lemon.cs.elte.hu") SET(CPACK_NSIS_URL_INFO_ABOUT "http:\\\\\\\\lemon.cs.elte.hu") SET(CPACK_NSIS_CONTACT "lemon-user@lemon.cs.elte.hu") SET(CPACK_NSIS_CREATE_ICONS_EXTRA " - CreateShortCut \\\"$SMPROGRAMS\\\\$STARTMENU_FOLDER\\\\Documentation.lnk\\\" \\\"$INSTDIR\\\\doc\\\\index.html\\\" + CreateShortCut \\\"$SMPROGRAMS\\\\$STARTMENU_FOLDER\\\\Documentation.lnk\\\" \\\"$INSTDIR\\\\share\\\\doc\\\\index.html\\\" ") SET(CPACK_NSIS_DELETE_ICONS_EXTRA " !insertmacro MUI_STARTMENU_GETFOLDER Application $MUI_TEMP @@ -86,4 +129,4 @@ ") INCLUDE(CPack) -ENDIF(WIN32) +ENDIF() diff -r c35afa9e89e7 -r ef88c0a30f85 INSTALL --- a/INSTALL Mon Jan 12 23:11:39 2009 +0100 +++ b/INSTALL Thu Nov 05 15:48:01 2009 +0100 @@ -5,6 +5,12 @@ tarballs and successfully extracted it. The latest version of LEMON is available at our web page (http://lemon.cs.elte.hu/). +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: @@ -21,8 +27,8 @@ 3. `make' This command compiles the non-template part of LEMON into libemon.a - file. It also compiles the programs in the tools and demo subdirectories - when enabled. + file. It also compiles the programs in the tools subdirectory by + default. 4. `make check' @@ -69,14 +75,6 @@ Set the installation prefix to PREFIX. By default it is /usr/local. ---enable-demo - - Build the examples in the demo subdirectory. - ---disable-demo - - Do not build the examples in the demo subdirectory (default). - --enable-tools Build the programs in the tools subdirectory (default). @@ -152,3 +150,26 @@ --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. diff -r c35afa9e89e7 -r ef88c0a30f85 LICENSE --- a/LICENSE Mon Jan 12 23:11:39 2009 +0100 +++ b/LICENSE Thu Nov 05 15:48:01 2009 +0100 @@ -1,10 +1,14 @@ -LEMON code without an explicit copyright is covered by the following +LEMON code without an explicit copyright notice is covered by the following copyright/license. Copyright (C) 2003-2009 Egervary Jeno Kombinatorikus Optimalizalasi Kutatocsoport (Egervary Combinatorial Optimization Research Group, EGRES). +=========================================================================== +Boost Software License, Version 1.0 +=========================================================================== + Permission is hereby granted, free of charge, to any person or organization obtaining a copy of the software and accompanying documentation covered by this license (the "Software") to use, reproduce, display, distribute, @@ -26,8 +30,3 @@ FOR ANY DAMAGES OR OTHER LIABILITY, WHETHER IN CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE. - -=========================================================================== -This license is a verbatim copy of the Boost Software License, Version 1.0. - - diff -r c35afa9e89e7 -r ef88c0a30f85 Makefile.am --- a/Makefile.am Mon Jan 12 23:11:39 2009 +0100 +++ b/Makefile.am Thu Nov 05 15:48:01 2009 +0100 @@ -11,8 +11,17 @@ m4/lx_check_cplex.m4 \ m4/lx_check_glpk.m4 \ m4/lx_check_soplex.m4 \ + m4/lx_check_coin.m4 \ CMakeLists.txt \ - cmake + 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) @@ -34,9 +43,13 @@ include lemon/Makefile.am include test/Makefile.am include doc/Makefile.am -include demo/Makefile.am include tools/Makefile.am +DIST_SUBDIRS = demo + +demo: + $(MAKE) $(AM_MAKEFLAGS) -C demo + MRPROPERFILES = \ aclocal.m4 \ config.h.in \ @@ -63,4 +76,4 @@ zcat $(PACKAGE)-$(VERSION).tar.gz | \ bzip2 --best -c > $(PACKAGE)-$(VERSION).tar.bz2 -.PHONY: mrproper dist-bz2 distcheck-bz2 +.PHONY: demo mrproper dist-bz2 distcheck-bz2 diff -r c35afa9e89e7 -r ef88c0a30f85 NEWS --- a/NEWS Mon Jan 12 23:11:39 2009 +0100 +++ b/NEWS Thu Nov 05 15:48:01 2009 +0100 @@ -1,3 +1,97 @@ +2009-05-13 Version 1.1 released + + This is the second stable release of the 1.x series. It + features a better coverage of the tools available in the 0.x + series, a thoroughly reworked LP/MIP interface plus various + improvements in the existing tools. + + * Much improved M$ Windows support + * Various improvements in the CMAKE build system + * Compilation warnings are fixed/suppressed + * Support IBM xlC compiler + * New algorithms + * Connectivity related algorithms (#61) + * Euler walks (#65) + * Preflow push-relabel max. flow algorithm (#176) + * Circulation algorithm (push-relabel based) (#175) + * Suurballe algorithm (#47) + * Gomory-Hu algorithm (#66) + * Hao-Orlin algorithm (#58) + * Edmond's maximum cardinality and weighted matching algorithms + in general graphs (#48,#265) + * Minimum cost arborescence/branching (#60) + * Network Simplex min. cost flow algorithm (#234) + * New data structures + * Full graph structure (#57) + * Grid graph structure (#57) + * Hypercube graph structure (#57) + * Graph adaptors (#67) + * ArcSet and EdgeSet classes (#67) + * Elevator class (#174) + * Other new tools + * LP/MIP interface (#44) + * Support for GLPK, CPLEX, Soplex, COIN-OR CLP and CBC + * Reader for the Nauty file format (#55) + * DIMACS readers (#167) + * Radix sort algorithms (#72) + * RangeIdMap and CrossRefMap (#160) + * New command line tools + * DIMACS to LGF converter (#182) + * lgf-gen - a graph generator (#45) + * DIMACS solver utility (#226) + * Other code improvements + * Lognormal distribution added to Random (#102) + * Better (i.e. O(1) time) item counting in SmartGraph (#3) + * The standard maps of graphs are guaranteed to be + reference maps (#190) + * Miscellaneous + * Various doc improvements + * Improved 0.x -> 1.x converter script + + * Several bugfixes (compared to release 1.0): + #170: Bugfix SmartDigraph::split() + #171: Bugfix in SmartGraph::restoreSnapshot() + #172: Extended test cases for graphs and digraphs + #173: Bugfix in Random + * operator()s always return a double now + * the faulty real(Num) and real(Num,Num) + have been removed + #187: Remove DijkstraWidestPathOperationTraits + #61: Bugfix in DfsVisit + #193: Bugfix in GraphReader::skipSection() + #195: Bugfix in ConEdgeIt() + #197: Bugfix in heap unionfind + * This bug affects Edmond's general matching algorithms + #207: Fix 'make install' without 'make html' using CMAKE + #208: Suppress or fix VS2008 compilation warnings + ----: Update the LEMON icon + ----: Enable the component-based installer + (in installers made by CPACK) + ----: Set the proper version for CMAKE in the tarballs + (made by autotools) + ----: Minor clarification in the LICENSE file + ----: Add missing unistd.h include to time_measure.h + #204: Compilation bug fixed in graph_to_eps.h with VS2005 + #214,#215: windows.h should never be included by lemon headers + #230: Build systems check the availability of 'long long' type + #229: Default implementation of Tolerance<> is used for integer types + #211,#212: Various fixes for compiling on AIX + ----: Improvements in CMAKE config + - docs is installed in share/doc/ + - detects newer versions of Ghostscript + #239: Fix missing 'inline' specifier in time_measure.h + #274,#280: Install lemon/config.h + #275: Prefix macro names with LEMON_ in lemon/config.h + ----: Small script for making the release tarballs added + ----: Minor improvement in unify-sources.sh (a76f55d7d397) + +2009-03-27 LEMON joins to the COIN-OR initiative + + COIN-OR (Computational Infrastructure for Operations Research, + http://www.coin-or.org) project is an initiative to spur the + development of open-source software for the operations research + community. + 2008-10-13 Version 1.0 released This is the first stable release of LEMON. Compared to the 0.x diff -r c35afa9e89e7 -r ef88c0a30f85 README --- a/README Mon Jan 12 23:11:39 2009 +0100 +++ b/README Thu Nov 05 15:48:01 2009 +0100 @@ -1,6 +1,6 @@ -================================================================== -LEMON - a Library of Efficient Models and Optimization in Networks -================================================================== +===================================================================== +LEMON - a Library for Efficient Modeling and Optimization in Networks +===================================================================== LEMON is an open source library written in C++. It provides easy-to-use implementations of common data structures and algorithms diff -r c35afa9e89e7 -r ef88c0a30f85 cmake/FindCOIN.cmake --- /dev/null Thu Jan 01 00:00:00 1970 +0000 +++ b/cmake/FindCOIN.cmake Thu Nov 05 15:48:01 2009 +0100 @@ -0,0 +1,88 @@ +SET(COIN_ROOT_DIR "" CACHE PATH "COIN root directory") + +FIND_PATH(COIN_INCLUDE_DIR coin/CoinUtilsConfig.h + HINTS ${COIN_ROOT_DIR}/include +) +FIND_LIBRARY(COIN_CBC_LIBRARY + NAMES Cbc libCbc + HINTS ${COIN_ROOT_DIR}/lib +) +FIND_LIBRARY(COIN_CBC_SOLVER_LIBRARY + NAMES CbcSolver libCbcSolver + HINTS ${COIN_ROOT_DIR}/lib +) +FIND_LIBRARY(COIN_CGL_LIBRARY + NAMES Cgl libCgl + HINTS ${COIN_ROOT_DIR}/lib +) +FIND_LIBRARY(COIN_CLP_LIBRARY + NAMES Clp libClp + HINTS ${COIN_ROOT_DIR}/lib +) +FIND_LIBRARY(COIN_COIN_UTILS_LIBRARY + NAMES CoinUtils libCoinUtils + HINTS ${COIN_ROOT_DIR}/lib +) +FIND_LIBRARY(COIN_OSI_LIBRARY + NAMES Osi libOsi + HINTS ${COIN_ROOT_DIR}/lib +) +FIND_LIBRARY(COIN_OSI_CBC_LIBRARY + NAMES OsiCbc libOsiCbc + HINTS ${COIN_ROOT_DIR}/lib +) +FIND_LIBRARY(COIN_OSI_CLP_LIBRARY + NAMES OsiClp libOsiClp + HINTS ${COIN_ROOT_DIR}/lib +) +FIND_LIBRARY(COIN_OSI_VOL_LIBRARY + NAMES OsiVol libOsiVol + HINTS ${COIN_ROOT_DIR}/lib +) +FIND_LIBRARY(COIN_VOL_LIBRARY + NAMES Vol libVol + HINTS ${COIN_ROOT_DIR}/lib +) + +INCLUDE(FindPackageHandleStandardArgs) +FIND_PACKAGE_HANDLE_STANDARD_ARGS(COIN DEFAULT_MSG + COIN_INCLUDE_DIR + COIN_CBC_LIBRARY + COIN_CBC_SOLVER_LIBRARY + COIN_CGL_LIBRARY + COIN_CLP_LIBRARY + COIN_COIN_UTILS_LIBRARY + COIN_OSI_LIBRARY + COIN_OSI_CBC_LIBRARY + COIN_OSI_CLP_LIBRARY + COIN_OSI_VOL_LIBRARY + COIN_VOL_LIBRARY +) + +IF(COIN_FOUND) + SET(COIN_INCLUDE_DIRS ${COIN_INCLUDE_DIR}) + SET(COIN_LIBRARIES "${COIN_CBC_LIBRARY};${COIN_CBC_SOLVER_LIBRARY};${COIN_CGL_LIBRARY};${COIN_CLP_LIBRARY};${COIN_COIN_UTILS_LIBRARY};${COIN_OSI_LIBRARY};${COIN_OSI_CBC_LIBRARY};${COIN_OSI_CLP_LIBRARY};${COIN_OSI_VOL_LIBRARY};${COIN_VOL_LIBRARY}") + SET(COIN_CLP_LIBRARIES "${COIN_CLP_LIBRARY};${COIN_COIN_UTILS_LIBRARY}") + SET(COIN_CBC_LIBRARIES ${COIN_LIBRARIES}) +ENDIF(COIN_FOUND) + +MARK_AS_ADVANCED( + COIN_INCLUDE_DIR + COIN_CBC_LIBRARY + COIN_CBC_SOLVER_LIBRARY + COIN_CGL_LIBRARY + COIN_CLP_LIBRARY + COIN_COIN_UTILS_LIBRARY + COIN_OSI_LIBRARY + COIN_OSI_CBC_LIBRARY + COIN_OSI_CLP_LIBRARY + COIN_OSI_VOL_LIBRARY + COIN_VOL_LIBRARY +) + +IF(COIN_FOUND) + SET(LEMON_HAVE_LP TRUE) + SET(LEMON_HAVE_MIP TRUE) + SET(LEMON_HAVE_CLP TRUE) + SET(LEMON_HAVE_CBC TRUE) +ENDIF(COIN_FOUND) diff -r c35afa9e89e7 -r ef88c0a30f85 cmake/FindCPLEX.cmake --- /dev/null Thu Jan 01 00:00:00 1970 +0000 +++ b/cmake/FindCPLEX.cmake Thu Nov 05 15:48:01 2009 +0100 @@ -0,0 +1,38 @@ +SET(CPLEX_ROOT_DIR "" CACHE PATH "CPLEX root directory") + +FIND_PATH(CPLEX_INCLUDE_DIR + ilcplex/cplex.h + PATHS "C:/ILOG/CPLEX91/include" + PATHS "/opt/ilog/cplex91/include" + HINTS ${CPLEX_ROOT_DIR}/include +) +FIND_LIBRARY(CPLEX_LIBRARY + cplex91 + PATHS "C:/ILOG/CPLEX91/lib/msvc7/stat_mda" + PATHS "/opt/ilog/cplex91/bin" + HINTS ${CPLEX_ROOT_DIR}/bin +) + +INCLUDE(FindPackageHandleStandardArgs) +FIND_PACKAGE_HANDLE_STANDARD_ARGS(CPLEX DEFAULT_MSG CPLEX_LIBRARY CPLEX_INCLUDE_DIR) + +FIND_PATH(CPLEX_BIN_DIR + cplex91.dll + PATHS "C:/ILOG/CPLEX91/bin/x86_win32" +) + +IF(CPLEX_FOUND) + SET(CPLEX_INCLUDE_DIRS ${CPLEX_INCLUDE_DIR}) + SET(CPLEX_LIBRARIES ${CPLEX_LIBRARY}) + IF(CMAKE_SYSTEM_NAME STREQUAL "Linux") + SET(CPLEX_LIBRARIES "${CPLEX_LIBRARIES};m;pthread") + ENDIF(CMAKE_SYSTEM_NAME STREQUAL "Linux") +ENDIF(CPLEX_FOUND) + +MARK_AS_ADVANCED(CPLEX_LIBRARY CPLEX_INCLUDE_DIR CPLEX_BIN_DIR) + +IF(CPLEX_FOUND) + SET(LEMON_HAVE_LP TRUE) + SET(LEMON_HAVE_MIP TRUE) + SET(LEMON_HAVE_CPLEX TRUE) +ENDIF(CPLEX_FOUND) diff -r c35afa9e89e7 -r ef88c0a30f85 cmake/FindGLPK.cmake --- /dev/null Thu Jan 01 00:00:00 1970 +0000 +++ b/cmake/FindGLPK.cmake Thu Nov 05 15:48:01 2009 +0100 @@ -0,0 +1,61 @@ +SET(GLPK_ROOT_DIR "" CACHE PATH "GLPK root directory") + +SET(GLPK_REGKEY "[HKEY_LOCAL_MACHINE\\SOFTWARE\\GnuWin32\\Glpk;InstallPath]") +GET_FILENAME_COMPONENT(GLPK_ROOT_PATH ${GLPK_REGKEY} ABSOLUTE) + +FIND_PATH(GLPK_INCLUDE_DIR + glpk.h + PATHS ${GLPK_REGKEY}/include + HINTS ${GLPK_ROOT_DIR}/include +) +FIND_LIBRARY(GLPK_LIBRARY + glpk + PATHS ${GLPK_REGKEY}/lib + HINTS ${GLPK_ROOT_DIR}/lib +) + +IF(GLPK_INCLUDE_DIR AND GLPK_LIBRARY) + FILE(READ ${GLPK_INCLUDE_DIR}/glpk.h GLPK_GLPK_H) + + STRING(REGEX MATCH "define[ ]+GLP_MAJOR_VERSION[ ]+[0-9]+" GLPK_MAJOR_VERSION_LINE "${GLPK_GLPK_H}") + STRING(REGEX REPLACE "define[ ]+GLP_MAJOR_VERSION[ ]+([0-9]+)" "\\1" GLPK_VERSION_MAJOR "${GLPK_MAJOR_VERSION_LINE}") + + STRING(REGEX MATCH "define[ ]+GLP_MINOR_VERSION[ ]+[0-9]+" GLPK_MINOR_VERSION_LINE "${GLPK_GLPK_H}") + STRING(REGEX REPLACE "define[ ]+GLP_MINOR_VERSION[ ]+([0-9]+)" "\\1" GLPK_VERSION_MINOR "${GLPK_MINOR_VERSION_LINE}") + + SET(GLPK_VERSION_STRING "${GLPK_VERSION_MAJOR}.${GLPK_VERSION_MINOR}") + + IF(GLPK_FIND_VERSION) + IF(GLPK_FIND_VERSION_COUNT GREATER 2) + MESSAGE(SEND_ERROR "unexpected version string") + ENDIF(GLPK_FIND_VERSION_COUNT GREATER 2) + + MATH(EXPR GLPK_REQUESTED_VERSION "${GLPK_FIND_VERSION_MAJOR}*100 + ${GLPK_FIND_VERSION_MINOR}") + MATH(EXPR GLPK_FOUND_VERSION "${GLPK_VERSION_MAJOR}*100 + ${GLPK_VERSION_MINOR}") + + IF(GLPK_FOUND_VERSION LESS GLPK_REQUESTED_VERSION) + SET(GLPK_PROPER_VERSION_FOUND FALSE) + ELSE(GLPK_FOUND_VERSION LESS GLPK_REQUESTED_VERSION) + SET(GLPK_PROPER_VERSION_FOUND TRUE) + ENDIF(GLPK_FOUND_VERSION LESS GLPK_REQUESTED_VERSION) + ELSE(GLPK_FIND_VERSION) + SET(GLPK_PROPER_VERSION_FOUND TRUE) + ENDIF(GLPK_FIND_VERSION) +ENDIF(GLPK_INCLUDE_DIR AND GLPK_LIBRARY) + +INCLUDE(FindPackageHandleStandardArgs) +FIND_PACKAGE_HANDLE_STANDARD_ARGS(GLPK DEFAULT_MSG GLPK_LIBRARY GLPK_INCLUDE_DIR GLPK_PROPER_VERSION_FOUND) + +IF(GLPK_FOUND) + SET(GLPK_INCLUDE_DIRS ${GLPK_INCLUDE_DIR}) + SET(GLPK_LIBRARIES ${GLPK_LIBRARY}) + SET(GLPK_BIN_DIR ${GLPK_ROOT_PATH}/bin) +ENDIF(GLPK_FOUND) + +MARK_AS_ADVANCED(GLPK_LIBRARY GLPK_INCLUDE_DIR GLPK_BIN_DIR) + +IF(GLPK_FOUND) + SET(LEMON_HAVE_LP TRUE) + SET(LEMON_HAVE_MIP TRUE) + SET(LEMON_HAVE_GLPK TRUE) +ENDIF(GLPK_FOUND) diff -r c35afa9e89e7 -r ef88c0a30f85 cmake/FindGhostscript.cmake --- a/cmake/FindGhostscript.cmake Mon Jan 12 23:11:39 2009 +0100 +++ b/cmake/FindGhostscript.cmake Thu Nov 05 15:48:01 2009 +0100 @@ -3,7 +3,7 @@ FIND_PROGRAM(GHOSTSCRIPT_EXECUTABLE NAMES gs gswin32c PATHS "$ENV{ProgramFiles}/gs" - PATH_SUFFIXES gs8.61/bin gs8.62/bin + PATH_SUFFIXES gs8.61/bin gs8.62/bin gs8.63/bin gs8.64/bin gs8.65/bin DOC "Ghostscript: PostScript and PDF language interpreter and previewer." ) diff -r c35afa9e89e7 -r ef88c0a30f85 cmake/LEMONConfig.cmake.in --- /dev/null Thu Jan 01 00:00:00 1970 +0000 +++ b/cmake/LEMONConfig.cmake.in Thu Nov 05 15:48:01 2009 +0100 @@ -0,0 +1,13 @@ +SET(LEMON_INCLUDE_DIR "@CMAKE_INSTALL_PREFIX@/include" CACHE PATH "LEMON include directory") +SET(LEMON_INCLUDE_DIRS "${LEMON_INCLUDE_DIR}") + +IF(UNIX) + SET(LEMON_LIB_NAME "libemon.a") +ELSEIF(WIN32) + SET(LEMON_LIB_NAME "lemon.lib") +ENDIF(UNIX) + +SET(LEMON_LIBRARY "@CMAKE_INSTALL_PREFIX@/lib/${LEMON_LIB_NAME}" CACHE FILEPATH "LEMON library") +SET(LEMON_LIBRARIES "${LEMON_LIBRARY}") + +MARK_AS_ADVANCED(LEMON_LIBRARY LEMON_INCLUDE_DIR) diff -r c35afa9e89e7 -r ef88c0a30f85 cmake/nsis/lemon.ico Binary file cmake/nsis/lemon.ico has changed diff -r c35afa9e89e7 -r ef88c0a30f85 cmake/version.cmake.in --- /dev/null Thu Jan 01 00:00:00 1970 +0000 +++ b/cmake/version.cmake.in Thu Nov 05 15:48:01 2009 +0100 @@ -0,0 +1,1 @@ +SET(LEMON_VERSION "@PACKAGE_VERSION@" CACHE STRING "LEMON version string.") diff -r c35afa9e89e7 -r ef88c0a30f85 configure.ac --- a/configure.ac Mon Jan 12 23:11:39 2009 +0100 +++ b/configure.ac Thu Nov 05 15:48:01 2009 +0100 @@ -2,14 +2,17 @@ dnl Version information. m4_define([lemon_version_number], - [m4_normalize(esyscmd([echo ${LEMON_VERSION}]))]) + [m4_normalize(esyscmd([echo ${LEMON_VERSION}]))]) dnl m4_define([lemon_version_number], []) m4_define([lemon_hg_path], [m4_normalize(esyscmd([./scripts/chg-len.py]))]) -m4_define([lemon_hg_revision], [m4_normalize(esyscmd([hg id -i]))]) +m4_define([lemon_hg_revision], [m4_normalize(esyscmd([hg id -i 2> /dev/null]))]) m4_define([lemon_version], [ifelse(lemon_version_number(), - [], - [lemon_hg_path().lemon_hg_revision()], - [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]) @@ -19,9 +22,17 @@ 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 @@ -30,6 +41,7 @@ AC_PROG_LIBTOOL AC_CHECK_PROG([doxygen_found],[doxygen],[yes],[no]) +AC_CHECK_PROG([python_found],[python],[yes],[no]) AC_CHECK_PROG([gs_found],[gs],[yes],[no]) dnl Detect Intel compiler. @@ -53,24 +65,11 @@ LX_CHECK_GLPK LX_CHECK_CPLEX LX_CHECK_SOPLEX -LX_CHECK_CLP +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 demo programs. -AC_ARG_ENABLE([demo], -AS_HELP_STRING([--enable-demo], [build the demo programs]) -AS_HELP_STRING([--disable-demo], [do not build the demo programs @<:@default@:>@]), - [], [enable_demo=no]) -AC_MSG_CHECKING([whether to build the demo programs]) -if test x"$enable_demo" != x"no"; then - AC_MSG_RESULT([yes]) -else - AC_MSG_RESULT([no]) -fi -AM_CONDITIONAL([WANT_DEMO], [test x"$enable_demo" != x"no"]) - dnl Disable/enable building the binary tools. AC_ARG_ENABLE([tools], AS_HELP_STRING([--enable-tools], [build additional tools @<:@default@:>@]) @@ -100,10 +99,12 @@ dnl Add dependencies on files generated by configure. AC_SUBST([CONFIG_STATUS_DEPENDENCIES], - ['$(top_srcdir)/doc/Doxyfile.in $(top_srcdir)/lemon/lemon.pc.in']) + ['$(top_srcdir)/doc/Doxyfile.in $(top_srcdir)/lemon/lemon.pc.in $(top_srcdir)/cmake/version.cmake.in']) AC_CONFIG_FILES([ Makefile +demo/Makefile +cmake/version.cmake doc/Doxyfile lemon/lemon.pc ]) @@ -118,12 +119,14 @@ 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 demo programs........... : $enable_demo echo Build additional tools........ : $enable_tools echo echo The packace will be installed in diff -r c35afa9e89e7 -r ef88c0a30f85 demo/CMakeLists.txt --- a/demo/CMakeLists.txt Mon Jan 12 23:11:39 2009 +0100 +++ b/demo/CMakeLists.txt Thu Nov 05 15:48:01 2009 +0100 @@ -1,13 +1,19 @@ -INCLUDE_DIRECTORIES(${CMAKE_SOURCE_DIR}) +INCLUDE_DIRECTORIES( + ${PROJECT_SOURCE_DIR} + ${PROJECT_BINARY_DIR} +) -LINK_DIRECTORIES(${CMAKE_BINARY_DIR}/lemon) +LINK_DIRECTORIES( + ${PROJECT_BINARY_DIR}/lemon +) SET(DEMOS arg_parser_demo graph_to_eps_demo - lgf_demo) + lgf_demo +) FOREACH(DEMO_NAME ${DEMOS}) ADD_EXECUTABLE(${DEMO_NAME} ${DEMO_NAME}.cc) TARGET_LINK_LIBRARIES(${DEMO_NAME} lemon) -ENDFOREACH(DEMO_NAME) +ENDFOREACH() diff -r c35afa9e89e7 -r ef88c0a30f85 demo/Makefile.am --- a/demo/Makefile.am Mon Jan 12 23:11:39 2009 +0100 +++ b/demo/Makefile.am Thu Nov 05 15:48:01 2009 +0100 @@ -1,16 +1,17 @@ -EXTRA_DIST += \ - demo/CMakeLists.txt \ - demo/digraph.lgf +AM_CXXFLAGS = $(WARNINGCXXFLAGS) -if WANT_DEMO +AM_CPPFLAGS = -I$(top_srcdir) -I$(top_builddir) +LDADD = $(top_builddir)/lemon/libemon.la -noinst_PROGRAMS += \ - demo/arg_parser_demo \ - demo/graph_to_eps_demo \ - demo/lgf_demo +EXTRA_DIST = \ + CMakeLists.txt \ + digraph.lgf -endif WANT_DEMO +noinst_PROGRAMS = \ + arg_parser_demo \ + graph_to_eps_demo \ + lgf_demo -demo_arg_parser_demo_SOURCES = demo/arg_parser_demo.cc -demo_graph_to_eps_demo_SOURCES = demo/graph_to_eps_demo.cc -demo_lgf_demo_SOURCES = demo/lgf_demo.cc +arg_parser_demo_SOURCES = arg_parser_demo.cc +graph_to_eps_demo_SOURCES = graph_to_eps_demo.cc +lgf_demo_SOURCES = lgf_demo.cc diff -r c35afa9e89e7 -r ef88c0a30f85 demo/graph_to_eps_demo.cc --- a/demo/graph_to_eps_demo.cc Mon Jan 12 23:11:39 2009 +0100 +++ b/demo/graph_to_eps_demo.cc Thu Nov 05 15:48:01 2009 +0100 @@ -182,7 +182,7 @@ ListDigraph::NodeMap hcolors(h); ListDigraph::NodeMap hcoords(h); - int cols=int(sqrt(double(palette.size()))); + int cols=int(std::sqrt(double(palette.size()))); for(int i=0;ireferences.dox + COMMAND ${DOXYGEN_EXECUTABLE} Doxyfile + WORKING_DIRECTORY ${CMAKE_CURRENT_BINARY_DIR} + ) + + SET_TARGET_PROPERTIES(html PROPERTIES PROJECT_LABEL BUILD_DOC) + IF(UNIX) - ADD_CUSTOM_TARGET(html - COMMAND rm -rf gen-images - COMMAND mkdir gen-images - COMMAND ${GHOSTSCRIPT_EXECUTABLE} -dNOPAUSE -dBATCH -q -dEPSCrop -dTextAlphaBits=4 -dGraphicsAlphaBits=4 -sDEVICE=pngalpha -r18 -sOutputFile=gen-images/grid_graph.png ${CMAKE_CURRENT_SOURCE_DIR}/images/grid_graph.eps - COMMAND ${GHOSTSCRIPT_EXECUTABLE} -dNOPAUSE -dBATCH -q -dEPSCrop -dTextAlphaBits=4 -dGraphicsAlphaBits=4 -sDEVICE=pngalpha -r18 -sOutputFile=gen-images/nodeshape_0.png ${CMAKE_CURRENT_SOURCE_DIR}/images/nodeshape_0.eps - COMMAND ${GHOSTSCRIPT_EXECUTABLE} -dNOPAUSE -dBATCH -q -dEPSCrop -dTextAlphaBits=4 -dGraphicsAlphaBits=4 -sDEVICE=pngalpha -r18 -sOutputFile=gen-images/nodeshape_1.png ${CMAKE_CURRENT_SOURCE_DIR}/images/nodeshape_1.eps - COMMAND ${GHOSTSCRIPT_EXECUTABLE} -dNOPAUSE -dBATCH -q -dEPSCrop -dTextAlphaBits=4 -dGraphicsAlphaBits=4 -sDEVICE=pngalpha -r18 -sOutputFile=gen-images/nodeshape_2.png ${CMAKE_CURRENT_SOURCE_DIR}/images/nodeshape_2.eps - COMMAND ${GHOSTSCRIPT_EXECUTABLE} -dNOPAUSE -dBATCH -q -dEPSCrop -dTextAlphaBits=4 -dGraphicsAlphaBits=4 -sDEVICE=pngalpha -r18 -sOutputFile=gen-images/nodeshape_3.png ${CMAKE_CURRENT_SOURCE_DIR}/images/nodeshape_3.eps - COMMAND ${GHOSTSCRIPT_EXECUTABLE} -dNOPAUSE -dBATCH -q -dEPSCrop -dTextAlphaBits=4 -dGraphicsAlphaBits=4 -sDEVICE=pngalpha -r18 -sOutputFile=gen-images/nodeshape_4.png ${CMAKE_CURRENT_SOURCE_DIR}/images/nodeshape_4.eps - COMMAND rm -rf html - COMMAND ${DOXYGEN_EXECUTABLE} Doxyfile - WORKING_DIRECTORY ${CMAKE_CURRENT_BINARY_DIR}) + INSTALL( + DIRECTORY ${CMAKE_CURRENT_BINARY_DIR}/html/ + DESTINATION share/doc/lemon/html + COMPONENT html_documentation + ) ELSEIF(WIN32) - ADD_CUSTOM_TARGET(html - COMMAND if exist gen-images rmdir /s /q gen-images - COMMAND mkdir gen-images - COMMAND ${GHOSTSCRIPT_EXECUTABLE} -dNOPAUSE -dBATCH -q -dEPSCrop -dTextAlphaBits=4 -dGraphicsAlphaBits=4 -sDEVICE=pngalpha -r18 -sOutputFile=gen-images/nodeshape_0.png ${CMAKE_CURRENT_SOURCE_DIR}/images/nodeshape_0.eps - COMMAND ${GHOSTSCRIPT_EXECUTABLE} -dNOPAUSE -dBATCH -q -dEPSCrop -dTextAlphaBits=4 -dGraphicsAlphaBits=4 -sDEVICE=pngalpha -r18 -sOutputFile=gen-images/nodeshape_1.png ${CMAKE_CURRENT_SOURCE_DIR}/images/nodeshape_1.eps - COMMAND ${GHOSTSCRIPT_EXECUTABLE} -dNOPAUSE -dBATCH -q -dEPSCrop -dTextAlphaBits=4 -dGraphicsAlphaBits=4 -sDEVICE=pngalpha -r18 -sOutputFile=gen-images/nodeshape_2.png ${CMAKE_CURRENT_SOURCE_DIR}/images/nodeshape_2.eps - COMMAND ${GHOSTSCRIPT_EXECUTABLE} -dNOPAUSE -dBATCH -q -dEPSCrop -dTextAlphaBits=4 -dGraphicsAlphaBits=4 -sDEVICE=pngalpha -r18 -sOutputFile=gen-images/nodeshape_3.png ${CMAKE_CURRENT_SOURCE_DIR}/images/nodeshape_3.eps - COMMAND ${GHOSTSCRIPT_EXECUTABLE} -dNOPAUSE -dBATCH -q -dEPSCrop -dTextAlphaBits=4 -dGraphicsAlphaBits=4 -sDEVICE=pngalpha -r18 -sOutputFile=gen-images/nodeshape_4.png ${CMAKE_CURRENT_SOURCE_DIR}/images/nodeshape_4.eps - COMMAND if exist html rmdir /s /q html - COMMAND ${DOXYGEN_EXECUTABLE} Doxyfile - WORKING_DIRECTORY ${CMAKE_CURRENT_BINARY_DIR}) - ENDIF(UNIX) -ENDIF(DOXYGEN_EXECUTABLE AND GHOSTSCRIPT_EXECUTABLE) + INSTALL( + DIRECTORY ${CMAKE_CURRENT_BINARY_DIR}/html/ + DESTINATION doc + COMPONENT html_documentation + ) + ENDIF() -INSTALL( - DIRECTORY ${CMAKE_CURRENT_BINARY_DIR}/html/ - DESTINATION doc - COMPONENT html_documentation) +ENDIF() diff -r c35afa9e89e7 -r ef88c0a30f85 doc/Doxyfile.in --- a/doc/Doxyfile.in Mon Jan 12 23:11:39 2009 +0100 +++ b/doc/Doxyfile.in Thu Nov 05 15:48:01 2009 +0100 @@ -1,4 +1,4 @@ -# Doxyfile 1.5.7.1 +# Doxyfile 1.5.9 #--------------------------------------------------------------------------- # Project related configuration options @@ -21,7 +21,6 @@ JAVADOC_AUTOBRIEF = NO QT_AUTOBRIEF = NO MULTILINE_CPP_IS_BRIEF = NO -DETAILS_AT_TOP = YES INHERIT_DOCS = NO SEPARATE_MEMBER_PAGES = NO TAB_SIZE = 8 @@ -91,7 +90,8 @@ "@abs_top_srcdir@/lemon/concepts" \ "@abs_top_srcdir@/demo" \ "@abs_top_srcdir@/tools" \ - "@abs_top_srcdir@/test/test_tools.h" + "@abs_top_srcdir@/test/test_tools.h" \ + "@abs_top_builddir@/doc/references.dox" INPUT_ENCODING = UTF-8 FILE_PATTERNS = *.h \ *.cc \ @@ -223,7 +223,7 @@ EXPAND_AS_DEFINED = SKIP_FUNCTION_MACROS = YES #--------------------------------------------------------------------------- -# Configuration::additions related to external references +# Options related to the search engine #--------------------------------------------------------------------------- TAGFILES = "@abs_top_srcdir@/doc/libstdc++.tag = http://gcc.gnu.org/onlinedocs/libstdc++/latest-doxygen/ " GENERATE_TAGFILE = html/lemon.tag diff -r c35afa9e89e7 -r ef88c0a30f85 doc/Makefile.am --- a/doc/Makefile.am Mon Jan 12 23:11:39 2009 +0100 +++ b/doc/Makefile.am Thu Nov 05 15:48:01 2009 +0100 @@ -8,6 +8,7 @@ doc/license.dox \ doc/mainpage.dox \ doc/migration.dox \ + doc/min_cost_flow.dox \ doc/named-param.dox \ doc/namespaces.dox \ doc/html \ @@ -21,8 +22,17 @@ 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_IMAGES18) \ + $(DOC_EPS_IMAGES27) DOC_PNG_IMAGES = \ $(DOC_EPS_IMAGES:%.eps=doc/gen-images/%.png) @@ -45,7 +55,30 @@ exit 1; \ fi -html-local: $(DOC_PNG_IMAGES) +$(DOC_EPS_IMAGES27:%.eps=doc/gen-images/%.png): doc/gen-images/%.png: doc/images/%.eps + -mkdir doc/gen-images + if test ${gs_found} = yes; then \ + $(GS_COMMAND) -sDEVICE=pngalpha -r27 -sOutputFile=$@ $<; \ + else \ + echo; \ + echo "Ghostscript not found."; \ + echo; \ + exit 1; \ + fi + +references.dox: doc/references.bib + if test ${python_found} = yes; then \ + cd doc; \ + python @abs_top_srcdir@/scripts/bib2dox.py @abs_top_builddir@/$< >$@; \ + cd ..; \ + else \ + echo; \ + echo "Python not found."; \ + echo; \ + exit 1; \ + fi + +html-local: $(DOC_PNG_IMAGES) references.dox if test ${doxygen_found} = yes; then \ cd doc; \ doxygen Doxyfile; \ @@ -70,19 +103,19 @@ install-html-local: doc/html @$(NORMAL_INSTALL) - $(mkinstalldirs) $(DESTDIR)$(htmldir)/docs + $(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)/docs/$$f"; \ - $(INSTALL_DATA) $$p $(DESTDIR)$(htmldir)/docs/$$f; \ + 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)/docs/$$f"; \ - rm -f $(DESTDIR)$(htmldir)/docs/$$f; \ + echo " rm -f $(DESTDIR)$(htmldir)/html/$$f"; \ + rm -f $(DESTDIR)$(htmldir)/html/$$f; \ done .PHONY: update-external-tags diff -r c35afa9e89e7 -r ef88c0a30f85 doc/groups.dox --- a/doc/groups.dox Mon Jan 12 23:11:39 2009 +0100 +++ b/doc/groups.dox Thu Nov 05 15:48:01 2009 +0100 @@ -20,7 +20,7 @@ /** @defgroup datas Data Structures -This group describes the several data structures implemented in LEMON. +This group contains the several data structures implemented in LEMON. */ /** @@ -138,21 +138,11 @@ */ /** -@defgroup semi_adaptors Semi-Adaptor Classes for Graphs -@ingroup graphs -\brief Graph types between real graphs and graph adaptors. - -This group describes some graph types between real graphs and graph adaptors. -These classes wrap graphs to give new functionality as the adaptors do it. -On the other hand they are not light-weight structures as the adaptors. -*/ - -/** @defgroup maps Maps @ingroup datas \brief Map structures implemented in LEMON. -This group describes the map structures implemented in LEMON. +This group contains the map structures implemented in LEMON. LEMON provides several special purpose maps and map adaptors that e.g. combine new maps from existing ones. @@ -165,7 +155,7 @@ @ingroup maps \brief Special graph-related maps. -This group describes maps that are specifically designed to assign +This group contains maps that are specifically designed to assign values to the nodes and arcs/edges of graphs. If you are looking for the standard graph maps (\c NodeMap, \c ArcMap, @@ -177,7 +167,7 @@ \ingroup maps \brief Tools to create new maps from existing ones -This group describes map adaptors that are used to create "implicit" +This group contains map adaptors that are used to create "implicit" maps from other maps. Most of them are \ref concepts::ReadMap "read-only maps". @@ -236,19 +226,11 @@ */ /** -@defgroup matrices Matrices -@ingroup datas -\brief Two dimensional data storages implemented in LEMON. - -This group describes two dimensional data storages implemented in LEMON. -*/ - -/** @defgroup paths Path Structures @ingroup datas \brief %Path structures implemented in LEMON. -This group describes the path structures implemented in LEMON. +This group contains the path structures implemented in LEMON. LEMON provides flexible data structures to work with paths. All of them have similar interfaces and they can be copied easily with @@ -256,7 +238,36 @@ efficient to have e.g. the Dijkstra algorithm to store its result in any kind of path structure. -\sa lemon::concepts::Path +\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" +*/ + +/** +@defgroup matrices Matrices +@ingroup datas +\brief Two dimensional data storages implemented in LEMON. + +This group contains two dimensional data storages implemented in LEMON. */ /** @@ -264,16 +275,38 @@ @ingroup datas \brief Auxiliary data structures implemented in LEMON. -This group describes some data structures implemented in LEMON in +This group contains some data structures implemented in LEMON in order to make it easier to implement combinatorial algorithms. */ /** +@defgroup geomdat Geometric Data Structures +@ingroup auxdat +\brief Geometric data structures implemented in LEMON. + +This group contains geometric data structures implemented in LEMON. + + - \ref lemon::dim2::Point "dim2::Point" implements a two dimensional + vector with the usual operations. + - \ref lemon::dim2::Box "dim2::Box" can be used to determine the + rectangular bounding box of a set of \ref lemon::dim2::Point + "dim2::Point"'s. +*/ + +/** +@defgroup 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 describes the several algorithms +\brief This group contains the several algorithms implemented in LEMON. -This group describes the several algorithms +This group contains the several algorithms implemented in LEMON. */ @@ -282,8 +315,9 @@ @ingroup algs \brief Common graph search algorithms. -This group describes the common graph search algorithms, namely -\e breadth-first \e search (BFS) and \e depth-first \e search (DFS). +This group contains the common graph search algorithms, namely +\e breadth-first \e search (BFS) and \e depth-first \e search (DFS) +\ref clrs01algorithms. */ /** @@ -291,7 +325,8 @@ @ingroup algs \brief Algorithms for finding shortest paths. -This group describes the algorithms for finding shortest paths in digraphs. +This group contains the algorithms for finding shortest paths in digraphs +\ref clrs01algorithms. - \ref Dijkstra algorithm for finding shortest paths from a source node when all arc lengths are non-negative. @@ -308,72 +343,83 @@ */ /** +@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 \brief Algorithms for finding maximum flows. -This group describes the algorithms for finding maximum flows and -feasible circulations. +This group contains the algorithms for finding maximum flows and +feasible circulations \ref clrs01algorithms, \ref amo93networkflows. The \e maximum \e flow \e problem is to find a flow of maximum value between a single source and a single target. Formally, there is a \f$G=(V,A)\f$ -digraph, a \f$cap:A\rightarrow\mathbf{R}^+_0\f$ capacity function and +digraph, a \f$cap: A\rightarrow\mathbf{R}^+_0\f$ capacity function and \f$s, t \in V\f$ source and target nodes. -A maximum flow is an \f$f:A\rightarrow\mathbf{R}^+_0\f$ solution of the +A maximum flow is an \f$f: A\rightarrow\mathbf{R}^+_0\f$ solution of the following optimization problem. -\f[ \max\sum_{a\in\delta_{out}(s)}f(a) - \sum_{a\in\delta_{in}(s)}f(a) \f] -\f[ \sum_{a\in\delta_{out}(v)} f(a) = \sum_{a\in\delta_{in}(v)} f(a) - \qquad \forall v\in V\setminus\{s,t\} \f] -\f[ 0 \leq f(a) \leq cap(a) \qquad \forall a\in A \f] +\f[ \max\sum_{sv\in A} f(sv) - \sum_{vs\in A} f(vs) \f] +\f[ \sum_{uv\in A} f(uv) = \sum_{vu\in A} f(vu) + \quad \forall u\in V\setminus\{s,t\} \f] +\f[ 0 \leq f(uv) \leq cap(uv) \quad \forall uv\in A \f] LEMON contains several algorithms for solving maximum flow problems: -- \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. +- \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 "Preflow" algorithm provides the +In most cases the \ref Preflow algorithm provides the fastest method for computing a maximum flow. All implementations -provides functions to also query the minimum cut, which is the dual -problem of the maximum flow. +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 +for finding feasible circulations, which is a somewhat different problem, +but it is strongly related to maximum flow. +For more information, see \ref Circulation. */ /** -@defgroup min_cost_flow Minimum Cost Flow Algorithms +@defgroup min_cost_flow_algs Minimum Cost Flow Algorithms @ingroup algs \brief Algorithms for finding minimum cost flows and circulations. -This group describes the algorithms for finding minimum cost flows and -circulations. +This group contains the algorithms for finding minimum cost flows and +circulations \ref amo93networkflows. For more information about this +problem and its dual solution, see \ref min_cost_flow +"Minimum Cost Flow Problem". -The \e minimum \e cost \e flow \e problem is to find a feasible flow of -minimum total cost from a set of supply nodes to a set of demand nodes -in a network with capacity constraints and arc costs. -Formally, let \f$G=(V,A)\f$ be a digraph, -\f$lower, upper: A\rightarrow\mathbf{Z}^+_0\f$ denote the lower and -upper bounds for the flow values on the arcs, -\f$cost: A\rightarrow\mathbf{Z}^+_0\f$ denotes the cost per unit flow -on the arcs, and -\f$supply: V\rightarrow\mathbf{Z}\f$ denotes the supply/demand values -of the nodes. -A minimum cost flow is an \f$f:A\rightarrow\mathbf{R}^+_0\f$ solution of -the following optimization problem. +LEMON contains several algorithms for this problem. + - \ref NetworkSimplex Primal Network Simplex algorithm with various + pivot strategies \ref dantzig63linearprog, \ref kellyoneill91netsimplex. + - \ref CostScaling Push-Relabel and Augment-Relabel algorithms based on + cost scaling \ref goldberg90approximation, \ref goldberg97efficient, + \ref bunnagel98efficient. + - \ref CapacityScaling Successive Shortest %Path algorithm with optional + capacity scaling \ref edmondskarp72theoretical. + - \ref CancelAndTighten The Cancel and Tighten algorithm + \ref goldberg89cyclecanceling. + - \ref CycleCanceling Cycle-Canceling algorithms + \ref klein67primal, \ref goldberg89cyclecanceling. -\f[ \min\sum_{a\in A} f(a) cost(a) \f] -\f[ \sum_{a\in\delta_{out}(v)} f(a) - \sum_{a\in\delta_{in}(v)} f(a) = - supply(v) \qquad \forall v\in V \f] -\f[ lower(a) \leq f(a) \leq upper(a) \qquad \forall a\in A \f] - -LEMON contains several algorithms for solving minimum cost flow problems: - - \ref CycleCanceling Cycle-canceling algorithms. - - \ref CapacityScaling Successive shortest path algorithm with optional - capacity scaling. - - \ref CostScaling Push-relabel and augment-relabel algorithms based on - cost scaling. - - \ref NetworkSimplex Primal network simplex algorithm with various - pivot strategies. +In general NetworkSimplex is the most efficient implementation, +but in special cases other algorithms could be faster. +For example, if the total supply and/or capacities are rather small, +CapacityScaling is usually the fastest algorithm (without effective scaling). */ /** @@ -382,7 +428,7 @@ \brief Algorithms for finding minimum cut in graphs. -This group describes the algorithms for finding minimum cut in graphs. +This group contains the algorithms for finding minimum cut in graphs. The \e minimum \e cut \e problem is to find a non-empty and non-complete \f$X\f$ subset of the nodes with minimum overall capacity on @@ -391,7 +437,7 @@ cut is the \f$X\f$ solution of the next optimization problem: \f[ \min_{X \subset V, X\not\in \{\emptyset, V\}} - \sum_{uv\in A, u\in X, v\not\in X}cap(uv) \f] + \sum_{uv\in A: u\in X, v\not\in X}cap(uv) \f] LEMON contains several algorithms related to minimum cut problems: @@ -399,7 +445,7 @@ in directed graphs. - \ref NagamochiIbaraki "Nagamochi-Ibaraki algorithm" for calculating minimum cut in undirected graphs. -- \ref GomoryHuTree "Gomory-Hu tree computation" for calculating +- \ref GomoryHu "Gomory-Hu tree computation" for calculating all-pairs minimum cut in undirected graphs. If you want to find minimum cut just between two distinict nodes, @@ -407,27 +453,40 @@ */ /** -@defgroup graph_prop Connectivity and Other Graph Properties +@defgroup min_mean_cycle Minimum Mean Cycle Algorithms @ingroup algs -\brief Algorithms for discovering the graph properties +\brief Algorithms for finding minimum mean cycles. -This group describes the algorithms for discovering the graph properties -like connectivity, bipartiteness, euler property, simplicity etc. +This group contains the algorithms for finding minimum mean cycles +\ref clrs01algorithms, \ref amo93networkflows. -\image html edge_biconnected_components.png -\image latex edge_biconnected_components.eps "bi-edge-connected components" width=\textwidth -*/ +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. -/** -@defgroup planar Planarity Embedding and Drawing -@ingroup algs -\brief Algorithms for planarity checking, embedding and drawing +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. -This group describes the algorithms for planarity checking, -embedding and drawing. +LEMON contains three algorithms for solving the minimum mean cycle problem: +- \ref Karp "Karp"'s original algorithm \ref amo93networkflows, + \ref dasdan98minmeancycle. +- \ref HartmannOrlin "Hartmann-Orlin"'s algorithm, which is an improved + version of Karp's algorithm \ref dasdan98minmeancycle. +- \ref Howard "Howard"'s policy iteration algorithm + \ref dasdan98minmeancycle. -\image html planar.png -\image latex planar.eps "Plane graph" width=\textwidth +In practice, the Howard algorithm proved to be by far the most efficient +one, though the best known theoretical bound on its running time is +exponential. +Both Karp and HartmannOrlin algorithms run in time O(ne) and use space +O(n2+e), but the latter one is typically faster due to the +applied early termination scheme. */ /** @@ -435,9 +494,10 @@ @ingroup algs \brief Algorithms for finding matchings in graphs and bipartite graphs. -This group contains algorithm objects and functions to calculate +This group contains the algorithms for calculating matchings in graphs and bipartite graphs. The general matching problem is -finding a subset of the arcs which does not shares common endpoints. +finding a subset of the edges for which each node has at most one incident +edge. There are several different algorithms for calculate matchings in graphs. The matching problems in bipartite graphs are generally @@ -470,12 +530,36 @@ */ /** -@defgroup spantree Minimum Spanning Tree Algorithms +@defgroup graph_properties Connectivity and Other Graph Properties @ingroup algs -\brief Algorithms for finding a minimum cost spanning tree in a graph. +\brief Algorithms for discovering the graph properties -This group describes the algorithms for finding a minimum cost spanning -tree in a graph. +This group contains the algorithms for discovering the graph properties +like connectivity, bipartiteness, euler property, simplicity etc. + +\image html connected_components.png +\image latex connected_components.eps "Connected components" width=\textwidth +*/ + +/** +@defgroup planar Planarity Embedding and Drawing +@ingroup algs +\brief Algorithms for planarity checking, embedding and drawing + +This group contains the algorithms for planarity checking, +embedding and drawing. + +\image html planar.png +\image latex planar.eps "Plane graph" width=\textwidth +*/ + +/** +@defgroup approx Approximation Algorithms +@ingroup algs +\brief Approximation algorithms. + +This group contains the approximation and heuristic algorithms +implemented in LEMON. */ /** @@ -483,36 +567,30 @@ @ingroup algs \brief Auxiliary algorithms implemented in LEMON. -This group describes some 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. +@defgroup gen_opt_group General Optimization Tools +\brief This group contains some general optimization frameworks +implemented in LEMON. -This group describes the approximation and heuristic algorithms +This group contains some general optimization frameworks implemented in LEMON. */ /** -@defgroup gen_opt_group General Optimization Tools -\brief This group describes some general optimization frameworks -implemented in LEMON. +@defgroup lp_group LP and MIP Solvers +@ingroup gen_opt_group +\brief LP and MIP solver interfaces for LEMON. -This group describes some general optimization frameworks -implemented in 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. -/** -@defgroup lp_group Lp and Mip Solvers -@ingroup gen_opt_group -\brief Lp and Mip solver interfaces for LEMON. - -This group describes Lp and Mip solver interfaces for LEMON. The -various LP solvers could be used in the same manner with this -interface. +The currently supported solvers are \ref glpk, \ref clp, \ref cbc, +\ref cplex, \ref soplex. */ /** @@ -529,7 +607,7 @@ @ingroup gen_opt_group \brief Metaheuristics for LEMON library. -This group describes some metaheuristic optimization tools. +This group contains some metaheuristic optimization tools. */ /** @@ -544,7 +622,7 @@ @ingroup utils \brief Simple basic graph utilities. -This group describes some simple basic graph utilities. +This group contains some simple basic graph utilities. */ /** @@ -552,7 +630,7 @@ @ingroup utils \brief Tools for development, debugging and testing. -This group describes several useful tools for development, +This group contains several useful tools for development, debugging and testing. */ @@ -561,7 +639,7 @@ @ingroup misc \brief Simple tools for measuring the performance of algorithms. -This group describes simple tools for measuring the performance +This group contains simple tools for measuring the performance of algorithms. */ @@ -570,14 +648,14 @@ @ingroup utils \brief Exceptions defined in LEMON. -This group describes the exceptions defined in LEMON. +This group contains the exceptions defined in LEMON. */ /** @defgroup io_group Input-Output \brief Graph Input-Output methods -This group describes the tools for importing and exporting graphs +This group contains the tools for importing and exporting graphs and graph related data. Now it supports the \ref lgf-format "LEMON Graph Format", the \c DIMACS format and the encapsulated postscript (EPS) format. @@ -588,7 +666,7 @@ @ingroup io_group \brief Reading and writing LEMON Graph Format. -This group describes methods for reading and writing +This group contains methods for reading and writing \ref lgf-format "LEMON Graph Format". */ @@ -597,12 +675,12 @@ @ingroup io_group \brief General \c EPS drawer and graph exporter -This group describes general \c EPS drawing methods and special +This group contains general \c EPS drawing methods and special graph exporting tools. */ /** -@defgroup dimacs_group DIMACS format +@defgroup dimacs_group DIMACS Format @ingroup io_group \brief Read and write files in DIMACS format @@ -621,7 +699,7 @@ @defgroup concept Concepts \brief Skeleton classes and concept checking classes -This group describes the data/algorithm skeletons and concept checking +This group contains the data/algorithm skeletons and concept checking classes implemented in LEMON. The purpose of the classes in this group is fourfold. @@ -651,8 +729,8 @@ @ingroup concept \brief Skeleton and concept checking classes for graph structures -This group describes the skeletons and concept checking classes of LEMON's -graph structures and helper classes used to implement these. +This group contains the skeletons and concept checking classes of +graph structures. */ /** @@ -660,19 +738,7 @@ @ingroup concept \brief Skeleton and concept checking classes for maps -This group describes the skeletons and concept checking classes of maps. -*/ - -/** -\anchor demoprograms - -@defgroup demos Demo Programs - -Some demo programs are listed here. Their full source codes can be found in -the \c demo subdirectory of the source tree. - -It order to compile them, use --enable-demo configure option when -build the library. +This group contains the skeletons and concept checking classes of maps. */ /** @@ -684,4 +750,16 @@ them, as well. */ +/** +\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. +*/ + } diff -r c35afa9e89e7 -r ef88c0a30f85 doc/images/bipartite_matching.eps --- /dev/null Thu Jan 01 00:00:00 1970 +0000 +++ b/doc/images/bipartite_matching.eps Thu Nov 05 15:48:01 2009 +0100 @@ -0,0 +1,586 @@ +%!PS-Adobe-3.0 EPSF-3.0 +%%BoundingBox: 15 18 829 570 +%%HiResBoundingBox: 15.1913 18.4493 828.078 569.438 +%%Creator: Karbon14 EPS Exportfilter 0.5 +%%CreationDate: (04/15/06 15:20:26) +%%For: (Balazs Dezso) () +%%Title: () + +/N {newpath} def +/C {closepath} def +/m {moveto} def +/c {curveto} def +/l {lineto} def +/s {stroke} def +/f {fill} def +/w {setlinewidth} def +/d {setdash} def +/r {setrgbcolor} def +/S {gsave} def +/R {grestore} def + +N +251.402 32.047 m +532.945 293.946 814.484 555.844 814.484 555.844 c +[] 0 d 1 0 0 r 3.92814 w s + +N +749.012 32.047 m +742.465 293.946 735.918 555.844 735.918 555.844 c +[] 0 d 0 0 0 r 1.96407 w s + +N +539.492 32.047 m +637.703 293.946 735.918 555.844 735.918 555.844 c +[] 0 d 0 0 0 r 1.96407 w s + +N +172.832 32.047 m +454.375 293.946 735.918 555.844 735.918 555.844 c +[] 0 d 0 0 0 r 1.96407 w s + +N +107.355 32.047 m +421.637 293.946 735.918 555.844 735.918 555.844 c +[] 0 d 1 0 0 r 3.92814 w s + +N +644.25 555.844 m +696.633 293.946 749.012 32.047 749.012 32.047 c +[] 0 d 0 0 0 r 1.96407 w s + +N +474.016 555.844 m +611.516 293.946 749.012 32.047 749.012 32.047 c +[] 0 d 1 0 0 r 3.92814 w s + +N +683.535 32.047 m +663.894 293.946 644.25 555.844 644.25 555.844 c +[] 0 d 0 0 0 r 1.96407 w s + +N +120.453 555.844 m +401.992 293.946 683.535 32.047 683.535 32.047 c +[] 0 d 0 0 0 r 1.96407 w s + +N +28.7853 555.844 m +356.16 293.946 683.535 32.047 683.535 32.047 c +[] 0 d 1 0 0 r 3.92814 w s + +N +539.492 32.047 m +546.039 293.946 552.586 555.844 552.586 555.844 c +[] 0 d 1 0 0 r 3.92814 w s + +N +316.875 32.047 m +349.613 293.946 382.351 555.844 382.351 555.844 c +[] 0 d 1 0 0 r 3.92814 w s + +N +107.355 32.047 m +244.855 293.946 382.351 555.844 382.351 555.844 c +[] 0 d 0 0 0 r 1.96407 w s + +N +290.687 555.844 m +375.805 293.946 460.922 32.047 460.922 32.047 c +[] 0 d 1 0 0 r 3.92814 w s + +N +120.453 555.844 m +290.687 293.946 460.922 32.047 460.922 32.047 c +[] 0 d 0 0 0 r 1.96407 w s + +N +172.832 32.047 m +146.64 293.946 120.453 555.844 120.453 555.844 c +[] 0 d 1 0 0 r 3.92814 w s + +N +15.6913 555.844 m +15.6913 555.844 l +15.6913 548.614 21.5553 542.75 28.7853 542.75 c +36.0163 542.75 41.8833 548.614 41.8833 555.844 c +41.8833 563.075 36.0163 568.938 28.7853 568.938 c +21.5553 568.938 15.6913 563.075 15.6913 555.844 c +15.6913 555.844 l +C +S 0 0 0 r f R + +N +16.8833 555.844 m +16.8833 555.844 l +16.8833 549.27 22.2113 543.942 28.7853 543.942 c +35.3593 543.942 40.6913 549.27 40.6913 555.844 c +40.6913 562.418 35.3593 567.747 28.7853 567.747 c +22.2113 567.747 16.8833 562.418 16.8833 555.844 c +16.8833 555.844 l +C +S 1 0.5 1 r f R + +N +107.355 555.844 m +107.355 555.844 l +107.355 548.614 113.223 542.75 120.453 542.75 c +127.683 542.75 133.547 548.614 133.547 555.844 c +133.547 563.075 127.683 568.938 120.453 568.938 c +113.223 568.938 107.355 563.075 107.355 555.844 c +107.355 555.844 l +C +S 0 0 0 r f R + +N +108.547 555.844 m +108.547 555.844 l +108.547 549.27 113.879 543.942 120.453 543.942 c +127.027 543.942 132.355 549.27 132.355 555.844 c +132.355 562.418 127.027 567.747 120.453 567.747 c +113.879 567.747 108.547 562.418 108.547 555.844 c +108.547 555.844 l +C +S 1 0 1 r f R + +N +199.019 555.844 m +199.019 555.844 l +199.019 548.614 204.887 542.75 212.117 542.75 c +219.348 542.75 225.211 548.614 225.211 555.844 c +225.211 563.075 219.348 568.938 212.117 568.938 c +204.887 568.938 199.019 563.075 199.019 555.844 c +199.019 555.844 l +C +S 0 0 0 r f R + +N +200.211 555.844 m +200.211 555.844 l +200.211 549.27 205.543 543.942 212.117 543.942 c +218.691 543.942 224.019 549.27 224.019 555.844 c +224.019 562.418 218.691 567.747 212.117 567.747 c +205.543 567.747 200.211 562.418 200.211 555.844 c +200.211 555.844 l +C +S 1 0.5 1 r f R + +N +277.59 555.844 m +277.59 555.844 l +277.59 548.614 283.457 542.75 290.687 542.75 c +297.918 542.75 303.781 548.614 303.781 555.844 c +303.781 563.075 297.918 568.938 290.687 568.938 c +283.457 568.938 277.59 563.075 277.59 555.844 c +277.59 555.844 l +C +S 0 0 0 r f R + +N +278.781 555.844 m +278.781 555.844 l +278.781 549.27 284.113 543.942 290.687 543.942 c +297.262 543.942 302.59 549.27 302.59 555.844 c +302.59 562.418 297.262 567.747 290.687 567.747 c +284.113 567.747 278.781 562.418 278.781 555.844 c +278.781 555.844 l +C +S 1 0 1 r f R + +N +369.258 555.844 m +369.258 555.844 l +369.258 548.614 375.121 542.75 382.351 542.75 c +389.582 542.75 395.445 548.614 395.445 555.844 c +395.445 563.075 389.582 568.938 382.351 568.938 c +375.121 568.938 369.258 563.075 369.258 555.844 c +369.258 555.844 l +C +S 0 0 0 r f R + +N +370.445 555.844 m +370.445 555.844 l +370.445 549.27 375.777 543.942 382.351 543.942 c +388.926 543.942 394.258 549.27 394.258 555.844 c +394.258 562.418 388.926 567.747 382.351 567.747 c +375.777 567.747 370.445 562.418 370.445 555.844 c +370.445 555.844 l +C +S 1 0 1 r f R + +N +460.922 555.844 m +460.922 555.844 l +460.922 548.614 466.785 542.75 474.016 542.75 c +481.246 542.75 487.109 548.614 487.109 555.844 c +487.109 563.075 481.246 568.938 474.016 568.938 c +466.785 568.938 460.922 563.075 460.922 555.844 c +460.922 555.844 l +C +S 0 0 0 r f R + +N +462.113 555.844 m +462.113 555.844 l +462.113 549.27 467.441 543.942 474.016 543.942 c +480.59 543.942 485.922 549.27 485.922 555.844 c +485.922 562.418 480.59 567.747 474.016 567.747 c +467.441 567.747 462.113 562.418 462.113 555.844 c +462.113 555.844 l +C +S 1 0.5 1 r f R + +N +539.492 555.844 m +539.492 555.844 l +539.492 548.614 545.355 542.75 552.586 542.75 c +559.816 542.75 565.68 548.614 565.68 555.844 c +565.68 563.075 559.816 568.938 552.586 568.938 c +545.355 568.938 539.492 563.075 539.492 555.844 c +539.492 555.844 l +C +S 0 0 0 r f R + +N +540.683 555.844 m +540.683 555.844 l +540.683 549.27 546.012 543.942 552.586 543.942 c +559.16 543.942 564.492 549.27 564.492 555.844 c +564.492 562.418 559.16 567.747 552.586 567.747 c +546.012 567.747 540.683 562.418 540.683 555.844 c +540.683 555.844 l +C +S 1 0 1 r f R + +N +631.156 555.844 m +631.156 555.844 l +631.156 548.614 637.019 542.75 644.25 542.75 c +651.48 542.75 657.348 548.614 657.348 555.844 c +657.348 563.075 651.48 568.938 644.25 568.938 c +637.019 568.938 631.156 563.075 631.156 555.844 c +631.156 555.844 l +C +S 0 0 0 r f R + +N +632.348 555.844 m +632.348 555.844 l +632.348 549.27 637.676 543.942 644.25 543.942 c +650.824 543.942 656.156 549.27 656.156 555.844 c +656.156 562.418 650.824 567.747 644.25 567.747 c +637.676 567.747 632.348 562.418 632.348 555.844 c +632.348 555.844 l +C +S 1 0.5 1 r f R + +N +722.82 555.844 m +722.82 555.844 l +722.82 548.614 728.687 542.75 735.918 542.75 c +743.149 542.75 749.012 548.614 749.012 555.844 c +749.012 563.075 743.149 568.938 735.918 568.938 c +728.687 568.938 722.82 563.075 722.82 555.844 c +722.82 555.844 l +C +S 0 0 0 r f R + +N +724.012 555.844 m +724.012 555.844 l +724.012 549.27 729.344 543.942 735.918 543.942 c +742.492 543.942 747.82 549.27 747.82 555.844 c +747.82 562.418 742.492 567.747 735.918 567.747 c +729.344 567.747 724.012 562.418 724.012 555.844 c +724.012 555.844 l +C +S 1 0 1 r f R + +N +801.391 555.844 m +801.391 555.844 l +801.391 548.614 807.254 542.75 814.484 542.75 c +821.715 542.75 827.578 548.614 827.578 555.844 c +827.578 563.075 821.715 568.938 814.484 568.938 c +807.254 568.938 801.391 563.075 801.391 555.844 c +801.391 555.844 l +C +S 0 0 0 r f R + +N +802.582 555.844 m +802.582 555.844 l +802.582 549.27 807.91 543.942 814.484 543.942 c +821.059 543.942 826.387 549.27 826.387 555.844 c +826.387 562.418 821.059 567.747 814.484 567.747 c +807.91 567.747 802.582 562.418 802.582 555.844 c +802.582 555.844 l +C +S 1 0 1 r f R + +N +15.6913 32.047 m +15.6913 32.047 l +15.6913 24.8165 21.5553 18.9493 28.7853 18.9493 c +36.0163 18.9493 41.8833 24.8165 41.8833 32.047 c +41.8833 39.2775 36.0163 45.1407 28.7853 45.1407 c +21.5553 45.1407 15.6913 39.2775 15.6913 32.047 c +15.6913 32.047 l +C +S 0 0 0 r f R + +N +16.8833 32.047 m +16.8833 32.047 l +16.8833 25.4728 22.2113 20.1407 28.7853 20.1407 c +35.3593 20.1407 40.6913 25.4728 40.6913 32.047 c +40.6913 38.6212 35.3593 43.9493 28.7853 43.9493 c +22.2113 43.9493 16.8833 38.6212 16.8833 32.047 c +16.8833 32.047 l +C +S 0.5 0.5 1 r f R + +N +94.2623 32.047 m +94.2623 32.047 l +94.2623 24.8165 100.125 18.9493 107.355 18.9493 c +114.586 18.9493 120.453 24.8165 120.453 32.047 c +120.453 39.2775 114.586 45.1407 107.355 45.1407 c +100.125 45.1407 94.2623 39.2775 94.2623 32.047 c +94.2623 32.047 l +C +S 0 0 0 r f R + +N +95.4533 32.047 m +95.4533 32.047 l +95.4533 25.4728 100.781 20.1407 107.355 20.1407 c +113.93 20.1407 119.262 25.4728 119.262 32.047 c +119.262 38.6212 113.93 43.9493 107.355 43.9493 c +100.781 43.9493 95.4533 38.6212 95.4533 32.047 c +95.4533 32.047 l +C +S 0.5 0.5 1 r f R + +N +159.734 32.047 m +159.734 32.047 l +159.734 24.8165 165.601 18.9493 172.832 18.9493 c +180.062 18.9493 185.926 24.8165 185.926 32.047 c +185.926 39.2775 180.062 45.1407 172.832 45.1407 c +165.601 45.1407 159.734 39.2775 159.734 32.047 c +159.734 32.047 l +C +S 0 0 0 r f R + +N +160.926 32.047 m +160.926 32.047 l +160.926 25.4728 166.258 20.1407 172.832 20.1407 c +179.406 20.1407 184.734 25.4728 184.734 32.047 c +184.734 38.6212 179.406 43.9493 172.832 43.9493 c +166.258 43.9493 160.926 38.6212 160.926 32.047 c +160.926 32.047 l +C +S 0.5 0.5 1 r f R + +N +238.305 32.047 m +238.305 32.047 l +238.305 24.8165 244.172 18.9493 251.402 18.9493 c +258.633 18.9493 264.496 24.8165 264.496 32.047 c +264.496 39.2775 258.633 45.1407 251.402 45.1407 c +244.172 45.1407 238.305 39.2775 238.305 32.047 c +238.305 32.047 l +C +S 0 0 0 r f R + +N +239.496 32.047 m +239.496 32.047 l +239.496 25.4728 244.828 20.1407 251.402 20.1407 c +257.976 20.1407 263.305 25.4728 263.305 32.047 c +263.305 38.6212 257.976 43.9493 251.402 43.9493 c +244.828 43.9493 239.496 38.6212 239.496 32.047 c +239.496 32.047 l +C +S 0.5 0.5 1 r f R + +N +303.781 32.047 m +303.781 32.047 l +303.781 24.8165 309.644 18.9493 316.875 18.9493 c +324.105 18.9493 329.973 24.8165 329.973 32.047 c +329.973 39.2775 324.105 45.1407 316.875 45.1407 c +309.644 45.1407 303.781 39.2775 303.781 32.047 c +303.781 32.047 l +C +S 0 0 0 r f R + +N +304.973 32.047 m +304.973 32.047 l +304.973 25.4728 310.301 20.1407 316.875 20.1407 c +323.449 20.1407 328.781 25.4728 328.781 32.047 c +328.781 38.6212 323.449 43.9493 316.875 43.9493 c +310.301 43.9493 304.973 38.6212 304.973 32.047 c +304.973 32.047 l +C +S 0.5 0.5 1 r f R + +N +382.351 32.047 m +382.351 32.047 l +382.351 24.8165 388.215 18.9493 395.445 18.9493 c +402.676 18.9493 408.543 24.8165 408.543 32.047 c +408.543 39.2775 402.676 45.1407 395.445 45.1407 c +388.215 45.1407 382.351 39.2775 382.351 32.047 c +382.351 32.047 l +C +S 0 0 0 r f R + +N +383.543 32.047 m +383.543 32.047 l +383.543 25.4728 388.871 20.1407 395.445 20.1407 c +402.019 20.1407 407.351 25.4728 407.351 32.047 c +407.351 38.6212 402.019 43.9493 395.445 43.9493 c +388.871 43.9493 383.543 38.6212 383.543 32.047 c +383.543 32.047 l +C +S 0.5 0.5 1 r f R + +N +447.828 32.047 m +447.828 32.047 l +447.828 24.8165 453.691 18.9493 460.922 18.9493 c +468.152 18.9493 474.016 24.8165 474.016 32.047 c +474.016 39.2775 468.152 45.1407 460.922 45.1407 c +453.691 45.1407 447.828 39.2775 447.828 32.047 c +447.828 32.047 l +C +S 0 0 0 r f R + +N +449.016 32.047 m +449.016 32.047 l +449.016 25.4728 454.348 20.1407 460.922 20.1407 c +467.496 20.1407 472.824 25.4728 472.824 32.047 c +472.824 38.6212 467.496 43.9493 460.922 43.9493 c +454.348 43.9493 449.016 38.6212 449.016 32.047 c +449.016 32.047 l +C +S 0.5 0.5 1 r f R + +N +526.394 32.047 m +526.394 32.047 l +526.394 24.8165 532.262 18.9493 539.492 18.9493 c +546.723 18.9493 552.586 24.8165 552.586 32.047 c +552.586 39.2775 546.723 45.1407 539.492 45.1407 c +532.262 45.1407 526.394 39.2775 526.394 32.047 c +526.394 32.047 l +C +S 0 0 0 r f R + +N +527.586 32.047 m +527.586 32.047 l +527.586 25.4728 532.918 20.1407 539.492 20.1407 c +546.066 20.1407 551.394 25.4728 551.394 32.047 c +551.394 38.6212 546.066 43.9493 539.492 43.9493 c +532.918 43.9493 527.586 38.6212 527.586 32.047 c +527.586 32.047 l +C +S 0.5 0.5 1 r f R + +N +591.871 32.047 m +591.871 32.047 l +591.871 24.8165 597.734 18.9493 604.965 18.9493 c +612.195 18.9493 618.062 24.8165 618.062 32.047 c +618.062 39.2775 612.195 45.1407 604.965 45.1407 c +597.734 45.1407 591.871 39.2775 591.871 32.047 c +591.871 32.047 l +C +S 0 0 0 r f R + +N +593.062 32.047 m +593.062 32.047 l +593.062 25.4728 598.39 20.1407 604.965 20.1407 c +611.539 20.1407 616.871 25.4728 616.871 32.047 c +616.871 38.6212 611.539 43.9493 604.965 43.9493 c +598.39 43.9493 593.062 38.6212 593.062 32.047 c +593.062 32.047 l +C +S 0.5 0.5 1 r f R + +N +670.441 32.047 m +670.441 32.047 l +670.441 24.8165 676.305 18.9493 683.535 18.9493 c +690.766 18.9493 696.633 24.8165 696.633 32.047 c +696.633 39.2775 690.766 45.1407 683.535 45.1407 c +676.305 45.1407 670.441 39.2775 670.441 32.047 c +670.441 32.047 l +C +S 0 0 0 r f R + +N +671.633 32.047 m +671.633 32.047 l +671.633 25.4728 676.961 20.1407 683.535 20.1407 c +690.109 20.1407 695.441 25.4728 695.441 32.047 c +695.441 38.6212 690.109 43.9493 683.535 43.9493 c +676.961 43.9493 671.633 38.6212 671.633 32.047 c +671.633 32.047 l +C +S 0 0 1 r f R + +N +735.918 32.047 m +735.918 32.047 l +735.918 24.8165 741.781 18.9493 749.012 18.9493 c +756.242 18.9493 762.106 24.8165 762.106 32.047 c +762.106 39.2775 756.242 45.1407 749.012 45.1407 c +741.781 45.1407 735.918 39.2775 735.918 32.047 c +735.918 32.047 l +C +S 0 0 0 r f R + +N +737.105 32.047 m +737.105 32.047 l +737.105 25.4728 742.437 20.1407 749.012 20.1407 c +755.586 20.1407 760.914 25.4728 760.914 32.047 c +760.914 38.6212 755.586 43.9493 749.012 43.9493 c +742.437 43.9493 737.105 38.6212 737.105 32.047 c +737.105 32.047 l +C +S 0 0 1 r f R + +N +801.391 32.047 m +801.391 32.047 l +801.391 24.8165 807.254 18.9493 814.484 18.9493 c +821.715 18.9493 827.578 24.8165 827.578 32.047 c +827.578 39.2775 821.715 45.1407 814.484 45.1407 c +807.254 45.1407 801.391 39.2775 801.391 32.047 c +801.391 32.047 l +C +S 0 0 0 r f R + +N +802.582 32.047 m +802.582 32.047 l +802.582 25.4728 807.91 20.1407 814.484 20.1407 c +821.059 20.1407 826.387 25.4728 826.387 32.047 c +826.387 38.6212 821.059 43.9493 814.484 43.9493 c +807.91 43.9493 802.582 38.6212 802.582 32.047 c +802.582 32.047 l +C +S 0.5 0.5 1 r f R + +%%EOF diff -r c35afa9e89e7 -r ef88c0a30f85 doc/images/bipartite_partitions.eps --- /dev/null Thu Jan 01 00:00:00 1970 +0000 +++ b/doc/images/bipartite_partitions.eps Thu Nov 05 15:48:01 2009 +0100 @@ -0,0 +1,114 @@ +%!PS-Adobe-2.0 EPSF-2.0 +%%Creator: LEMON, graphToEps() +%%CreationDate: Tue Nov 15 16:51:43 2005 +%%BoundingBox: 0 0 842 596 +%%EndComments +/lb { setlinewidth setrgbcolor newpath moveto + 4 2 roll 1 index 1 index curveto stroke } bind def +/l { setlinewidth setrgbcolor newpath moveto lineto stroke } bind def +/c { newpath dup 3 index add 2 index moveto 0 360 arc closepath } bind def +/sq { newpath 2 index 1 index add 2 index 2 index add moveto + 2 index 1 index sub 2 index 2 index add lineto + 2 index 1 index sub 2 index 2 index sub lineto + 2 index 1 index add 2 index 2 index sub lineto + closepath pop pop pop} bind def +/di { newpath 2 index 1 index add 2 index moveto + 2 index 2 index 2 index add lineto + 2 index 1 index sub 2 index lineto + 2 index 2 index 2 index sub lineto + closepath pop pop pop} bind def +/nc { 0 0 0 setrgbcolor 5 index 5 index 5 index c fill + setrgbcolor 1.1 div c fill + } bind def +/nsq { 0 0 0 setrgbcolor 5 index 5 index 5 index sq fill + setrgbcolor 1.1 div sq fill + } bind def +/ndi { 0 0 0 setrgbcolor 5 index 5 index 5 index di fill + setrgbcolor 1.1 div di fill + } bind def +/arrl 1 def +/arrw 0.3 def +/lrl { 2 index mul exch 2 index mul exch rlineto pop} bind def +/arr { setrgbcolor /y1 exch def /x1 exch def /dy exch def /dx exch def + /w exch def /len exch def + newpath x1 dy w 2 div mul add y1 dx w 2 div mul sub moveto + len w sub arrl sub dx dy lrl + arrw dy dx neg lrl + dx arrl w add mul dy w 2 div arrw add mul sub + dy arrl w add mul dx w 2 div arrw add mul add rlineto + dx arrl w add mul neg dy w 2 div arrw add mul sub + dy arrl w add mul neg dx w 2 div arrw add mul add rlineto + arrw dy dx neg lrl + len w sub arrl sub neg dx dy lrl + closepath fill } bind def +/cshow { 2 index 2 index moveto dup stringwidth pop + neg 2 div fosi .35 mul neg rmoveto show pop pop} def + +gsave +90 rotate +0 -842 translate +71.6378 15 translate +0.389093 dup scale +90 rotate +1197.47 -613.138 translate +%Edges: +gsave +513.857 -446.322 296.569 -487.43 79.2808 -528.539 0 0 0 2 lb +513.857 -446.322 575.52 -315.655 637.183 -184.989 0 0 0 2 lb +393.468 566.711 494.771 434.577 596.074 302.442 0 0 0 2 lb +393.468 566.711 155.625 579.925 -82.2171 593.138 0 0 0 2 lb +393.468 566.711 251.056 450.726 108.644 334.741 0 0 0 2 lb +869.153 52.8539 732.613 177.648 596.074 302.442 0 0 0 2 lb +869.153 52.8539 753.168 -66.0676 637.183 -184.989 0 0 0 2 lb +-82.2171 593.138 -91.0261 346.487 -99.8351 99.8351 0 0 0 2 lb +-663.61 546.157 -753.168 394.936 -842.726 243.715 0 0 0 2 lb +-663.61 546.157 -574.052 437.513 -484.494 328.869 0 0 0 2 lb +-1077.63 161.498 -960.178 202.606 -842.726 243.715 0 0 0 2 lb +-1077.63 161.498 -968.987 66.0674 -860.344 -29.3633 0 0 0 2 lb +-1177.47 -234.906 -1029.18 -381.722 -880.898 -528.539 0 0 0 2 lb +-1177.47 -234.906 -1018.91 -132.135 -860.344 -29.3633 0 0 0 2 lb +-880.898 -528.539 -744.359 -387.595 -607.82 -246.651 0 0 0 2 lb +-499.175 -499.175 -355.295 -475.685 -211.415 -452.194 0 0 0 2 lb +-499.175 -499.175 -553.498 -372.913 -607.82 -246.651 0 0 0 2 lb +-499.175 -499.175 -386.587 -315.087 -274 -131 0 0 0 2 lb +79.2808 -528.539 -66.0671 -490.366 -211.415 -452.194 0 0 0 2 lb +637.183 -184.989 421.363 -253.993 205.543 -322.996 0 0 0 2 lb +205.543 -322.996 162.966 -226.097 120.389 -129.198 0 0 0 2 lb +399.34 88.0898 259.865 -20.5541 120.389 -129.198 0 0 0 2 lb +399.34 88.0898 253.992 211.415 108.644 334.741 0 0 0 2 lb +-842.726 243.715 -471.281 171.775 -99.8351 99.8351 0 0 0 2 lb +-842.726 243.715 -558.363 56.3575 -274 -131 0 0 0 2 lb +-860.344 -29.3633 -734.082 -138.007 -607.82 -246.651 0 0 0 2 lb +-211.415 -452.194 -45.513 -290.696 120.389 -129.198 0 0 0 2 lb +-99.8351 99.8351 4.40445 217.288 108.644 334.741 0 0 0 2 lb +-99.8351 99.8351 -292.165 214.352 -484.494 328.869 0 0 0 2 lb +120.389 -129.198 -76.8055 -130.099 -274 -131 0 0 0 2 lb +grestore +%Nodes: +gsave +-274 -131 20 1 0 0 nc +-607.82 -246.651 20 1 0 0 nc +-484.494 328.869 20 0 0 1 nc +108.644 334.741 20 0 0 1 nc +120.389 -129.198 20 0 0 1 nc +-99.8351 99.8351 20 1 0 0 nc +-211.415 -452.194 20 1 0 0 nc +-860.344 -29.3633 20 0 0 1 nc +-842.726 243.715 20 0 0 1 nc +399.34 88.0898 20 1 0 0 nc +205.543 -322.996 20 1 0 0 nc +637.183 -184.989 20 0 0 1 nc +79.2808 -528.539 20 0 0 1 nc +-499.175 -499.175 20 0 0 1 nc +-880.898 -528.539 20 0 0 1 nc +-1177.47 -234.906 20 1 0 0 nc +-1077.63 161.498 20 1 0 0 nc +-663.61 546.157 20 1 0 0 nc +-82.2171 593.138 20 0 0 1 nc +596.074 302.442 20 0 0 1 nc +869.153 52.8539 20 1 0 0 nc +393.468 566.711 20 1 0 0 nc +513.857 -446.322 20 1 0 0 nc +grestore +grestore +showpage diff -r c35afa9e89e7 -r ef88c0a30f85 doc/images/connected_components.eps --- /dev/null Thu Jan 01 00:00:00 1970 +0000 +++ b/doc/images/connected_components.eps Thu Nov 05 15:48:01 2009 +0100 @@ -0,0 +1,159 @@ +%!PS-Adobe-2.0 EPSF-2.0 +%%Creator: LEMON, graphToEps() +%%CreationDate: Fri Nov 4 13:47:12 2005 +%%BoundingBox: 0 0 842 596 +%%EndComments +/lb { setlinewidth setrgbcolor newpath moveto + 4 2 roll 1 index 1 index curveto stroke } bind def +/l { setlinewidth setrgbcolor newpath moveto lineto stroke } bind def +/c { newpath dup 3 index add 2 index moveto 0 360 arc closepath } bind def +/sq { newpath 2 index 1 index add 2 index 2 index add moveto + 2 index 1 index sub 2 index 2 index add lineto + 2 index 1 index sub 2 index 2 index sub lineto + 2 index 1 index add 2 index 2 index sub lineto + closepath pop pop pop} bind def +/di { newpath 2 index 1 index add 2 index moveto + 2 index 2 index 2 index add lineto + 2 index 1 index sub 2 index lineto + 2 index 2 index 2 index sub lineto + closepath pop pop pop} bind def +/nc { 0 0 0 setrgbcolor 5 index 5 index 5 index c fill + setrgbcolor 1.1 div c fill + } bind def +/nsq { 0 0 0 setrgbcolor 5 index 5 index 5 index sq fill + setrgbcolor 1.1 div sq fill + } bind def +/ndi { 0 0 0 setrgbcolor 5 index 5 index 5 index di fill + setrgbcolor 1.1 div di fill + } bind def +/arrl 1 def +/arrw 0.3 def +/lrl { 2 index mul exch 2 index mul exch rlineto pop} bind def +/arr { setrgbcolor /y1 exch def /x1 exch def /dy exch def /dx exch def + /w exch def /len exch def + newpath x1 dy w 2 div mul add y1 dx w 2 div mul sub moveto + len w sub arrl sub dx dy lrl + arrw dy dx neg lrl + dx arrl w add mul dy w 2 div arrw add mul sub + dy arrl w add mul dx w 2 div arrw add mul add rlineto + dx arrl w add mul neg dy w 2 div arrw add mul sub + dy arrl w add mul neg dx w 2 div arrw add mul add rlineto + arrw dy dx neg lrl + len w sub arrl sub neg dx dy lrl + closepath fill } bind def +/cshow { 2 index 2 index moveto dup stringwidth pop + neg 2 div fosi .35 mul neg rmoveto show pop pop} def + +gsave +90 rotate +0 -842 translate +71.0944 15 translate +0.434694 dup scale +90 rotate +860.856 -588.349 translate +%Edges: +gsave +574.035 177.301 622.149 225.748 670.264 274.195 0 0 0 2 lb +694.579 115.483 682.421 194.839 670.264 274.195 0 0 0 2 lb +280.402 10.3938 246.402 -6.60595 212.403 -23.6057 0 0 0 2 lb +280.402 10.3938 283.493 -18.9695 286.584 -48.3327 0 0 0 2 lb +212.403 -23.6057 249.493 -35.9692 286.584 -48.3327 0 0 0 2 lb +286.584 -48.3327 326.765 -79.2414 366.947 -110.15 0 0 0 2 lb +286.584 -48.3327 278.857 -111.695 271.13 -175.058 0 0 0 2 lb +438.037 -88.514 417.946 -142.604 397.855 -196.694 0 0 0 2 lb +438.037 -88.514 402.492 -99.332 366.947 -110.15 0 0 0 2 lb +397.855 -196.694 382.401 -153.422 366.947 -110.15 0 0 0 2 lb +366.947 -110.15 319.038 -142.604 271.13 -175.058 0 0 0 2 lb +271.13 -175.058 274.221 -213.694 277.311 -252.33 0 0 0 2 lb +271.13 -175.058 238.675 -190.512 206.221 -205.967 0 0 0 2 lb +277.311 -252.33 241.766 -229.149 206.221 -205.967 0 0 0 2 lb +-840.856 -246.718 -804.351 -66.7145 -767.847 113.289 0 0 0 2 lb +-579.033 445.603 -673.44 279.446 -767.847 113.289 0 0 0 2 lb +-579.033 445.603 -524.906 302.104 -470.779 158.605 0 0 0 2 lb +-767.847 113.289 -619.313 135.947 -470.779 158.605 0 0 0 2 lb +906.312 201.403 946.592 42.798 986.873 -115.807 0 0 0 2 lb +906.312 201.403 834.562 91.8901 762.812 -17.6227 0 0 0 2 lb +986.873 -115.807 874.842 -66.7148 762.812 -17.6227 0 0 0 2 lb +-470.779 158.605 -390.218 50.3508 -309.657 -57.9033 0 0 0 2 lb +422.945 521.129 208.955 541.269 -5.03507 561.41 0 0 0 2 lb +422.945 521.129 376.371 417.911 329.797 314.692 0 0 0 2 lb +422.945 521.129 474.554 276.928 526.164 32.7279 0 0 0 2 lb +-5.03507 561.41 -36.5042 440.568 -67.9734 319.727 0 0 0 2 lb +329.797 314.692 130.912 317.209 -67.9734 319.727 0 0 0 2 lb +-67.9734 319.727 229.095 176.227 526.164 32.7279 0 0 0 2 lb +762.812 -17.6227 644.488 7.5526 526.164 32.7279 0 0 0 2 lb +762.812 -17.6227 746.448 -162.381 730.084 -307.139 0 0 0 2 lb +526.164 32.7279 470.779 -128.394 415.393 -289.516 0 0 0 2 lb +730.084 -307.139 572.738 -298.327 415.393 -289.516 0 0 0 2 lb +415.393 -289.516 173.71 -318.468 -67.9734 -347.42 0 0 0 2 lb +-67.9734 -347.42 -188.815 -202.662 -309.657 -57.9033 0 0 0 2 lb +-67.9734 -347.42 -195.758 -390.692 -323.543 -433.964 0 0 0 2 lb +-309.657 -57.9033 -424.775 -160.272 -539.894 -262.64 0 0 0 2 lb +-323.543 -433.964 -431.719 -348.302 -539.894 -262.64 0 0 0 2 lb +-26.6953 -19.9585 44.8558 -96.8093 116.407 -173.66 0 0 0 2 lb +-26.6953 -19.9585 87.2563 9.19185 201.208 38.3422 0 0 0 2 lb +-26.6953 -19.9585 -144.622 43.6422 -262.548 107.243 0 0 0 2 lb +-26.6953 -19.9585 -20.0703 56.8923 -13.4452 133.743 0 0 0 2 lb +116.407 -173.66 158.808 -67.6589 201.208 38.3422 0 0 0 2 lb +-262.548 107.243 -137.997 120.493 -13.4452 133.743 0 0 0 2 lb +-262.548 107.243 -221.472 176.144 -180.397 245.045 0 0 0 2 lb +-13.4452 133.743 -96.9211 189.394 -180.397 245.045 0 0 0 2 lb +-180.397 245.045 -142.256 345.099 -132.697 451.748 0 0 0 2 lb +-180.397 245.045 -170.838 351.694 -132.697 451.748 0 0 0 2 lb +-416.25 345.746 -274.474 398.747 -132.697 451.748 0 0 0 2 lb +-416.25 345.746 -393.725 457.048 -371.2 568.349 0 0 0 2 lb +-132.697 451.748 -251.948 510.048 -371.2 568.349 0 0 0 2 lb +670.264 274.195 629.188 409.347 588.113 544.499 0 0 0 2 lb +670.264 274.195 797.466 341.771 924.667 409.347 0 0 0 2 lb +588.113 544.499 756.39 476.923 924.667 409.347 0 0 0 2 lb +-689.204 -237.261 -614.799 -102.648 -567.302 43.6423 0 0 0 2 lb +-689.204 -237.261 -641.707 -90.9706 -567.302 43.6423 0 0 0 2 lb +grestore +%Nodes: +gsave +-567.302 43.6423 20 0 0 0 nc +-689.204 -237.261 20 0 0 0 nc +924.667 409.347 20 1 0 0 nc +588.113 544.499 20 1 0 0 nc +670.264 274.195 20 1 0 0 nc +-371.2 568.349 20 0 1 0 nc +-132.697 451.748 20 0 1 0 nc +-416.25 345.746 20 0 1 0 nc +-180.397 245.045 20 0 1 0 nc +-13.4452 133.743 20 0 1 0 nc +-262.548 107.243 20 0 1 0 nc +201.208 38.3422 20 0 1 0 nc +116.407 -173.66 20 0 1 0 nc +-26.6953 -19.9585 20 0 1 0 nc +-539.894 -262.64 20 0 0 1 nc +-323.543 -433.964 20 0 0 1 nc +-309.657 -57.9033 20 0 0 1 nc +-67.9734 -347.42 20 0 0 1 nc +415.393 -289.516 20 0 0 1 nc +730.084 -307.139 20 0 0 1 nc +526.164 32.7279 20 0 0 1 nc +762.812 -17.6227 20 0 0 1 nc +-67.9734 319.727 20 0 0 1 nc +329.797 314.692 20 0 0 1 nc +-5.03507 561.41 20 0 0 1 nc +422.945 521.129 20 0 0 1 nc +-470.779 158.605 20 0 0 1 nc +986.873 -115.807 20 0 0 1 nc +906.312 201.403 20 0 0 1 nc +-767.847 113.289 20 0 0 1 nc +-579.033 445.603 20 0 0 1 nc +-840.856 -246.718 20 0 0 1 nc +206.221 -205.967 20 1 1 0 nc +277.311 -252.33 20 1 1 0 nc +271.13 -175.058 20 1 1 0 nc +366.947 -110.15 20 1 1 0 nc +397.855 -196.694 20 1 1 0 nc +438.037 -88.514 20 1 1 0 nc +286.584 -48.3327 20 1 1 0 nc +212.403 -23.6057 20 1 1 0 nc +280.402 10.3938 20 1 1 0 nc +694.579 115.483 20 1 0 0 nc +574.035 177.301 20 1 0 0 nc +grestore +grestore +showpage diff -r c35afa9e89e7 -r ef88c0a30f85 doc/images/edge_biconnected_components.eps --- /dev/null Thu Jan 01 00:00:00 1970 +0000 +++ b/doc/images/edge_biconnected_components.eps Thu Nov 05 15:48:01 2009 +0100 @@ -0,0 +1,159 @@ +%!PS-Adobe-2.0 EPSF-2.0 +%%Creator: LEMON, graphToEps() +%%CreationDate: Fri Nov 4 13:47:12 2005 +%%BoundingBox: 0 0 842 596 +%%EndComments +/lb { setlinewidth setrgbcolor newpath moveto + 4 2 roll 1 index 1 index curveto stroke } bind def +/l { setlinewidth setrgbcolor newpath moveto lineto stroke } bind def +/c { newpath dup 3 index add 2 index moveto 0 360 arc closepath } bind def +/sq { newpath 2 index 1 index add 2 index 2 index add moveto + 2 index 1 index sub 2 index 2 index add lineto + 2 index 1 index sub 2 index 2 index sub lineto + 2 index 1 index add 2 index 2 index sub lineto + closepath pop pop pop} bind def +/di { newpath 2 index 1 index add 2 index moveto + 2 index 2 index 2 index add lineto + 2 index 1 index sub 2 index lineto + 2 index 2 index 2 index sub lineto + closepath pop pop pop} bind def +/nc { 0 0 0 setrgbcolor 5 index 5 index 5 index c fill + setrgbcolor 1.1 div c fill + } bind def +/nsq { 0 0 0 setrgbcolor 5 index 5 index 5 index sq fill + setrgbcolor 1.1 div sq fill + } bind def +/ndi { 0 0 0 setrgbcolor 5 index 5 index 5 index di fill + setrgbcolor 1.1 div di fill + } bind def +/arrl 1 def +/arrw 0.3 def +/lrl { 2 index mul exch 2 index mul exch rlineto pop} bind def +/arr { setrgbcolor /y1 exch def /x1 exch def /dy exch def /dx exch def + /w exch def /len exch def + newpath x1 dy w 2 div mul add y1 dx w 2 div mul sub moveto + len w sub arrl sub dx dy lrl + arrw dy dx neg lrl + dx arrl w add mul dy w 2 div arrw add mul sub + dy arrl w add mul dx w 2 div arrw add mul add rlineto + dx arrl w add mul neg dy w 2 div arrw add mul sub + dy arrl w add mul neg dx w 2 div arrw add mul add rlineto + arrw dy dx neg lrl + len w sub arrl sub neg dx dy lrl + closepath fill } bind def +/cshow { 2 index 2 index moveto dup stringwidth pop + neg 2 div fosi .35 mul neg rmoveto show pop pop} def + +gsave +90 rotate +0 -842 translate +71.0944 15 translate +0.434694 dup scale +90 rotate +860.856 -588.349 translate +%Edges: +gsave +574.035 177.301 622.149 225.748 670.264 274.195 1 0 0 2 lb +694.579 115.483 682.421 194.839 670.264 274.195 1 0 0 2 lb +280.402 10.3938 246.402 -6.60595 212.403 -23.6057 0 0 1 2 lb +280.402 10.3938 283.493 -18.9695 286.584 -48.3327 0 0 1 2 lb +212.403 -23.6057 249.493 -35.9692 286.584 -48.3327 0 0 1 2 lb +286.584 -48.3327 326.765 -79.2414 366.947 -110.15 0 0 1 2 lb +286.584 -48.3327 278.857 -111.695 271.13 -175.058 0 0 1 2 lb +438.037 -88.514 417.946 -142.604 397.855 -196.694 0 0 1 2 lb +438.037 -88.514 402.492 -99.332 366.947 -110.15 0 0 1 2 lb +397.855 -196.694 382.401 -153.422 366.947 -110.15 0 0 1 2 lb +366.947 -110.15 319.038 -142.604 271.13 -175.058 0 0 1 2 lb +271.13 -175.058 274.221 -213.694 277.311 -252.33 0 0 1 2 lb +271.13 -175.058 238.675 -190.512 206.221 -205.967 0 0 1 2 lb +277.311 -252.33 241.766 -229.149 206.221 -205.967 0 0 1 2 lb +-840.856 -246.718 -804.351 -66.7145 -767.847 113.289 1 0 0 2 lb +-579.033 445.603 -673.44 279.446 -767.847 113.289 0 0 1 2 lb +-579.033 445.603 -524.906 302.104 -470.779 158.605 0 0 1 2 lb +-767.847 113.289 -619.313 135.947 -470.779 158.605 0 0 1 2 lb +906.312 201.403 946.592 42.798 986.873 -115.807 0 0 1 2 lb +906.312 201.403 834.562 91.8901 762.812 -17.6227 0 0 1 2 lb +986.873 -115.807 874.842 -66.7148 762.812 -17.6227 0 0 1 2 lb +-470.779 158.605 -390.218 50.3508 -309.657 -57.9033 1 0 0 2 lb +422.945 521.129 208.955 541.269 -5.03507 561.41 0 0 1 2 lb +422.945 521.129 376.371 417.911 329.797 314.692 0 0 1 2 lb +422.945 521.129 474.554 276.928 526.164 32.7279 0 0 1 2 lb +-5.03507 561.41 -36.5042 440.568 -67.9734 319.727 0 0 1 2 lb +329.797 314.692 130.912 317.209 -67.9734 319.727 0 0 1 2 lb +-67.9734 319.727 229.095 176.227 526.164 32.7279 0 0 1 2 lb +762.812 -17.6227 644.488 7.5526 526.164 32.7279 0 0 1 2 lb +762.812 -17.6227 746.448 -162.381 730.084 -307.139 0 0 1 2 lb +526.164 32.7279 470.779 -128.394 415.393 -289.516 0 0 1 2 lb +730.084 -307.139 572.738 -298.327 415.393 -289.516 0 0 1 2 lb +415.393 -289.516 173.71 -318.468 -67.9734 -347.42 1 0 0 2 lb +-67.9734 -347.42 -188.815 -202.662 -309.657 -57.9033 0 0 1 2 lb +-67.9734 -347.42 -195.758 -390.692 -323.543 -433.964 0 0 1 2 lb +-309.657 -57.9033 -424.775 -160.272 -539.894 -262.64 0 0 1 2 lb +-323.543 -433.964 -431.719 -348.302 -539.894 -262.64 0 0 1 2 lb +-26.6953 -19.9585 44.8558 -96.8093 116.407 -173.66 0 0 1 2 lb +-26.6953 -19.9585 87.2563 9.19185 201.208 38.3422 0 0 1 2 lb +-26.6953 -19.9585 -144.622 43.6422 -262.548 107.243 0 0 1 2 lb +-26.6953 -19.9585 -20.0703 56.8923 -13.4452 133.743 0 0 1 2 lb +116.407 -173.66 158.808 -67.6589 201.208 38.3422 0 0 1 2 lb +-262.548 107.243 -137.997 120.493 -13.4452 133.743 0 0 1 2 lb +-262.548 107.243 -221.472 176.144 -180.397 245.045 0 0 1 2 lb +-13.4452 133.743 -96.9211 189.394 -180.397 245.045 0 0 1 2 lb +-180.397 245.045 -142.256 345.099 -132.697 451.748 0 0 1 2 lb +-180.397 245.045 -170.838 351.694 -132.697 451.748 0 0 1 2 lb +-416.25 345.746 -274.474 398.747 -132.697 451.748 0 0 1 2 lb +-416.25 345.746 -393.725 457.048 -371.2 568.349 0 0 1 2 lb +-132.697 451.748 -251.948 510.048 -371.2 568.349 0 0 1 2 lb +670.264 274.195 629.188 409.347 588.113 544.499 0 0 1 2 lb +670.264 274.195 797.466 341.771 924.667 409.347 0 0 1 2 lb +588.113 544.499 756.39 476.923 924.667 409.347 0 0 1 2 lb +-689.204 -237.261 -614.799 -102.648 -567.302 43.6423 0 0 1 2 lb +-689.204 -237.261 -641.707 -90.9706 -567.302 43.6423 0 0 1 2 lb +grestore +%Nodes: +gsave +-567.302 43.6423 20 0 0 0 nc +-689.204 -237.261 20 0 0 0 nc +924.667 409.347 20 0 0 1 nc +588.113 544.499 20 0 0 1 nc +670.264 274.195 20 0 0 1 nc +-371.2 568.349 20 1 1 0 nc +-132.697 451.748 20 1 1 0 nc +-416.25 345.746 20 1 1 0 nc +-180.397 245.045 20 1 1 0 nc +-13.4452 133.743 20 1 1 0 nc +-262.548 107.243 20 1 1 0 nc +201.208 38.3422 20 1 1 0 nc +116.407 -173.66 20 1 1 0 nc +-26.6953 -19.9585 20 1 1 0 nc +-539.894 -262.64 20 0 0.5 0 nc +-323.543 -433.964 20 0 0.5 0 nc +-309.657 -57.9033 20 0 0.5 0 nc +-67.9734 -347.42 20 0 0.5 0 nc +415.393 -289.516 20 0.5 0 0 nc +730.084 -307.139 20 0.5 0 0 nc +526.164 32.7279 20 0.5 0 0 nc +762.812 -17.6227 20 0.5 0 0 nc +-67.9734 319.727 20 0.5 0 0 nc +329.797 314.692 20 0.5 0 0 nc +-5.03507 561.41 20 0.5 0 0 nc +422.945 521.129 20 0.5 0 0 nc +-470.779 158.605 20 0 1 1 nc +986.873 -115.807 20 0.5 0 0 nc +906.312 201.403 20 0.5 0 0 nc +-767.847 113.289 20 0 1 1 nc +-579.033 445.603 20 0 1 1 nc +-840.856 -246.718 20 1 0 1 nc +206.221 -205.967 20 0 0 0.5 nc +277.311 -252.33 20 0 0 0.5 nc +271.13 -175.058 20 0 0 0.5 nc +366.947 -110.15 20 0 0 0.5 nc +397.855 -196.694 20 0 0 0.5 nc +438.037 -88.514 20 0 0 0.5 nc +286.584 -48.3327 20 0 0 0.5 nc +212.403 -23.6057 20 0 0 0.5 nc +280.402 10.3938 20 0 0 0.5 nc +694.579 115.483 20 1 0 0 nc +574.035 177.301 20 0 1 0 nc +grestore +grestore +showpage diff -r c35afa9e89e7 -r ef88c0a30f85 doc/images/node_biconnected_components.eps --- /dev/null Thu Jan 01 00:00:00 1970 +0000 +++ b/doc/images/node_biconnected_components.eps Thu Nov 05 15:48:01 2009 +0100 @@ -0,0 +1,159 @@ +%!PS-Adobe-2.0 EPSF-2.0 +%%Creator: LEMON, graphToEps() +%%CreationDate: Fri Nov 4 13:47:12 2005 +%%BoundingBox: 0 0 842 596 +%%EndComments +/lb { setlinewidth setrgbcolor newpath moveto + 4 2 roll 1 index 1 index curveto stroke } bind def +/l { setlinewidth setrgbcolor newpath moveto lineto stroke } bind def +/c { newpath dup 3 index add 2 index moveto 0 360 arc closepath } bind def +/sq { newpath 2 index 1 index add 2 index 2 index add moveto + 2 index 1 index sub 2 index 2 index add lineto + 2 index 1 index sub 2 index 2 index sub lineto + 2 index 1 index add 2 index 2 index sub lineto + closepath pop pop pop} bind def +/di { newpath 2 index 1 index add 2 index moveto + 2 index 2 index 2 index add lineto + 2 index 1 index sub 2 index lineto + 2 index 2 index 2 index sub lineto + closepath pop pop pop} bind def +/nc { 0 0 0 setrgbcolor 5 index 5 index 5 index c fill + setrgbcolor 1.1 div c fill + } bind def +/nsq { 0 0 0 setrgbcolor 5 index 5 index 5 index sq fill + setrgbcolor 1.1 div sq fill + } bind def +/ndi { 0 0 0 setrgbcolor 5 index 5 index 5 index di fill + setrgbcolor 1.1 div di fill + } bind def +/arrl 1 def +/arrw 0.3 def +/lrl { 2 index mul exch 2 index mul exch rlineto pop} bind def +/arr { setrgbcolor /y1 exch def /x1 exch def /dy exch def /dx exch def + /w exch def /len exch def + newpath x1 dy w 2 div mul add y1 dx w 2 div mul sub moveto + len w sub arrl sub dx dy lrl + arrw dy dx neg lrl + dx arrl w add mul dy w 2 div arrw add mul sub + dy arrl w add mul dx w 2 div arrw add mul add rlineto + dx arrl w add mul neg dy w 2 div arrw add mul sub + dy arrl w add mul neg dx w 2 div arrw add mul add rlineto + arrw dy dx neg lrl + len w sub arrl sub neg dx dy lrl + closepath fill } bind def +/cshow { 2 index 2 index moveto dup stringwidth pop + neg 2 div fosi .35 mul neg rmoveto show pop pop} def + +gsave +90 rotate +0 -842 translate +71.0944 15 translate +0.434694 dup scale +90 rotate +860.856 -588.349 translate +%Edges: +gsave +574.035 177.301 622.149 225.748 670.264 274.195 0 1 0 5 lb +694.579 115.483 682.421 194.839 670.264 274.195 1 0 0 5 lb +280.402 10.3938 246.402 -6.60595 212.403 -23.6057 1 1 0.5 5 lb +280.402 10.3938 283.493 -18.9695 286.584 -48.3327 1 1 0.5 5 lb +212.403 -23.6057 249.493 -35.9692 286.584 -48.3327 1 1 0.5 5 lb +286.584 -48.3327 326.765 -79.2414 366.947 -110.15 1 0.5 1 5 lb +286.584 -48.3327 278.857 -111.695 271.13 -175.058 1 0.5 1 5 lb +438.037 -88.514 417.946 -142.604 397.855 -196.694 0.5 0.5 1 5 lb +438.037 -88.514 402.492 -99.332 366.947 -110.15 0.5 0.5 1 5 lb +397.855 -196.694 382.401 -153.422 366.947 -110.15 0.5 0.5 1 5 lb +366.947 -110.15 319.038 -142.604 271.13 -175.058 1 0.5 1 5 lb +271.13 -175.058 274.221 -213.694 277.311 -252.33 0.5 1 1 5 lb +271.13 -175.058 238.675 -190.512 206.221 -205.967 0.5 1 1 5 lb +277.311 -252.33 241.766 -229.149 206.221 -205.967 0.5 1 1 5 lb +-840.856 -246.718 -804.351 -66.7145 -767.847 113.289 0 0.5 0 5 lb +-579.033 445.603 -673.44 279.446 -767.847 113.289 0 0 0.5 5 lb +-579.033 445.603 -524.906 302.104 -470.779 158.605 0 0 0.5 5 lb +-767.847 113.289 -619.313 135.947 -470.779 158.605 0 0 0.5 5 lb +906.312 201.403 946.592 42.798 986.873 -115.807 0 0.5 0.5 5 lb +906.312 201.403 834.562 91.8901 762.812 -17.6227 0 0.5 0.5 5 lb +986.873 -115.807 874.842 -66.7148 762.812 -17.6227 0 0.5 0.5 5 lb +-470.779 158.605 -390.218 50.3508 -309.657 -57.9033 0.5 0.5 0 5 lb +422.945 521.129 208.955 541.269 -5.03507 561.41 0.5 0 0.5 5 lb +422.945 521.129 376.371 417.911 329.797 314.692 0.5 0 0.5 5 lb +422.945 521.129 474.554 276.928 526.164 32.7279 0.5 0 0.5 5 lb +-5.03507 561.41 -36.5042 440.568 -67.9734 319.727 0.5 0 0.5 5 lb +329.797 314.692 130.912 317.209 -67.9734 319.727 0.5 0 0.5 5 lb +-67.9734 319.727 229.095 176.227 526.164 32.7279 0.5 0 0.5 5 lb +762.812 -17.6227 644.488 7.5526 526.164 32.7279 0.5 0.5 0.5 5 lb +762.812 -17.6227 746.448 -162.381 730.084 -307.139 0.5 0.5 0.5 5 lb +526.164 32.7279 470.779 -128.394 415.393 -289.516 0.5 0.5 0.5 5 lb +730.084 -307.139 572.738 -298.327 415.393 -289.516 0.5 0.5 0.5 5 lb +415.393 -289.516 173.71 -318.468 -67.9734 -347.42 1 0.5 0.5 5 lb +-67.9734 -347.42 -188.815 -202.662 -309.657 -57.9033 0.5 1 0.5 5 lb +-67.9734 -347.42 -195.758 -390.692 -323.543 -433.964 0.5 1 0.5 5 lb +-309.657 -57.9033 -424.775 -160.272 -539.894 -262.64 0.5 1 0.5 5 lb +-323.543 -433.964 -431.719 -348.302 -539.894 -262.64 0.5 1 0.5 5 lb +-26.6953 -19.9585 44.8558 -96.8093 116.407 -173.66 1 1 0 5 lb +-26.6953 -19.9585 87.2563 9.19185 201.208 38.3422 1 1 0 5 lb +-26.6953 -19.9585 -144.622 43.6422 -262.548 107.243 1 0 1 5 lb +-26.6953 -19.9585 -20.0703 56.8923 -13.4452 133.743 1 0 1 5 lb +116.407 -173.66 158.808 -67.6589 201.208 38.3422 1 1 0 5 lb +-262.548 107.243 -137.997 120.493 -13.4452 133.743 1 0 1 5 lb +-262.548 107.243 -221.472 176.144 -180.397 245.045 1 0 1 5 lb +-13.4452 133.743 -96.9211 189.394 -180.397 245.045 1 0 1 5 lb +-180.397 245.045 -140.307 344.649 -132.697 451.748 0 1 1 5 lb +-180.397 245.045 -172.787 352.144 -132.697 451.748 0 1 1 5 lb +-416.25 345.746 -274.474 398.747 -132.697 451.748 0.5 0 0 5 lb +-416.25 345.746 -393.725 457.048 -371.2 568.349 0.5 0 0 5 lb +-132.697 451.748 -251.948 510.048 -371.2 568.349 0.5 0 0 5 lb +670.264 274.195 629.188 409.347 588.113 544.499 0 0 1 5 lb +670.264 274.195 797.466 341.771 924.667 409.347 0 0 1 5 lb +588.113 544.499 756.39 476.923 924.667 409.347 0 0 1 5 lb +-689.204 -237.261 -612.964 -103.444 -567.302 43.6423 0 0 0 5 lb +-689.204 -237.261 -643.542 -90.1744 -567.302 43.6423 0 0 0 5 lb +grestore +%Nodes: +gsave +-567.302 43.6423 20 0 0 1 nc +-689.204 -237.261 20 0 0 1 nc +924.667 409.347 20 0 0 1 nc +588.113 544.499 20 0 0 1 nc +670.264 274.195 20 1 0 0 nc +-371.2 568.349 20 0 0 1 nc +-132.697 451.748 20 1 0 0 nc +-416.25 345.746 20 0 0 1 nc +-180.397 245.045 20 1 0 0 nc +-13.4452 133.743 20 0 0 1 nc +-262.548 107.243 20 0 0 1 nc +201.208 38.3422 20 0 0 1 nc +116.407 -173.66 20 0 0 1 nc +-26.6953 -19.9585 20 1 0 0 nc +-539.894 -262.64 20 0 0 1 nc +-323.543 -433.964 20 0 0 1 nc +-309.657 -57.9033 20 1 0 0 nc +-67.9734 -347.42 20 1 0 0 nc +415.393 -289.516 20 1 0 0 nc +730.084 -307.139 20 0 0 1 nc +526.164 32.7279 20 1 0 0 nc +762.812 -17.6227 20 1 0 0 nc +-67.9734 319.727 20 0 0 1 nc +329.797 314.692 20 0 0 1 nc +-5.03507 561.41 20 0 0 1 nc +422.945 521.129 20 0 0 1 nc +-470.779 158.605 20 1 0 0 nc +986.873 -115.807 20 0 0 1 nc +906.312 201.403 20 0 0 1 nc +-767.847 113.289 20 1 0 0 nc +-579.033 445.603 20 0 0 1 nc +-840.856 -246.718 20 0 0 1 nc +206.221 -205.967 20 0 0 1 nc +277.311 -252.33 20 0 0 1 nc +271.13 -175.058 20 1 0 0 nc +366.947 -110.15 20 1 0 0 nc +397.855 -196.694 20 0 0 1 nc +438.037 -88.514 20 0 0 1 nc +286.584 -48.3327 20 1 0 0 nc +212.403 -23.6057 20 0 0 1 nc +280.402 10.3938 20 0 0 1 nc +694.579 115.483 20 0 0 1 nc +574.035 177.301 20 0 0 1 nc +grestore +grestore +showpage diff -r c35afa9e89e7 -r ef88c0a30f85 doc/images/strongly_connected_components.eps --- /dev/null Thu Jan 01 00:00:00 1970 +0000 +++ b/doc/images/strongly_connected_components.eps Thu Nov 05 15:48:01 2009 +0100 @@ -0,0 +1,180 @@ +%!PS-Adobe-2.0 EPSF-2.0 +%%Creator: LEMON, graphToEps() +%%CreationDate: Fri Nov 4 13:47:12 2005 +%%BoundingBox: 0 0 842 596 +%%EndComments +/lb { setlinewidth setrgbcolor newpath moveto + 4 2 roll 1 index 1 index curveto stroke } bind def +/l { setlinewidth setrgbcolor newpath moveto lineto stroke } bind def +/c { newpath dup 3 index add 2 index moveto 0 360 arc closepath } bind def +/sq { newpath 2 index 1 index add 2 index 2 index add moveto + 2 index 1 index sub 2 index 2 index add lineto + 2 index 1 index sub 2 index 2 index sub lineto + 2 index 1 index add 2 index 2 index sub lineto + closepath pop pop pop} bind def +/di { newpath 2 index 1 index add 2 index moveto + 2 index 2 index 2 index add lineto + 2 index 1 index sub 2 index lineto + 2 index 2 index 2 index sub lineto + closepath pop pop pop} bind def +/nc { 0 0 0 setrgbcolor 5 index 5 index 5 index c fill + setrgbcolor 1.1 div c fill + } bind def +/nsq { 0 0 0 setrgbcolor 5 index 5 index 5 index sq fill + setrgbcolor 1.1 div sq fill + } bind def +/ndi { 0 0 0 setrgbcolor 5 index 5 index 5 index di fill + setrgbcolor 1.1 div di fill + } bind def +/arrl 10 def +/arrw 3 def +/lrl { 2 index mul exch 2 index mul exch rlineto pop} bind def +/arr { setrgbcolor /y1 exch def /x1 exch def /dy exch def /dx exch def + /w exch def /len exch def + newpath x1 dy w 2 div mul add y1 dx w 2 div mul sub moveto + len w sub arrl sub dx dy lrl + arrw dy dx neg lrl + dx arrl w add mul dy w 2 div arrw add mul sub + dy arrl w add mul dx w 2 div arrw add mul add rlineto + dx arrl w add mul neg dy w 2 div arrw add mul sub + dy arrl w add mul neg dx w 2 div arrw add mul add rlineto + arrw dy dx neg lrl + len w sub arrl sub neg dx dy lrl + closepath fill } bind def +/cshow { 2 index 2 index moveto dup stringwidth pop + neg 2 div fosi .35 mul neg rmoveto show pop pop} def + +gsave +90 rotate +0 -842 translate +77.1122 15 translate +0.585745 dup scale +90 rotate +695.963 -397.916 translate +%Edges: +gsave +2 setlinewidth 0 0 1 setrgbcolor newpath +218.178 27.2723 moveto +192.373 -40.1551 188.622 -49.9556 169.228 -100.631 curveto stroke +newpath 164.939 -111.838 moveto 165.492 -99.2013 lineto 172.964 -102.061 lineto closepath fill +2 setlinewidth 0 0 1 setrgbcolor newpath +44.8044 15.5841 moveto +119.293 20.6059 129.775 21.3125 186.25 25.1199 curveto stroke +newpath 198.223 25.927 moveto 186.519 21.1289 lineto 185.981 29.1108 lineto closepath fill +2 setlinewidth 1 0 0 setrgbcolor newpath +218.178 27.2723 moveto +285.395 -87.4449 290.763 -96.6058 348.102 -194.464 curveto stroke +newpath 354.169 -204.818 moveto 344.651 -196.487 lineto 351.554 -192.442 lineto closepath fill +2 setlinewidth 0 0 1 setrgbcolor newpath +157.79 -130.517 moveto +108.71 -67.0521 102.27 -58.7243 64.3804 -9.72954 curveto stroke +newpath 57.0394 -0.236898 moveto 67.5446 -7.28254 lineto 61.2162 -12.1765 lineto closepath fill +2 setlinewidth 1 0 0 setrgbcolor newpath +-105.193 -261.035 moveto +-35.6576 -132.801 -30.5923 -123.459 29.5506 -12.5464 curveto stroke +newpath 35.2708 -1.99743 moveto 33.0669 -14.4531 lineto 26.0343 -10.6397 lineto closepath fill +2 setlinewidth 0 0 1 setrgbcolor newpath +-465.576 -42.8564 moveto +-559.078 -25.5413 -569.47 -23.6169 -644.498 -9.72286 curveto stroke +newpath -656.297 -7.5378 moveto -643.77 -5.78973 lineto -645.226 -13.656 lineto closepath fill +2 setlinewidth 0 0 1 setrgbcolor newpath +-574.666 -153.893 moveto +-528.842 -107.252 -521.515 -99.794 -488.002 -65.683 curveto stroke +newpath -479.592 -57.123 moveto -485.149 -68.4863 lineto -490.856 -62.8797 lineto closepath fill +2 setlinewidth 1 0 0 setrgbcolor newpath +-490.901 120.777 moveto +-480.122 51.1328 -478.519 40.7713 -470.47 -11.2329 curveto stroke +newpath -468.635 -23.0917 moveto -474.423 -11.8447 lineto -466.517 -10.6212 lineto closepath fill +2 setlinewidth 0 0 1 setrgbcolor newpath +-675.963 -3.89604 moveto +-632.116 -68.8235 -626.228 -77.5422 -592.575 -127.374 curveto stroke +newpath -585.859 -137.319 moveto -595.89 -129.612 lineto -589.26 -125.135 lineto closepath fill +2 setlinewidth 0 0 1 setrgbcolor newpath +-490.901 120.777 moveto +-435.445 215.844 -430.107 224.995 -384.3 303.522 curveto stroke +newpath -378.253 313.887 moveto -380.845 301.507 lineto -387.755 305.537 lineto closepath fill +2 setlinewidth 0 0 1 setrgbcolor newpath +-266.879 114.933 moveto +-367.067 117.547 -377.642 117.822 -458.912 119.943 curveto stroke +newpath -470.908 120.255 moveto -458.807 123.941 lineto -459.016 115.944 lineto closepath fill +2 setlinewidth 0 0 1 setrgbcolor newpath +-368.176 331.163 moveto +-322.511 233.685 -318.018 224.095 -280.454 143.911 curveto stroke +newpath -275.364 133.044 moveto -284.076 142.214 lineto -276.832 145.608 lineto closepath fill +2 setlinewidth 1 0 0 setrgbcolor newpath +-266.879 114.933 moveto +-224.004 235.52 -220.448 245.52 -184.094 347.765 curveto stroke +newpath -180.074 359.072 moveto -180.325 346.425 lineto -187.863 349.105 lineto closepath fill +2 setlinewidth 0 0 1 setrgbcolor newpath +-251.294 -335.059 moveto +-189.25 -303.624 -179.902 -298.887 -133.738 -275.498 curveto stroke +newpath -123.034 -270.074 moveto -131.93 -279.066 lineto -135.546 -271.93 lineto closepath fill +2 setlinewidth 0 0 1 setrgbcolor newpath +-389.604 -136.361 moveto +-327.15 -226.083 -321.098 -234.777 -269.576 -308.795 curveto stroke +newpath -262.72 -318.644 moveto -272.859 -311.081 lineto -266.293 -306.51 lineto closepath fill +2 setlinewidth 1 0 0 setrgbcolor newpath +5.84406 175.322 moveto +-76.0754 267.926 -83.1051 275.873 -152.172 353.948 curveto stroke +newpath -160.122 362.936 moveto -149.176 356.598 lineto -155.168 351.298 lineto closepath fill +2 setlinewidth 0 0 1 setrgbcolor newpath +169.478 311.683 moveto +96.8003 251.119 88.6819 244.353 30.4273 195.808 curveto stroke +newpath 21.2086 188.126 moveto 27.8666 198.881 lineto 32.988 192.735 lineto closepath fill +2 setlinewidth 0 0 1 setrgbcolor newpath +342.851 111.037 moveto +263.766 202.563 256.831 210.589 190.4 287.47 curveto stroke +newpath 182.554 296.55 moveto 193.427 290.085 lineto 187.373 284.855 lineto closepath fill +2 setlinewidth 0 0 1 setrgbcolor newpath +5.84406 175.322 moveto +163.16 145.314 173.605 143.321 311.418 117.033 curveto stroke +newpath 323.205 114.784 moveto 310.668 113.104 lineto 312.167 120.962 lineto closepath fill +2 setlinewidth 0 0 1 setrgbcolor newpath +342.851 111.037 moveto +497.255 2.58683 505.964 -3.53033 643.932 -100.436 curveto stroke +newpath 653.752 -107.334 moveto 641.633 -103.71 lineto 646.231 -97.163 lineto closepath fill +2 setlinewidth 0 0 1 setrgbcolor newpath +364.28 -222.074 moveto +354.298 -66.9063 353.616 -56.2971 344.905 79.1029 curveto stroke +newpath 344.135 91.0781 moveto 348.897 79.3597 lineto 340.914 78.8461 lineto closepath fill +2 setlinewidth 0 0 1 setrgbcolor newpath +670.118 -118.829 moveto +528.037 -166.793 517.967 -170.192 394.599 -211.839 curveto stroke +newpath 383.229 -215.677 moveto 393.32 -208.049 lineto 395.878 -215.629 lineto closepath fill +2 setlinewidth 1 0 0 setrgbcolor newpath +-105.193 -261.035 moveto +118.401 -242.479 129.015 -241.598 332.39 -224.721 curveto stroke +newpath 344.348 -223.728 moveto 332.72 -228.707 lineto 332.059 -220.734 lineto closepath fill +2 setlinewidth 0 0 1 setrgbcolor newpath +-105.193 -261.035 moveto +-160.867 -161.176 -166.028 -151.918 -212.336 -68.858 curveto stroke +newpath -218.179 -58.3769 moveto -208.842 -66.9102 lineto -215.829 -70.8058 lineto closepath fill +2 setlinewidth 0 0 1 setrgbcolor newpath +-227.918 -40.9084 moveto +-298.35 -82.4884 -307.42 -87.8432 -362.048 -120.093 curveto stroke +newpath -372.381 -126.193 moveto -364.081 -116.648 lineto -360.014 -123.537 lineto closepath fill +grestore +%Nodes: +gsave +-389.604 -136.361 20 0 1 0 nc +-227.918 -40.9084 20 0 1 0 nc +-105.193 -261.035 20 0 1 0 nc +364.28 -222.074 20 1 1 0 nc +670.118 -118.829 20 1 1 0 nc +342.851 111.037 20 1 1 0 nc +5.84406 175.322 20 1 1 0 nc +169.478 311.683 20 1 1 0 nc +-173.374 377.916 20 1 0 1 nc +-251.294 -335.059 20 0 1 0 nc +-266.879 114.933 20 0 0 0 nc +-368.176 331.163 20 0 0 0 nc +-490.901 120.777 20 0 0 0 nc +-574.666 -153.893 20 1 0 0 nc +-675.963 -3.89604 20 1 0 0 nc +-465.576 -42.8564 20 1 0 0 nc +44.8044 15.5841 20 0 0 1 nc +157.79 -130.517 20 0 0 1 nc +218.178 27.2723 20 0 0 1 nc +grestore +grestore +showpage diff -r c35afa9e89e7 -r ef88c0a30f85 doc/mainpage.dox --- a/doc/mainpage.dox Mon Jan 12 23:11:39 2009 +0100 +++ b/doc/mainpage.dox Thu Nov 05 15:48:01 2009 +0100 @@ -21,15 +21,11 @@ \section intro Introduction -\subsection whatis What is LEMON - -LEMON stands for -Library of Efficient Models -and Optimization in Networks. -It is a C++ template -library aimed at combinatorial optimization tasks which -often involve in working -with graphs. +LEMON stands for Library for Efficient Modeling +and Optimization in Networks. +It is a C++ template library providing efficient implementation of common +data structures and algorithms with focus on combinatorial optimization +problems in graphs and networks. LEMON is an open source @@ -39,22 +35,22 @@ \ref license "license terms". -\subsection howtoread How to read the documentation +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. -If you want to get a quick start and see the most important features then -take a look at our \ref quicktour -"Quick Tour to LEMON" which will guide you along. +\section howtoread How to Read the Documentation -If you already feel like using our library, see the page that tells you -\ref getstart "How to start using LEMON". +If you would like to get to know the library, see +LEMON Tutorial. -If you -want to see how LEMON works, see -some \ref demoprograms "demo programs". - -If you know what you are looking for then try to find it under the -Modules -section. +If you know what you are looking for, then try to find it under the +Modules section. If you are a user of the old (0.x) series of LEMON, please check out the \ref migration "Migration Guide" for the backward incompatibilities. diff -r c35afa9e89e7 -r ef88c0a30f85 doc/min_cost_flow.dox --- /dev/null Thu Jan 01 00:00:00 1970 +0000 +++ b/doc/min_cost_flow.dox Thu Nov 05 15:48:01 2009 +0100 @@ -0,0 +1,153 @@ +/* -*- 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. + * + */ + +namespace lemon { + +/** +\page min_cost_flow Minimum Cost Flow Problem + +\section mcf_def Definition (GEQ form) + +The \e minimum \e cost \e flow \e problem is to find a feasible flow of +minimum total cost from a set of supply nodes to a set of demand nodes +in a network with capacity constraints (lower and upper bounds) +and arc costs \ref amo93networkflows. + +Formally, let \f$G=(V,A)\f$ be a digraph, \f$lower: A\rightarrow\mathbf{R}\f$, +\f$upper: A\rightarrow\mathbf{R}\cup\{+\infty\}\f$ denote the lower and +upper bounds for the flow values on the arcs, for which +\f$lower(uv) \leq upper(uv)\f$ must hold for all \f$uv\in A\f$, +\f$cost: A\rightarrow\mathbf{R}\f$ denotes the cost per unit flow +on the arcs and \f$sup: V\rightarrow\mathbf{R}\f$ denotes the +signed supply values of the nodes. +If \f$sup(u)>0\f$, then \f$u\f$ is a supply node with \f$sup(u)\f$ +supply, if \f$sup(u)<0\f$, then \f$u\f$ is a demand node with +\f$-sup(u)\f$ demand. +A minimum cost flow is an \f$f: A\rightarrow\mathbf{R}\f$ solution +of the following optimization problem. + +\f[ \min\sum_{uv\in A} f(uv) \cdot cost(uv) \f] +\f[ \sum_{uv\in A} f(uv) - \sum_{vu\in A} f(vu) \geq + sup(u) \quad \forall u\in V \f] +\f[ lower(uv) \leq f(uv) \leq upper(uv) \quad \forall uv\in A \f] + +The sum of the supply values, i.e. \f$\sum_{u\in V} sup(u)\f$ must be +zero or negative in order to have a feasible solution (since the sum +of the expressions on the left-hand side of the inequalities is zero). +It means that the total demand must be greater or equal to the total +supply and all the supplies have to be carried out from the supply nodes, +but there could be demands that are not satisfied. +If \f$\sum_{u\in V} sup(u)\f$ is zero, then all the supply/demand +constraints have to be satisfied with equality, i.e. all demands +have to be satisfied and all supplies have to be used. + + +\section mcf_algs Algorithms + +LEMON contains several algorithms for solving this problem, for more +information see \ref min_cost_flow_algs "Minimum Cost Flow Algorithms". + +A feasible solution for this problem can be found using \ref Circulation. + + +\section mcf_dual Dual Solution + +The dual solution of the minimum cost flow problem is represented by +node potentials \f$\pi: V\rightarrow\mathbf{R}\f$. +An \f$f: A\rightarrow\mathbf{R}\f$ primal feasible solution is optimal +if and only if for some \f$\pi: V\rightarrow\mathbf{R}\f$ node potentials +the following \e complementary \e slackness optimality conditions hold. + + - For all \f$uv\in A\f$ arcs: + - if \f$cost^\pi(uv)>0\f$, then \f$f(uv)=lower(uv)\f$; + - if \f$lower(uv)"less or equal" (LEQ) supply/demand constraints, +instead of the "greater or equal" (GEQ) constraints. + +\f[ \min\sum_{uv\in A} f(uv) \cdot cost(uv) \f] +\f[ \sum_{uv\in A} f(uv) - \sum_{vu\in A} f(vu) \leq + sup(u) \quad \forall u\in V \f] +\f[ lower(uv) \leq f(uv) \leq upper(uv) \quad \forall uv\in A \f] + +It means that the total demand must be less or equal to the +total supply (i.e. \f$\sum_{u\in V} sup(u)\f$ must be zero or +positive) and all the demands have to be satisfied, but there +could be supplies that are not carried out from the supply +nodes. +The equality form is also a special case of this form, of course. + +You could easily transform this case to the \ref mcf_def "GEQ form" +of the problem by reversing the direction of the arcs and taking the +negative of the supply values (e.g. using \ref ReverseDigraph and +\ref NegMap adaptors). +However \ref NetworkSimplex algorithm also supports this form directly +for the sake of convenience. + +Note that the optimality conditions for this supply constraint type are +slightly differ from the conditions that are discussed for the GEQ form, +namely the potentials have to be non-negative instead of non-positive. +An \f$f: A\rightarrow\mathbf{R}\f$ feasible solution of this problem +is optimal if and only if for some \f$\pi: V\rightarrow\mathbf{R}\f$ +node potentials the following conditions hold. + + - For all \f$uv\in A\f$ arcs: + - if \f$cost^\pi(uv)>0\f$, then \f$f(uv)=lower(uv)\f$; + - if \f$lower(uv)=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$. + +*/ +} diff -r c35afa9e89e7 -r ef88c0a30f85 doc/references.bib --- /dev/null Thu Jan 01 00:00:00 1970 +0000 +++ b/doc/references.bib Thu Nov 05 15:48:01 2009 +0100 @@ -0,0 +1,301 @@ +%%%%% Defining LEMON %%%%% + +@misc{lemon, + key = {LEMON}, + title = {{LEMON} -- {L}ibrary for {E}fficient {M}odeling and + {O}ptimization in {N}etworks}, + howpublished = {\url{http://lemon.cs.elte.hu/}}, + year = 2009 +} + +@misc{egres, + key = {EGRES}, + title = {{EGRES} -- {E}gerv{\'a}ry {R}esearch {G}roup on + {C}ombinatorial {O}ptimization}, + url = {http://www.cs.elte.hu/egres/} +} + +@misc{coinor, + key = {COIN-OR}, + title = {{COIN-OR} -- {C}omputational {I}nfrastructure for + {O}perations {R}esearch}, + url = {http://www.coin-or.org/} +} + + +%%%%% Other libraries %%%%%% + +@misc{boost, + key = {Boost}, + title = {{B}oost {C++} {L}ibraries}, + url = {http://www.boost.org/} +} + +@book{bglbook, + author = {Jeremy G. Siek and Lee-Quan Lee and Andrew + Lumsdaine}, + title = {The Boost Graph Library: User Guide and Reference + Manual}, + publisher = {Addison-Wesley}, + year = 2002 +} + +@misc{leda, + key = {LEDA}, + title = {{LEDA} -- {L}ibrary of {E}fficient {D}ata {T}ypes and + {A}lgorithms}, + url = {http://www.algorithmic-solutions.com/} +} + +@book{ledabook, + author = {Kurt Mehlhorn and Stefan N{\"a}her}, + title = {{LEDA}: {A} platform for combinatorial and geometric + computing}, + isbn = {0-521-56329-1}, + publisher = {Cambridge University Press}, + address = {New York, NY, USA}, + year = 1999 +} + + +%%%%% Tools that LEMON depends on %%%%% + +@misc{cmake, + key = {CMake}, + title = {{CMake} -- {C}ross {P}latform {M}ake}, + url = {http://www.cmake.org/} +} + +@misc{doxygen, + key = {Doxygen}, + title = {{Doxygen} -- {S}ource code documentation generator + tool}, + url = {http://www.doxygen.org/} +} + + +%%%%% LP/MIP libraries %%%%% + +@misc{glpk, + key = {GLPK}, + title = {{GLPK} -- {GNU} {L}inear {P}rogramming {K}it}, + url = {http://www.gnu.org/software/glpk/} +} + +@misc{clp, + key = {Clp}, + title = {{Clp} -- {Coin-Or} {L}inear {P}rogramming}, + url = {http://projects.coin-or.org/Clp/} +} + +@misc{cbc, + key = {Cbc}, + title = {{Cbc} -- {Coin-Or} {B}ranch and {C}ut}, + url = {http://projects.coin-or.org/Cbc/} +} + +@misc{cplex, + key = {CPLEX}, + title = {{ILOG} {CPLEX}}, + url = {http://www.ilog.com/} +} + +@misc{soplex, + key = {SoPlex}, + title = {{SoPlex} -- {T}he {S}equential {O}bject-{O}riented + {S}implex}, + url = {http://soplex.zib.de/} +} + + +%%%%% General books %%%%% + +@book{amo93networkflows, + author = {Ravindra K. Ahuja and Thomas L. Magnanti and James + B. Orlin}, + title = {Network Flows: Theory, Algorithms, and Applications}, + publisher = {Prentice-Hall, Inc.}, + year = 1993, + month = feb, + isbn = {978-0136175490} +} + +@book{schrijver03combinatorial, + author = {Alexander Schrijver}, + title = {Combinatorial Optimization: Polyhedra and Efficiency}, + publisher = {Springer-Verlag}, + year = 2003, + isbn = {978-3540443896} +} + +@book{clrs01algorithms, + author = {Thomas H. Cormen and Charles E. Leiserson and Ronald + L. Rivest and Clifford Stein}, + title = {Introduction to Algorithms}, + publisher = {The MIT Press}, + year = 2001, + edition = {2nd} +} + +@book{stroustrup00cpp, + author = {Bjarne Stroustrup}, + title = {The C++ Programming Language}, + edition = {3rd}, + publisher = {Addison-Wesley Professional}, + isbn = 0201700735, + month = {February}, + year = 2000 +} + + +%%%%% Maximum flow algorithms %%%%% + +@article{edmondskarp72theoretical, + author = {Jack Edmonds and Richard M. Karp}, + title = {Theoretical improvements in algorithmic efficiency + for network flow problems}, + journal = {Journal of the ACM}, + year = 1972, + volume = 19, + number = 2, + pages = {248-264} +} + +@article{goldberg88newapproach, + author = {Andrew V. Goldberg and Robert E. Tarjan}, + title = {A new approach to the maximum flow problem}, + journal = {Journal of the ACM}, + year = 1988, + volume = 35, + number = 4, + pages = {921-940} +} + +@article{dinic70algorithm, + author = {E. A. Dinic}, + title = {Algorithm for solution of a problem of maximum flow + in a network with power estimation}, + journal = {Soviet Math. Doklady}, + year = 1970, + volume = 11, + pages = {1277-1280} +} + +@article{goldberg08partial, + author = {Andrew V. Goldberg}, + title = {The Partial Augment-Relabel Algorithm for the + Maximum Flow Problem}, + journal = {16th Annual European Symposium on Algorithms}, + year = 2008, + pages = {466-477} +} + +@article{sleator83dynamic, + author = {Daniel D. Sleator and Robert E. Tarjan}, + title = {A data structure for dynamic trees}, + journal = {Journal of Computer and System Sciences}, + year = 1983, + volume = 26, + number = 3, + pages = {362-391} +} + + +%%%%% Minimum mean cycle algorithms %%%%% + +@article{karp78characterization, + author = {Richard M. Karp}, + title = {A characterization of the minimum cycle mean in a + digraph}, + journal = {Discrete Math.}, + year = 1978, + volume = 23, + pages = {309-311} +} + +@article{dasdan98minmeancycle, + author = {Ali Dasdan and Rajesh K. Gupta}, + title = {Faster Maximum and Minimum Mean Cycle Alogrithms for + System Performance Analysis}, + journal = {IEEE Transactions on Computer-Aided Design of + Integrated Circuits and Systems}, + year = 1998, + volume = 17, + number = 10, + pages = {889-899} +} + + +%%%%% Minimum cost flow algorithms %%%%% + +@article{klein67primal, + author = {Morton Klein}, + title = {A primal method for minimal cost flows with + applications to the assignment and transportation + problems}, + journal = {Management Science}, + year = 1967, + volume = 14, + pages = {205-220} +} + +@article{goldberg89cyclecanceling, + author = {Andrew V. Goldberg and Robert E. Tarjan}, + title = {Finding minimum-cost circulations by canceling + negative cycles}, + journal = {Journal of the ACM}, + year = 1989, + volume = 36, + number = 4, + pages = {873-886} +} + +@article{goldberg90approximation, + author = {Andrew V. Goldberg and Robert E. Tarjan}, + title = {Finding Minimum-Cost Circulations by Successive + Approximation}, + journal = {Mathematics of Operations Research}, + year = 1990, + volume = 15, + number = 3, + pages = {430-466} +} + +@article{goldberg97efficient, + author = {Andrew V. Goldberg}, + title = {An Efficient Implementation of a Scaling + Minimum-Cost Flow Algorithm}, + journal = {Journal of Algorithms}, + year = 1997, + volume = 22, + number = 1, + pages = {1-29} +} + +@article{bunnagel98efficient, + author = {Ursula B{\"u}nnagel and Bernhard Korte and Jens + Vygen}, + title = {Efficient implementation of the {G}oldberg-{T}arjan + minimum-cost flow algorithm}, + journal = {Optimization Methods and Software}, + year = 1998, + volume = 10, + pages = {157-174} +} + +@book{dantzig63linearprog, + author = {George B. Dantzig}, + title = {Linear Programming and Extensions}, + publisher = {Princeton University Press}, + year = 1963 +} + +@mastersthesis{kellyoneill91netsimplex, + author = {Damian J. Kelly and Garrett M. O'Neill}, + title = {The Minimum Cost Flow Problem and The Network + Simplex Method}, + school = {University College}, + address = {Dublin, Ireland}, + year = 1991, + month = sep, +} diff -r c35afa9e89e7 -r ef88c0a30f85 lemon/CMakeLists.txt --- a/lemon/CMakeLists.txt Mon Jan 12 23:11:39 2009 +0100 +++ b/lemon/CMakeLists.txt Thu Nov 05 15:48:01 2009 +0100 @@ -1,18 +1,68 @@ -INCLUDE_DIRECTORIES(${CMAKE_SOURCE_DIR}) +INCLUDE_DIRECTORIES( + ${PROJECT_SOURCE_DIR} + ${PROJECT_BINARY_DIR} +) -ADD_LIBRARY(lemon +CONFIGURE_FILE( + ${CMAKE_CURRENT_SOURCE_DIR}/config.h.cmake + ${CMAKE_CURRENT_BINARY_DIR}/config.h +) + +SET(LEMON_SOURCES arg_parser.cc base.cc color.cc - random.cc) + lp_base.cc + lp_skeleton.cc + random.cc + bits/windows.cc +) + +IF(LEMON_HAVE_GLPK) + SET(LEMON_SOURCES ${LEMON_SOURCES} glpk.cc) + INCLUDE_DIRECTORIES(${GLPK_INCLUDE_DIRS}) + IF(WIN32) + INSTALL(FILES ${GLPK_BIN_DIR}/glpk.dll DESTINATION bin) + INSTALL(FILES ${GLPK_BIN_DIR}/libltdl3.dll DESTINATION bin) + INSTALL(FILES ${GLPK_BIN_DIR}/zlib1.dll DESTINATION bin) + ENDIF() +ENDIF() + +IF(LEMON_HAVE_CPLEX) + SET(LEMON_SOURCES ${LEMON_SOURCES} cplex.cc) + INCLUDE_DIRECTORIES(${CPLEX_INCLUDE_DIRS}) +ENDIF() + +IF(LEMON_HAVE_CLP) + SET(LEMON_SOURCES ${LEMON_SOURCES} clp.cc) + INCLUDE_DIRECTORIES(${COIN_INCLUDE_DIRS}) +ENDIF() + +IF(LEMON_HAVE_CBC) + SET(LEMON_SOURCES ${LEMON_SOURCES} cbc.cc) + INCLUDE_DIRECTORIES(${COIN_INCLUDE_DIRS}) +ENDIF() + +ADD_LIBRARY(lemon ${LEMON_SOURCES}) +IF(UNIX) + SET_TARGET_PROPERTIES(lemon PROPERTIES OUTPUT_NAME emon) +ENDIF() INSTALL( TARGETS lemon ARCHIVE DESTINATION lib - COMPONENT library) + COMPONENT library +) INSTALL( DIRECTORY . bits concepts DESTINATION include/lemon COMPONENT headers - FILES_MATCHING PATTERN "*.h") + FILES_MATCHING PATTERN "*.h" +) + +INSTALL( + FILES ${CMAKE_CURRENT_BINARY_DIR}/config.h + DESTINATION include/lemon + COMPONENT headers +) diff -r c35afa9e89e7 -r ef88c0a30f85 lemon/Makefile.am --- a/lemon/Makefile.am Mon Jan 12 23:11:39 2009 +0100 +++ b/lemon/Makefile.am Thu Nov 05 15:48:01 2009 +0100 @@ -1,6 +1,7 @@ EXTRA_DIST += \ lemon/lemon.pc.in \ - lemon/CMakeLists.txt + lemon/CMakeLists.txt \ + lemon/config.h.cmake pkgconfig_DATA += lemon/lemon.pc @@ -12,20 +13,25 @@ lemon/color.cc \ lemon/lp_base.cc \ lemon/lp_skeleton.cc \ - lemon/random.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) + $(CLP_CXXFLAGS) \ + $(CBC_CXXFLAGS) lemon_libemon_la_LDFLAGS = \ $(GLPK_LIBS) \ $(CPLEX_LIBS) \ $(SOPLEX_LIBS) \ - $(CLP_LIBS) + $(CLP_LIBS) \ + $(CBC_LIBS) if HAVE_GLPK lemon_libemon_la_SOURCES += lemon/glpk.cc @@ -43,16 +49,25 @@ 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/bellman_ford.h \ lemon/bfs.h \ lemon/bin_heap.h \ + lemon/binom_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 \ @@ -63,11 +78,19 @@ lemon/edge_set.h \ lemon/elevator.h \ lemon/error.h \ + lemon/euler.h \ + lemon/fib_heap.h \ + lemon/fourary_heap.h \ lemon/full_graph.h \ lemon/glpk.h \ + lemon/gomory_hu.h \ lemon/graph_to_eps.h \ lemon/grid_graph.h \ + lemon/hartmann_orlin.h \ + lemon/howard.h \ lemon/hypercube_graph.h \ + lemon/karp.h \ + lemon/kary_heap.h \ lemon/kruskal.h \ lemon/hao_orlin.h \ lemon/lgf_reader.h \ @@ -76,26 +99,30 @@ lemon/lp.h \ lemon/lp_base.h \ lemon/lp_skeleton.h \ - lemon/list_graph.h \ lemon/maps.h \ + lemon/matching.h \ lemon/math.h \ - lemon/max_matching.h \ + lemon/min_cost_arborescence.h \ lemon/nauty_reader.h \ + lemon/network_simplex.h \ + lemon/pairing_heap.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/static_graph.h \ lemon/suurballe.h \ lemon/time_measure.h \ lemon/tolerance.h \ - lemon/unionfind.h + lemon/unionfind.h \ + lemon/bits/windows.h bits_HEADERS += \ lemon/bits/alteration_notifier.h \ lemon/bits/array_map.h \ - lemon/bits/base_extender.h \ lemon/bits/bezier.h \ lemon/bits/default_map.h \ lemon/bits/edge_set_extender.h \ diff -r c35afa9e89e7 -r ef88c0a30f85 lemon/adaptors.h --- a/lemon/adaptors.h Mon Jan 12 23:11:39 2009 +0100 +++ b/lemon/adaptors.h Thu Nov 05 15:48:01 2009 +0100 @@ -30,29 +30,35 @@ #include #include +#include #include #include namespace lemon { - template +#ifdef _MSC_VER +#define LEMON_SCOPE_FIX(OUTER, NESTED) OUTER::NESTED +#else +#define LEMON_SCOPE_FIX(OUTER, NESTED) typename OUTER::template NESTED +#endif + + template class DigraphAdaptorBase { public: - typedef _Digraph Digraph; + typedef DGR Digraph; typedef DigraphAdaptorBase Adaptor; - typedef Digraph ParentDigraph; protected: - Digraph* _digraph; + DGR* _digraph; DigraphAdaptorBase() : _digraph(0) { } - void setDigraph(Digraph& digraph) { _digraph = &digraph; } + void initialize(DGR& digraph) { _digraph = &digraph; } public: - DigraphAdaptorBase(Digraph& digraph) : _digraph(&digraph) { } - - typedef typename Digraph::Node Node; - typedef typename Digraph::Arc Arc; + DigraphAdaptorBase(DGR& digraph) : _digraph(&digraph) { } + + typedef typename DGR::Node Node; + typedef typename DGR::Arc Arc; void first(Node& i) const { _digraph->first(i); } void first(Arc& i) const { _digraph->first(i); } @@ -67,13 +73,13 @@ Node source(const Arc& a) const { return _digraph->source(a); } Node target(const Arc& a) const { return _digraph->target(a); } - typedef NodeNumTagIndicator NodeNumTag; + typedef NodeNumTagIndicator NodeNumTag; int nodeNum() const { return _digraph->nodeNum(); } - typedef ArcNumTagIndicator ArcNumTag; + typedef ArcNumTagIndicator ArcNumTag; int arcNum() const { return _digraph->arcNum(); } - typedef FindArcTagIndicator FindArcTag; + typedef FindArcTagIndicator FindArcTag; Arc findArc(const Node& u, const Node& v, const Arc& prev = INVALID) const { return _digraph->findArc(u, v, prev); } @@ -95,22 +101,20 @@ int maxNodeId() const { return _digraph->maxNodeId(); } int maxArcId() const { return _digraph->maxArcId(); } - typedef typename ItemSetTraits::ItemNotifier NodeNotifier; + typedef typename ItemSetTraits::ItemNotifier NodeNotifier; NodeNotifier& notifier(Node) const { return _digraph->notifier(Node()); } - typedef typename ItemSetTraits::ItemNotifier ArcNotifier; + typedef typename ItemSetTraits::ItemNotifier ArcNotifier; ArcNotifier& notifier(Arc) const { return _digraph->notifier(Arc()); } - template - class NodeMap : public Digraph::template NodeMap<_Value> { + template + class NodeMap : public DGR::template NodeMap { + typedef typename DGR::template NodeMap Parent; + public: - - typedef typename Digraph::template NodeMap<_Value> Parent; - explicit NodeMap(const Adaptor& adaptor) : Parent(*adaptor._digraph) {} - - NodeMap(const Adaptor& adaptor, const _Value& value) + NodeMap(const Adaptor& adaptor, const V& value) : Parent(*adaptor._digraph, value) { } private: @@ -126,16 +130,14 @@ }; - template - class ArcMap : public Digraph::template ArcMap<_Value> { + template + class ArcMap : public DGR::template ArcMap { + typedef typename DGR::template ArcMap Parent; + public: - - typedef typename Digraph::template ArcMap<_Value> Parent; - - explicit ArcMap(const Adaptor& adaptor) + explicit ArcMap(const DigraphAdaptorBase& adaptor) : Parent(*adaptor._digraph) {} - - ArcMap(const Adaptor& adaptor, const _Value& value) + ArcMap(const DigraphAdaptorBase& adaptor, const V& value) : Parent(*adaptor._digraph, value) {} private: @@ -153,25 +155,24 @@ }; - template + template class GraphAdaptorBase { public: - typedef _Graph Graph; - typedef Graph ParentGraph; + typedef GR Graph; protected: - Graph* _graph; + GR* _graph; GraphAdaptorBase() : _graph(0) {} - void setGraph(Graph& graph) { _graph = &graph; } + void initialize(GR& graph) { _graph = &graph; } public: - GraphAdaptorBase(Graph& graph) : _graph(&graph) {} - - typedef typename Graph::Node Node; - typedef typename Graph::Arc Arc; - typedef typename Graph::Edge Edge; + GraphAdaptorBase(GR& graph) : _graph(&graph) {} + + typedef typename GR::Node Node; + typedef typename GR::Arc Arc; + typedef typename GR::Edge Edge; void first(Node& i) const { _graph->first(i); } void first(Arc& i) const { _graph->first(i); } @@ -239,22 +240,23 @@ int maxArcId() const { return _graph->maxArcId(); } int maxEdgeId() const { return _graph->maxEdgeId(); } - typedef typename ItemSetTraits::ItemNotifier NodeNotifier; + typedef typename ItemSetTraits::ItemNotifier NodeNotifier; NodeNotifier& notifier(Node) const { return _graph->notifier(Node()); } - typedef typename ItemSetTraits::ItemNotifier ArcNotifier; + typedef typename ItemSetTraits::ItemNotifier ArcNotifier; ArcNotifier& notifier(Arc) const { return _graph->notifier(Arc()); } - typedef typename ItemSetTraits::ItemNotifier EdgeNotifier; + typedef typename ItemSetTraits::ItemNotifier EdgeNotifier; EdgeNotifier& notifier(Edge) const { return _graph->notifier(Edge()); } - template - class NodeMap : public Graph::template NodeMap<_Value> { + template + class NodeMap : public GR::template NodeMap { + typedef typename GR::template NodeMap Parent; + public: - typedef typename Graph::template NodeMap<_Value> Parent; - explicit NodeMap(const GraphAdaptorBase& adapter) + explicit NodeMap(const GraphAdaptorBase& adapter) : Parent(*adapter._graph) {} - NodeMap(const GraphAdaptorBase& adapter, const _Value& value) + NodeMap(const GraphAdaptorBase& adapter, const V& value) : Parent(*adapter._graph, value) {} private: @@ -270,13 +272,14 @@ }; - template - class ArcMap : public Graph::template ArcMap<_Value> { + template + class ArcMap : public GR::template ArcMap { + typedef typename GR::template ArcMap Parent; + public: - typedef typename Graph::template ArcMap<_Value> Parent; - explicit ArcMap(const GraphAdaptorBase& adapter) + explicit ArcMap(const GraphAdaptorBase& adapter) : Parent(*adapter._graph) {} - ArcMap(const GraphAdaptorBase& adapter, const _Value& value) + ArcMap(const GraphAdaptorBase& adapter, const V& value) : Parent(*adapter._graph, value) {} private: @@ -291,13 +294,14 @@ } }; - template - class EdgeMap : public Graph::template EdgeMap<_Value> { + template + class EdgeMap : public GR::template EdgeMap { + typedef typename GR::template EdgeMap Parent; + public: - typedef typename Graph::template EdgeMap<_Value> Parent; - explicit EdgeMap(const GraphAdaptorBase& adapter) + explicit EdgeMap(const GraphAdaptorBase& adapter) : Parent(*adapter._graph) {} - EdgeMap(const GraphAdaptorBase& adapter, const _Value& value) + EdgeMap(const GraphAdaptorBase& adapter, const V& value) : Parent(*adapter._graph, value) {} private: @@ -314,11 +318,11 @@ }; - template - class ReverseDigraphBase : public DigraphAdaptorBase<_Digraph> { + template + class ReverseDigraphBase : public DigraphAdaptorBase { + typedef DigraphAdaptorBase Parent; public: - typedef _Digraph Digraph; - typedef DigraphAdaptorBase<_Digraph> Parent; + typedef DGR Digraph; protected: ReverseDigraphBase() : Parent() { } public: @@ -336,7 +340,7 @@ Arc addArc(const Node& u, const Node& v) { return Parent::addArc(v, u); } - typedef FindArcTagIndicator FindArcTag; + typedef FindArcTagIndicator FindArcTag; Arc findArc(const Node& u, const Node& v, const Arc& prev = INVALID) const { return Parent::findArc(v, u, prev); @@ -356,23 +360,23 @@ /// by adding or removing nodes or arcs, unless the \c GR template /// parameter is set to be \c const. /// - /// \tparam GR The type of the adapted digraph. + /// \tparam DGR The type of the adapted digraph. /// It must conform to the \ref concepts::Digraph "Digraph" concept. /// It can also be specified to be \c const. /// /// \note The \c Node and \c Arc types of this adaptor and the adapted /// digraph are convertible to each other. - template + template #ifdef DOXYGEN class ReverseDigraph { #else class ReverseDigraph : - public DigraphAdaptorExtender > { + public DigraphAdaptorExtender > { #endif + typedef DigraphAdaptorExtender > Parent; public: /// The type of the adapted digraph. - typedef GR Digraph; - typedef DigraphAdaptorExtender > Parent; + typedef DGR Digraph; protected: ReverseDigraph() { } public: @@ -380,8 +384,8 @@ /// \brief Constructor /// /// Creates a reverse digraph adaptor for the given digraph. - explicit ReverseDigraph(Digraph& digraph) { - Parent::setDigraph(digraph); + explicit ReverseDigraph(DGR& digraph) { + Parent::initialize(digraph); } }; @@ -390,33 +394,31 @@ /// This function just returns a read-only \ref ReverseDigraph adaptor. /// \ingroup graph_adaptors /// \relates ReverseDigraph - template - ReverseDigraph reverseDigraph(const GR& digraph) { - return ReverseDigraph(digraph); + template + ReverseDigraph reverseDigraph(const DGR& digraph) { + return ReverseDigraph(digraph); } - template - class SubDigraphBase : public DigraphAdaptorBase<_Digraph> { + template + class SubDigraphBase : public DigraphAdaptorBase { + typedef DigraphAdaptorBase Parent; public: - typedef _Digraph Digraph; - typedef _NodeFilterMap NodeFilterMap; - typedef _ArcFilterMap ArcFilterMap; + typedef DGR Digraph; + typedef NF NodeFilterMap; + typedef AF ArcFilterMap; typedef SubDigraphBase Adaptor; - typedef DigraphAdaptorBase<_Digraph> Parent; protected: - NodeFilterMap* _node_filter; - ArcFilterMap* _arc_filter; + NF* _node_filter; + AF* _arc_filter; SubDigraphBase() : Parent(), _node_filter(0), _arc_filter(0) { } - void setNodeFilterMap(NodeFilterMap& node_filter) { + void initialize(DGR& digraph, NF& node_filter, AF& arc_filter) { + Parent::initialize(digraph); _node_filter = &node_filter; - } - void setArcFilterMap(ArcFilterMap& arc_filter) { - _arc_filter = &arc_filter; + _arc_filter = &arc_filter; } public: @@ -487,7 +489,7 @@ typedef False NodeNumTag; typedef False ArcNumTag; - typedef FindArcTagIndicator FindArcTag; + typedef FindArcTagIndicator FindArcTag; Arc findArc(const Node& source, const Node& target, const Arc& prev = INVALID) const { if (!(*_node_filter)[source] || !(*_node_filter)[target]) { @@ -500,18 +502,22 @@ return arc; } - template - class NodeMap : public SubMapExtender > { + public: + + template + class NodeMap + : public SubMapExtender, + LEMON_SCOPE_FIX(DigraphAdaptorBase, NodeMap)> { + typedef SubMapExtender, + LEMON_SCOPE_FIX(DigraphAdaptorBase, NodeMap)> Parent; + public: - typedef _Value Value; - typedef SubMapExtender > MapParent; - - NodeMap(const Adaptor& adaptor) - : MapParent(adaptor) {} - NodeMap(const Adaptor& adaptor, const Value& value) - : MapParent(adaptor, value) {} + typedef V Value; + + NodeMap(const SubDigraphBase& adaptor) + : Parent(adaptor) {} + NodeMap(const SubDigraphBase& adaptor, const V& value) + : Parent(adaptor, value) {} private: NodeMap& operator=(const NodeMap& cmap) { @@ -520,23 +526,25 @@ template NodeMap& operator=(const CMap& cmap) { - MapParent::operator=(cmap); + Parent::operator=(cmap); return *this; } }; - template - class ArcMap : public SubMapExtender > { + template + class ArcMap + : public SubMapExtender, + LEMON_SCOPE_FIX(DigraphAdaptorBase, ArcMap)> { + typedef SubMapExtender, + LEMON_SCOPE_FIX(DigraphAdaptorBase, ArcMap)> Parent; + public: - typedef _Value Value; - typedef SubMapExtender > MapParent; - - ArcMap(const Adaptor& adaptor) - : MapParent(adaptor) {} - ArcMap(const Adaptor& adaptor, const Value& value) - : MapParent(adaptor, value) {} + typedef V Value; + + ArcMap(const SubDigraphBase& adaptor) + : Parent(adaptor) {} + ArcMap(const SubDigraphBase& adaptor, const V& value) + : Parent(adaptor, value) {} private: ArcMap& operator=(const ArcMap& cmap) { @@ -545,34 +553,33 @@ template ArcMap& operator=(const CMap& cmap) { - MapParent::operator=(cmap); + Parent::operator=(cmap); return *this; } }; }; - template - class SubDigraphBase<_Digraph, _NodeFilterMap, _ArcFilterMap, false> - : public DigraphAdaptorBase<_Digraph> { + template + class SubDigraphBase + : public DigraphAdaptorBase { + typedef DigraphAdaptorBase Parent; public: - typedef _Digraph Digraph; - typedef _NodeFilterMap NodeFilterMap; - typedef _ArcFilterMap ArcFilterMap; + typedef DGR Digraph; + typedef NF NodeFilterMap; + typedef AF ArcFilterMap; typedef SubDigraphBase Adaptor; - typedef DigraphAdaptorBase Parent; protected: - NodeFilterMap* _node_filter; - ArcFilterMap* _arc_filter; + NF* _node_filter; + AF* _arc_filter; SubDigraphBase() : Parent(), _node_filter(0), _arc_filter(0) { } - void setNodeFilterMap(NodeFilterMap& node_filter) { + void initialize(DGR& digraph, NF& node_filter, AF& arc_filter) { + Parent::initialize(digraph); _node_filter = &node_filter; - } - void setArcFilterMap(ArcFilterMap& arc_filter) { - _arc_filter = &arc_filter; + _arc_filter = &arc_filter; } public: @@ -627,7 +634,7 @@ typedef False NodeNumTag; typedef False ArcNumTag; - typedef FindArcTagIndicator FindArcTag; + typedef FindArcTagIndicator FindArcTag; Arc findArc(const Node& source, const Node& target, const Arc& prev = INVALID) const { if (!(*_node_filter)[source] || !(*_node_filter)[target]) { @@ -640,18 +647,20 @@ return arc; } - template - class NodeMap : public SubMapExtender > { + template + class NodeMap + : public SubMapExtender, + LEMON_SCOPE_FIX(DigraphAdaptorBase, NodeMap)> { + typedef SubMapExtender, + LEMON_SCOPE_FIX(DigraphAdaptorBase, NodeMap)> Parent; + public: - typedef _Value Value; - typedef SubMapExtender > MapParent; - - NodeMap(const Adaptor& adaptor) - : MapParent(adaptor) {} - NodeMap(const Adaptor& adaptor, const Value& value) - : MapParent(adaptor, value) {} + typedef V Value; + + NodeMap(const SubDigraphBase& adaptor) + : Parent(adaptor) {} + NodeMap(const SubDigraphBase& adaptor, const V& value) + : Parent(adaptor, value) {} private: NodeMap& operator=(const NodeMap& cmap) { @@ -660,23 +669,25 @@ template NodeMap& operator=(const CMap& cmap) { - MapParent::operator=(cmap); + Parent::operator=(cmap); return *this; } }; - template - class ArcMap : public SubMapExtender > { + template + class ArcMap + : public SubMapExtender, + LEMON_SCOPE_FIX(DigraphAdaptorBase, ArcMap)> { + typedef SubMapExtender, + LEMON_SCOPE_FIX(DigraphAdaptorBase, ArcMap)> Parent; + public: - typedef _Value Value; - typedef SubMapExtender > MapParent; - - ArcMap(const Adaptor& adaptor) - : MapParent(adaptor) {} - ArcMap(const Adaptor& adaptor, const Value& value) - : MapParent(adaptor, value) {} + typedef V Value; + + ArcMap(const SubDigraphBase& adaptor) + : Parent(adaptor) {} + ArcMap(const SubDigraphBase& adaptor, const V& value) + : Parent(adaptor, value) {} private: ArcMap& operator=(const ArcMap& cmap) { @@ -685,7 +696,7 @@ template ArcMap& operator=(const CMap& cmap) { - MapParent::operator=(cmap); + Parent::operator=(cmap); return *this; } }; @@ -708,17 +719,17 @@ /// by adding or removing nodes or arcs, unless the \c GR template /// parameter is set to be \c const. /// - /// \tparam GR The type of the adapted digraph. + /// \tparam DGR The type of the adapted digraph. /// It must conform to the \ref concepts::Digraph "Digraph" concept. /// It can also be specified to be \c const. /// \tparam NF The type of the node filter map. /// It must be a \c bool (or convertible) node map of the /// adapted digraph. The default type is - /// \ref concepts::Digraph::NodeMap "GR::NodeMap". + /// \ref concepts::Digraph::NodeMap "DGR::NodeMap". /// \tparam AF The type of the arc filter map. /// It must be \c bool (or convertible) arc map of the /// adapted digraph. The default type is - /// \ref concepts::Digraph::ArcMap "GR::ArcMap". + /// \ref concepts::Digraph::ArcMap "DGR::ArcMap". /// /// \note The \c Node and \c Arc types of this adaptor and the adapted /// digraph are convertible to each other. @@ -726,24 +737,24 @@ /// \see FilterNodes /// \see FilterArcs #ifdef DOXYGEN - template + template class SubDigraph { #else - template, - typename AF = typename GR::template ArcMap > + template, + typename AF = typename DGR::template ArcMap > class SubDigraph : - public DigraphAdaptorExtender > { + public DigraphAdaptorExtender > { #endif public: /// The type of the adapted digraph. - typedef GR Digraph; + typedef DGR Digraph; /// The type of the node filter map. typedef NF NodeFilterMap; /// The type of the arc filter map. typedef AF ArcFilterMap; - typedef DigraphAdaptorExtender > + typedef DigraphAdaptorExtender > Parent; typedef typename Parent::Node Node; @@ -757,11 +768,8 @@ /// /// Creates a subdigraph for the given digraph with the /// given node and arc filter maps. - SubDigraph(Digraph& digraph, NodeFilterMap& node_filter, - ArcFilterMap& arc_filter) { - setDigraph(digraph); - setNodeFilterMap(node_filter); - setArcFilterMap(arc_filter); + SubDigraph(DGR& digraph, NF& node_filter, AF& arc_filter) { + Parent::initialize(digraph, node_filter, arc_filter); } /// \brief Sets the status of the given node @@ -823,62 +831,60 @@ /// This function just returns a read-only \ref SubDigraph adaptor. /// \ingroup graph_adaptors /// \relates SubDigraph - template - SubDigraph - subDigraph(const GR& digraph, - NF& node_filter_map, AF& arc_filter_map) { - return SubDigraph - (digraph, node_filter_map, arc_filter_map); + template + SubDigraph + subDigraph(const DGR& digraph, + NF& node_filter, AF& arc_filter) { + return SubDigraph + (digraph, node_filter, arc_filter); } - template - SubDigraph - subDigraph(const GR& digraph, - const NF& node_filter_map, AF& arc_filter_map) { - return SubDigraph - (digraph, node_filter_map, arc_filter_map); + template + SubDigraph + subDigraph(const DGR& digraph, + const NF& node_filter, AF& arc_filter) { + return SubDigraph + (digraph, node_filter, arc_filter); } - template - SubDigraph - subDigraph(const GR& digraph, - NF& node_filter_map, const AF& arc_filter_map) { - return SubDigraph - (digraph, node_filter_map, arc_filter_map); + template + SubDigraph + subDigraph(const DGR& digraph, + NF& node_filter, const AF& arc_filter) { + return SubDigraph + (digraph, node_filter, arc_filter); } - template - SubDigraph - subDigraph(const GR& digraph, - const NF& node_filter_map, const AF& arc_filter_map) { - return SubDigraph - (digraph, node_filter_map, arc_filter_map); + template + SubDigraph + subDigraph(const DGR& digraph, + const NF& node_filter, const AF& arc_filter) { + return SubDigraph + (digraph, node_filter, arc_filter); } - template - class SubGraphBase : public GraphAdaptorBase<_Graph> { + template + class SubGraphBase : public GraphAdaptorBase { + typedef GraphAdaptorBase Parent; public: - typedef _Graph Graph; - typedef _NodeFilterMap NodeFilterMap; - typedef _EdgeFilterMap EdgeFilterMap; + typedef GR Graph; + typedef NF NodeFilterMap; + typedef EF EdgeFilterMap; typedef SubGraphBase Adaptor; - typedef GraphAdaptorBase<_Graph> Parent; protected: - NodeFilterMap* _node_filter_map; - EdgeFilterMap* _edge_filter_map; + NF* _node_filter; + EF* _edge_filter; SubGraphBase() - : Parent(), _node_filter_map(0), _edge_filter_map(0) { } - - void setNodeFilterMap(NodeFilterMap& node_filter_map) { - _node_filter_map=&node_filter_map; - } - void setEdgeFilterMap(EdgeFilterMap& edge_filter_map) { - _edge_filter_map=&edge_filter_map; + : Parent(), _node_filter(0), _edge_filter(0) { } + + void initialize(GR& graph, NF& node_filter, EF& edge_filter) { + Parent::initialize(graph); + _node_filter = &node_filter; + _edge_filter = &edge_filter; } public: @@ -889,95 +895,95 @@ void first(Node& i) const { Parent::first(i); - while (i!=INVALID && !(*_node_filter_map)[i]) Parent::next(i); + while (i!=INVALID && !(*_node_filter)[i]) Parent::next(i); } void first(Arc& i) const { Parent::first(i); - while (i!=INVALID && (!(*_edge_filter_map)[i] - || !(*_node_filter_map)[Parent::source(i)] - || !(*_node_filter_map)[Parent::target(i)])) + while (i!=INVALID && (!(*_edge_filter)[i] + || !(*_node_filter)[Parent::source(i)] + || !(*_node_filter)[Parent::target(i)])) Parent::next(i); } void first(Edge& i) const { Parent::first(i); - while (i!=INVALID && (!(*_edge_filter_map)[i] - || !(*_node_filter_map)[Parent::u(i)] - || !(*_node_filter_map)[Parent::v(i)])) + while (i!=INVALID && (!(*_edge_filter)[i] + || !(*_node_filter)[Parent::u(i)] + || !(*_node_filter)[Parent::v(i)])) Parent::next(i); } void firstIn(Arc& i, const Node& n) const { Parent::firstIn(i, n); - while (i!=INVALID && (!(*_edge_filter_map)[i] - || !(*_node_filter_map)[Parent::source(i)])) + while (i!=INVALID && (!(*_edge_filter)[i] + || !(*_node_filter)[Parent::source(i)])) Parent::nextIn(i); } void firstOut(Arc& i, const Node& n) const { Parent::firstOut(i, n); - while (i!=INVALID && (!(*_edge_filter_map)[i] - || !(*_node_filter_map)[Parent::target(i)])) + while (i!=INVALID && (!(*_edge_filter)[i] + || !(*_node_filter)[Parent::target(i)])) Parent::nextOut(i); } void firstInc(Edge& i, bool& d, const Node& n) const { Parent::firstInc(i, d, n); - while (i!=INVALID && (!(*_edge_filter_map)[i] - || !(*_node_filter_map)[Parent::u(i)] - || !(*_node_filter_map)[Parent::v(i)])) + while (i!=INVALID && (!(*_edge_filter)[i] + || !(*_node_filter)[Parent::u(i)] + || !(*_node_filter)[Parent::v(i)])) Parent::nextInc(i, d); } void next(Node& i) const { Parent::next(i); - while (i!=INVALID && !(*_node_filter_map)[i]) Parent::next(i); + while (i!=INVALID && !(*_node_filter)[i]) Parent::next(i); } void next(Arc& i) const { Parent::next(i); - while (i!=INVALID && (!(*_edge_filter_map)[i] - || !(*_node_filter_map)[Parent::source(i)] - || !(*_node_filter_map)[Parent::target(i)])) + while (i!=INVALID && (!(*_edge_filter)[i] + || !(*_node_filter)[Parent::source(i)] + || !(*_node_filter)[Parent::target(i)])) Parent::next(i); } void next(Edge& i) const { Parent::next(i); - while (i!=INVALID && (!(*_edge_filter_map)[i] - || !(*_node_filter_map)[Parent::u(i)] - || !(*_node_filter_map)[Parent::v(i)])) + while (i!=INVALID && (!(*_edge_filter)[i] + || !(*_node_filter)[Parent::u(i)] + || !(*_node_filter)[Parent::v(i)])) Parent::next(i); } void nextIn(Arc& i) const { Parent::nextIn(i); - while (i!=INVALID && (!(*_edge_filter_map)[i] - || !(*_node_filter_map)[Parent::source(i)])) + while (i!=INVALID && (!(*_edge_filter)[i] + || !(*_node_filter)[Parent::source(i)])) Parent::nextIn(i); } void nextOut(Arc& i) const { Parent::nextOut(i); - while (i!=INVALID && (!(*_edge_filter_map)[i] - || !(*_node_filter_map)[Parent::target(i)])) + while (i!=INVALID && (!(*_edge_filter)[i] + || !(*_node_filter)[Parent::target(i)])) Parent::nextOut(i); } void nextInc(Edge& i, bool& d) const { Parent::nextInc(i, d); - while (i!=INVALID && (!(*_edge_filter_map)[i] - || !(*_node_filter_map)[Parent::u(i)] - || !(*_node_filter_map)[Parent::v(i)])) + while (i!=INVALID && (!(*_edge_filter)[i] + || !(*_node_filter)[Parent::u(i)] + || !(*_node_filter)[Parent::v(i)])) Parent::nextInc(i, d); } - void status(const Node& n, bool v) const { _node_filter_map->set(n, v); } - void status(const Edge& e, bool v) const { _edge_filter_map->set(e, v); } - - bool status(const Node& n) const { return (*_node_filter_map)[n]; } - bool status(const Edge& e) const { return (*_edge_filter_map)[e]; } + void status(const Node& n, bool v) const { _node_filter->set(n, v); } + void status(const Edge& e, bool v) const { _edge_filter->set(e, v); } + + bool status(const Node& n) const { return (*_node_filter)[n]; } + bool status(const Edge& e) const { return (*_edge_filter)[e]; } typedef False NodeNumTag; typedef False ArcNumTag; @@ -986,11 +992,11 @@ typedef FindArcTagIndicator FindArcTag; Arc findArc(const Node& u, const Node& v, const Arc& prev = INVALID) const { - if (!(*_node_filter_map)[u] || !(*_node_filter_map)[v]) { + if (!(*_node_filter)[u] || !(*_node_filter)[v]) { return INVALID; } Arc arc = Parent::findArc(u, v, prev); - while (arc != INVALID && !(*_edge_filter_map)[arc]) { + while (arc != INVALID && !(*_edge_filter)[arc]) { arc = Parent::findArc(u, v, arc); } return arc; @@ -999,28 +1005,30 @@ typedef FindEdgeTagIndicator FindEdgeTag; Edge findEdge(const Node& u, const Node& v, const Edge& prev = INVALID) const { - if (!(*_node_filter_map)[u] || !(*_node_filter_map)[v]) { + if (!(*_node_filter)[u] || !(*_node_filter)[v]) { return INVALID; } Edge edge = Parent::findEdge(u, v, prev); - while (edge != INVALID && !(*_edge_filter_map)[edge]) { + while (edge != INVALID && !(*_edge_filter)[edge]) { edge = Parent::findEdge(u, v, edge); } return edge; } - template - class NodeMap : public SubMapExtender > { + template + class NodeMap + : public SubMapExtender, + LEMON_SCOPE_FIX(GraphAdaptorBase, NodeMap)> { + typedef SubMapExtender, + LEMON_SCOPE_FIX(GraphAdaptorBase, NodeMap)> Parent; + public: - typedef _Value Value; - typedef SubMapExtender > MapParent; - - NodeMap(const Adaptor& adaptor) - : MapParent(adaptor) {} - NodeMap(const Adaptor& adaptor, const Value& value) - : MapParent(adaptor, value) {} + typedef V Value; + + NodeMap(const SubGraphBase& adaptor) + : Parent(adaptor) {} + NodeMap(const SubGraphBase& adaptor, const V& value) + : Parent(adaptor, value) {} private: NodeMap& operator=(const NodeMap& cmap) { @@ -1029,23 +1037,25 @@ template NodeMap& operator=(const CMap& cmap) { - MapParent::operator=(cmap); + Parent::operator=(cmap); return *this; } }; - template - class ArcMap : public SubMapExtender > { + template + class ArcMap + : public SubMapExtender, + LEMON_SCOPE_FIX(GraphAdaptorBase, ArcMap)> { + typedef SubMapExtender, + LEMON_SCOPE_FIX(GraphAdaptorBase, ArcMap)> Parent; + public: - typedef _Value Value; - typedef SubMapExtender > MapParent; - - ArcMap(const Adaptor& adaptor) - : MapParent(adaptor) {} - ArcMap(const Adaptor& adaptor, const Value& value) - : MapParent(adaptor, value) {} + typedef V Value; + + ArcMap(const SubGraphBase& adaptor) + : Parent(adaptor) {} + ArcMap(const SubGraphBase& adaptor, const V& value) + : Parent(adaptor, value) {} private: ArcMap& operator=(const ArcMap& cmap) { @@ -1054,24 +1064,26 @@ template ArcMap& operator=(const CMap& cmap) { - MapParent::operator=(cmap); + Parent::operator=(cmap); return *this; } }; - template - class EdgeMap : public SubMapExtender > { + template + class EdgeMap + : public SubMapExtender, + LEMON_SCOPE_FIX(GraphAdaptorBase, EdgeMap)> { + typedef SubMapExtender, + LEMON_SCOPE_FIX(GraphAdaptorBase, EdgeMap)> Parent; + public: - typedef _Value Value; - typedef SubMapExtender > MapParent; - - EdgeMap(const Adaptor& adaptor) - : MapParent(adaptor) {} - - EdgeMap(const Adaptor& adaptor, const Value& value) - : MapParent(adaptor, value) {} + typedef V Value; + + EdgeMap(const SubGraphBase& adaptor) + : Parent(adaptor) {} + + EdgeMap(const SubGraphBase& adaptor, const V& value) + : Parent(adaptor, value) {} private: EdgeMap& operator=(const EdgeMap& cmap) { @@ -1080,34 +1092,33 @@ template EdgeMap& operator=(const CMap& cmap) { - MapParent::operator=(cmap); + Parent::operator=(cmap); return *this; } }; }; - template - class SubGraphBase<_Graph, _NodeFilterMap, _EdgeFilterMap, false> - : public GraphAdaptorBase<_Graph> { + template + class SubGraphBase + : public GraphAdaptorBase { + typedef GraphAdaptorBase Parent; public: - typedef _Graph Graph; - typedef _NodeFilterMap NodeFilterMap; - typedef _EdgeFilterMap EdgeFilterMap; + typedef GR Graph; + typedef NF NodeFilterMap; + typedef EF EdgeFilterMap; typedef SubGraphBase Adaptor; - typedef GraphAdaptorBase<_Graph> Parent; protected: - NodeFilterMap* _node_filter_map; - EdgeFilterMap* _edge_filter_map; - SubGraphBase() : Parent(), - _node_filter_map(0), _edge_filter_map(0) { } - - void setNodeFilterMap(NodeFilterMap& node_filter_map) { - _node_filter_map=&node_filter_map; - } - void setEdgeFilterMap(EdgeFilterMap& edge_filter_map) { - _edge_filter_map=&edge_filter_map; + NF* _node_filter; + EF* _edge_filter; + SubGraphBase() + : Parent(), _node_filter(0), _edge_filter(0) { } + + void initialize(GR& graph, NF& node_filter, EF& edge_filter) { + Parent::initialize(graph); + _node_filter = &node_filter; + _edge_filter = &edge_filter; } public: @@ -1118,65 +1129,65 @@ void first(Node& i) const { Parent::first(i); - while (i!=INVALID && !(*_node_filter_map)[i]) Parent::next(i); + while (i!=INVALID && !(*_node_filter)[i]) Parent::next(i); } void first(Arc& i) const { Parent::first(i); - while (i!=INVALID && !(*_edge_filter_map)[i]) Parent::next(i); + while (i!=INVALID && !(*_edge_filter)[i]) Parent::next(i); } void first(Edge& i) const { Parent::first(i); - while (i!=INVALID && !(*_edge_filter_map)[i]) Parent::next(i); + while (i!=INVALID && !(*_edge_filter)[i]) Parent::next(i); } void firstIn(Arc& i, const Node& n) const { Parent::firstIn(i, n); - while (i!=INVALID && !(*_edge_filter_map)[i]) Parent::nextIn(i); + while (i!=INVALID && !(*_edge_filter)[i]) Parent::nextIn(i); } void firstOut(Arc& i, const Node& n) const { Parent::firstOut(i, n); - while (i!=INVALID && !(*_edge_filter_map)[i]) Parent::nextOut(i); + while (i!=INVALID && !(*_edge_filter)[i]) Parent::nextOut(i); } void firstInc(Edge& i, bool& d, const Node& n) const { Parent::firstInc(i, d, n); - while (i!=INVALID && !(*_edge_filter_map)[i]) Parent::nextInc(i, d); + while (i!=INVALID && !(*_edge_filter)[i]) Parent::nextInc(i, d); } void next(Node& i) const { Parent::next(i); - while (i!=INVALID && !(*_node_filter_map)[i]) Parent::next(i); + while (i!=INVALID && !(*_node_filter)[i]) Parent::next(i); } void next(Arc& i) const { Parent::next(i); - while (i!=INVALID && !(*_edge_filter_map)[i]) Parent::next(i); + while (i!=INVALID && !(*_edge_filter)[i]) Parent::next(i); } void next(Edge& i) const { Parent::next(i); - while (i!=INVALID && !(*_edge_filter_map)[i]) Parent::next(i); + while (i!=INVALID && !(*_edge_filter)[i]) Parent::next(i); } void nextIn(Arc& i) const { Parent::nextIn(i); - while (i!=INVALID && !(*_edge_filter_map)[i]) Parent::nextIn(i); + while (i!=INVALID && !(*_edge_filter)[i]) Parent::nextIn(i); } void nextOut(Arc& i) const { Parent::nextOut(i); - while (i!=INVALID && !(*_edge_filter_map)[i]) Parent::nextOut(i); + while (i!=INVALID && !(*_edge_filter)[i]) Parent::nextOut(i); } void nextInc(Edge& i, bool& d) const { Parent::nextInc(i, d); - while (i!=INVALID && !(*_edge_filter_map)[i]) Parent::nextInc(i, d); + while (i!=INVALID && !(*_edge_filter)[i]) Parent::nextInc(i, d); } - void status(const Node& n, bool v) const { _node_filter_map->set(n, v); } - void status(const Edge& e, bool v) const { _edge_filter_map->set(e, v); } - - bool status(const Node& n) const { return (*_node_filter_map)[n]; } - bool status(const Edge& e) const { return (*_edge_filter_map)[e]; } + void status(const Node& n, bool v) const { _node_filter->set(n, v); } + void status(const Edge& e, bool v) const { _edge_filter->set(e, v); } + + bool status(const Node& n) const { return (*_node_filter)[n]; } + bool status(const Edge& e) const { return (*_edge_filter)[e]; } typedef False NodeNumTag; typedef False ArcNumTag; @@ -1186,7 +1197,7 @@ Arc findArc(const Node& u, const Node& v, const Arc& prev = INVALID) const { Arc arc = Parent::findArc(u, v, prev); - while (arc != INVALID && !(*_edge_filter_map)[arc]) { + while (arc != INVALID && !(*_edge_filter)[arc]) { arc = Parent::findArc(u, v, arc); } return arc; @@ -1196,24 +1207,26 @@ Edge findEdge(const Node& u, const Node& v, const Edge& prev = INVALID) const { Edge edge = Parent::findEdge(u, v, prev); - while (edge != INVALID && !(*_edge_filter_map)[edge]) { + while (edge != INVALID && !(*_edge_filter)[edge]) { edge = Parent::findEdge(u, v, edge); } return edge; } - template - class NodeMap : public SubMapExtender > { + template + class NodeMap + : public SubMapExtender, + LEMON_SCOPE_FIX(GraphAdaptorBase, NodeMap)> { + typedef SubMapExtender, + LEMON_SCOPE_FIX(GraphAdaptorBase, NodeMap)> Parent; + public: - typedef _Value Value; - typedef SubMapExtender > MapParent; - - NodeMap(const Adaptor& adaptor) - : MapParent(adaptor) {} - NodeMap(const Adaptor& adaptor, const Value& value) - : MapParent(adaptor, value) {} + typedef V Value; + + NodeMap(const SubGraphBase& adaptor) + : Parent(adaptor) {} + NodeMap(const SubGraphBase& adaptor, const V& value) + : Parent(adaptor, value) {} private: NodeMap& operator=(const NodeMap& cmap) { @@ -1222,23 +1235,25 @@ template NodeMap& operator=(const CMap& cmap) { - MapParent::operator=(cmap); + Parent::operator=(cmap); return *this; } }; - template - class ArcMap : public SubMapExtender > { + template + class ArcMap + : public SubMapExtender, + LEMON_SCOPE_FIX(GraphAdaptorBase, ArcMap)> { + typedef SubMapExtender, + LEMON_SCOPE_FIX(GraphAdaptorBase, ArcMap)> Parent; + public: - typedef _Value Value; - typedef SubMapExtender > MapParent; - - ArcMap(const Adaptor& adaptor) - : MapParent(adaptor) {} - ArcMap(const Adaptor& adaptor, const Value& value) - : MapParent(adaptor, value) {} + typedef V Value; + + ArcMap(const SubGraphBase& adaptor) + : Parent(adaptor) {} + ArcMap(const SubGraphBase& adaptor, const V& value) + : Parent(adaptor, value) {} private: ArcMap& operator=(const ArcMap& cmap) { @@ -1247,24 +1262,26 @@ template ArcMap& operator=(const CMap& cmap) { - MapParent::operator=(cmap); + Parent::operator=(cmap); return *this; } }; - template - class EdgeMap : public SubMapExtender > { + template + class EdgeMap + : public SubMapExtender, + LEMON_SCOPE_FIX(GraphAdaptorBase, EdgeMap)> { + typedef SubMapExtender, + LEMON_SCOPE_FIX(GraphAdaptorBase, EdgeMap)> Parent; + public: - typedef _Value Value; - typedef SubMapExtender > MapParent; - - EdgeMap(const Adaptor& adaptor) - : MapParent(adaptor) {} - - EdgeMap(const Adaptor& adaptor, const _Value& value) - : MapParent(adaptor, value) {} + typedef V Value; + + EdgeMap(const SubGraphBase& adaptor) + : Parent(adaptor) {} + + EdgeMap(const SubGraphBase& adaptor, const V& value) + : Parent(adaptor, value) {} private: EdgeMap& operator=(const EdgeMap& cmap) { @@ -1273,7 +1290,7 @@ template EdgeMap& operator=(const CMap& cmap) { - MapParent::operator=(cmap); + Parent::operator=(cmap); return *this; } }; @@ -1332,7 +1349,7 @@ /// The type of the edge filter map. typedef EF EdgeFilterMap; - typedef GraphAdaptorExtender< SubGraphBase > + typedef GraphAdaptorExtender > Parent; typedef typename Parent::Node Node; @@ -1346,11 +1363,8 @@ /// /// Creates a subgraph for the given graph with the given node /// and edge filter maps. - SubGraph(Graph& graph, NodeFilterMap& node_filter_map, - EdgeFilterMap& edge_filter_map) { - setGraph(graph); - setNodeFilterMap(node_filter_map); - setEdgeFilterMap(edge_filter_map); + SubGraph(GR& graph, NF& node_filter, EF& edge_filter) { + initialize(graph, node_filter, edge_filter); } /// \brief Sets the status of the given node @@ -1414,34 +1428,30 @@ /// \relates SubGraph template SubGraph - subGraph(const GR& graph, - NF& node_filter_map, EF& edge_filter_map) { + subGraph(const GR& graph, NF& node_filter, EF& edge_filter) { return SubGraph - (graph, node_filter_map, edge_filter_map); + (graph, node_filter, edge_filter); } template SubGraph - subGraph(const GR& graph, - const NF& node_filter_map, EF& edge_filter_map) { + subGraph(const GR& graph, const NF& node_filter, EF& edge_filter) { return SubGraph - (graph, node_filter_map, edge_filter_map); + (graph, node_filter, edge_filter); } template SubGraph - subGraph(const GR& graph, - NF& node_filter_map, const EF& edge_filter_map) { + subGraph(const GR& graph, NF& node_filter, const EF& edge_filter) { return SubGraph - (graph, node_filter_map, edge_filter_map); + (graph, node_filter, edge_filter); } template SubGraph - subGraph(const GR& graph, - const NF& node_filter_map, const EF& edge_filter_map) { + subGraph(const GR& graph, const NF& node_filter, const EF& edge_filter) { return SubGraph - (graph, node_filter_map, edge_filter_map); + (graph, node_filter, edge_filter); } @@ -1481,25 +1491,24 @@ typename Enable = void> class FilterNodes : public DigraphAdaptorExtender< - SubDigraphBase, true> > { + SubDigraphBase >, + true> > { #endif + typedef DigraphAdaptorExtender< + SubDigraphBase >, + true> > Parent; + public: typedef GR Digraph; typedef NF NodeFilterMap; - typedef DigraphAdaptorExtender< - SubDigraphBase, true> > - Parent; - typedef typename Parent::Node Node; protected: - ConstMap const_true_map; - - FilterNodes() : const_true_map(true) { - Parent::setArcFilterMap(const_true_map); - } + ConstMap > const_true_map; + + FilterNodes() : const_true_map() {} public: @@ -1507,12 +1516,10 @@ /// /// Creates a subgraph for the given digraph or graph with the /// given node filter map. - FilterNodes(GR& graph, NodeFilterMap& node_filter) : - Parent(), const_true_map(true) + FilterNodes(GR& graph, NF& node_filter) + : Parent(), const_true_map() { - Parent::setDigraph(graph); - Parent::setNodeFilterMap(node_filter); - Parent::setArcFilterMap(const_true_map); + Parent::initialize(graph, node_filter, const_true_map); } /// \brief Sets the status of the given node @@ -1547,30 +1554,30 @@ class FilterNodes >::type> : public GraphAdaptorExtender< - SubGraphBase, true> > { + SubGraphBase >, + true> > { + + typedef GraphAdaptorExtender< + SubGraphBase >, + true> > Parent; public: + typedef GR Graph; typedef NF NodeFilterMap; - typedef GraphAdaptorExtender< - SubGraphBase, true> > - Parent; typedef typename Parent::Node Node; + protected: - ConstMap const_true_map; - - FilterNodes() : const_true_map(true) { - Parent::setEdgeFilterMap(const_true_map); - } + ConstMap > const_true_map; + + FilterNodes() : const_true_map() {} public: - FilterNodes(Graph& _graph, NodeFilterMap& node_filter_map) : - Parent(), const_true_map(true) { - Parent::setGraph(_graph); - Parent::setNodeFilterMap(node_filter_map); - Parent::setEdgeFilterMap(const_true_map); + FilterNodes(GR& graph, NodeFilterMap& node_filter) : + Parent(), const_true_map() { + Parent::initialize(graph, node_filter, const_true_map); } void status(const Node& n, bool v) const { Parent::status(n, v); } @@ -1588,14 +1595,14 @@ /// \relates FilterNodes template FilterNodes - filterNodes(const GR& graph, NF& node_filter_map) { - return FilterNodes(graph, node_filter_map); + filterNodes(const GR& graph, NF& node_filter) { + return FilterNodes(graph, node_filter); } template FilterNodes - filterNodes(const GR& graph, const NF& node_filter_map) { - return FilterNodes(graph, node_filter_map); + filterNodes(const GR& graph, const NF& node_filter) { + return FilterNodes(graph, node_filter); } /// \ingroup graph_adaptors @@ -1612,45 +1619,45 @@ /// by adding or removing nodes or arcs, unless the \c GR template /// parameter is set to be \c const. /// - /// \tparam GR The type of the adapted digraph. + /// \tparam DGR The type of the adapted digraph. /// It must conform to the \ref concepts::Digraph "Digraph" concept. /// It can also be specified to be \c const. /// \tparam AF The type of the arc filter map. /// It must be a \c bool (or convertible) arc map of the /// adapted digraph. The default type is - /// \ref concepts::Digraph::ArcMap "GR::ArcMap". + /// \ref concepts::Digraph::ArcMap "DGR::ArcMap". /// /// \note The \c Node and \c Arc types of this adaptor and the adapted /// digraph are convertible to each other. #ifdef DOXYGEN - template class FilterArcs { #else - template > + template > class FilterArcs : public DigraphAdaptorExtender< - SubDigraphBase, AF, false> > { + SubDigraphBase >, + AF, false> > { #endif + typedef DigraphAdaptorExtender< + SubDigraphBase >, + AF, false> > Parent; + public: + /// The type of the adapted digraph. - typedef GR Digraph; + typedef DGR Digraph; /// The type of the arc filter map. typedef AF ArcFilterMap; - typedef DigraphAdaptorExtender< - SubDigraphBase, AF, false> > - Parent; - typedef typename Parent::Arc Arc; protected: - ConstMap const_true_map; - - FilterArcs() : const_true_map(true) { - Parent::setNodeFilterMap(const_true_map); - } + ConstMap > const_true_map; + + FilterArcs() : const_true_map() {} public: @@ -1658,11 +1665,9 @@ /// /// Creates a subdigraph for the given digraph with the given arc /// filter map. - FilterArcs(Digraph& digraph, ArcFilterMap& arc_filter) - : Parent(), const_true_map(true) { - Parent::setDigraph(digraph); - Parent::setNodeFilterMap(const_true_map); - Parent::setArcFilterMap(arc_filter); + FilterArcs(DGR& digraph, ArcFilterMap& arc_filter) + : Parent(), const_true_map() { + Parent::initialize(digraph, const_true_map, arc_filter); } /// \brief Sets the status of the given arc @@ -1698,16 +1703,16 @@ /// This function just returns a read-only \ref FilterArcs adaptor. /// \ingroup graph_adaptors /// \relates FilterArcs - template - FilterArcs - filterArcs(const GR& digraph, AF& arc_filter_map) { - return FilterArcs(digraph, arc_filter_map); + template + FilterArcs + filterArcs(const DGR& digraph, AF& arc_filter) { + return FilterArcs(digraph, arc_filter); } - template - FilterArcs - filterArcs(const GR& digraph, const AF& arc_filter_map) { - return FilterArcs(digraph, arc_filter_map); + template + FilterArcs + filterArcs(const DGR& digraph, const AF& arc_filter) { + return FilterArcs(digraph, arc_filter); } /// \ingroup graph_adaptors @@ -1743,22 +1748,24 @@ typename EF = typename GR::template EdgeMap > class FilterEdges : public GraphAdaptorExtender< - SubGraphBase, EF, false> > { + SubGraphBase >, + EF, false> > { #endif + typedef GraphAdaptorExtender< + SubGraphBase >, + EF, false> > Parent; + public: + /// The type of the adapted graph. typedef GR Graph; /// The type of the edge filter map. typedef EF EdgeFilterMap; - typedef GraphAdaptorExtender< - SubGraphBase, EF, false> > - Parent; - typedef typename Parent::Edge Edge; protected: - ConstMap const_true_map; + ConstMap > const_true_map; FilterEdges() : const_true_map(true) { Parent::setNodeFilterMap(const_true_map); @@ -1770,11 +1777,9 @@ /// /// Creates a subgraph for the given graph with the given edge /// filter map. - FilterEdges(Graph& graph, EdgeFilterMap& edge_filter_map) : - Parent(), const_true_map(true) { - Parent::setGraph(graph); - Parent::setNodeFilterMap(const_true_map); - Parent::setEdgeFilterMap(edge_filter_map); + FilterEdges(GR& graph, EF& edge_filter) + : Parent(), const_true_map() { + Parent::initialize(graph, const_true_map, edge_filter); } /// \brief Sets the status of the given edge @@ -1812,21 +1817,21 @@ /// \relates FilterEdges template FilterEdges - filterEdges(const GR& graph, EF& edge_filter_map) { - return FilterEdges(graph, edge_filter_map); + filterEdges(const GR& graph, EF& edge_filter) { + return FilterEdges(graph, edge_filter); } template FilterEdges - filterEdges(const GR& graph, const EF& edge_filter_map) { - return FilterEdges(graph, edge_filter_map); + filterEdges(const GR& graph, const EF& edge_filter) { + return FilterEdges(graph, edge_filter); } - template + template class UndirectorBase { public: - typedef _Digraph Digraph; + typedef DGR Digraph; typedef UndirectorBase Adaptor; typedef True UndirectedTag; @@ -1834,31 +1839,31 @@ typedef typename Digraph::Arc Edge; typedef typename Digraph::Node Node; - class Arc : public Edge { + class Arc { friend class UndirectorBase; protected: + Edge _edge; bool _forward; - Arc(const Edge& edge, bool forward) : - Edge(edge), _forward(forward) {} + Arc(const Edge& edge, bool forward) + : _edge(edge), _forward(forward) {} public: Arc() {} - Arc(Invalid) : Edge(INVALID), _forward(true) {} + Arc(Invalid) : _edge(INVALID), _forward(true) {} + + operator const Edge&() const { return _edge; } bool operator==(const Arc &other) const { - return _forward == other._forward && - static_cast(*this) == static_cast(other); + return _forward == other._forward && _edge == other._edge; } bool operator!=(const Arc &other) const { - return _forward != other._forward || - static_cast(*this) != static_cast(other); + return _forward != other._forward || _edge != other._edge; } bool operator<(const Arc &other) const { return _forward < other._forward || - (_forward == other._forward && - static_cast(*this) < static_cast(other)); + (_forward == other._forward && _edge < other._edge); } }; @@ -1871,7 +1876,7 @@ } void first(Arc& a) const { - _digraph->first(a); + _digraph->first(a._edge); a._forward = true; } @@ -1879,7 +1884,7 @@ if (a._forward) { a._forward = false; } else { - _digraph->next(a); + _digraph->next(a._edge); a._forward = true; } } @@ -1893,48 +1898,48 @@ } void firstOut(Arc& a, const Node& n) const { - _digraph->firstIn(a, n); - if( static_cast(a) != INVALID ) { + _digraph->firstIn(a._edge, n); + if (a._edge != INVALID ) { a._forward = false; } else { - _digraph->firstOut(a, n); + _digraph->firstOut(a._edge, n); a._forward = true; } } void nextOut(Arc &a) const { if (!a._forward) { - Node n = _digraph->target(a); - _digraph->nextIn(a); - if (static_cast(a) == INVALID ) { - _digraph->firstOut(a, n); + Node n = _digraph->target(a._edge); + _digraph->nextIn(a._edge); + if (a._edge == INVALID) { + _digraph->firstOut(a._edge, n); a._forward = true; } } else { - _digraph->nextOut(a); + _digraph->nextOut(a._edge); } } void firstIn(Arc &a, const Node &n) const { - _digraph->firstOut(a, n); - if (static_cast(a) != INVALID ) { + _digraph->firstOut(a._edge, n); + if (a._edge != INVALID ) { a._forward = false; } else { - _digraph->firstIn(a, n); + _digraph->firstIn(a._edge, n); a._forward = true; } } void nextIn(Arc &a) const { if (!a._forward) { - Node n = _digraph->source(a); - _digraph->nextOut(a); - if( static_cast(a) == INVALID ) { - _digraph->firstIn(a, n); + Node n = _digraph->source(a._edge); + _digraph->nextOut(a._edge); + if (a._edge == INVALID ) { + _digraph->firstIn(a._edge, n); a._forward = true; } } else { - _digraph->nextIn(a); + _digraph->nextIn(a._edge); } } @@ -1967,19 +1972,16 @@ } Node source(const Arc &a) const { - return a._forward ? _digraph->source(a) : _digraph->target(a); + return a._forward ? _digraph->source(a._edge) : _digraph->target(a._edge); } Node target(const Arc &a) const { - return a._forward ? _digraph->target(a) : _digraph->source(a); + return a._forward ? _digraph->target(a._edge) : _digraph->source(a._edge); } static Arc direct(const Edge &e, bool d) { return Arc(e, d); } - Arc direct(const Edge &e, const Node& n) const { - return Arc(e, _digraph->source(e) == n); - } static bool direction(const Arc &a) { return a._forward; } @@ -2062,34 +2064,35 @@ private: - template + template class ArcMapBase { private: - typedef typename Digraph::template ArcMap<_Value> MapImpl; + typedef typename DGR::template ArcMap MapImpl; public: typedef typename MapTraits::ReferenceMapTag ReferenceMapTag; - typedef _Value Value; + typedef V Value; typedef Arc Key; typedef typename MapTraits::ConstReturnValue ConstReturnValue; typedef typename MapTraits::ReturnValue ReturnValue; typedef typename MapTraits::ConstReturnValue ConstReference; typedef typename MapTraits::ReturnValue Reference; - ArcMapBase(const Adaptor& adaptor) : + ArcMapBase(const UndirectorBase& adaptor) : _forward(*adaptor._digraph), _backward(*adaptor._digraph) {} - ArcMapBase(const Adaptor& adaptor, const Value& v) - : _forward(*adaptor._digraph, v), _backward(*adaptor._digraph, v) {} - - void set(const Arc& a, const Value& v) { + ArcMapBase(const UndirectorBase& adaptor, const V& value) + : _forward(*adaptor._digraph, value), + _backward(*adaptor._digraph, value) {} + + void set(const Arc& a, const V& value) { if (direction(a)) { - _forward.set(a, v); + _forward.set(a, value); } else { - _backward.set(a, v); + _backward.set(a, value); } } @@ -2117,17 +2120,17 @@ public: - template - class NodeMap : public Digraph::template NodeMap<_Value> { + template + class NodeMap : public DGR::template NodeMap { + typedef typename DGR::template NodeMap Parent; + public: - - typedef _Value Value; - typedef typename Digraph::template NodeMap Parent; - - explicit NodeMap(const Adaptor& adaptor) + typedef V Value; + + explicit NodeMap(const UndirectorBase& adaptor) : Parent(*adaptor._digraph) {} - NodeMap(const Adaptor& adaptor, const _Value& value) + NodeMap(const UndirectorBase& adaptor, const V& value) : Parent(*adaptor._digraph, value) { } private: @@ -2143,18 +2146,18 @@ }; - template + template class ArcMap - : public SubMapExtender > - { + : public SubMapExtender, ArcMapBase > { + typedef SubMapExtender, ArcMapBase > Parent; + public: - typedef _Value Value; - typedef SubMapExtender > Parent; - - explicit ArcMap(const Adaptor& adaptor) + typedef V Value; + + explicit ArcMap(const UndirectorBase& adaptor) : Parent(adaptor) {} - ArcMap(const Adaptor& adaptor, const Value& value) + ArcMap(const UndirectorBase& adaptor, const V& value) : Parent(adaptor, value) {} private: @@ -2169,17 +2172,17 @@ } }; - template - class EdgeMap : public Digraph::template ArcMap<_Value> { + template + class EdgeMap : public Digraph::template ArcMap { + typedef typename Digraph::template ArcMap Parent; + public: - - typedef _Value Value; - typedef typename Digraph::template ArcMap Parent; - - explicit EdgeMap(const Adaptor& adaptor) + typedef V Value; + + explicit EdgeMap(const UndirectorBase& adaptor) : Parent(*adaptor._digraph) {} - EdgeMap(const Adaptor& adaptor, const Value& value) + EdgeMap(const UndirectorBase& adaptor, const V& value) : Parent(*adaptor._digraph, value) {} private: @@ -2195,19 +2198,22 @@ }; - typedef typename ItemSetTraits::ItemNotifier NodeNotifier; + typedef typename ItemSetTraits::ItemNotifier NodeNotifier; NodeNotifier& notifier(Node) const { return _digraph->notifier(Node()); } - typedef typename ItemSetTraits::ItemNotifier EdgeNotifier; + typedef typename ItemSetTraits::ItemNotifier EdgeNotifier; EdgeNotifier& notifier(Edge) const { return _digraph->notifier(Edge()); } + + typedef EdgeNotifier ArcNotifier; + ArcNotifier& notifier(Arc) const { return _digraph->notifier(Edge()); } protected: UndirectorBase() : _digraph(0) {} - Digraph* _digraph; - - void setDigraph(Digraph& digraph) { + DGR* _digraph; + + void initialize(DGR& digraph) { _digraph = &digraph; } @@ -2226,7 +2232,7 @@ /// by adding or removing nodes or edges, unless the \c GR template /// parameter is set to be \c const. /// - /// \tparam GR The type of the adapted digraph. + /// \tparam DGR The type of the adapted digraph. /// It must conform to the \ref concepts::Digraph "Digraph" concept. /// It can also be specified to be \c const. /// @@ -2236,17 +2242,17 @@ /// each other. /// (Thus the \c Arc type of the adaptor is convertible to the \c Arc type /// of the adapted digraph.) - template + template #ifdef DOXYGEN class Undirector { #else class Undirector : - public GraphAdaptorExtender > { + public GraphAdaptorExtender > { #endif + typedef GraphAdaptorExtender > Parent; public: /// The type of the adapted digraph. - typedef GR Digraph; - typedef GraphAdaptorExtender > Parent; + typedef DGR Digraph; protected: Undirector() { } public: @@ -2254,34 +2260,35 @@ /// \brief Constructor /// /// Creates an undirected graph from the given digraph. - Undirector(Digraph& digraph) { - setDigraph(digraph); + Undirector(DGR& digraph) { + initialize(digraph); } /// \brief Arc map combined from two original arc maps /// /// This map adaptor class adapts two arc maps of the underlying /// digraph to get an arc map of the undirected graph. - /// Its value type is inherited from the first arc map type - /// (\c %ForwardMap). - template + /// Its value type is inherited from the first arc map type (\c FW). + /// \tparam FW The type of the "foward" arc map. + /// \tparam BK The type of the "backward" arc map. + template class CombinedArcMap { public: /// The key type of the map typedef typename Parent::Arc Key; /// The value type of the map - typedef typename ForwardMap::Value Value; - - typedef typename MapTraits::ReferenceMapTag ReferenceMapTag; - - typedef typename MapTraits::ReturnValue ReturnValue; - typedef typename MapTraits::ConstReturnValue ConstReturnValue; - typedef typename MapTraits::ReturnValue Reference; - typedef typename MapTraits::ConstReturnValue ConstReference; + typedef typename FW::Value Value; + + typedef typename MapTraits::ReferenceMapTag ReferenceMapTag; + + typedef typename MapTraits::ReturnValue ReturnValue; + typedef typename MapTraits::ConstReturnValue ConstReturnValue; + typedef typename MapTraits::ReturnValue Reference; + typedef typename MapTraits::ConstReturnValue ConstReference; /// Constructor - CombinedArcMap(ForwardMap& forward, BackwardMap& backward) + CombinedArcMap(FW& forward, BK& backward) : _forward(&forward), _backward(&backward) {} /// Sets the value associated with the given key. @@ -2313,39 +2320,36 @@ protected: - ForwardMap* _forward; - BackwardMap* _backward; + FW* _forward; + BK* _backward; }; /// \brief Returns a combined arc map /// /// This function just returns a combined arc map. - template - static CombinedArcMap - combinedArcMap(ForwardMap& forward, BackwardMap& backward) { - return CombinedArcMap(forward, backward); + template + static CombinedArcMap + combinedArcMap(FW& forward, BK& backward) { + return CombinedArcMap(forward, backward); } - template - static CombinedArcMap - combinedArcMap(const ForwardMap& forward, BackwardMap& backward) { - return CombinedArcMap(forward, backward); + template + static CombinedArcMap + combinedArcMap(const FW& forward, BK& backward) { + return CombinedArcMap(forward, backward); } - template - static CombinedArcMap - combinedArcMap(ForwardMap& forward, const BackwardMap& backward) { - return CombinedArcMap(forward, backward); + template + static CombinedArcMap + combinedArcMap(FW& forward, const BK& backward) { + return CombinedArcMap(forward, backward); } - template - static CombinedArcMap - combinedArcMap(const ForwardMap& forward, const BackwardMap& backward) { - return CombinedArcMap(forward, backward); + template + static CombinedArcMap + combinedArcMap(const FW& forward, const BK& backward) { + return CombinedArcMap(forward, backward); } }; @@ -2355,21 +2359,21 @@ /// This function just returns a read-only \ref Undirector adaptor. /// \ingroup graph_adaptors /// \relates Undirector - template - Undirector undirector(const GR& digraph) { - return Undirector(digraph); + template + Undirector undirector(const DGR& digraph) { + return Undirector(digraph); } - template + template class OrienterBase { public: - typedef _Graph Graph; - typedef _DirectionMap DirectionMap; - - typedef typename Graph::Node Node; - typedef typename Graph::Edge Arc; + typedef GR Graph; + typedef DM DirectionMap; + + typedef typename GR::Node Node; + typedef typename GR::Edge Arc; void reverseArc(const Arc& arc) { _direction->set(arc, !(*_direction)[arc]); @@ -2448,22 +2452,22 @@ int maxNodeId() const { return _graph->maxNodeId(); } int maxArcId() const { return _graph->maxEdgeId(); } - typedef typename ItemSetTraits::ItemNotifier NodeNotifier; + typedef typename ItemSetTraits::ItemNotifier NodeNotifier; NodeNotifier& notifier(Node) const { return _graph->notifier(Node()); } - typedef typename ItemSetTraits::ItemNotifier ArcNotifier; + typedef typename ItemSetTraits::ItemNotifier ArcNotifier; ArcNotifier& notifier(Arc) const { return _graph->notifier(Arc()); } - template - class NodeMap : public _Graph::template NodeMap<_Value> { + template + class NodeMap : public GR::template NodeMap { + typedef typename GR::template NodeMap Parent; + public: - typedef typename _Graph::template NodeMap<_Value> Parent; - - explicit NodeMap(const OrienterBase& adapter) + explicit NodeMap(const OrienterBase& adapter) : Parent(*adapter._graph) {} - NodeMap(const OrienterBase& adapter, const _Value& value) + NodeMap(const OrienterBase& adapter, const V& value) : Parent(*adapter._graph, value) {} private: @@ -2479,16 +2483,16 @@ }; - template - class ArcMap : public _Graph::template EdgeMap<_Value> { + template + class ArcMap : public GR::template EdgeMap { + typedef typename Graph::template EdgeMap Parent; + public: - typedef typename Graph::template EdgeMap<_Value> Parent; - - explicit ArcMap(const OrienterBase& adapter) + explicit ArcMap(const OrienterBase& adapter) : Parent(*adapter._graph) { } - ArcMap(const OrienterBase& adapter, const _Value& value) + ArcMap(const OrienterBase& adapter, const V& value) : Parent(*adapter._graph, value) { } private: @@ -2507,16 +2511,13 @@ protected: Graph* _graph; - DirectionMap* _direction; - - void setDirectionMap(DirectionMap& direction) { + DM* _direction; + + void initialize(GR& graph, DM& direction) { + _graph = &graph; _direction = &direction; } - void setGraph(Graph& graph) { - _graph = &graph; - } - }; /// \ingroup graph_adaptors @@ -2556,6 +2557,7 @@ class Orienter : public DigraphAdaptorExtender > { #endif + typedef DigraphAdaptorExtender > Parent; public: /// The type of the adapted graph. @@ -2563,18 +2565,18 @@ /// The type of the direction edge map. typedef DM DirectionMap; - typedef DigraphAdaptorExtender > Parent; typedef typename Parent::Arc Arc; + protected: Orienter() { } + public: /// \brief Constructor /// /// Constructor of the adaptor. - Orienter(Graph& graph, DirectionMap& direction) { - setGraph(graph); - setDirectionMap(direction); + Orienter(GR& graph, DM& direction) { + Parent::initialize(graph, direction); } /// \brief Reverses the given arc @@ -2594,67 +2596,62 @@ /// \relates Orienter template Orienter - orienter(const GR& graph, DM& direction_map) { - return Orienter(graph, direction_map); + orienter(const GR& graph, DM& direction) { + return Orienter(graph, direction); } template Orienter - orienter(const GR& graph, const DM& direction_map) { - return Orienter(graph, direction_map); + orienter(const GR& graph, const DM& direction) { + return Orienter(graph, direction); } namespace _adaptor_bits { - template + template class ResForwardFilter { public: - typedef typename Digraph::Arc Key; + typedef typename DGR::Arc Key; typedef bool Value; private: - const CapacityMap* _capacity; - const FlowMap* _flow; - Tolerance _tolerance; + const CM* _capacity; + const FM* _flow; + TL _tolerance; + public: - ResForwardFilter(const CapacityMap& capacity, const FlowMap& flow, - const Tolerance& tolerance = Tolerance()) + ResForwardFilter(const CM& capacity, const FM& flow, + const TL& tolerance = TL()) : _capacity(&capacity), _flow(&flow), _tolerance(tolerance) { } - bool operator[](const typename Digraph::Arc& a) const { + bool operator[](const typename DGR::Arc& a) const { return _tolerance.positive((*_capacity)[a] - (*_flow)[a]); } }; - template + template class ResBackwardFilter { public: - typedef typename Digraph::Arc Key; + typedef typename DGR::Arc Key; typedef bool Value; private: - const CapacityMap* _capacity; - const FlowMap* _flow; - Tolerance _tolerance; + const CM* _capacity; + const FM* _flow; + TL _tolerance; public: - ResBackwardFilter(const CapacityMap& capacity, const FlowMap& flow, - const Tolerance& tolerance = Tolerance()) + ResBackwardFilter(const CM& capacity, const FM& flow, + const TL& tolerance = TL()) : _capacity(&capacity), _flow(&flow), _tolerance(tolerance) { } - bool operator[](const typename Digraph::Arc& a) const { + bool operator[](const typename DGR::Arc& a) const { return _tolerance.positive((*_flow)[a]); } }; @@ -2681,7 +2678,7 @@ /// arcs). /// This class conforms to the \ref concepts::Digraph "Digraph" concept. /// - /// \tparam GR The type of the adapted digraph. + /// \tparam DGR The type of the adapted digraph. /// It must conform to the \ref concepts::Digraph "Digraph" concept. /// It is implicitly \c const. /// \tparam CM The type of the capacity map. @@ -2703,25 +2700,26 @@ /// convertible to each other, moreover the \c Arc type of the adaptor /// is convertible to the \c Arc type of the adapted digraph. #ifdef DOXYGEN - template + template class ResidualDigraph #else - template, + template, typename FM = CM, typename TL = Tolerance > - class ResidualDigraph : - public FilterArcs< - Undirector, - typename Undirector::template CombinedArcMap< - _adaptor_bits::ResForwardFilter, - _adaptor_bits::ResBackwardFilter > > + class ResidualDigraph + : public SubDigraph< + Undirector, + ConstMap >, + typename Undirector::template CombinedArcMap< + _adaptor_bits::ResForwardFilter, + _adaptor_bits::ResBackwardFilter > > #endif { public: /// The type of the underlying digraph. - typedef GR Digraph; + typedef DGR Digraph; /// The type of the capacity map. typedef CM CapacityMap; /// The type of the flow map. @@ -2736,21 +2734,24 @@ typedef Undirector Undirected; - typedef _adaptor_bits::ResForwardFilter ForwardFilter; - - typedef _adaptor_bits::ResBackwardFilter BackwardFilter; + typedef ConstMap > NodeFilter; + + typedef _adaptor_bits::ResForwardFilter ForwardFilter; + + typedef _adaptor_bits::ResBackwardFilter BackwardFilter; typedef typename Undirected:: template CombinedArcMap ArcFilter; - typedef FilterArcs Parent; + typedef SubDigraph Parent; const CapacityMap* _capacity; FlowMap* _flow; Undirected _graph; + NodeFilter _node_filter; ForwardFilter _forward_filter; BackwardFilter _backward_filter; ArcFilter _arc_filter; @@ -2761,15 +2762,15 @@ /// /// Constructor of the residual digraph adaptor. The parameters are the /// digraph, the capacity map, the flow map, and a tolerance object. - ResidualDigraph(const Digraph& digraph, const CapacityMap& capacity, - FlowMap& flow, const Tolerance& tolerance = Tolerance()) - : Parent(), _capacity(&capacity), _flow(&flow), _graph(digraph), + ResidualDigraph(const DGR& digraph, const CM& capacity, + FM& flow, const TL& tolerance = Tolerance()) + : Parent(), _capacity(&capacity), _flow(&flow), + _graph(digraph), _node_filter(), _forward_filter(capacity, flow, tolerance), _backward_filter(capacity, flow, tolerance), _arc_filter(_forward_filter, _backward_filter) { - Parent::setDigraph(_graph); - Parent::setArcFilterMap(_arc_filter); + Parent::initialize(_graph, _node_filter, _arc_filter); } typedef typename Parent::Arc Arc; @@ -2845,7 +2846,8 @@ typedef typename CapacityMap::Value Value; /// Constructor - ResidualCapacity(const Adaptor& adaptor) : _adaptor(&adaptor) {} + ResidualCapacity(const ResidualDigraph& adaptor) + : _adaptor(&adaptor) {} /// Returns the value associated with the given residual arc Value operator[](const Arc& a) const { @@ -2865,26 +2867,27 @@ /// \brief Returns a (read-only) Residual adaptor /// - /// This function just returns a (read-only) \ref Residual adaptor. + /// This function just returns a (read-only) \ref ResidualDigraph adaptor. /// \ingroup graph_adaptors - /// \relates Residual - template - ResidualDigraph - residualDigraph(const GR& digraph, const CM& capacity_map, FM& flow_map) { - return ResidualDigraph (digraph, capacity_map, flow_map); + /// \relates ResidualDigraph + template + ResidualDigraph + residualDigraph(const DGR& digraph, const CM& capacity_map, FM& flow_map) { + return ResidualDigraph (digraph, capacity_map, flow_map); } - template + template class SplitNodesBase { + typedef DigraphAdaptorBase Parent; + public: - typedef _Digraph Digraph; - typedef DigraphAdaptorBase Parent; + typedef DGR Digraph; typedef SplitNodesBase Adaptor; - typedef typename Digraph::Node DigraphNode; - typedef typename Digraph::Arc DigraphArc; + typedef typename DGR::Node DigraphNode; + typedef typename DGR::Arc DigraphArc; class Node; class Arc; @@ -3148,32 +3151,32 @@ private: - template + template class NodeMapBase - : public MapTraits > { - typedef typename Parent::template NodeMap<_Value> NodeImpl; + : public MapTraits > { + typedef typename Parent::template NodeMap NodeImpl; public: typedef Node Key; - typedef _Value Value; + typedef V Value; typedef typename MapTraits::ReferenceMapTag ReferenceMapTag; typedef typename MapTraits::ReturnValue ReturnValue; typedef typename MapTraits::ConstReturnValue ConstReturnValue; typedef typename MapTraits::ReturnValue Reference; typedef typename MapTraits::ConstReturnValue ConstReference; - NodeMapBase(const Adaptor& adaptor) + NodeMapBase(const SplitNodesBase& adaptor) : _in_map(*adaptor._digraph), _out_map(*adaptor._digraph) {} - NodeMapBase(const Adaptor& adaptor, const Value& value) + NodeMapBase(const SplitNodesBase& adaptor, const V& value) : _in_map(*adaptor._digraph, value), _out_map(*adaptor._digraph, value) {} - void set(const Node& key, const Value& val) { - if (Adaptor::inNode(key)) { _in_map.set(key, val); } + void set(const Node& key, const V& val) { + if (SplitNodesBase::inNode(key)) { _in_map.set(key, val); } else {_out_map.set(key, val); } } ReturnValue operator[](const Node& key) { - if (Adaptor::inNode(key)) { return _in_map[key]; } + if (SplitNodesBase::inNode(key)) { return _in_map[key]; } else { return _out_map[key]; } } @@ -3186,47 +3189,47 @@ NodeImpl _in_map, _out_map; }; - template + template class ArcMapBase - : public MapTraits > { - typedef typename Parent::template ArcMap<_Value> ArcImpl; - typedef typename Parent::template NodeMap<_Value> NodeImpl; + : public MapTraits > { + typedef typename Parent::template ArcMap ArcImpl; + typedef typename Parent::template NodeMap NodeImpl; public: typedef Arc Key; - typedef _Value Value; + typedef V Value; typedef typename MapTraits::ReferenceMapTag ReferenceMapTag; typedef typename MapTraits::ReturnValue ReturnValue; typedef typename MapTraits::ConstReturnValue ConstReturnValue; typedef typename MapTraits::ReturnValue Reference; typedef typename MapTraits::ConstReturnValue ConstReference; - ArcMapBase(const Adaptor& adaptor) + ArcMapBase(const SplitNodesBase& adaptor) : _arc_map(*adaptor._digraph), _node_map(*adaptor._digraph) {} - ArcMapBase(const Adaptor& adaptor, const Value& value) + ArcMapBase(const SplitNodesBase& adaptor, const V& value) : _arc_map(*adaptor._digraph, value), _node_map(*adaptor._digraph, value) {} - void set(const Arc& key, const Value& val) { - if (Adaptor::origArc(key)) { - _arc_map.set(key._item.first(), val); + void set(const Arc& key, const V& val) { + if (SplitNodesBase::origArc(key)) { + _arc_map.set(static_cast(key), val); } else { - _node_map.set(key._item.second(), val); + _node_map.set(static_cast(key), val); } } ReturnValue operator[](const Arc& key) { - if (Adaptor::origArc(key)) { - return _arc_map[key._item.first()]; + if (SplitNodesBase::origArc(key)) { + return _arc_map[static_cast(key)]; } else { - return _node_map[key._item.second()]; + return _node_map[static_cast(key)]; } } ConstReturnValue operator[](const Arc& key) const { - if (Adaptor::origArc(key)) { - return _arc_map[key._item.first()]; + if (SplitNodesBase::origArc(key)) { + return _arc_map[static_cast(key)]; } else { - return _node_map[key._item.second()]; + return _node_map[static_cast(key)]; } } @@ -3237,18 +3240,18 @@ public: - template + template class NodeMap - : public SubMapExtender > - { + : public SubMapExtender, NodeMapBase > { + typedef SubMapExtender, NodeMapBase > Parent; + public: - typedef _Value Value; - typedef SubMapExtender > Parent; - - NodeMap(const Adaptor& adaptor) + typedef V Value; + + NodeMap(const SplitNodesBase& adaptor) : Parent(adaptor) {} - NodeMap(const Adaptor& adaptor, const Value& value) + NodeMap(const SplitNodesBase& adaptor, const V& value) : Parent(adaptor, value) {} private: @@ -3263,18 +3266,18 @@ } }; - template + template class ArcMap - : public SubMapExtender > - { + : public SubMapExtender, ArcMapBase > { + typedef SubMapExtender, ArcMapBase > Parent; + public: - typedef _Value Value; - typedef SubMapExtender > Parent; - - ArcMap(const Adaptor& adaptor) + typedef V Value; + + ArcMap(const SplitNodesBase& adaptor) : Parent(adaptor) {} - ArcMap(const Adaptor& adaptor, const Value& value) + ArcMap(const SplitNodesBase& adaptor, const V& value) : Parent(adaptor, value) {} private: @@ -3293,9 +3296,9 @@ SplitNodesBase() : _digraph(0) {} - Digraph* _digraph; - - void setDigraph(Digraph& digraph) { + DGR* _digraph; + + void initialize(Digraph& digraph) { _digraph = &digraph; } @@ -3322,25 +3325,26 @@ /// costs/capacities of the original digraph to the \e bind \e arcs /// in the adaptor. /// - /// \tparam GR The type of the adapted digraph. + /// \tparam DGR The type of the adapted digraph. /// It must conform to the \ref concepts::Digraph "Digraph" concept. /// It is implicitly \c const. /// /// \note The \c Node type of this adaptor is converible to the \c Node /// type of the adapted digraph. - template + template #ifdef DOXYGEN class SplitNodes { #else class SplitNodes - : public DigraphAdaptorExtender > { + : public DigraphAdaptorExtender > { #endif + typedef DigraphAdaptorExtender > Parent; + public: - typedef GR Digraph; - typedef DigraphAdaptorExtender > Parent; - - typedef typename Digraph::Node DigraphNode; - typedef typename Digraph::Arc DigraphArc; + typedef DGR Digraph; + + typedef typename DGR::Node DigraphNode; + typedef typename DGR::Arc DigraphArc; typedef typename Parent::Node Node; typedef typename Parent::Arc Arc; @@ -3348,8 +3352,8 @@ /// \brief Constructor /// /// Constructor of the adaptor. - SplitNodes(const Digraph& g) { - Parent::setDigraph(g); + SplitNodes(const DGR& g) { + Parent::initialize(g); } /// \brief Returns \c true if the given node is an in-node. @@ -3418,30 +3422,31 @@ /// /// This map adaptor class adapts two node maps of the original digraph /// to get a node map of the split digraph. - /// Its value type is inherited from the first node map type - /// (\c InNodeMap). - template + /// Its value type is inherited from the first node map type (\c IN). + /// \tparam IN The type of the node map for the in-nodes. + /// \tparam OUT The type of the node map for the out-nodes. + template class CombinedNodeMap { public: /// The key type of the map typedef Node Key; /// The value type of the map - typedef typename InNodeMap::Value Value; - - typedef typename MapTraits::ReferenceMapTag ReferenceMapTag; - typedef typename MapTraits::ReturnValue ReturnValue; - typedef typename MapTraits::ConstReturnValue ConstReturnValue; - typedef typename MapTraits::ReturnValue Reference; - typedef typename MapTraits::ConstReturnValue ConstReference; + typedef typename IN::Value Value; + + typedef typename MapTraits::ReferenceMapTag ReferenceMapTag; + typedef typename MapTraits::ReturnValue ReturnValue; + typedef typename MapTraits::ConstReturnValue ConstReturnValue; + typedef typename MapTraits::ReturnValue Reference; + typedef typename MapTraits::ConstReturnValue ConstReference; /// Constructor - CombinedNodeMap(InNodeMap& in_map, OutNodeMap& out_map) + CombinedNodeMap(IN& in_map, OUT& out_map) : _in_map(in_map), _out_map(out_map) {} /// Returns the value associated with the given key. Value operator[](const Key& key) const { - if (Parent::inNode(key)) { + if (SplitNodesBase::inNode(key)) { return _in_map[key]; } else { return _out_map[key]; @@ -3450,7 +3455,7 @@ /// Returns a reference to the value associated with the given key. Value& operator[](const Key& key) { - if (Parent::inNode(key)) { + if (SplitNodesBase::inNode(key)) { return _in_map[key]; } else { return _out_map[key]; @@ -3459,7 +3464,7 @@ /// Sets the value associated with the given key. void set(const Key& key, const Value& value) { - if (Parent::inNode(key)) { + if (SplitNodesBase::inNode(key)) { _in_map.set(key, value); } else { _out_map.set(key, value); @@ -3468,8 +3473,8 @@ private: - InNodeMap& _in_map; - OutNodeMap& _out_map; + IN& _in_map; + OUT& _out_map; }; @@ -3477,29 +3482,28 @@ /// \brief Returns a combined node map /// /// This function just returns a combined node map. - template - static CombinedNodeMap - combinedNodeMap(InNodeMap& in_map, OutNodeMap& out_map) { - return CombinedNodeMap(in_map, out_map); + template + static CombinedNodeMap + combinedNodeMap(IN& in_map, OUT& out_map) { + return CombinedNodeMap(in_map, out_map); } - template - static CombinedNodeMap - combinedNodeMap(const InNodeMap& in_map, OutNodeMap& out_map) { - return CombinedNodeMap(in_map, out_map); + template + static CombinedNodeMap + combinedNodeMap(const IN& in_map, OUT& out_map) { + return CombinedNodeMap(in_map, out_map); } - template - static CombinedNodeMap - combinedNodeMap(InNodeMap& in_map, const OutNodeMap& out_map) { - return CombinedNodeMap(in_map, out_map); + template + static CombinedNodeMap + combinedNodeMap(IN& in_map, const OUT& out_map) { + return CombinedNodeMap(in_map, out_map); } - template - static CombinedNodeMap - combinedNodeMap(const InNodeMap& in_map, const OutNodeMap& out_map) { - return CombinedNodeMap(in_map, out_map); + template + static CombinedNodeMap + combinedNodeMap(const IN& in_map, const OUT& out_map) { + return CombinedNodeMap(in_map, out_map); } /// \brief Arc map combined from an arc map and a node map of the @@ -3507,30 +3511,31 @@ /// /// This map adaptor class adapts an arc map and a node map of the /// original digraph to get an arc map of the split digraph. - /// Its value type is inherited from the original arc map type - /// (\c ArcMap). - template + /// Its value type is inherited from the original arc map type (\c AM). + /// \tparam AM The type of the arc map. + /// \tparam NM the type of the node map. + template class CombinedArcMap { public: /// The key type of the map typedef Arc Key; /// The value type of the map - typedef typename ArcMap::Value Value; - - typedef typename MapTraits::ReferenceMapTag ReferenceMapTag; - typedef typename MapTraits::ReturnValue ReturnValue; - typedef typename MapTraits::ConstReturnValue ConstReturnValue; - typedef typename MapTraits::ReturnValue Reference; - typedef typename MapTraits::ConstReturnValue ConstReference; + typedef typename AM::Value Value; + + typedef typename MapTraits::ReferenceMapTag ReferenceMapTag; + typedef typename MapTraits::ReturnValue ReturnValue; + typedef typename MapTraits::ConstReturnValue ConstReturnValue; + typedef typename MapTraits::ReturnValue Reference; + typedef typename MapTraits::ConstReturnValue ConstReference; /// Constructor - CombinedArcMap(ArcMap& arc_map, NodeMap& node_map) + CombinedArcMap(AM& arc_map, NM& node_map) : _arc_map(arc_map), _node_map(node_map) {} /// Returns the value associated with the given key. Value operator[](const Key& arc) const { - if (Parent::origArc(arc)) { + if (SplitNodesBase::origArc(arc)) { return _arc_map[arc]; } else { return _node_map[arc]; @@ -3539,7 +3544,7 @@ /// Returns a reference to the value associated with the given key. Value& operator[](const Key& arc) { - if (Parent::origArc(arc)) { + if (SplitNodesBase::origArc(arc)) { return _arc_map[arc]; } else { return _node_map[arc]; @@ -3548,7 +3553,7 @@ /// Sets the value associated with the given key. void set(const Arc& arc, const Value& val) { - if (Parent::origArc(arc)) { + if (SplitNodesBase::origArc(arc)) { _arc_map.set(arc, val); } else { _node_map.set(arc, val); @@ -3556,8 +3561,10 @@ } private: - ArcMap& _arc_map; - NodeMap& _node_map; + + AM& _arc_map; + NM& _node_map; + }; /// \brief Returns a combined arc map @@ -3594,12 +3601,14 @@ /// This function just returns a (read-only) \ref SplitNodes adaptor. /// \ingroup graph_adaptors /// \relates SplitNodes - template - SplitNodes - splitNodes(const GR& digraph) { - return SplitNodes(digraph); + template + SplitNodes + splitNodes(const DGR& digraph) { + return SplitNodes(digraph); } +#undef LEMON_SCOPE_FIX + } //namespace lemon #endif //LEMON_ADAPTORS_H diff -r c35afa9e89e7 -r ef88c0a30f85 lemon/base.cc --- a/lemon/base.cc Mon Jan 12 23:11:39 2009 +0100 +++ b/lemon/base.cc Thu Nov 05 15:48:01 2009 +0100 @@ -23,7 +23,7 @@ #include namespace lemon { - float Tolerance::def_epsilon = 1e-4; + float Tolerance::def_epsilon = static_cast(1e-4); double Tolerance::def_epsilon = 1e-10; long double Tolerance::def_epsilon = 1e-14; diff -r c35afa9e89e7 -r ef88c0a30f85 lemon/bellman_ford.h --- /dev/null Thu Jan 01 00:00:00 1970 +0000 +++ b/lemon/bellman_ford.h Thu Nov 05 15:48:01 2009 +0100 @@ -0,0 +1,1101 @@ +/* -*- C++ -*- + * + * This file is a part of LEMON, a generic C++ optimization library + * + * Copyright (C) 2003-2008 + * Egervary Jeno Kombinatorikus Optimalizalasi Kutatocsoport + * (Egervary Research Group on Combinatorial Optimization, EGRES). + * + * Permission to use, modify and distribute this software is granted + * provided that this copyright notice appears in all copies. For + * precise terms see the accompanying LICENSE file. + * + * This software is provided "AS IS" with no warranty of any kind, + * express or implied, and with no claim as to its suitability for any + * purpose. + * + */ + +#ifndef LEMON_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". +#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); + } + _mask = new MaskMap(*_gr, false); + } + + 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); + } + } + } + + /// \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 \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 \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. + 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 + diff -r c35afa9e89e7 -r ef88c0a30f85 lemon/bfs.h --- a/lemon/bfs.h Mon Jan 12 23:11:39 2009 +0100 +++ b/lemon/bfs.h Thu Nov 05 15:48:01 2009 +0100 @@ -47,13 +47,13 @@ /// ///The type of the map that stores the predecessor ///arcs of the shortest paths. - ///It must meet the \ref concepts::WriteMap "WriteMap" concept. + ///It must conform to the \ref concepts::WriteMap "WriteMap" concept. typedef typename Digraph::template NodeMap PredMap; - ///Instantiates a PredMap. + ///Instantiates a \c PredMap. - ///This function instantiates a PredMap. + ///This function instantiates a \ref PredMap. ///\param g is the digraph, to which we would like to define the - ///PredMap. + ///\ref PredMap. static PredMap *createPredMap(const Digraph &g) { return new PredMap(g); @@ -62,13 +62,14 @@ ///The type of the map that indicates which nodes are processed. ///The type of the map that indicates which nodes are processed. - ///It must meet the \ref concepts::WriteMap "WriteMap" concept. + ///It must conform to the \ref concepts::WriteMap "WriteMap" concept. + ///By default it is a NullMap. typedef NullMap ProcessedMap; - ///Instantiates a ProcessedMap. + ///Instantiates a \c ProcessedMap. - ///This function instantiates a ProcessedMap. + ///This function instantiates a \ref ProcessedMap. ///\param g is the digraph, to which - ///we would like to define the ProcessedMap + ///we would like to define the \ref ProcessedMap #ifdef DOXYGEN static ProcessedMap *createProcessedMap(const Digraph &g) #else @@ -81,13 +82,13 @@ ///The type of the map that indicates which nodes are reached. ///The type of the map that indicates which nodes are reached. - ///It must meet the \ref concepts::ReadWriteMap "ReadWriteMap" concept. + ///It must conform to the \ref concepts::ReadWriteMap "ReadWriteMap" concept. typedef typename Digraph::template NodeMap ReachedMap; - ///Instantiates a ReachedMap. + ///Instantiates a \c ReachedMap. - ///This function instantiates a ReachedMap. + ///This function instantiates a \ref ReachedMap. ///\param g is the digraph, to which - ///we would like to define the ReachedMap. + ///we would like to define the \ref ReachedMap. static ReachedMap *createReachedMap(const Digraph &g) { return new ReachedMap(g); @@ -96,13 +97,13 @@ ///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 meet the \ref concepts::WriteMap "WriteMap" concept. + ///It must conform to the \ref concepts::WriteMap "WriteMap" concept. typedef typename Digraph::template NodeMap DistMap; - ///Instantiates a DistMap. + ///Instantiates a \c DistMap. - ///This function instantiates a DistMap. + ///This function instantiates a \ref DistMap. ///\param g is the digraph, to which we would like to define the - ///DistMap. + ///\ref DistMap. static DistMap *createDistMap(const Digraph &g) { return new DistMap(g); @@ -221,11 +222,11 @@ } }; ///\brief \ref named-templ-param "Named parameter" for setting - ///PredMap type. + ///\c PredMap type. /// ///\ref named-templ-param "Named parameter" for setting - ///PredMap type. - ///It must meet the \ref concepts::WriteMap "WriteMap" concept. + ///\c PredMap type. + ///It must conform to the \ref concepts::WriteMap "WriteMap" concept. template struct SetPredMap : public Bfs< Digraph, SetPredMapTraits > { typedef Bfs< Digraph, SetPredMapTraits > Create; @@ -241,11 +242,11 @@ } }; ///\brief \ref named-templ-param "Named parameter" for setting - ///DistMap type. + ///\c DistMap type. /// ///\ref named-templ-param "Named parameter" for setting - ///DistMap type. - ///It must meet the \ref concepts::WriteMap "WriteMap" concept. + ///\c DistMap type. + ///It must conform to the \ref concepts::WriteMap "WriteMap" concept. template struct SetDistMap : public Bfs< Digraph, SetDistMapTraits > { typedef Bfs< Digraph, SetDistMapTraits > Create; @@ -261,11 +262,11 @@ } }; ///\brief \ref named-templ-param "Named parameter" for setting - ///ReachedMap type. + ///\c ReachedMap type. /// ///\ref named-templ-param "Named parameter" for setting - ///ReachedMap type. - ///It must meet the \ref concepts::ReadWriteMap "ReadWriteMap" concept. + ///\c ReachedMap type. + ///It must conform to the \ref concepts::ReadWriteMap "ReadWriteMap" concept. template struct SetReachedMap : public Bfs< Digraph, SetReachedMapTraits > { typedef Bfs< Digraph, SetReachedMapTraits > Create; @@ -281,11 +282,11 @@ } }; ///\brief \ref named-templ-param "Named parameter" for setting - ///ProcessedMap type. + ///\c ProcessedMap type. /// ///\ref named-templ-param "Named parameter" for setting - ///ProcessedMap type. - ///It must meet the \ref concepts::WriteMap "WriteMap" concept. + ///\c ProcessedMap type. + ///It must conform to the \ref concepts::WriteMap "WriteMap" concept. template struct SetProcessedMap : public Bfs< Digraph, SetProcessedMapTraits > { typedef Bfs< Digraph, SetProcessedMapTraits > Create; @@ -300,10 +301,10 @@ } }; ///\brief \ref named-templ-param "Named parameter" for setting - ///ProcessedMap type to be Digraph::NodeMap. + ///\c ProcessedMap type to be Digraph::NodeMap. /// ///\ref named-templ-param "Named parameter" for setting - ///ProcessedMap type to be Digraph::NodeMap. + ///\c ProcessedMap type to be Digraph::NodeMap. ///If you don't set it explicitly, it will be automatically allocated. struct SetStandardProcessedMap : public Bfs< Digraph, SetStandardProcessedMapTraits > { @@ -413,8 +414,8 @@ ///\name Execution Control ///The simplest way to execute the BFS algorithm is to use one of the ///member functions called \ref run(Node) "run()".\n - ///If you need more control on the execution, first you have to call - ///\ref init(), then you can add several source nodes with + ///If you need better control on the execution, you have to call + ///\ref init() first, then you can add several source nodes with ///\ref addSource(). Finally the actual path computation can be ///performed with one of the \ref start() functions. @@ -737,9 +738,9 @@ ///@{ - ///The shortest path to a node. + ///The shortest path to the given node. - ///Returns the shortest path to a node. + ///Returns the shortest path to the given node from the root(s). /// ///\warning \c t should be reached from the root(s). /// @@ -747,9 +748,9 @@ ///must be called before using this function. Path path(Node t) const { return Path(*G, *_pred, t); } - ///The distance of a node from the root(s). + ///The distance of the given node from the root(s). - ///Returns the distance of a 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. @@ -758,29 +759,31 @@ ///must be called before using this function. int dist(Node v) const { return (*_dist)[v]; } - ///Returns the 'previous arc' of the shortest path tree for a node. - + ///\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 the node \c v, i.e. it returns the last arc of a ///shortest path from a root to \c v. It is \c INVALID if \c v ///is not reached from the root(s) or if \c v is a root. /// ///The shortest path tree used here is equal to the shortest path - ///tree used in \ref predNode(). + ///tree used in \ref predNode() and \ref predMap(). /// ///\pre Either \ref run(Node) "run()" or \ref init() ///must be called before using this function. Arc predArc(Node v) const { return (*_pred)[v];} - ///Returns the 'previous node' of the shortest path tree for a node. - + ///\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 the node \c v, i.e. it returns the last but one node - ///from a shortest path from a root to \c v. It is \c INVALID + ///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(). + ///tree used in \ref predArc() and \ref predMap(). /// ///\pre Either \ref run(Node) "run()" or \ref init() ///must be called before using this function. @@ -801,13 +804,13 @@ ///predecessor arcs. /// ///Returns a const reference to the node map that stores the predecessor - ///arcs, which form the shortest path tree. + ///arcs, which form the shortest path tree (forest). /// ///\pre Either \ref run(Node) "run()" or \ref init() ///must be called before using this function. const PredMap &predMap() const { return *_pred;} - ///Checks if a node is reached from the root(s). + ///Checks if the given node is reached from the root(s). ///Returns \c true if \c v is reached from the root(s). /// @@ -833,7 +836,7 @@ /// ///The type of the map that stores the predecessor ///arcs of the shortest paths. - ///It must meet the \ref concepts::WriteMap "WriteMap" concept. + ///It must conform to the \ref concepts::WriteMap "WriteMap" concept. typedef typename Digraph::template NodeMap PredMap; ///Instantiates a PredMap. @@ -848,7 +851,7 @@ ///The type of the map that indicates which nodes are processed. ///The type of the map that indicates which nodes are processed. - ///It must meet the \ref concepts::WriteMap "WriteMap" concept. + ///It must conform to the \ref concepts::WriteMap "WriteMap" concept. ///By default it is a NullMap. typedef NullMap ProcessedMap; ///Instantiates a ProcessedMap. @@ -868,7 +871,7 @@ ///The type of the map that indicates which nodes are reached. ///The type of the map that indicates which nodes are reached. - ///It must meet the \ref concepts::ReadWriteMap "ReadWriteMap" concept. + ///It must conform to the \ref concepts::ReadWriteMap "ReadWriteMap" concept. typedef typename Digraph::template NodeMap ReachedMap; ///Instantiates a ReachedMap. @@ -883,7 +886,7 @@ ///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 meet the \ref concepts::WriteMap "WriteMap" concept. + ///It must conform to the \ref concepts::WriteMap "WriteMap" concept. typedef typename Digraph::template NodeMap DistMap; ///Instantiates a DistMap. @@ -898,18 +901,14 @@ ///The type of the shortest paths. ///The type of the shortest paths. - ///It must meet the \ref concepts::Path "Path" concept. + ///It must conform to the \ref concepts::Path "Path" concept. typedef lemon::Path Path; }; /// Default traits class used by BfsWizard - /// 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. + /// Default traits class used by BfsWizard. + /// \tparam GR The type of the digraph. template class BfsWizardBase : public BfsWizardDefaultTraits { @@ -937,7 +936,7 @@ public: /// Constructor. - /// This constructor does not require parameters, therefore it initiates + /// This constructor does not require parameters, it initiates /// all of the attributes to \c 0. BfsWizardBase() : _g(0), _reached(0), _processed(0), _pred(0), _dist(0), _path(0), _di(0) {} @@ -967,7 +966,6 @@ { typedef TR Base; - ///The type of the digraph the algorithm runs on. typedef typename TR::Digraph Digraph; typedef typename Digraph::Node Node; @@ -975,16 +973,10 @@ typedef typename Digraph::Arc Arc; 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; public: @@ -1067,11 +1059,12 @@ static PredMap *createPredMap(const Digraph &) { return 0; }; SetPredMapBase(const TR &b) : TR(b) {} }; - ///\brief \ref named-func-param "Named parameter" - ///for setting PredMap object. + + ///\brief \ref named-templ-param "Named parameter" for setting + ///the predecessor map. /// - ///\ref named-func-param "Named parameter" - ///for setting PredMap object. + ///\ref named-templ-param "Named parameter" function for setting + ///the map that stores the predecessor arcs of the nodes. template BfsWizard > predMap(const T &t) { @@ -1085,11 +1078,12 @@ static ReachedMap *createReachedMap(const Digraph &) { return 0; }; SetReachedMapBase(const TR &b) : TR(b) {} }; - ///\brief \ref named-func-param "Named parameter" - ///for setting ReachedMap object. + + ///\brief \ref named-templ-param "Named parameter" for setting + ///the reached map. /// - /// \ref named-func-param "Named parameter" - ///for setting ReachedMap object. + ///\ref named-templ-param "Named parameter" function for setting + ///the map that indicates which nodes are reached. template BfsWizard > reachedMap(const T &t) { @@ -1103,11 +1097,13 @@ static DistMap *createDistMap(const Digraph &) { return 0; }; SetDistMapBase(const TR &b) : TR(b) {} }; - ///\brief \ref named-func-param "Named parameter" - ///for setting DistMap object. + + ///\brief \ref named-templ-param "Named parameter" for setting + ///the distance map. /// - /// \ref named-func-param "Named parameter" - ///for setting DistMap object. + ///\ref named-templ-param "Named parameter" function for setting + ///the map that stores the distances of the nodes calculated + ///by the algorithm. template BfsWizard > distMap(const T &t) { @@ -1121,11 +1117,12 @@ static ProcessedMap *createProcessedMap(const Digraph &) { return 0; }; SetProcessedMapBase(const TR &b) : TR(b) {} }; - ///\brief \ref named-func-param "Named parameter" - ///for setting ProcessedMap object. + + ///\brief \ref named-func-param "Named parameter" for setting + ///the processed map. /// - /// \ref named-func-param "Named parameter" - ///for setting ProcessedMap object. + ///\ref named-templ-param "Named parameter" function for setting + ///the map that indicates which nodes are processed. template BfsWizard > processedMap(const T &t) { @@ -1194,9 +1191,9 @@ /// /// This class defines the interface of the BfsVisit events, and /// it could be the base of a real visitor class. - template + template struct BfsVisitor { - typedef _Digraph Digraph; + typedef GR Digraph; typedef typename Digraph::Arc Arc; typedef typename Digraph::Node Node; /// \brief Called for the source node(s) of the BFS. @@ -1224,9 +1221,9 @@ void examine(const Arc& arc) {} }; #else - template + template struct BfsVisitor { - typedef _Digraph Digraph; + typedef GR Digraph; typedef typename Digraph::Arc Arc; typedef typename Digraph::Node Node; void start(const Node&) {} @@ -1254,17 +1251,17 @@ /// \brief Default traits class of BfsVisit class. /// /// Default traits class of BfsVisit class. - /// \tparam _Digraph The type of the digraph the algorithm runs on. - template + /// \tparam GR The type of the digraph the algorithm runs on. + template struct BfsVisitDefaultTraits { /// \brief The type of the digraph the algorithm runs on. - typedef _Digraph Digraph; + typedef GR Digraph; /// \brief The type of the map that indicates which nodes are reached. /// /// The type of the map that indicates which nodes are reached. - /// It must meet the \ref concepts::ReadWriteMap "ReadWriteMap" concept. + /// It must conform to the \ref concepts::ReadWriteMap "ReadWriteMap" concept. typedef typename Digraph::template NodeMap ReachedMap; /// \brief Instantiates a ReachedMap. @@ -1280,12 +1277,12 @@ /// \ingroup search /// - /// \brief %BFS algorithm class with visitor interface. + /// \brief BFS algorithm class with visitor interface. /// - /// This class provides an efficient implementation of the %BFS algorithm + /// This class provides an efficient implementation of the BFS algorithm /// with visitor interface. /// - /// The %BfsVisit class provides an alternative interface to the Bfs + /// The BfsVisit class provides an alternative interface to the Bfs /// class. It works with callback mechanism, the BfsVisit object calls /// the member functions of the \c Visitor class on every BFS event. /// @@ -1294,37 +1291,37 @@ /// events of the BFS algorithm. Otherwise consider to use Bfs or bfs() /// instead. /// - /// \tparam _Digraph The type of the digraph the algorithm runs on. - /// The default value is - /// \ref ListDigraph. The value of _Digraph is not used directly by - /// \ref BfsVisit, it is only passed to \ref BfsVisitDefaultTraits. - /// \tparam _Visitor The Visitor type that is used by the algorithm. - /// \ref BfsVisitor "BfsVisitor<_Digraph>" is an empty visitor, which + /// \tparam GR The type of the digraph the algorithm runs on. + /// The default type is \ref ListDigraph. + /// The value of GR is not used directly by \ref BfsVisit, + /// it is only passed to \ref BfsVisitDefaultTraits. + /// \tparam VS The Visitor type that is used by the algorithm. + /// \ref BfsVisitor "BfsVisitor" is an empty visitor, which /// does not observe the BFS events. If you want to observe the BFS /// events, you should implement your own visitor class. - /// \tparam _Traits Traits class to set various data types used by the + /// \tparam TR Traits class to set various data types used by the /// algorithm. The default traits class is - /// \ref BfsVisitDefaultTraits "BfsVisitDefaultTraits<_Digraph>". + /// \ref BfsVisitDefaultTraits "BfsVisitDefaultTraits". /// See \ref BfsVisitDefaultTraits for the documentation of /// a BFS visit traits class. #ifdef DOXYGEN - template + template #else - template , - typename _Traits = BfsVisitDefaultTraits<_Digraph> > + template , + typename TR = BfsVisitDefaultTraits > #endif class BfsVisit { public: ///The traits class. - typedef _Traits Traits; + typedef TR Traits; ///The type of the digraph the algorithm runs on. typedef typename Traits::Digraph Digraph; ///The visitor type used by the algorithm. - typedef _Visitor Visitor; + typedef VS Visitor; ///The type of the map that indicates which nodes are reached. typedef typename Traits::ReachedMap ReachedMap; @@ -1425,8 +1422,8 @@ /// \name Execution Control /// The simplest way to execute the BFS algorithm is to use one of the /// member functions called \ref run(Node) "run()".\n - /// If you need more control on the execution, first you have to call - /// \ref init(), then you can add several source nodes with + /// If you need better control on the execution, you have to call + /// \ref init() first, then you can add several source nodes with /// \ref addSource(). Finally the actual path computation can be /// performed with one of the \ref start() functions. @@ -1735,7 +1732,7 @@ ///@{ - /// \brief Checks if a node is reached from the root(s). + /// \brief Checks if the given node is reached from the root(s). /// /// Returns \c true if \c v is reached from the root(s). /// diff -r c35afa9e89e7 -r ef88c0a30f85 lemon/bin_heap.h --- a/lemon/bin_heap.h Mon Jan 12 23:11:39 2009 +0100 +++ b/lemon/bin_heap.h Thu Nov 05 15:48:01 2009 +0100 @@ -19,9 +19,9 @@ #ifndef LEMON_BIN_HEAP_H #define LEMON_BIN_HEAP_H -///\ingroup auxdat +///\ingroup heaps ///\file -///\brief Binary Heap implementation. +///\brief Binary heap implementation. #include #include @@ -29,112 +29,110 @@ namespace lemon { - ///\ingroup auxdat + /// \ingroup heaps /// - ///\brief A Binary Heap implementation. + /// \brief Binary heap data structure. /// - ///This class implements the \e binary \e heap data structure. A \e heap - ///is a data structure for storing items with specified values called \e - ///priorities in such a way that finding the item with minimum priority is - ///efficient. \c Compare specifies the ordering of the priorities. In a heap - ///one can change the priority of an item, add or erase an item, etc. + /// This class implements the \e binary \e heap data structure. + /// It fully conforms to the \ref concepts::Heap "heap concept". /// - ///\tparam _Prio Type of the priority of the items. - ///\tparam _ItemIntMap A read and writable Item int map, used internally - ///to handle the cross references. - ///\tparam _Compare A class for the ordering of the priorities. The - ///default is \c std::less<_Prio>. - /// - ///\sa FibHeap - ///\sa Dijkstra - template > + /// \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 BinHeap { + public: - public: - ///\e - typedef _ItemIntMap ItemIntMap; - ///\e - typedef _Prio Prio; - ///\e + /// 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; - ///\e + /// Type of the item-priority pairs. typedef std::pair Pair; - ///\e - typedef _Compare Compare; + /// Functor type for comparing the priorities. + typedef CMP Compare; - /// \brief Type to represent the items states. + /// \brief Type to represent the states of the items. /// - /// 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 + /// 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 ItemIntMap \e should be initialized in such way that it maps - /// PRE_HEAP (-1) to any element to be put in the heap... + /// 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, - PRE_HEAP = -1, - POST_HEAP = -2 + IN_HEAP = 0, ///< = 0. + PRE_HEAP = -1, ///< = -1. + POST_HEAP = -2 ///< = -2. }; private: - std::vector data; - Compare comp; - ItemIntMap &iim; + std::vector _data; + Compare _comp; + ItemIntMap &_iim; public: - /// \brief The constructor. + + /// \brief Constructor. /// - /// The constructor. - /// \param _iim should be given to the constructor, since it is used - /// internally to handle the cross references. The value of the map - /// should be PRE_HEAP (-1) for each element. - explicit BinHeap(ItemIntMap &_iim) : iim(_iim) {} + /// 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 BinHeap(ItemIntMap &map) : _iim(map) {} - /// \brief The constructor. + /// \brief Constructor. /// - /// The constructor. - /// \param _iim should be given to the constructor, since it is used - /// internally to handle the cross references. The value of the map - /// should be PRE_HEAP (-1) for each element. + /// 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. + BinHeap(ItemIntMap &map, const Compare &comp) + : _iim(map), _comp(comp) {} + + + /// \brief The number of items stored in the heap. /// - /// \param _comp The comparator function object. - BinHeap(ItemIntMap &_iim, const Compare &_comp) - : iim(_iim), comp(_comp) {} + /// 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(); } - /// The number of items stored in the heap. + /// \brief Make the heap empty. /// - /// \brief Returns the number of items stored in the heap. - int size() const { return data.size(); } - - /// \brief Checks if the heap stores no items. - /// - /// Returns \c true if and only if the heap stores no items. - bool empty() const { return data.empty(); } - - /// \brief Make empty this heap. - /// - /// Make empty this heap. It does not change the cross reference map. - /// If you want to reuse what is not surely empty you should first clear - /// the heap and after that you should set the cross reference map for - /// each item to \c PRE_HEAP. + /// 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(); + _data.clear(); } private: static int parent(int i) { return (i-1)/2; } - static int second_child(int i) { return 2*i+2; } + static int secondChild(int i) { return 2*i+2; } bool less(const Pair &p1, const Pair &p2) const { - return comp(p1.second, p2.second); + return _comp(p1.second, p2.second); } - int bubble_up(int hole, Pair p) { + int bubbleUp(int hole, Pair p) { int par = parent(hole); - while( hole>0 && less(p,data[par]) ) { - move(data[par],hole); + while( hole>0 && less(p,_data[par]) ) { + move(_data[par],hole); hole = par; par = parent(hole); } @@ -142,21 +140,21 @@ return hole; } - int bubble_down(int hole, Pair p, int length) { - int child = second_child(hole); + int bubbleDown(int hole, Pair p, int length) { + int child = secondChild(hole); while(child < length) { - if( less(data[child-1], data[child]) ) { + if( less(_data[child-1], _data[child]) ) { --child; } - if( !less(data[child], p) ) + if( !less(_data[child], p) ) goto ok; - move(data[child], hole); + move(_data[child], hole); hole = child; - child = second_child(hole); + child = secondChild(hole); } child--; - if( child 0) { - bubble_down(0, data[n], n); + bubbleDown(0, _data[n], n); } - data.pop_back(); + _data.pop_back(); } - /// \brief Deletes \c i from the heap. + /// \brief Remove the given item 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. + /// 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); + int h = _iim[i]; + int n = _data.size()-1; + _iim.set(_data[h].first, POST_HEAP); if( h < n ) { - if ( bubble_up(h, data[n]) == h) { - bubble_down(h, data[n], n); + if ( bubbleUp(h, _data[n]) == h) { + bubbleDown(h, _data[n], n); } } - data.pop_back(); + _data.pop_back(); } - - /// \brief Returns the priority of \c i. + /// \brief The priority of the given item. /// - /// This function returns the priority of item \c i. - /// \pre \c i must be in the heap. + /// This function returns the priority of the given item. /// \param i The item. + /// \pre \e i must be in the heap. Prio operator[](const Item &i) const { - int idx = iim[i]; - return data[idx].second; + int idx = _iim[i]; + return _data[idx].second; } - /// \brief \c i gets to the heap with priority \c p independently - /// if \c i was already there. + /// \brief Set the priority of an item or insert it, if it is + /// not stored in the heap. /// - /// 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. + /// This method sets the priority of the given item if it is + /// already stored in the heap. Otherwise it inserts the given + /// item into the heap with the given priority. /// \param i The item. /// \param p The priority. void set(const Item &i, const Prio &p) { - int idx = iim[i]; + int idx = _iim[i]; if( idx < 0 ) { push(i,p); } - else if( comp(p, data[idx].second) ) { - bubble_up(idx, Pair(i,p)); + else if( _comp(p, _data[idx].second) ) { + bubbleUp(idx, Pair(i,p)); } else { - bubble_down(idx, Pair(i,p), data.size()); + bubbleDown(idx, Pair(i,p), _data.size()); } } - /// \brief Decreases the priority of \c i to \c p. + /// \brief Decrease the priority of an item to the given value. /// - /// 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. + /// This function decreases the priority of an item to the given value. /// \param i The item. /// \param p The priority. + /// \pre \e i must be stored in the heap with priority at least \e p. void decrease(const Item &i, const Prio &p) { - int idx = iim[i]; - bubble_up(idx, Pair(i,p)); + int idx = _iim[i]; + bubbleUp(idx, Pair(i,p)); } - /// \brief Increases the priority of \c i to \c p. + /// \brief Increase the priority of an item to the given value. /// - /// 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. + /// This function increases the priority of an item to the given value. /// \param i The item. /// \param p The priority. + /// \pre \e i must be stored in the heap with priority at most \e p. void increase(const Item &i, const Prio &p) { - int idx = iim[i]; - bubble_down(idx, Pair(i,p), data.size()); + int idx = _iim[i]; + bubbleDown(idx, Pair(i,p), _data.size()); } - /// \brief Returns if \c item is in, has already been in, or has - /// never been in the heap. + /// \brief Return the state of an item. /// - /// This method returns PRE_HEAP if \c item has never been in the - /// heap, IN_HEAP if it is in the heap at the moment, and POST_HEAP - /// otherwise. In the latter case it is possible that \c item will - /// get back to the heap again. + /// This method returns \c PRE_HEAP if the given item has never + /// been in the heap, \c IN_HEAP if it is in the heap at the moment, + /// and \c POST_HEAP otherwise. + /// In the latter case it is possible that the item will get back + /// to the heap again. /// \param i The item. State state(const Item &i) const { - int s = iim[i]; + int s = _iim[i]; if( s>=0 ) s=0; return State(s); } - /// \brief Sets the state of the \c item in the heap. + /// \brief Set the state of an 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. + /// 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) { @@ -319,24 +319,25 @@ if (state(i) == IN_HEAP) { erase(i); } - iim[i] = st; + _iim[i] = st; break; case IN_HEAP: break; } } - /// \brief Replaces an item in the heap. + /// \brief Replace 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. + /// 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; + int idx = _iim[i]; + _iim.set(i, _iim[j]); + _iim.set(j, idx); + _data[idx].first = j; } }; // class BinHeap diff -r c35afa9e89e7 -r ef88c0a30f85 lemon/binom_heap.h --- /dev/null Thu Jan 01 00:00:00 1970 +0000 +++ b/lemon/binom_heap.h Thu Nov 05 15:48:01 2009 +0100 @@ -0,0 +1,445 @@ +/* -*- 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_BINOM_HEAP_H +#define LEMON_BINOM_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 BinomHeap { + 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 BinomHeap(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. + BinomHeap(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 BinomHeap; + + 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_BINOM_HEAP_H + diff -r c35afa9e89e7 -r ef88c0a30f85 lemon/bits/array_map.h --- a/lemon/bits/array_map.h Mon Jan 12 23:11:39 2009 +0100 +++ b/lemon/bits/array_map.h Thu Nov 05 15:48:01 2009 +0100 @@ -47,7 +47,7 @@ : public ItemSetTraits<_Graph, _Item>::ItemNotifier::ObserverBase { public: // The graph type. - typedef _Graph Graph; + typedef _Graph GraphType; // The item type. typedef _Item Item; // The reference map tag. @@ -63,13 +63,17 @@ // The reference type of the map. typedef _Value& Reference; + // The map type. + typedef ArrayMap Map; + // The notifier type. typedef typename ItemSetTraits<_Graph, _Item>::ItemNotifier Notifier; + private: + // The MapBase of the Map which imlements the core regisitry function. typedef typename Notifier::ObserverBase Parent; - private: typedef std::allocator Allocator; public: @@ -77,7 +81,7 @@ // \brief Graph initialized map constructor. // // Graph initialized map constructor. - explicit ArrayMap(const Graph& graph) { + explicit ArrayMap(const GraphType& graph) { Parent::attach(graph.notifier(Item())); allocate_memory(); Notifier* nf = Parent::notifier(); @@ -91,7 +95,7 @@ // \brief Constructor to use default value to initialize the map. // // It constructs a map and initialize all of the the map. - ArrayMap(const Graph& graph, const Value& value) { + ArrayMap(const GraphType& graph, const Value& value) { Parent::attach(graph.notifier(Item())); allocate_memory(); Notifier* nf = Parent::notifier(); @@ -135,7 +139,7 @@ // \brief Template assign operator. // - // The given parameter should be conform to the ReadMap + // The given parameter should conform to the ReadMap // concecpt and could be indiced by the current item set of // the NodeMap. In this case the value for each item // is assigned by the value of the given ReadMap. diff -r c35afa9e89e7 -r ef88c0a30f85 lemon/bits/base_extender.h --- a/lemon/bits/base_extender.h Mon Jan 12 23:11:39 2009 +0100 +++ /dev/null Thu Jan 01 00:00:00 1970 +0000 @@ -1,494 +0,0 @@ -/* -*- mode: C++; indent-tabs-mode: nil; -*- - * - * This file is a part of LEMON, a generic C++ optimization library. - * - * Copyright (C) 2003-2009 - * Egervary Jeno Kombinatorikus Optimalizalasi Kutatocsoport - * (Egervary Research Group on Combinatorial Optimization, EGRES). - * - * Permission to use, modify and distribute this software is granted - * provided that this copyright notice appears in all copies. For - * precise terms see the accompanying LICENSE file. - * - * This software is provided "AS IS" with no warranty of any kind, - * express or implied, and with no claim as to its suitability for any - * purpose. - * - */ - -#ifndef LEMON_BITS_BASE_EXTENDER_H -#define LEMON_BITS_BASE_EXTENDER_H - -#include -#include - -#include -#include - -#include -#include - -//\ingroup digraphbits -//\file -//\brief Extenders for the graph types -namespace lemon { - - // \ingroup digraphbits - // - // \brief BaseDigraph to BaseGraph extender - template - class UndirDigraphExtender : public Base { - - public: - - typedef Base Parent; - typedef typename Parent::Arc Edge; - typedef typename Parent::Node Node; - - typedef True UndirectedTag; - - class Arc : public Edge { - friend class UndirDigraphExtender; - - protected: - bool forward; - - Arc(const Edge &ue, bool _forward) : - Edge(ue), forward(_forward) {} - - public: - Arc() {} - - // Invalid arc constructor - Arc(Invalid i) : Edge(i), forward(true) {} - - bool operator==(const Arc &that) const { - return forward==that.forward && Edge(*this)==Edge(that); - } - bool operator!=(const Arc &that) const { - return forward!=that.forward || Edge(*this)!=Edge(that); - } - bool operator<(const Arc &that) const { - return forward> 1), bool(ix & 1)); - } - - Edge edgeFromId(int ix) const { - return Parent::arcFromId(ix); - } - - int id(const Node &n) const { - return Parent::id(n); - } - - int id(const Edge &e) const { - return Parent::id(e); - } - - int id(const Arc &e) const { - return 2 * Parent::id(e) + int(e.forward); - } - - int maxNodeId() const { - return Parent::maxNodeId(); - } - - int maxArcId() const { - return 2 * Parent::maxArcId() + 1; - } - - int maxEdgeId() const { - return Parent::maxArcId(); - } - - int arcNum() const { - return 2 * Parent::arcNum(); - } - - int edgeNum() const { - return Parent::arcNum(); - } - - Arc findArc(Node s, Node t, Arc p = INVALID) const { - if (p == INVALID) { - Edge arc = Parent::findArc(s, t); - if (arc != INVALID) return direct(arc, true); - arc = Parent::findArc(t, s); - if (arc != INVALID) return direct(arc, false); - } else if (direction(p)) { - Edge arc = Parent::findArc(s, t, p); - if (arc != INVALID) return direct(arc, true); - arc = Parent::findArc(t, s); - if (arc != INVALID) return direct(arc, false); - } else { - Edge arc = Parent::findArc(t, s, p); - if (arc != INVALID) return direct(arc, false); - } - return INVALID; - } - - Edge findEdge(Node s, Node t, Edge p = INVALID) const { - if (s != t) { - if (p == INVALID) { - Edge arc = Parent::findArc(s, t); - if (arc != INVALID) return arc; - arc = Parent::findArc(t, s); - if (arc != INVALID) return arc; - } else if (Parent::s(p) == s) { - Edge arc = Parent::findArc(s, t, p); - if (arc != INVALID) return arc; - arc = Parent::findArc(t, s); - if (arc != INVALID) return arc; - } else { - Edge arc = Parent::findArc(t, s, p); - if (arc != INVALID) return arc; - } - } else { - return Parent::findArc(s, t, p); - } - return INVALID; - } - }; - - template - class BidirBpGraphExtender : public Base { - public: - typedef Base Parent; - typedef BidirBpGraphExtender Digraph; - - typedef typename Parent::Node Node; - typedef typename Parent::Edge Edge; - - - using Parent::first; - using Parent::next; - - using Parent::id; - - class Red : public Node { - friend class BidirBpGraphExtender; - public: - Red() {} - Red(const Node& node) : Node(node) { - LEMON_DEBUG(Parent::red(node) || node == INVALID, - typename Parent::NodeSetError()); - } - Red& operator=(const Node& node) { - LEMON_DEBUG(Parent::red(node) || node == INVALID, - typename Parent::NodeSetError()); - Node::operator=(node); - return *this; - } - Red(Invalid) : Node(INVALID) {} - Red& operator=(Invalid) { - Node::operator=(INVALID); - return *this; - } - }; - - void first(Red& node) const { - Parent::firstRed(static_cast(node)); - } - void next(Red& node) const { - Parent::nextRed(static_cast(node)); - } - - int id(const Red& node) const { - return Parent::redId(node); - } - - class Blue : public Node { - friend class BidirBpGraphExtender; - public: - Blue() {} - Blue(const Node& node) : Node(node) { - LEMON_DEBUG(Parent::blue(node) || node == INVALID, - typename Parent::NodeSetError()); - } - Blue& operator=(const Node& node) { - LEMON_DEBUG(Parent::blue(node) || node == INVALID, - typename Parent::NodeSetError()); - Node::operator=(node); - return *this; - } - Blue(Invalid) : Node(INVALID) {} - Blue& operator=(Invalid) { - Node::operator=(INVALID); - return *this; - } - }; - - void first(Blue& node) const { - Parent::firstBlue(static_cast(node)); - } - void next(Blue& node) const { - Parent::nextBlue(static_cast(node)); - } - - int id(const Blue& node) const { - return Parent::redId(node); - } - - Node source(const Edge& arc) const { - return red(arc); - } - Node target(const Edge& arc) const { - return blue(arc); - } - - void firstInc(Edge& arc, bool& dir, const Node& node) const { - if (Parent::red(node)) { - Parent::firstFromRed(arc, node); - dir = true; - } else { - Parent::firstFromBlue(arc, node); - dir = static_cast(arc) == INVALID; - } - } - void nextInc(Edge& arc, bool& dir) const { - if (dir) { - Parent::nextFromRed(arc); - } else { - Parent::nextFromBlue(arc); - if (arc == INVALID) dir = true; - } - } - - class Arc : public Edge { - friend class BidirBpGraphExtender; - protected: - bool forward; - - Arc(const Edge& arc, bool _forward) - : Edge(arc), forward(_forward) {} - - public: - Arc() {} - Arc (Invalid) : Edge(INVALID), forward(true) {} - bool operator==(const Arc& i) const { - return Edge::operator==(i) && forward == i.forward; - } - bool operator!=(const Arc& i) const { - return Edge::operator!=(i) || forward != i.forward; - } - bool operator<(const Arc& i) const { - return Edge::operator<(i) || - (!(i.forward(arc)); - arc.forward = true; - } - - void next(Arc& arc) const { - if (!arc.forward) { - Parent::next(static_cast(arc)); - } - arc.forward = !arc.forward; - } - - void firstOut(Arc& arc, const Node& node) const { - if (Parent::red(node)) { - Parent::firstFromRed(arc, node); - arc.forward = true; - } else { - Parent::firstFromBlue(arc, node); - arc.forward = static_cast(arc) == INVALID; - } - } - void nextOut(Arc& arc) const { - if (arc.forward) { - Parent::nextFromRed(arc); - } else { - Parent::nextFromBlue(arc); - arc.forward = static_cast(arc) == INVALID; - } - } - - void firstIn(Arc& arc, const Node& node) const { - if (Parent::blue(node)) { - Parent::firstFromBlue(arc, node); - arc.forward = true; - } else { - Parent::firstFromRed(arc, node); - arc.forward = static_cast(arc) == INVALID; - } - } - void nextIn(Arc& arc) const { - if (arc.forward) { - Parent::nextFromBlue(arc); - } else { - Parent::nextFromRed(arc); - arc.forward = static_cast(arc) == INVALID; - } - } - - Node source(const Arc& arc) const { - return arc.forward ? Parent::red(arc) : Parent::blue(arc); - } - Node target(const Arc& arc) const { - return arc.forward ? Parent::blue(arc) : Parent::red(arc); - } - - int id(const Arc& arc) const { - return (Parent::id(static_cast(arc)) << 1) + - (arc.forward ? 0 : 1); - } - Arc arcFromId(int ix) const { - return Arc(Parent::fromEdgeId(ix >> 1), (ix & 1) == 0); - } - int maxArcId() const { - return (Parent::maxEdgeId() << 1) + 1; - } - - bool direction(const Arc& arc) const { - return arc.forward; - } - - Arc direct(const Edge& arc, bool dir) const { - return Arc(arc, dir); - } - - int arcNum() const { - return 2 * Parent::edgeNum(); - } - - int edgeNum() const { - return Parent::edgeNum(); - } - - - }; -} - -#endif diff -r c35afa9e89e7 -r ef88c0a30f85 lemon/bits/default_map.h --- a/lemon/bits/default_map.h Mon Jan 12 23:11:39 2009 +0100 +++ b/lemon/bits/default_map.h Thu Nov 05 15:48:01 2009 +0100 @@ -19,6 +19,7 @@ #ifndef LEMON_BITS_DEFAULT_MAP_H #define LEMON_BITS_DEFAULT_MAP_H +#include #include #include //#include @@ -96,7 +97,7 @@ }; -#if defined __GNUC__ && !defined __STRICT_ANSI__ +#if defined LEMON_HAVE_LONG_LONG // long long template @@ -152,15 +153,16 @@ template class DefaultMap : public DefaultMapSelector<_Graph, _Item, _Value>::Map { + typedef typename DefaultMapSelector<_Graph, _Item, _Value>::Map Parent; + public: - typedef typename DefaultMapSelector<_Graph, _Item, _Value>::Map Parent; typedef DefaultMap<_Graph, _Item, _Value> Map; - - typedef typename Parent::Graph Graph; + + typedef typename Parent::GraphType GraphType; typedef typename Parent::Value Value; - explicit DefaultMap(const Graph& graph) : Parent(graph) {} - DefaultMap(const Graph& graph, const Value& value) + explicit DefaultMap(const GraphType& graph) : Parent(graph) {} + DefaultMap(const GraphType& graph, const Value& value) : Parent(graph, value) {} DefaultMap& operator=(const DefaultMap& cmap) { diff -r c35afa9e89e7 -r ef88c0a30f85 lemon/bits/edge_set_extender.h --- a/lemon/bits/edge_set_extender.h Mon Jan 12 23:11:39 2009 +0100 +++ b/lemon/bits/edge_set_extender.h Thu Nov 05 15:48:01 2009 +0100 @@ -19,22 +19,25 @@ #ifndef LEMON_BITS_EDGE_SET_EXTENDER_H #define LEMON_BITS_EDGE_SET_EXTENDER_H +#include #include #include +#include -///\ingroup digraphbits -///\file -///\brief Extenders for the arc set types +//\ingroup digraphbits +//\file +//\brief Extenders for the arc set types namespace lemon { - /// \ingroup digraphbits - /// - /// \brief Extender for the ArcSets + // \ingroup digraphbits + // + // \brief Extender for the ArcSets template class ArcSetExtender : public Base { + typedef Base Parent; + public: - typedef Base Parent; typedef ArcSetExtender Digraph; // Base extensions @@ -70,7 +73,7 @@ // Alteration notifier extensions - /// The arc observer registry. + // The arc observer registry. typedef AlterationNotifier ArcNotifier; protected: @@ -81,9 +84,7 @@ using Parent::notifier; - /// \brief Gives back the arc alteration notifier. - /// - /// Gives back the arc alteration notifier. + // Gives back the arc alteration notifier. ArcNotifier& notifier(Arc) const { return arc_notifier; } @@ -183,30 +184,30 @@ }; - /// \brief Base node of the iterator - /// - /// Returns the base node (ie. the source in this case) of the iterator + // \brief Base node of the iterator + // + // Returns the base node (ie. the source in this case) of the iterator Node baseNode(const OutArcIt &e) const { return Parent::source(static_cast(e)); } - /// \brief Running node of the iterator - /// - /// Returns the running node (ie. the target in this case) of the - /// iterator + // \brief Running node of the iterator + // + // Returns the running node (ie. the target in this case) of the + // iterator Node runningNode(const OutArcIt &e) const { return Parent::target(static_cast(e)); } - /// \brief Base node of the iterator - /// - /// Returns the base node (ie. the target in this case) of the iterator + // \brief Base node of the iterator + // + // Returns the base node (ie. the target in this case) of the iterator Node baseNode(const InArcIt &e) const { return Parent::target(static_cast(e)); } - /// \brief Running node of the iterator - /// - /// Returns the running node (ie. the source in this case) of the - /// iterator + // \brief Running node of the iterator + // + // Returns the running node (ie. the source in this case) of the + // iterator Node runningNode(const InArcIt &e) const { return Parent::source(static_cast(e)); } @@ -218,10 +219,9 @@ template class ArcMap : public MapExtender > { - public: - typedef ArcSetExtender Digraph; typedef MapExtender > Parent; + public: explicit ArcMap(const Digraph& _g) : Parent(_g) {} ArcMap(const Digraph& _g, const _Value& _v) @@ -269,22 +269,21 @@ }; - /// \ingroup digraphbits - /// - /// \brief Extender for the EdgeSets + // \ingroup digraphbits + // + // \brief Extender for the EdgeSets template class EdgeSetExtender : public Base { + typedef Base Parent; public: - typedef Base Parent; - typedef EdgeSetExtender Digraph; + typedef EdgeSetExtender Graph; typedef typename Parent::Node Node; typedef typename Parent::Arc Arc; typedef typename Parent::Edge Edge; - int maxId(Node) const { return Parent::maxNodeId(); } @@ -350,22 +349,22 @@ class NodeIt : public Node { - const Digraph* digraph; + const Graph* graph; public: NodeIt() {} NodeIt(Invalid i) : Node(i) { } - explicit NodeIt(const Digraph& _graph) : digraph(&_graph) { + explicit NodeIt(const Graph& _graph) : graph(&_graph) { _graph.first(static_cast(*this)); } - NodeIt(const Digraph& _graph, const Node& node) - : Node(node), digraph(&_graph) {} + NodeIt(const Graph& _graph, const Node& node) + : Node(node), graph(&_graph) {} NodeIt& operator++() { - digraph->next(*this); + graph->next(*this); return *this; } @@ -373,22 +372,22 @@ class ArcIt : public Arc { - const Digraph* digraph; + const Graph* graph; public: ArcIt() { } ArcIt(Invalid i) : Arc(i) { } - explicit ArcIt(const Digraph& _graph) : digraph(&_graph) { + explicit ArcIt(const Graph& _graph) : graph(&_graph) { _graph.first(static_cast(*this)); } - ArcIt(const Digraph& _graph, const Arc& e) : - Arc(e), digraph(&_graph) { } + ArcIt(const Graph& _graph, const Arc& e) : + Arc(e), graph(&_graph) { } ArcIt& operator++() { - digraph->next(*this); + graph->next(*this); return *this; } @@ -396,23 +395,23 @@ class OutArcIt : public Arc { - const Digraph* digraph; + const Graph* graph; public: OutArcIt() { } OutArcIt(Invalid i) : Arc(i) { } - OutArcIt(const Digraph& _graph, const Node& node) - : digraph(&_graph) { + OutArcIt(const Graph& _graph, const Node& node) + : graph(&_graph) { _graph.firstOut(*this, node); } - OutArcIt(const Digraph& _graph, const Arc& arc) - : Arc(arc), digraph(&_graph) {} + OutArcIt(const Graph& _graph, const Arc& arc) + : Arc(arc), graph(&_graph) {} OutArcIt& operator++() { - digraph->nextOut(*this); + graph->nextOut(*this); return *this; } @@ -420,23 +419,23 @@ class InArcIt : public Arc { - const Digraph* digraph; + const Graph* graph; public: InArcIt() { } InArcIt(Invalid i) : Arc(i) { } - InArcIt(const Digraph& _graph, const Node& node) - : digraph(&_graph) { + InArcIt(const Graph& _graph, const Node& node) + : graph(&_graph) { _graph.firstIn(*this, node); } - InArcIt(const Digraph& _graph, const Arc& arc) : - Arc(arc), digraph(&_graph) {} + InArcIt(const Graph& _graph, const Arc& arc) : + Arc(arc), graph(&_graph) {} InArcIt& operator++() { - digraph->nextIn(*this); + graph->nextIn(*this); return *this; } @@ -444,22 +443,22 @@ class EdgeIt : public Parent::Edge { - const Digraph* digraph; + const Graph* graph; public: EdgeIt() { } EdgeIt(Invalid i) : Edge(i) { } - explicit EdgeIt(const Digraph& _graph) : digraph(&_graph) { + explicit EdgeIt(const Graph& _graph) : graph(&_graph) { _graph.first(static_cast(*this)); } - EdgeIt(const Digraph& _graph, const Edge& e) : - Edge(e), digraph(&_graph) { } + EdgeIt(const Graph& _graph, const Edge& e) : + Edge(e), graph(&_graph) { } EdgeIt& operator++() { - digraph->next(*this); + graph->next(*this); return *this; } @@ -467,7 +466,7 @@ class IncEdgeIt : public Parent::Edge { friend class EdgeSetExtender; - const Digraph* digraph; + const Graph* graph; bool direction; public: @@ -475,58 +474,58 @@ IncEdgeIt(Invalid i) : Edge(i), direction(false) { } - IncEdgeIt(const Digraph& _graph, const Node &n) : digraph(&_graph) { + IncEdgeIt(const Graph& _graph, const Node &n) : graph(&_graph) { _graph.firstInc(*this, direction, n); } - IncEdgeIt(const Digraph& _graph, const Edge &ue, const Node &n) - : digraph(&_graph), Edge(ue) { + IncEdgeIt(const Graph& _graph, const Edge &ue, const Node &n) + : graph(&_graph), Edge(ue) { direction = (_graph.source(ue) == n); } IncEdgeIt& operator++() { - digraph->nextInc(*this, direction); + graph->nextInc(*this, direction); return *this; } }; - /// \brief Base node of the iterator - /// - /// Returns the base node (ie. the source in this case) of the iterator + // \brief Base node of the iterator + // + // Returns the base node (ie. the source in this case) of the iterator Node baseNode(const OutArcIt &e) const { return Parent::source(static_cast(e)); } - /// \brief Running node of the iterator - /// - /// Returns the running node (ie. the target in this case) of the - /// iterator + // \brief Running node of the iterator + // + // Returns the running node (ie. the target in this case) of the + // iterator Node runningNode(const OutArcIt &e) const { return Parent::target(static_cast(e)); } - /// \brief Base node of the iterator - /// - /// Returns the base node (ie. the target in this case) of the iterator + // \brief Base node of the iterator + // + // Returns the base node (ie. the target in this case) of the iterator Node baseNode(const InArcIt &e) const { return Parent::target(static_cast(e)); } - /// \brief Running node of the iterator - /// - /// Returns the running node (ie. the source in this case) of the - /// iterator + // \brief Running node of the iterator + // + // Returns the running node (ie. the source in this case) of the + // iterator Node runningNode(const InArcIt &e) const { return Parent::source(static_cast(e)); } - /// Base node of the iterator - /// - /// Returns the base node of the iterator + // Base node of the iterator + // + // Returns the base node of the iterator Node baseNode(const IncEdgeIt &e) const { return e.direction ? u(e) : v(e); } - /// Running node of the iterator - /// - /// Returns the running node of the iterator + // Running node of the iterator + // + // Returns the running node of the iterator Node runningNode(const IncEdgeIt &e) const { return e.direction ? v(e) : u(e); } @@ -534,14 +533,13 @@ template class ArcMap - : public MapExtender > { + : public MapExtender > { + typedef MapExtender > Parent; + public: - typedef EdgeSetExtender Digraph; - typedef MapExtender > Parent; - - ArcMap(const Digraph& _g) + explicit ArcMap(const Graph& _g) : Parent(_g) {} - ArcMap(const Digraph& _g, const _Value& _v) + ArcMap(const Graph& _g, const _Value& _v) : Parent(_g, _v) {} ArcMap& operator=(const ArcMap& cmap) { @@ -559,15 +557,14 @@ template class EdgeMap - : public MapExtender > { + : public MapExtender > { + typedef MapExtender > Parent; + public: - typedef EdgeSetExtender Digraph; - typedef MapExtender > Parent; - - EdgeMap(const Digraph& _g) + explicit EdgeMap(const Graph& _g) : Parent(_g) {} - EdgeMap(const Digraph& _g, const _Value& _v) + EdgeMap(const Graph& _g, const _Value& _v) : Parent(_g, _v) {} EdgeMap& operator=(const EdgeMap& cmap) { diff -r c35afa9e89e7 -r ef88c0a30f85 lemon/bits/graph_adaptor_extender.h --- a/lemon/bits/graph_adaptor_extender.h Mon Jan 12 23:11:39 2009 +0100 +++ b/lemon/bits/graph_adaptor_extender.h Thu Nov 05 15:48:01 2009 +0100 @@ -22,15 +22,14 @@ #include #include -#include - namespace lemon { template class DigraphAdaptorExtender : public _Digraph { + typedef _Digraph Parent; + public: - typedef _Digraph Parent; typedef _Digraph Digraph; typedef DigraphAdaptorExtender Adaptor; @@ -175,9 +174,10 @@ template class GraphAdaptorExtender : public _Graph { + typedef _Graph Parent; + public: - typedef _Graph Parent; typedef _Graph Graph; typedef GraphAdaptorExtender Adaptor; diff -r c35afa9e89e7 -r ef88c0a30f85 lemon/bits/graph_extender.h --- a/lemon/bits/graph_extender.h Mon Jan 12 23:11:39 2009 +0100 +++ b/lemon/bits/graph_extender.h Thu Nov 05 15:48:01 2009 +0100 @@ -37,9 +37,10 @@ // \brief Extender for the digraph implementations template class DigraphExtender : public Base { + typedef Base Parent; + public: - typedef Base Parent; typedef DigraphExtender Digraph; // Base extensions @@ -55,11 +56,11 @@ return Parent::maxArcId(); } - Node fromId(int id, Node) const { + static Node fromId(int id, Node) { return Parent::nodeFromId(id); } - Arc fromId(int id, Arc) const { + static Arc fromId(int id, Arc) { return Parent::arcFromId(id); } @@ -218,10 +219,9 @@ template class NodeMap : public MapExtender > { - public: - typedef DigraphExtender Digraph; typedef MapExtender > Parent; + public: explicit NodeMap(const Digraph& digraph) : Parent(digraph) {} NodeMap(const Digraph& digraph, const _Value& value) @@ -243,10 +243,9 @@ template class ArcMap : public MapExtender > { - public: - typedef DigraphExtender Digraph; typedef MapExtender > Parent; + public: explicit ArcMap(const Digraph& digraph) : Parent(digraph) {} ArcMap(const Digraph& digraph, const _Value& value) @@ -330,9 +329,10 @@ // \brief Extender for the Graphs template class GraphExtender : public Base { + typedef Base Parent; + public: - typedef Base Parent; typedef GraphExtender Graph; typedef True UndirectedTag; @@ -355,15 +355,15 @@ return Parent::maxEdgeId(); } - Node fromId(int id, Node) const { + static Node fromId(int id, Node) { return Parent::nodeFromId(id); } - Arc fromId(int id, Arc) const { + static Arc fromId(int id, Arc) { return Parent::arcFromId(id); } - Edge fromId(int id, Edge) const { + static Edge fromId(int id, Edge) { return Parent::edgeFromId(id); } @@ -601,11 +601,10 @@ template class NodeMap : public MapExtender > { - public: - typedef GraphExtender Graph; typedef MapExtender > Parent; - NodeMap(const Graph& graph) + public: + explicit NodeMap(const Graph& graph) : Parent(graph) {} NodeMap(const Graph& graph, const _Value& value) : Parent(graph, value) {} @@ -626,11 +625,10 @@ template class ArcMap : public MapExtender > { - public: - typedef GraphExtender Graph; typedef MapExtender > Parent; - ArcMap(const Graph& graph) + public: + explicit ArcMap(const Graph& graph) : Parent(graph) {} ArcMap(const Graph& graph, const _Value& value) : Parent(graph, value) {} @@ -651,11 +649,10 @@ template class EdgeMap : public MapExtender > { - public: - typedef GraphExtender Graph; typedef MapExtender > Parent; - EdgeMap(const Graph& graph) + public: + explicit EdgeMap(const Graph& graph) : Parent(graph) {} EdgeMap(const Graph& graph, const _Value& value) diff -r c35afa9e89e7 -r ef88c0a30f85 lemon/bits/map_extender.h --- a/lemon/bits/map_extender.h Mon Jan 12 23:11:39 2009 +0100 +++ b/lemon/bits/map_extender.h Thu Nov 05 15:48:01 2009 +0100 @@ -36,17 +36,20 @@ // \brief Extender for maps template class MapExtender : public _Map { + typedef _Map Parent; + typedef typename Parent::GraphType GraphType; + public: - typedef _Map Parent; typedef MapExtender Map; - - - typedef typename Parent::Graph Graph; typedef typename Parent::Key Item; typedef typename Parent::Key Key; typedef typename Parent::Value Value; + typedef typename Parent::Reference Reference; + typedef typename Parent::ConstReference ConstReference; + + typedef typename Parent::ReferenceMapTag ReferenceMapTag; class MapIt; class ConstMapIt; @@ -56,10 +59,10 @@ public: - MapExtender(const Graph& graph) + MapExtender(const GraphType& graph) : Parent(graph) {} - MapExtender(const Graph& graph, const Value& value) + MapExtender(const GraphType& graph, const Value& value) : Parent(graph, value) {} private: @@ -75,9 +78,10 @@ public: class MapIt : public Item { + typedef Item Parent; + public: - typedef Item Parent; typedef typename Map::Value Value; MapIt() {} @@ -114,10 +118,10 @@ }; class ConstMapIt : public Item { + typedef Item Parent; + public: - typedef Item Parent; - typedef typename Map::Value Value; ConstMapIt() {} @@ -145,10 +149,10 @@ }; class ItemIt : public Item { + typedef Item Parent; + public: - typedef Item Parent; - ItemIt() {} ItemIt(Invalid i) : Parent(i) { } @@ -176,17 +180,20 @@ // \brief Extender for maps which use a subset of the items. template class SubMapExtender : public _Map { + typedef _Map Parent; + typedef _Graph GraphType; + public: - typedef _Map Parent; typedef SubMapExtender Map; - - typedef _Graph Graph; - typedef typename Parent::Key Item; typedef typename Parent::Key Key; typedef typename Parent::Value Value; + typedef typename Parent::Reference Reference; + typedef typename Parent::ConstReference ConstReference; + + typedef typename Parent::ReferenceMapTag ReferenceMapTag; class MapIt; class ConstMapIt; @@ -196,10 +203,10 @@ public: - SubMapExtender(const Graph& _graph) + SubMapExtender(const GraphType& _graph) : Parent(_graph), graph(_graph) {} - SubMapExtender(const Graph& _graph, const Value& _value) + SubMapExtender(const GraphType& _graph, const Value& _value) : Parent(_graph, _value), graph(_graph) {} private: @@ -219,9 +226,9 @@ public: class MapIt : public Item { + typedef Item Parent; + public: - - typedef Item Parent; typedef typename Map::Value Value; MapIt() {} @@ -258,10 +265,10 @@ }; class ConstMapIt : public Item { + typedef Item Parent; + public: - typedef Item Parent; - typedef typename Map::Value Value; ConstMapIt() {} @@ -289,10 +296,10 @@ }; class ItemIt : public Item { + typedef Item Parent; + public: - typedef Item Parent; - ItemIt() {} ItemIt(Invalid i) : Parent(i) { } @@ -316,7 +323,7 @@ private: - const Graph& graph; + const GraphType& graph; }; diff -r c35afa9e89e7 -r ef88c0a30f85 lemon/bits/path_dump.h --- a/lemon/bits/path_dump.h Mon Jan 12 23:11:39 2009 +0100 +++ b/lemon/bits/path_dump.h Thu Nov 05 15:48:01 2009 +0100 @@ -16,8 +16,11 @@ * */ -#ifndef LEMON_BITS_PRED_MAP_PATH_H -#define LEMON_BITS_PRED_MAP_PATH_H +#ifndef LEMON_BITS_PATH_DUMP_H +#define LEMON_BITS_PATH_DUMP_H + +#include +#include namespace lemon { diff -r c35afa9e89e7 -r ef88c0a30f85 lemon/bits/solver_bits.h --- a/lemon/bits/solver_bits.h Mon Jan 12 23:11:39 2009 +0100 +++ b/lemon/bits/solver_bits.h Thu Nov 05 15:48:01 2009 +0100 @@ -19,6 +19,8 @@ #ifndef LEMON_BITS_SOLVER_BITS_H #define LEMON_BITS_SOLVER_BITS_H +#include + namespace lemon { namespace _solver_bits { diff -r c35afa9e89e7 -r ef88c0a30f85 lemon/bits/traits.h --- a/lemon/bits/traits.h Mon Jan 12 23:11:39 2009 +0100 +++ b/lemon/bits/traits.h Thu Nov 05 15:48:01 2009 +0100 @@ -29,117 +29,123 @@ struct InvalidType {}; - template + template class ItemSetTraits {}; - template + template struct NodeNotifierIndicator { typedef InvalidType Type; }; - template + template struct NodeNotifierIndicator< - Graph, - typename enable_if::type + GR, + typename enable_if::type > { - typedef typename Graph::NodeNotifier Type; + typedef typename GR::NodeNotifier Type; }; - template - class ItemSetTraits<_Graph, typename _Graph::Node> { + template + class ItemSetTraits { public: - typedef _Graph Graph; + typedef GR Graph; + typedef GR Digraph; - typedef typename Graph::Node Item; - typedef typename Graph::NodeIt ItemIt; + typedef typename GR::Node Item; + typedef typename GR::NodeIt ItemIt; - typedef typename NodeNotifierIndicator::Type ItemNotifier; + typedef typename NodeNotifierIndicator::Type ItemNotifier; - template - class Map : public Graph::template NodeMap<_Value> { + template + class Map : public GR::template NodeMap { + typedef typename GR::template NodeMap Parent; + public: - typedef typename Graph::template NodeMap<_Value> Parent; - typedef typename Graph::template NodeMap<_Value> Type; + typedef typename GR::template NodeMap Type; typedef typename Parent::Value Value; - Map(const Graph& _digraph) : Parent(_digraph) {} - Map(const Graph& _digraph, const Value& _value) + Map(const GR& _digraph) : Parent(_digraph) {} + Map(const GR& _digraph, const Value& _value) : Parent(_digraph, _value) {} }; }; - template + template struct ArcNotifierIndicator { typedef InvalidType Type; }; - template + template struct ArcNotifierIndicator< - Graph, - typename enable_if::type + GR, + typename enable_if::type > { - typedef typename Graph::ArcNotifier Type; + typedef typename GR::ArcNotifier Type; }; - template - class ItemSetTraits<_Graph, typename _Graph::Arc> { + template + class ItemSetTraits { public: - typedef _Graph Graph; + typedef GR Graph; + typedef GR Digraph; - typedef typename Graph::Arc Item; - typedef typename Graph::ArcIt ItemIt; + typedef typename GR::Arc Item; + typedef typename GR::ArcIt ItemIt; - typedef typename ArcNotifierIndicator::Type ItemNotifier; + typedef typename ArcNotifierIndicator::Type ItemNotifier; - template - class Map : public Graph::template ArcMap<_Value> { + template + class Map : public GR::template ArcMap { + typedef typename GR::template ArcMap Parent; + public: - typedef typename Graph::template ArcMap<_Value> Parent; - typedef typename Graph::template ArcMap<_Value> Type; + typedef typename GR::template ArcMap Type; typedef typename Parent::Value Value; - Map(const Graph& _digraph) : Parent(_digraph) {} - Map(const Graph& _digraph, const Value& _value) + Map(const GR& _digraph) : Parent(_digraph) {} + Map(const GR& _digraph, const Value& _value) : Parent(_digraph, _value) {} }; }; - template + template struct EdgeNotifierIndicator { typedef InvalidType Type; }; - template + template struct EdgeNotifierIndicator< - Graph, - typename enable_if::type + GR, + typename enable_if::type > { - typedef typename Graph::EdgeNotifier Type; + typedef typename GR::EdgeNotifier Type; }; - template - class ItemSetTraits<_Graph, typename _Graph::Edge> { + template + class ItemSetTraits { public: - typedef _Graph Graph; + typedef GR Graph; + typedef GR Digraph; - typedef typename Graph::Edge Item; - typedef typename Graph::EdgeIt ItemIt; + typedef typename GR::Edge Item; + typedef typename GR::EdgeIt ItemIt; - typedef typename EdgeNotifierIndicator::Type ItemNotifier; + typedef typename EdgeNotifierIndicator::Type ItemNotifier; - template - class Map : public Graph::template EdgeMap<_Value> { + template + class Map : public GR::template EdgeMap { + typedef typename GR::template EdgeMap Parent; + public: - typedef typename Graph::template EdgeMap<_Value> Parent; - typedef typename Graph::template EdgeMap<_Value> Type; + typedef typename GR::template EdgeMap Type; typedef typename Parent::Value Value; - Map(const Graph& _digraph) : Parent(_digraph) {} - Map(const Graph& _digraph, const Value& _value) + Map(const GR& _digraph) : Parent(_digraph) {} + Map(const GR& _digraph, const Value& _value) : Parent(_digraph, _value) {} }; @@ -204,93 +210,93 @@ // Indicators for the tags - template + template struct NodeNumTagIndicator { static const bool value = false; }; - template + template struct NodeNumTagIndicator< - Graph, - typename enable_if::type + GR, + typename enable_if::type > { static const bool value = true; }; - template + template struct ArcNumTagIndicator { static const bool value = false; }; - template + template struct ArcNumTagIndicator< - Graph, - typename enable_if::type + GR, + typename enable_if::type > { static const bool value = true; }; - template + template struct EdgeNumTagIndicator { static const bool value = false; }; - template + template struct EdgeNumTagIndicator< - Graph, - typename enable_if::type + GR, + typename enable_if::type > { static const bool value = true; }; - template + template struct FindArcTagIndicator { static const bool value = false; }; - template + template struct FindArcTagIndicator< - Graph, - typename enable_if::type + GR, + typename enable_if::type > { static const bool value = true; }; - template + template struct FindEdgeTagIndicator { static const bool value = false; }; - template + template struct FindEdgeTagIndicator< - Graph, - typename enable_if::type + GR, + typename enable_if::type > { static const bool value = true; }; - template + template struct UndirectedTagIndicator { static const bool value = false; }; - template + template struct UndirectedTagIndicator< - Graph, - typename enable_if::type + GR, + typename enable_if::type > { static const bool value = true; }; - template + template struct BuildTagIndicator { static const bool value = false; }; - template + template struct BuildTagIndicator< - Graph, - typename enable_if::type + GR, + typename enable_if::type > { static const bool value = true; }; diff -r c35afa9e89e7 -r ef88c0a30f85 lemon/bits/vector_map.h --- a/lemon/bits/vector_map.h Mon Jan 12 23:11:39 2009 +0100 +++ b/lemon/bits/vector_map.h Thu Nov 05 15:48:01 2009 +0100 @@ -56,7 +56,7 @@ public: // The graph type of the map. - typedef _Graph Graph; + typedef _Graph GraphType; // The item type of the map. typedef _Item Item; // The reference map tag. @@ -72,20 +72,24 @@ // The map type. typedef VectorMap Map; - // The base class of the map. - typedef typename Notifier::ObserverBase Parent; // The reference type of the map; typedef typename Container::reference Reference; // The const reference type of the map; typedef typename Container::const_reference ConstReference; + private: + + // The base class of the map. + typedef typename Notifier::ObserverBase Parent; + + public: // \brief Constructor to attach the new map into the notifier. // // It constructs a map and attachs it into the notifier. // It adds all the items of the graph to the map. - VectorMap(const Graph& graph) { + VectorMap(const GraphType& graph) { Parent::attach(graph.notifier(Item())); container.resize(Parent::notifier()->maxId() + 1); } @@ -94,7 +98,7 @@ // // It constructs a map uses a given value to initialize the map. // It adds all the items of the graph to the map. - VectorMap(const Graph& graph, const Value& value) { + VectorMap(const GraphType& graph, const Value& value) { Parent::attach(graph.notifier(Item())); container.resize(Parent::notifier()->maxId() + 1, value); } @@ -124,7 +128,7 @@ // \brief Template assign operator. // - // The given parameter should be conform to the ReadMap + // The given parameter should conform to the ReadMap // concecpt and could be indiced by the current item set of // the NodeMap. In this case the value for each item // is assigned by the value of the given ReadMap. diff -r c35afa9e89e7 -r ef88c0a30f85 lemon/bits/windows.cc --- /dev/null Thu Jan 01 00:00:00 1970 +0000 +++ b/lemon/bits/windows.cc Thu Nov 05 15:48:01 2009 +0100 @@ -0,0 +1,132 @@ +/* -*- mode: C++; indent-tabs-mode: nil; -*- + * + * This file is a part of LEMON, a generic C++ optimization library. + * + * Copyright (C) 2003-2009 + * Egervary Jeno Kombinatorikus Optimalizalasi Kutatocsoport + * (Egervary Research Group on Combinatorial Optimization, EGRES). + * + * Permission to use, modify and distribute this software is granted + * provided that this copyright notice appears in all copies. For + * precise terms see the accompanying LICENSE file. + * + * This software is provided "AS IS" with no warranty of any kind, + * express or implied, and with no claim as to its suitability for any + * purpose. + * + */ + +///\file +///\brief Some basic non-inline functions and static global data. + +#include + +#ifdef WIN32 +#ifndef WIN32_LEAN_AND_MEAN +#define WIN32_LEAN_AND_MEAN +#endif +#ifndef NOMINMAX +#define NOMINMAX +#endif +#ifdef UNICODE +#undef UNICODE +#endif +#include +#ifdef LOCALE_INVARIANT +#define MY_LOCALE LOCALE_INVARIANT +#else +#define MY_LOCALE LOCALE_NEUTRAL +#endif +#else +#include +#include +#include +#include +#endif + +#include +#include + +namespace lemon { + namespace bits { + void getWinProcTimes(double &rtime, + double &utime, double &stime, + double &cutime, double &cstime) + { +#ifdef WIN32 + static const double ch = 4294967296.0e-7; + static const double cl = 1.0e-7; + + FILETIME system; + GetSystemTimeAsFileTime(&system); + rtime = ch * system.dwHighDateTime + cl * system.dwLowDateTime; + + FILETIME create, exit, kernel, user; + if (GetProcessTimes(GetCurrentProcess(),&create, &exit, &kernel, &user)) { + utime = ch * user.dwHighDateTime + cl * user.dwLowDateTime; + stime = ch * kernel.dwHighDateTime + cl * kernel.dwLowDateTime; + cutime = 0; + cstime = 0; + } else { + rtime = 0; + utime = 0; + stime = 0; + cutime = 0; + cstime = 0; + } +#else + timeval tv; + gettimeofday(&tv, 0); + rtime=tv.tv_sec+double(tv.tv_usec)/1e6; + + tms ts; + double tck=sysconf(_SC_CLK_TCK); + times(&ts); + utime=ts.tms_utime/tck; + stime=ts.tms_stime/tck; + cutime=ts.tms_cutime/tck; + cstime=ts.tms_cstime/tck; +#endif + } + + std::string getWinFormattedDate() + { + std::ostringstream os; +#ifdef WIN32 + SYSTEMTIME time; + GetSystemTime(&time); + char buf1[11], buf2[9], buf3[5]; + if (GetDateFormat(MY_LOCALE, 0, &time, + ("ddd MMM dd"), buf1, 11) && + GetTimeFormat(MY_LOCALE, 0, &time, + ("HH':'mm':'ss"), buf2, 9) && + GetDateFormat(MY_LOCALE, 0, &time, + ("yyyy"), buf3, 5)) { + os << buf1 << ' ' << buf2 << ' ' << buf3; + } + else os << "unknown"; +#else + timeval tv; + gettimeofday(&tv, 0); + + char cbuf[26]; + ctime_r(&tv.tv_sec,cbuf); + os << cbuf; +#endif + return os.str(); + } + + int getWinRndSeed() + { +#ifdef WIN32 + FILETIME time; + GetSystemTimeAsFileTime(&time); + return GetCurrentProcessId() + time.dwHighDateTime + time.dwLowDateTime; +#else + timeval tv; + gettimeofday(&tv, 0); + return getpid() + tv.tv_sec + tv.tv_usec; +#endif + } + } +} diff -r c35afa9e89e7 -r ef88c0a30f85 lemon/bits/windows.h --- /dev/null Thu Jan 01 00:00:00 1970 +0000 +++ b/lemon/bits/windows.h Thu Nov 05 15:48:01 2009 +0100 @@ -0,0 +1,34 @@ +/* -*- mode: C++; indent-tabs-mode: nil; -*- + * + * This file is a part of LEMON, a generic C++ optimization library. + * + * Copyright (C) 2003-2009 + * Egervary Jeno Kombinatorikus Optimalizalasi Kutatocsoport + * (Egervary Research Group on Combinatorial Optimization, EGRES). + * + * Permission to use, modify and distribute this software is granted + * provided that this copyright notice appears in all copies. For + * precise terms see the accompanying LICENSE file. + * + * This software is provided "AS IS" with no warranty of any kind, + * express or implied, and with no claim as to its suitability for any + * purpose. + * + */ + +#ifndef LEMON_BITS_WINDOWS_H +#define LEMON_BITS_WINDOWS_H + +#include + +namespace lemon { + namespace bits { + void getWinProcTimes(double &rtime, + double &utime, double &stime, + double &cutime, double &cstime); + std::string getWinFormattedDate(); + int getWinRndSeed(); + } +} + +#endif diff -r c35afa9e89e7 -r ef88c0a30f85 lemon/bucket_heap.h --- /dev/null Thu Jan 01 00:00:00 1970 +0000 +++ b/lemon/bucket_heap.h Thu Nov 05 15:48:01 2009 +0100 @@ -0,0 +1,594 @@ +/* -*- 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_BUCKET_HEAP_H +#define LEMON_BUCKET_HEAP_H + +///\ingroup heaps +///\file +///\brief Bucket heap implementation. + +#include +#include +#include + +namespace lemon { + + namespace _bucket_heap_bits { + + template + struct DirectionTraits { + static bool less(int left, int right) { + return left < right; + } + static void increase(int& value) { + ++value; + } + }; + + template <> + struct DirectionTraits { + static bool less(int left, int right) { + return left > right; + } + static void increase(int& value) { + --value; + } + }; + + } + + /// \ingroup heaps + /// + /// \brief Bucket heap data structure. + /// + /// This class implements the \e bucket \e heap data structure. + /// It practically conforms to the \ref concepts::Heap "heap concept", + /// but it has some limitations. + /// + /// The bucket heap is a very simple structure. It can store only + /// \c int priorities and it maintains a list of items for each priority + /// in the range [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 + template + class BucketHeap { + + public: + + /// Type of the item-int map. + typedef IM ItemIntMap; + /// Type of the priorities. + typedef int Prio; + /// Type of the items stored in the heap. + typedef typename ItemIntMap::Key Item; + /// Type of the item-priority pairs. + typedef std::pair Pair; + + private: + + typedef _bucket_heap_bits::DirectionTraits Direction; + + public: + + /// \brief Type to represent the states of the items. + /// + /// Each item has a state associated to it. It can be "in heap", + /// "pre-heap" or "post-heap". The latter two are indifferent from the + /// heap's point of view, but may be useful to the user. + /// + /// The item-int map must be initialized in such way that it assigns + /// \c PRE_HEAP (-1) to any element to be put in the heap. + enum State { + IN_HEAP = 0, ///< = 0. + PRE_HEAP = -1, ///< = -1. + POST_HEAP = -2 ///< = -2. + }; + + public: + + /// \brief Constructor. + /// + /// Constructor. + /// \param map A map that assigns \c int values to the items. + /// It is used internally to handle the cross references. + /// The assigned value must be \c PRE_HEAP (-1) for each item. + explicit BucketHeap(ItemIntMap &map) : _iim(map), _minimum(0) {} + + /// \brief The number of items stored in the heap. + /// + /// This function returns the number of items stored in the heap. + int size() const { return _data.size(); } + + /// \brief Check if the heap is empty. + /// + /// This function returns \c true if the heap is empty. + bool empty() const { return _data.empty(); } + + /// \brief Make the heap empty. + /// + /// This functon makes the heap empty. + /// It does not change the cross reference map. If you want to reuse + /// a heap that is not surely empty, you should first clear it and + /// then you should set the cross reference map to \c PRE_HEAP + /// for each item. + void clear() { + _data.clear(); _first.clear(); _minimum = 0; + } + + private: + + void relocateLast(int idx) { + if (idx + 1 < int(_data.size())) { + _data[idx] = _data.back(); + if (_data[idx].prev != -1) { + _data[_data[idx].prev].next = idx; + } else { + _first[_data[idx].value] = idx; + } + if (_data[idx].next != -1) { + _data[_data[idx].next].prev = idx; + } + _iim[_data[idx].item] = idx; + } + _data.pop_back(); + } + + void unlace(int idx) { + if (_data[idx].prev != -1) { + _data[_data[idx].prev].next = _data[idx].next; + } else { + _first[_data[idx].value] = _data[idx].next; + } + if (_data[idx].next != -1) { + _data[_data[idx].next].prev = _data[idx].prev; + } + } + + void lace(int idx) { + if (int(_first.size()) <= _data[idx].value) { + _first.resize(_data[idx].value + 1, -1); + } + _data[idx].next = _first[_data[idx].value]; + if (_data[idx].next != -1) { + _data[_data[idx].next].prev = idx; + } + _first[_data[idx].value] = idx; + _data[idx].prev = -1; + } + + public: + + /// \brief Insert a pair of item and priority into the heap. + /// + /// This function inserts \c p.first to the heap with priority + /// \c p.second. + /// \param p The pair to insert. + /// \pre \c p.first must not be stored in the heap. + void push(const Pair& p) { + push(p.first, p.second); + } + + /// \brief Insert an item into the heap with the given priority. + /// + /// This function inserts the given item into the heap with the + /// given priority. + /// \param i The item to insert. + /// \param p The priority of the item. + /// \pre \e i must not be stored in the heap. + void push(const Item &i, const Prio &p) { + int idx = _data.size(); + _iim[i] = idx; + _data.push_back(BucketItem(i, p)); + lace(idx); + if (Direction::less(p, _minimum)) { + _minimum = p; + } + } + + /// \brief Return the item having minimum priority. + /// + /// This function returns the item having minimum priority. + /// \pre The heap must be non-empty. + Item top() const { + while (_first[_minimum] == -1) { + Direction::increase(_minimum); + } + return _data[_first[_minimum]].item; + } + + /// \brief The minimum priority. + /// + /// This function returns the minimum priority. + /// \pre The heap must be non-empty. + Prio prio() const { + while (_first[_minimum] == -1) { + Direction::increase(_minimum); + } + return _minimum; + } + + /// \brief Remove the item having minimum priority. + /// + /// This function removes the item having minimum priority. + /// \pre The heap must be non-empty. + void pop() { + while (_first[_minimum] == -1) { + Direction::increase(_minimum); + } + int idx = _first[_minimum]; + _iim[_data[idx].item] = -2; + unlace(idx); + relocateLast(idx); + } + + /// \brief Remove the given item from the heap. + /// + /// This function removes the given item from the heap if it is + /// already stored. + /// \param i The item to delete. + /// \pre \e i must be in the heap. + void erase(const Item &i) { + int idx = _iim[i]; + _iim[_data[idx].item] = -2; + unlace(idx); + relocateLast(idx); + } + + /// \brief The priority of the given item. + /// + /// This function returns the priority of the given item. + /// \param i The item. + /// \pre \e i must be in the heap. + Prio operator[](const Item &i) const { + int idx = _iim[i]; + return _data[idx].value; + } + + /// \brief Set the priority of an item or insert it, if it is + /// not stored in the heap. + /// + /// This method sets the priority of the given item if it is + /// already stored in the heap. Otherwise it inserts the given + /// item into the heap with the given priority. + /// \param i The item. + /// \param p The priority. + void set(const Item &i, const Prio &p) { + int idx = _iim[i]; + if (idx < 0) { + push(i, p); + } else if (Direction::less(p, _data[idx].value)) { + decrease(i, p); + } else { + increase(i, p); + } + } + + /// \brief Decrease the priority of an item to the given value. + /// + /// This function decreases the priority of an item to the given value. + /// \param i The item. + /// \param p The priority. + /// \pre \e i must be stored in the heap with priority at least \e p. + void decrease(const Item &i, const Prio &p) { + int idx = _iim[i]; + unlace(idx); + _data[idx].value = p; + if (Direction::less(p, _minimum)) { + _minimum = p; + } + lace(idx); + } + + /// \brief Increase the priority of an item to the given value. + /// + /// This function increases the priority of an item to the given value. + /// \param i The item. + /// \param p The priority. + /// \pre \e i must be stored in the heap with priority at most \e p. + void increase(const Item &i, const Prio &p) { + int idx = _iim[i]; + unlace(idx); + _data[idx].value = p; + lace(idx); + } + + /// \brief Return the state of an item. + /// + /// This method returns \c PRE_HEAP if the given item has never + /// been in the heap, \c IN_HEAP if it is in the heap at the moment, + /// and \c POST_HEAP otherwise. + /// In the latter case it is possible that the item will get back + /// to the heap again. + /// \param i The item. + State state(const Item &i) const { + int idx = _iim[i]; + if (idx >= 0) idx = 0; + return State(idx); + } + + /// \brief Set the state of an item in the heap. + /// + /// This function sets the state of the given item in the heap. + /// It can be used to manually clear the heap when it is important + /// to achive better time complexity. + /// \param i The item. + /// \param st The state. It should not be \c IN_HEAP. + void state(const Item& i, State st) { + switch (st) { + case POST_HEAP: + case PRE_HEAP: + if (state(i) == IN_HEAP) { + erase(i); + } + _iim[i] = st; + break; + case IN_HEAP: + break; + } + } + + private: + + struct BucketItem { + BucketItem(const Item& _item, int _value) + : item(_item), value(_value) {} + + Item item; + int value; + + int prev, next; + }; + + ItemIntMap& _iim; + std::vector _first; + std::vector _data; + mutable int _minimum; + + }; // class BucketHeap + + /// \ingroup heaps + /// + /// \brief Simplified bucket heap data structure. + /// + /// This class implements a simplified \e bucket \e heap data + /// structure. It does not provide some functionality, but it is + /// faster and simpler than BucketHeap. The main difference is + /// that BucketHeap stores a doubly-linked list for each key while + /// this class stores only simply-linked lists. It supports erasing + /// only for the item having minimum priority and it does not support + /// key increasing and decreasing. + /// + /// Note that this implementation does not conform to the + /// \ref concepts::Heap "heap concept" due to the lack of some + /// functionality. + /// + /// \tparam IM A read-writable item map with \c int values, used + /// internally to handle the cross references. + /// \tparam MIN Indicate if the heap is a \e min-heap or a \e max-heap. + /// The default is \e min-heap. If this parameter is set to \c false, + /// then the comparison is reversed, so the top(), prio() and pop() + /// functions deal with the item having maximum priority instead of the + /// minimum. + /// + /// \sa BucketHeap + template + class SimpleBucketHeap { + + public: + + /// Type of the item-int map. + typedef IM ItemIntMap; + /// Type of the priorities. + typedef int Prio; + /// Type of the items stored in the heap. + typedef typename ItemIntMap::Key Item; + /// Type of the item-priority pairs. + typedef std::pair Pair; + + private: + + typedef _bucket_heap_bits::DirectionTraits Direction; + + public: + + /// \brief Type to represent the states of the items. + /// + /// Each item has a state associated to it. It can be "in heap", + /// "pre-heap" or "post-heap". The latter two are indifferent from the + /// heap's point of view, but may be useful to the user. + /// + /// The item-int map must be initialized in such way that it assigns + /// \c PRE_HEAP (-1) to any element to be put in the heap. + enum State { + IN_HEAP = 0, ///< = 0. + PRE_HEAP = -1, ///< = -1. + POST_HEAP = -2 ///< = -2. + }; + + public: + + /// \brief Constructor. + /// + /// Constructor. + /// \param map A map that assigns \c int values to the items. + /// It is used internally to handle the cross references. + /// The assigned value must be \c PRE_HEAP (-1) for each item. + explicit SimpleBucketHeap(ItemIntMap &map) + : _iim(map), _free(-1), _num(0), _minimum(0) {} + + /// \brief The number of items stored in the heap. + /// + /// This function returns the number of items stored in the heap. + int size() const { return _num; } + + /// \brief Check if the heap is empty. + /// + /// This function returns \c true if the heap is empty. + bool empty() const { return _num == 0; } + + /// \brief Make the heap empty. + /// + /// This functon makes the heap empty. + /// It does not change the cross reference map. If you want to reuse + /// a heap that is not surely empty, you should first clear it and + /// then you should set the cross reference map to \c PRE_HEAP + /// for each item. + void clear() { + _data.clear(); _first.clear(); _free = -1; _num = 0; _minimum = 0; + } + + /// \brief Insert a pair of item and priority into the heap. + /// + /// This function inserts \c p.first to the heap with priority + /// \c p.second. + /// \param p The pair to insert. + /// \pre \c p.first must not be stored in the heap. + void push(const Pair& p) { + push(p.first, p.second); + } + + /// \brief Insert an item into the heap with the given priority. + /// + /// This function inserts the given item into the heap with the + /// given priority. + /// \param i The item to insert. + /// \param p The priority of the item. + /// \pre \e i must not be stored in the heap. + void push(const Item &i, const Prio &p) { + int idx; + if (_free == -1) { + idx = _data.size(); + _data.push_back(BucketItem(i)); + } else { + idx = _free; + _free = _data[idx].next; + _data[idx].item = i; + } + _iim[i] = idx; + if (p >= int(_first.size())) _first.resize(p + 1, -1); + _data[idx].next = _first[p]; + _first[p] = idx; + if (Direction::less(p, _minimum)) { + _minimum = p; + } + ++_num; + } + + /// \brief Return the item having minimum priority. + /// + /// This function returns the item having minimum priority. + /// \pre The heap must be non-empty. + Item top() const { + while (_first[_minimum] == -1) { + Direction::increase(_minimum); + } + return _data[_first[_minimum]].item; + } + + /// \brief The minimum priority. + /// + /// This function returns the minimum priority. + /// \pre The heap must be non-empty. + Prio prio() const { + while (_first[_minimum] == -1) { + Direction::increase(_minimum); + } + return _minimum; + } + + /// \brief Remove the item having minimum priority. + /// + /// This function removes the item having minimum priority. + /// \pre The heap must be non-empty. + void pop() { + while (_first[_minimum] == -1) { + Direction::increase(_minimum); + } + int idx = _first[_minimum]; + _iim[_data[idx].item] = -2; + _first[_minimum] = _data[idx].next; + _data[idx].next = _free; + _free = idx; + --_num; + } + + /// \brief The priority of the given item. + /// + /// This function returns the priority of the given item. + /// \param i The item. + /// \pre \e i must be in the heap. + /// \warning This operator is not a constant time function because + /// it scans the whole data structure to find the proper value. + Prio operator[](const Item &i) const { + for (int k = 0; k < int(_first.size()); ++k) { + int idx = _first[k]; + while (idx != -1) { + if (_data[idx].item == i) { + return k; + } + idx = _data[idx].next; + } + } + return -1; + } + + /// \brief Return the state of an item. + /// + /// This method returns \c PRE_HEAP if the given item has never + /// been in the heap, \c IN_HEAP if it is in the heap at the moment, + /// and \c POST_HEAP otherwise. + /// In the latter case it is possible that the item will get back + /// to the heap again. + /// \param i The item. + State state(const Item &i) const { + int idx = _iim[i]; + if (idx >= 0) idx = 0; + return State(idx); + } + + private: + + struct BucketItem { + BucketItem(const Item& _item) + : item(_item) {} + + Item item; + int next; + }; + + ItemIntMap& _iim; + std::vector _first; + std::vector _data; + int _free, _num; + mutable int _minimum; + + }; // class SimpleBucketHeap + +} + +#endif diff -r c35afa9e89e7 -r ef88c0a30f85 lemon/cbc.cc --- /dev/null Thu Jan 01 00:00:00 1970 +0000 +++ b/lemon/cbc.cc Thu Nov 05 15:48:01 2009 +0100 @@ -0,0 +1,475 @@ +/* -*- mode: C++; indent-tabs-mode: nil; -*- + * + * This file is a part of LEMON, a generic C++ optimization library. + * + * Copyright (C) 2003-2009 + * Egervary Jeno Kombinatorikus Optimalizalasi Kutatocsoport + * (Egervary Research Group on Combinatorial Optimization, EGRES). + * + * Permission to use, modify and distribute this software is granted + * provided that this copyright notice appears in all copies. For + * precise terms see the accompanying LICENSE file. + * + * This software is provided "AS IS" with no warranty of any kind, + * express or implied, and with no claim as to its suitability for any + * purpose. + * + */ + +///\file +///\brief Implementation of the CBC MIP solver interface. + +#include "cbc.h" + +#include +#include +#include + +#ifdef COIN_HAS_CLP +#include "coin/OsiClpSolverInterface.hpp" +#endif +#ifdef COIN_HAS_OSL +#include "coin/OsiOslSolverInterface.hpp" +#endif + +#include "coin/CbcCutGenerator.hpp" +#include "coin/CbcHeuristicLocal.hpp" +#include "coin/CbcHeuristicGreedy.hpp" +#include "coin/CbcHeuristicFPump.hpp" +#include "coin/CbcHeuristicRINS.hpp" + +#include "coin/CglGomory.hpp" +#include "coin/CglProbing.hpp" +#include "coin/CglKnapsackCover.hpp" +#include "coin/CglOddHole.hpp" +#include "coin/CglClique.hpp" +#include "coin/CglFlowCover.hpp" +#include "coin/CglMixedIntegerRounding.hpp" + +#include "coin/CbcHeuristic.hpp" + +namespace lemon { + + CbcMip::CbcMip() { + _prob = new CoinModel(); + _prob->setProblemName("LEMON"); + _osi_solver = 0; + _cbc_model = 0; + messageLevel(MESSAGE_NOTHING); + } + + CbcMip::CbcMip(const CbcMip& other) { + _prob = new CoinModel(*other._prob); + _prob->setProblemName("LEMON"); + _osi_solver = 0; + _cbc_model = 0; + messageLevel(MESSAGE_NOTHING); + } + + CbcMip::~CbcMip() { + delete _prob; + if (_osi_solver) delete _osi_solver; + if (_cbc_model) delete _cbc_model; + } + + const char* CbcMip::_solverName() const { return "CbcMip"; } + + int CbcMip::_addCol() { + _prob->addColumn(0, 0, 0, -COIN_DBL_MAX, COIN_DBL_MAX, 0.0, 0, false); + return _prob->numberColumns() - 1; + } + + CbcMip* CbcMip::newSolver() const { + CbcMip* newlp = new CbcMip; + return newlp; + } + + CbcMip* CbcMip::cloneSolver() const { + CbcMip* copylp = new CbcMip(*this); + return copylp; + } + + int CbcMip::_addRow() { + _prob->addRow(0, 0, 0, -COIN_DBL_MAX, COIN_DBL_MAX); + return _prob->numberRows() - 1; + } + + int CbcMip::_addRow(Value l, ExprIterator b, ExprIterator e, Value u) { + std::vector 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) { + _prob->deleteColumn(i); + } + + void CbcMip::_eraseRow(int i) { + _prob->deleteRow(i); + } + + void CbcMip::_eraseColId(int i) { + cols.eraseIndex(i); + } + + void CbcMip::_eraseRowId(int i) { + rows.eraseIndex(i); + } + + void CbcMip::_getColName(int c, std::string& name) const { + name = _prob->getColumnName(c); + } + + void CbcMip::_setColName(int c, const std::string& name) { + _prob->setColumnName(c, name.c_str()); + } + + int CbcMip::_colByName(const std::string& name) const { + return _prob->column(name.c_str()); + } + + void CbcMip::_getRowName(int r, std::string& name) const { + name = _prob->getRowName(r); + } + + void CbcMip::_setRowName(int r, const std::string& name) { + _prob->setRowName(r, name.c_str()); + } + + int CbcMip::_rowByName(const std::string& name) const { + return _prob->row(name.c_str()); + } + + void CbcMip::_setRowCoeffs(int i, ExprIterator b, ExprIterator e) { + for (ExprIterator it = b; it != e; ++it) { + _prob->setElement(i, it->first, it->second); + } + } + + void CbcMip::_getRowCoeffs(int ix, InsertIterator b) const { + int length = _prob->numberRows(); + + std::vector indices(length); + std::vector values(length); + + length = _prob->getRow(ix, &indices[0], &values[0]); + + for (int i = 0; i < length; ++i) { + *b = std::make_pair(indices[i], values[i]); + ++b; + } + } + + void CbcMip::_setColCoeffs(int ix, ExprIterator b, ExprIterator e) { + for (ExprIterator it = b; it != e; ++it) { + _prob->setElement(it->first, ix, it->second); + } + } + + void CbcMip::_getColCoeffs(int ix, InsertIterator b) const { + int length = _prob->numberColumns(); + + std::vector indices(length); + std::vector values(length); + + length = _prob->getColumn(ix, &indices[0], &values[0]); + + for (int i = 0; i < length; ++i) { + *b = std::make_pair(indices[i], values[i]); + ++b; + } + } + + void CbcMip::_setCoeff(int ix, int jx, Value value) { + _prob->setElement(ix, jx, value); + } + + CbcMip::Value CbcMip::_getCoeff(int ix, int jx) const { + return _prob->getElement(ix, jx); + } + + + void CbcMip::_setColLowerBound(int i, Value lo) { + LEMON_ASSERT(lo != INF, "Invalid bound"); + _prob->setColumnLower(i, lo == - INF ? - COIN_DBL_MAX : lo); + } + + CbcMip::Value CbcMip::_getColLowerBound(int i) const { + double val = _prob->getColumnLower(i); + return val == - COIN_DBL_MAX ? - INF : val; + } + + void CbcMip::_setColUpperBound(int i, Value up) { + LEMON_ASSERT(up != -INF, "Invalid bound"); + _prob->setColumnUpper(i, up == INF ? COIN_DBL_MAX : up); + } + + CbcMip::Value CbcMip::_getColUpperBound(int i) const { + double val = _prob->getColumnUpper(i); + return val == COIN_DBL_MAX ? INF : val; + } + + void CbcMip::_setRowLowerBound(int i, Value lo) { + LEMON_ASSERT(lo != INF, "Invalid bound"); + _prob->setRowLower(i, lo == - INF ? - COIN_DBL_MAX : lo); + } + + CbcMip::Value CbcMip::_getRowLowerBound(int i) const { + double val = _prob->getRowLower(i); + return val == - COIN_DBL_MAX ? - INF : val; + } + + void CbcMip::_setRowUpperBound(int i, Value up) { + LEMON_ASSERT(up != -INF, "Invalid bound"); + _prob->setRowUpper(i, up == INF ? COIN_DBL_MAX : up); + } + + CbcMip::Value CbcMip::_getRowUpperBound(int i) const { + double val = _prob->getRowUpper(i); + return val == COIN_DBL_MAX ? INF : val; + } + + void CbcMip::_setObjCoeffs(ExprIterator b, ExprIterator e) { + int num = _prob->numberColumns(); + for (int i = 0; i < num; ++i) { + _prob->setColumnObjective(i, 0.0); + } + for (ExprIterator it = b; it != e; ++it) { + _prob->setColumnObjective(it->first, it->second); + } + } + + void CbcMip::_getObjCoeffs(InsertIterator b) const { + int num = _prob->numberColumns(); + for (int i = 0; i < num; ++i) { + Value coef = _prob->getColumnObjective(i); + if (coef != 0.0) { + *b = std::make_pair(i, coef); + ++b; + } + } + } + + void CbcMip::_setObjCoeff(int i, Value obj_coef) { + _prob->setColumnObjective(i, obj_coef); + } + + CbcMip::Value CbcMip::_getObjCoeff(int i) const { + return _prob->getColumnObjective(i); + } + + CbcMip::SolveExitStatus CbcMip::_solve() { + + if (_osi_solver) { + delete _osi_solver; + } +#ifdef COIN_HAS_CLP + _osi_solver = new OsiClpSolverInterface(); +#elif COIN_HAS_OSL + _osi_solver = new OsiOslSolverInterface(); +#else +#error Cannot instantiate Osi solver +#endif + + _osi_solver->loadFromCoinModel(*_prob); + + if (_cbc_model) { + delete _cbc_model; + } + _cbc_model= new CbcModel(*_osi_solver); + + _osi_solver->messageHandler()->setLogLevel(_message_level); + _cbc_model->setLogLevel(_message_level); + + _cbc_model->initialSolve(); + _cbc_model->solver()->setHintParam(OsiDoReducePrint, true, OsiHintTry); + + if (!_cbc_model->isInitialSolveAbandoned() && + _cbc_model->isInitialSolveProvenOptimal() && + !_cbc_model->isInitialSolveProvenPrimalInfeasible() && + !_cbc_model->isInitialSolveProvenDualInfeasible()) { + + CglProbing generator1; + generator1.setUsingObjective(true); + generator1.setMaxPass(3); + generator1.setMaxProbe(100); + generator1.setMaxLook(50); + generator1.setRowCuts(3); + _cbc_model->addCutGenerator(&generator1, -1, "Probing"); + + CglGomory generator2; + generator2.setLimit(300); + _cbc_model->addCutGenerator(&generator2, -1, "Gomory"); + + CglKnapsackCover generator3; + _cbc_model->addCutGenerator(&generator3, -1, "Knapsack"); + + CglOddHole generator4; + generator4.setMinimumViolation(0.005); + generator4.setMinimumViolationPer(0.00002); + generator4.setMaximumEntries(200); + _cbc_model->addCutGenerator(&generator4, -1, "OddHole"); + + CglClique generator5; + generator5.setStarCliqueReport(false); + generator5.setRowCliqueReport(false); + _cbc_model->addCutGenerator(&generator5, -1, "Clique"); + + CglMixedIntegerRounding mixedGen; + _cbc_model->addCutGenerator(&mixedGen, -1, "MixedIntegerRounding"); + + CglFlowCover flowGen; + _cbc_model->addCutGenerator(&flowGen, -1, "FlowCover"); + +#ifdef COIN_HAS_CLP + OsiClpSolverInterface* osiclp = + dynamic_cast(_cbc_model->solver()); + if (osiclp->getNumRows() < 300 && osiclp->getNumCols() < 500) { + osiclp->setupForRepeatedUse(2, 0); + } +#endif + + CbcRounding heuristic1(*_cbc_model); + heuristic1.setWhen(3); + _cbc_model->addHeuristic(&heuristic1); + + CbcHeuristicLocal heuristic2(*_cbc_model); + heuristic2.setWhen(3); + _cbc_model->addHeuristic(&heuristic2); + + CbcHeuristicGreedyCover heuristic3(*_cbc_model); + heuristic3.setAlgorithm(11); + heuristic3.setWhen(3); + _cbc_model->addHeuristic(&heuristic3); + + CbcHeuristicFPump heuristic4(*_cbc_model); + heuristic4.setWhen(3); + _cbc_model->addHeuristic(&heuristic4); + + CbcHeuristicRINS heuristic5(*_cbc_model); + heuristic5.setWhen(3); + _cbc_model->addHeuristic(&heuristic5); + + if (_cbc_model->getNumCols() < 500) { + _cbc_model->setMaximumCutPassesAtRoot(-100); + } else if (_cbc_model->getNumCols() < 5000) { + _cbc_model->setMaximumCutPassesAtRoot(100); + } else { + _cbc_model->setMaximumCutPassesAtRoot(20); + } + + if (_cbc_model->getNumCols() < 5000) { + _cbc_model->setNumberStrong(10); + } + + _cbc_model->solver()->setIntParam(OsiMaxNumIterationHotStart, 100); + _cbc_model->branchAndBound(); + } + + if (_cbc_model->isAbandoned()) { + return UNSOLVED; + } else { + return SOLVED; + } + } + + CbcMip::Value CbcMip::_getSol(int i) const { + return _cbc_model->getColSolution()[i]; + } + + CbcMip::Value CbcMip::_getSolValue() const { + return _cbc_model->getObjValue(); + } + + CbcMip::ProblemType CbcMip::_getType() const { + if (_cbc_model->isProvenOptimal()) { + return OPTIMAL; + } else if (_cbc_model->isContinuousUnbounded()) { + return UNBOUNDED; + } + return FEASIBLE; + } + + void CbcMip::_setSense(Sense sense) { + switch (sense) { + case MIN: + _prob->setOptimizationDirection(1.0); + break; + case MAX: + _prob->setOptimizationDirection(- 1.0); + break; + } + } + + CbcMip::Sense CbcMip::_getSense() const { + if (_prob->optimizationDirection() > 0.0) { + return MIN; + } else if (_prob->optimizationDirection() < 0.0) { + return MAX; + } else { + LEMON_ASSERT(false, "Wrong sense"); + return CbcMip::Sense(); + } + } + + void CbcMip::_setColType(int i, CbcMip::ColTypes col_type) { + switch (col_type){ + case INTEGER: + _prob->setInteger(i); + break; + case REAL: + _prob->setContinuous(i); + break; + default:; + LEMON_ASSERT(false, "Wrong sense"); + } + } + + CbcMip::ColTypes CbcMip::_getColType(int i) const { + return _prob->getColumnIsInteger(i) ? INTEGER : REAL; + } + + void CbcMip::_clear() { + delete _prob; + if (_osi_solver) { + delete _osi_solver; + _osi_solver = 0; + } + if (_cbc_model) { + delete _cbc_model; + _cbc_model = 0; + } + + _prob = new CoinModel(); + rows.clear(); + cols.clear(); + } + + void CbcMip::_messageLevel(MessageLevel level) { + switch (level) { + case MESSAGE_NOTHING: + _message_level = 0; + break; + case MESSAGE_ERROR: + _message_level = 1; + break; + case MESSAGE_WARNING: + _message_level = 1; + break; + case MESSAGE_NORMAL: + _message_level = 2; + break; + case MESSAGE_VERBOSE: + _message_level = 3; + break; + } + } + +} //END OF NAMESPACE LEMON diff -r c35afa9e89e7 -r ef88c0a30f85 lemon/cbc.h --- /dev/null Thu Jan 01 00:00:00 1970 +0000 +++ b/lemon/cbc.h Thu Nov 05 15:48:01 2009 +0100 @@ -0,0 +1,130 @@ +/* -*- 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. + * + */ + +// -*- C++ -*- +#ifndef LEMON_CBC_H +#define LEMON_CBC_H + +///\file +///\brief Header of the LEMON-CBC mip solver interface. +///\ingroup lp_group + +#include + +class CoinModel; +class OsiSolverInterface; +class CbcModel; + +namespace lemon { + + /// \brief Interface for the CBC MIP solver + /// + /// This class implements an interface for the CBC MIP solver. + ///\ingroup lp_group + class CbcMip : public MipSolver { + protected: + + CoinModel *_prob; + OsiSolverInterface *_osi_solver; + CbcModel *_cbc_model; + + public: + + /// \e + CbcMip(); + /// \e + CbcMip(const CbcMip&); + /// \e + ~CbcMip(); + /// \e + virtual CbcMip* newSolver() const; + /// \e + virtual CbcMip* cloneSolver() const; + + protected: + + virtual const char* _solverName() const; + + virtual int _addCol(); + virtual int _addRow(); + virtual int _addRow(Value l, ExprIterator b, ExprIterator e, Value u); + + virtual void _eraseCol(int i); + virtual void _eraseRow(int i); + + virtual void _eraseColId(int i); + virtual void _eraseRowId(int i); + + virtual void _getColName(int col, std::string& name) const; + virtual void _setColName(int col, const std::string& name); + virtual int _colByName(const std::string& name) const; + + virtual void _getRowName(int row, std::string& name) const; + virtual void _setRowName(int row, const std::string& name); + virtual int _rowByName(const std::string& name) const; + + virtual void _setRowCoeffs(int i, ExprIterator b, ExprIterator e); + virtual void _getRowCoeffs(int i, InsertIterator b) const; + + virtual void _setColCoeffs(int i, ExprIterator b, ExprIterator e); + virtual void _getColCoeffs(int i, InsertIterator b) const; + + virtual void _setCoeff(int row, int col, Value value); + virtual Value _getCoeff(int row, int col) const; + + virtual void _setColLowerBound(int i, Value value); + virtual Value _getColLowerBound(int i) const; + virtual void _setColUpperBound(int i, Value value); + virtual Value _getColUpperBound(int i) const; + + virtual void _setRowLowerBound(int i, Value value); + virtual Value _getRowLowerBound(int i) const; + virtual void _setRowUpperBound(int i, Value value); + virtual Value _getRowUpperBound(int i) const; + + virtual void _setObjCoeffs(ExprIterator b, ExprIterator e); + virtual void _getObjCoeffs(InsertIterator b) const; + + virtual void _setObjCoeff(int i, Value obj_coef); + virtual Value _getObjCoeff(int i) const; + + virtual void _setSense(Sense sense); + virtual Sense _getSense() const; + + virtual ColTypes _getColType(int col) const; + virtual void _setColType(int col, ColTypes col_type); + + virtual SolveExitStatus _solve(); + virtual ProblemType _getType() const; + virtual Value _getSol(int i) const; + virtual Value _getSolValue() const; + + virtual void _clear(); + + virtual void _messageLevel(MessageLevel level); + void _applyMessageLevel(); + + int _message_level; + + + + }; + +} + +#endif diff -r c35afa9e89e7 -r ef88c0a30f85 lemon/circulation.h --- a/lemon/circulation.h Mon Jan 12 23:11:39 2009 +0100 +++ b/lemon/circulation.h Thu Nov 05 15:48:01 2009 +0100 @@ -21,6 +21,7 @@ #include #include +#include ///\ingroup max_flow ///\file @@ -31,52 +32,56 @@ /// \brief Default traits class of Circulation class. /// /// Default traits class of Circulation class. - /// \tparam _Diraph Digraph type. - /// \tparam _LCapMap Lower bound capacity map type. - /// \tparam _UCapMap Upper bound capacity map type. - /// \tparam _DeltaMap Delta map type. - template + /// + /// \tparam GR Type of the digraph the algorithm runs on. + /// \tparam LM The type of the lower bound map. + /// \tparam UM The type of the upper bound (capacity) map. + /// \tparam SM The type of the supply map. + template struct CirculationDefaultTraits { /// \brief The type of the digraph the algorithm runs on. - typedef _Diraph Digraph; + typedef GR Digraph; - /// \brief The type of the map that stores the circulation lower - /// bound. + /// \brief The type of the lower bound map. /// - /// The type of the map that stores the circulation lower bound. - /// It must meet the \ref concepts::ReadMap "ReadMap" concept. - typedef _LCapMap LCapMap; + /// The type of the map that stores the lower bounds on the arcs. + /// It must conform to the \ref concepts::ReadMap "ReadMap" concept. + typedef LM LowerMap; - /// \brief The type of the map that stores the circulation upper - /// bound. + /// \brief The type of the upper bound (capacity) map. /// - /// The type of the map that stores the circulation upper bound. - /// It must meet the \ref concepts::ReadMap "ReadMap" concept. - typedef _UCapMap UCapMap; + /// The type of the map that stores the upper bounds (capacities) + /// on the arcs. + /// It must conform to the \ref concepts::ReadMap "ReadMap" concept. + typedef UM UpperMap; - /// \brief The type of the map that stores the lower bound for - /// the supply of the nodes. + /// \brief The type of supply map. /// - /// The type of the map that stores the lower bound for the supply - /// of the nodes. It must meet the \ref concepts::ReadMap "ReadMap" - /// concept. - typedef _DeltaMap DeltaMap; + /// The type of the map that stores the signed supply values of the + /// nodes. + /// It must conform to the \ref concepts::ReadMap "ReadMap" concept. + typedef SM SupplyMap; - /// \brief The type of the flow values. - typedef typename DeltaMap::Value Value; + /// \brief The type of the flow and supply values. + typedef typename SupplyMap::Value Value; /// \brief The type of the map that stores the flow values. /// /// The type of the map that stores the flow values. - /// It must meet the \ref concepts::ReadWriteMap "ReadWriteMap" concept. + /// 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. /// /// This function instantiates a \ref FlowMap. - /// \param digraph The digraph, to which we would like to define + /// \param digraph The digraph for which we would like to define /// the flow map. static FlowMap* createFlowMap(const Digraph& digraph) { return new FlowMap(digraph); @@ -86,14 +91,17 @@ /// /// The elevator type used by the algorithm. /// - /// \sa Elevator - /// \sa LinkedElevator + /// \sa Elevator, LinkedElevator +#ifdef DOXYGEN + typedef lemon::Elevator Elevator; +#else typedef lemon::Elevator Elevator; +#endif /// \brief Instantiates an Elevator. /// /// This function instantiates an \ref Elevator. - /// \param digraph The digraph, to which we would like to define + /// \param digraph The digraph for which we would like to define /// the elevator. /// \param max_level The maximum level of the elevator. static Elevator* createElevator(const Digraph& digraph, int max_level) { @@ -111,73 +119,90 @@ \brief Push-relabel algorithm for the network circulation problem. \ingroup max_flow - This class implements a push-relabel algorithm for the network - circulation problem. + This class implements a push-relabel algorithm for the \e network + \e circulation problem. It is to find a feasible circulation when lower and upper bounds - are given for the flow values on the arcs and lower bounds - are given for the supply values of the nodes. + are given for the flow values on the arcs and lower bounds are + given for the difference between the outgoing and incoming flow + at the nodes. The exact formulation of this problem is the following. - Let \f$G=(V,A)\f$ be a digraph, - \f$lower, upper: A\rightarrow\mathbf{R}^+_0\f$, - \f$delta: V\rightarrow\mathbf{R}\f$. Find a feasible circulation - \f$f: A\rightarrow\mathbf{R}^+_0\f$ so that - \f[ \sum_{a\in\delta_{out}(v)} f(a) - \sum_{a\in\delta_{in}(v)} f(a) - \geq delta(v) \quad \forall v\in V, \f] - \f[ lower(a)\leq f(a) \leq upper(a) \quad \forall a\in A. \f] - \note \f$delta(v)\f$ specifies a lower bound for the supply of node - \f$v\f$. It can be either positive or negative, however note that - \f$\sum_{v\in V}delta(v)\f$ should be zero or negative in order to - have a feasible solution. + Let \f$G=(V,A)\f$ be a digraph, \f$lower: A\rightarrow\mathbf{R}\f$ + \f$upper: A\rightarrow\mathbf{R}\cup\{\infty\}\f$ denote the lower and + upper bounds on the arcs, for which \f$lower(uv) \leq upper(uv)\f$ + holds for all \f$uv\in A\f$, and \f$sup: V\rightarrow\mathbf{R}\f$ + denotes the signed supply values of the nodes. + If \f$sup(u)>0\f$, then \f$u\f$ is a supply node with \f$sup(u)\f$ + supply, if \f$sup(u)<0\f$, then \f$u\f$ is a demand node with + \f$-sup(u)\f$ demand. + A feasible circulation is an \f$f: A\rightarrow\mathbf{R}\f$ + solution of the following problem. - \note A special case of this problem is when - \f$\sum_{v\in V}delta(v) = 0\f$. Then the supply of each node \f$v\f$ - will be \e equal \e to \f$delta(v)\f$, if a circulation can be found. - Thus a feasible solution for the - \ref min_cost_flow "minimum cost flow" problem can be calculated - in this way. + \f[ \sum_{uv\in A} f(uv) - \sum_{vu\in A} f(vu) + \geq sup(u) \quad \forall u\in V, \f] + \f[ lower(uv) \leq f(uv) \leq upper(uv) \quad \forall uv\in A. \f] + + The sum of the supply values, i.e. \f$\sum_{u\in V} sup(u)\f$ must be + zero or negative in order to have a feasible solution (since the sum + of the expressions on the left-hand side of the inequalities is zero). + It means that the total demand must be greater or equal to the total + supply and all the supplies have to be carried out from the supply nodes, + but there could be demands that are not satisfied. + If \f$\sum_{u\in V} sup(u)\f$ is zero, then all the supply/demand + constraints have to be satisfied with equality, i.e. all demands + have to be satisfied and all supplies have to be used. + + If you need the opposite inequalities in the supply/demand constraints + (i.e. the total demand is less than the total supply and all the demands + have to be satisfied while there could be supplies that are not used), + then you could easily transform the problem to the above form by reversing + the direction of the arcs and taking the negative of the supply values + (e.g. using \ref ReverseDigraph and \ref NegMap adaptors). - \tparam _Digraph The type of the digraph the algorithm runs on. - \tparam _LCapMap The type of the lower bound capacity map. The default - map type is \ref concepts::Digraph::ArcMap "_Digraph::ArcMap". - \tparam _UCapMap The type of the upper bound capacity map. The default - map type is \c _LCapMap. - \tparam _DeltaMap The type of the map that stores the lower bound - for the supply of the nodes. The default map type is - \c _Digraph::ArcMap<_UCapMap::Value>. + This algorithm either calculates a feasible circulation, or provides + a \ref barrier() "barrier", which prooves that a feasible soultion + cannot exist. + + Note that this algorithm also provides a feasible solution for the + \ref min_cost_flow "minimum cost flow problem". + + \tparam GR The type of the digraph the algorithm runs on. + \tparam LM The type of the lower bound map. The default + map type is \ref concepts::Digraph::ArcMap "GR::ArcMap". + \tparam UM The type of the upper bound (capacity) map. + The default map type is \c LM. + \tparam SM The type of the supply map. The default map type is + \ref concepts::Digraph::NodeMap "GR::NodeMap". */ #ifdef DOXYGEN -template< typename _Digraph, - typename _LCapMap, - typename _UCapMap, - typename _DeltaMap, - typename _Traits > +template< typename GR, + typename LM, + typename UM, + typename SM, + typename TR > #else -template< typename _Digraph, - typename _LCapMap = typename _Digraph::template ArcMap, - typename _UCapMap = _LCapMap, - typename _DeltaMap = typename _Digraph:: - template NodeMap, - typename _Traits=CirculationDefaultTraits<_Digraph, _LCapMap, - _UCapMap, _DeltaMap> > +template< typename GR, + typename LM = typename GR::template ArcMap, + typename UM = LM, + typename SM = typename GR::template NodeMap, + typename TR = CirculationDefaultTraits > #endif class Circulation { public: ///The \ref CirculationDefaultTraits "traits class" of the algorithm. - typedef _Traits Traits; + typedef TR Traits; ///The type of the digraph the algorithm runs on. typedef typename Traits::Digraph Digraph; - ///The type of the flow values. + ///The type of the flow and supply values. typedef typename Traits::Value Value; - /// The type of the lower bound capacity map. - typedef typename Traits::LCapMap LCapMap; - /// The type of the upper bound capacity map. - typedef typename Traits::UCapMap UCapMap; - /// \brief The type of the map that stores the lower bound for - /// the supply of the nodes. - typedef typename Traits::DeltaMap DeltaMap; + ///The type of the lower bound map. + typedef typename Traits::LowerMap LowerMap; + ///The type of the upper bound (capacity) map. + typedef typename Traits::UpperMap UpperMap; + ///The type of the supply map. + typedef typename Traits::SupplyMap SupplyMap; ///The type of the flow map. typedef typename Traits::FlowMap FlowMap; @@ -193,9 +218,9 @@ const Digraph &_g; int _node_num; - const LCapMap *_lo; - const UCapMap *_up; - const DeltaMap *_delta; + const LowerMap *_lo; + const UpperMap *_up; + const SupplyMap *_supply; FlowMap *_flow; bool _local_flow; @@ -217,9 +242,9 @@ ///@{ - template + template struct SetFlowMapTraits : public Traits { - typedef _FlowMap FlowMap; + typedef T FlowMap; static FlowMap *createFlowMap(const Digraph&) { LEMON_ASSERT(false, "FlowMap is not initialized"); return 0; // ignore warnings @@ -231,17 +256,17 @@ /// /// \ref named-templ-param "Named parameter" for setting FlowMap /// type. - template + template struct SetFlowMap - : public Circulation > { - typedef Circulation > Create; + : public Circulation > { + typedef Circulation > Create; }; - template + template struct SetElevatorTraits : public Traits { - typedef _Elevator Elevator; + typedef T Elevator; static Elevator *createElevator(const Digraph&, int) { LEMON_ASSERT(false, "Elevator is not initialized"); return 0; // ignore warnings @@ -257,17 +282,17 @@ /// \ref elevator(Elevator&) "elevator()" function before calling /// \ref run() or \ref init(). /// \sa SetStandardElevator - template + template struct SetElevator - : public Circulation > { - typedef Circulation > Create; + : public Circulation > { + typedef Circulation > Create; }; - template + template struct SetStandardElevatorTraits : public Traits { - typedef _Elevator Elevator; + typedef T Elevator; static Elevator *createElevator(const Digraph& digraph, int max_level) { return new Elevator(digraph, max_level); } @@ -285,12 +310,12 @@ /// algorithm with the \ref elevator(Elevator&) "elevator()" function /// before calling \ref run() or \ref init(). /// \sa SetElevator - template + template struct SetStandardElevator - : public Circulation > { - typedef Circulation > Create; + : public Circulation > { + typedef Circulation > Create; }; /// @} @@ -301,18 +326,20 @@ public: - /// The constructor of the class. + /// Constructor. /// The constructor of the class. - /// \param g The digraph the algorithm runs on. - /// \param lo The lower bound capacity of the arcs. - /// \param up The upper bound capacity of the arcs. - /// \param delta The lower bound for the supply of the nodes. - Circulation(const Digraph &g,const LCapMap &lo, - const UCapMap &up,const DeltaMap &delta) - : _g(g), _node_num(), - _lo(&lo),_up(&up),_delta(&delta),_flow(0),_local_flow(false), - _level(0), _local_level(false), _excess(0), _el() {} + /// + /// \param graph The digraph the algorithm runs on. + /// \param lower The lower bounds for the flow values on the arcs. + /// \param upper The upper bounds (capacities) for the flow values + /// on the arcs. + /// \param supply The signed supply values of the nodes. + Circulation(const Digraph &graph, const LowerMap &lower, + const UpperMap &upper, const SupplyMap &supply) + : _g(graph), _lo(&lower), _up(&upper), _supply(&supply), + _flow(NULL), _local_flow(false), _level(NULL), _local_level(false), + _excess(NULL) {} /// Destructor. ~Circulation() { @@ -322,6 +349,13 @@ private: + bool checkBoundMaps() { + for (ArcIt e(_g);e!=INVALID;++e) { + if (_tol.less((*_up)[e], (*_lo)[e])) return false; + } + return true; + } + void createStructures() { _node_num = _el = countNodes(_g); @@ -352,30 +386,30 @@ public: - /// Sets the lower bound capacity map. + /// Sets the lower bound map. - /// Sets the lower bound capacity map. + /// Sets the lower bound map. /// \return (*this) - Circulation& lowerCapMap(const LCapMap& map) { + Circulation& lowerMap(const LowerMap& map) { _lo = ↦ return *this; } - /// Sets the upper bound capacity map. + /// Sets the upper bound (capacity) map. - /// Sets the upper bound capacity map. + /// Sets the upper bound (capacity) map. /// \return (*this) - Circulation& upperCapMap(const LCapMap& map) { + Circulation& upperMap(const UpperMap& map) { _up = ↦ return *this; } - /// Sets the lower bound map for the supply of the nodes. + /// Sets the supply map. - /// Sets the lower bound map for the supply of the nodes. + /// Sets the supply map. /// \return (*this) - Circulation& deltaMap(const DeltaMap& map) { - _delta = ↦ + Circulation& supplyMap(const SupplyMap& map) { + _supply = ↦ return *this; } @@ -423,25 +457,27 @@ return *_level; } - /// \brief Sets the tolerance used by algorithm. + /// \brief Sets the tolerance used by the algorithm. /// - /// Sets the tolerance used by algorithm. - Circulation& tolerance(const Tolerance& tolerance) const { + /// Sets the tolerance object used by the algorithm. + /// \return (*this) + Circulation& tolerance(const Tolerance& tolerance) { _tol = tolerance; return *this; } /// \brief Returns a const reference to the tolerance. /// - /// Returns a const reference to the tolerance. + /// Returns a const reference to the tolerance object used by + /// the algorithm. const Tolerance& tolerance() const { - return tolerance; + return _tol; } /// \name Execution Control /// The simplest way to execute the algorithm is to call \ref run().\n - /// If you need more control on the initial solution or the execution, - /// first you have to call one of the \ref init() functions, then + /// If you need better control on the initial solution or the execution, + /// you have to call one of the \ref init() functions first, then /// the \ref start() function. ///@{ @@ -452,16 +488,19 @@ /// to the lower bound. void init() { + LEMON_DEBUG(checkBoundMaps(), + "Upper bounds must be greater or equal to the lower bounds"); + createStructures(); for(NodeIt n(_g);n!=INVALID;++n) { - _excess->set(n, (*_delta)[n]); + (*_excess)[n] = (*_supply)[n]; } for (ArcIt e(_g);e!=INVALID;++e) { _flow->set(e, (*_lo)[e]); - _excess->set(_g.target(e), (*_excess)[_g.target(e)] + (*_flow)[e]); - _excess->set(_g.source(e), (*_excess)[_g.source(e)] - (*_flow)[e]); + (*_excess)[_g.target(e)] += (*_flow)[e]; + (*_excess)[_g.source(e)] -= (*_flow)[e]; } // global relabeling tested, but in general case it provides @@ -481,26 +520,29 @@ /// to construct the initial solution. void greedyInit() { + LEMON_DEBUG(checkBoundMaps(), + "Upper bounds must be greater or equal to the lower bounds"); + createStructures(); for(NodeIt n(_g);n!=INVALID;++n) { - _excess->set(n, (*_delta)[n]); + (*_excess)[n] = (*_supply)[n]; } for (ArcIt e(_g);e!=INVALID;++e) { - if (!_tol.positive((*_excess)[_g.target(e)] + (*_up)[e])) { + if (!_tol.less(-(*_excess)[_g.target(e)], (*_up)[e])) { _flow->set(e, (*_up)[e]); - _excess->set(_g.target(e), (*_excess)[_g.target(e)] + (*_up)[e]); - _excess->set(_g.source(e), (*_excess)[_g.source(e)] - (*_up)[e]); - } else if (_tol.positive((*_excess)[_g.target(e)] + (*_lo)[e])) { + (*_excess)[_g.target(e)] += (*_up)[e]; + (*_excess)[_g.source(e)] -= (*_up)[e]; + } else if (_tol.less(-(*_excess)[_g.target(e)], (*_lo)[e])) { _flow->set(e, (*_lo)[e]); - _excess->set(_g.target(e), (*_excess)[_g.target(e)] + (*_lo)[e]); - _excess->set(_g.source(e), (*_excess)[_g.source(e)] - (*_lo)[e]); + (*_excess)[_g.target(e)] += (*_lo)[e]; + (*_excess)[_g.source(e)] -= (*_lo)[e]; } else { Value fc = -(*_excess)[_g.target(e)]; _flow->set(e, fc); - _excess->set(_g.target(e), 0); - _excess->set(_g.source(e), (*_excess)[_g.source(e)] - fc); + (*_excess)[_g.target(e)] = 0; + (*_excess)[_g.source(e)] -= fc; } } @@ -539,16 +581,16 @@ if((*_level)[v]set(e, (*_flow)[e] + exc); - _excess->set(v, (*_excess)[v] + exc); + (*_excess)[v] += exc; if(!_level->active(v) && _tol.positive((*_excess)[v])) _level->activate(v); - _excess->set(act,0); + (*_excess)[act] = 0; _level->deactivate(act); goto next_l; } else { _flow->set(e, (*_up)[e]); - _excess->set(v, (*_excess)[v] + fc); + (*_excess)[v] += fc; if(!_level->active(v) && _tol.positive((*_excess)[v])) _level->activate(v); exc-=fc; @@ -563,16 +605,16 @@ if((*_level)[v]set(e, (*_flow)[e] - exc); - _excess->set(v, (*_excess)[v] + exc); + (*_excess)[v] += exc; if(!_level->active(v) && _tol.positive((*_excess)[v])) _level->activate(v); - _excess->set(act,0); + (*_excess)[act] = 0; _level->deactivate(act); goto next_l; } else { _flow->set(e, (*_lo)[e]); - _excess->set(v, (*_excess)[v] + fc); + (*_excess)[v] += fc; if(!_level->active(v) && _tol.positive((*_excess)[v])) _level->activate(v); exc-=fc; @@ -581,7 +623,7 @@ else if((*_level)[v]set(act, exc); + (*_excess)[act] = exc; if(!_tol.positive(exc)) _level->deactivate(act); else if(mlevel==_node_num) { _level->liftHighestActiveToTop(); @@ -628,9 +670,9 @@ ///@{ - /// \brief Returns the flow on the given arc. + /// \brief Returns the flow value on the given arc. /// - /// Returns the flow on the given arc. + /// Returns the flow value on the given arc. /// /// \pre Either \ref run() or \ref init() must be called before /// using this function. @@ -653,8 +695,8 @@ Barrier is a set \e B of nodes for which - \f[ \sum_{a\in\delta_{out}(B)} upper(a) - - \sum_{a\in\delta_{in}(B)} lower(a) < \sum_{v\in B}delta(v) \f] + \f[ \sum_{uv\in A: u\in B} upper(uv) - + \sum_{uv\in A: v\in B} lower(uv) < \sum_{v\in B} sup(v) \f] holds. The existence of a set with this property prooves that a feasible circualtion cannot exist. @@ -684,7 +726,7 @@ /// empty set, so \c bar[v] will be \c false for all nodes \c v. /// /// \note This function calls \ref barrier() for each node, - /// so it runs in \f$O(n)\f$ time. + /// so it runs in O(n) time. /// /// \pre Either \ref run() or \ref init() must be called before /// using this function. @@ -717,7 +759,7 @@ if((*_flow)[e]<(*_lo)[e]||(*_flow)[e]>(*_up)[e]) return false; for(NodeIt n(_g);n!=INVALID;++n) { - Value dif=-(*_delta)[n]; + Value dif=-(*_supply)[n]; for(InArcIt e(_g,n);e!=INVALID;++e) dif-=(*_flow)[e]; for(OutArcIt e(_g,n);e!=INVALID;++e) dif+=(*_flow)[e]; if(_tol.negative(dif)) return false; @@ -733,14 +775,20 @@ bool checkBarrier() const { Value delta=0; + Value inf_cap = std::numeric_limits::has_infinity ? + std::numeric_limits::infinity() : + std::numeric_limits::max(); for(NodeIt n(_g);n!=INVALID;++n) if(barrier(n)) - delta-=(*_delta)[n]; + delta-=(*_supply)[n]; for(ArcIt e(_g);e!=INVALID;++e) { Node s=_g.source(e); Node t=_g.target(e); - if(barrier(s)&&!barrier(t)) delta+=(*_up)[e]; + if(barrier(s)&&!barrier(t)) { + if (_tol.less(inf_cap - (*_up)[e], delta)) return false; + delta+=(*_up)[e]; + } else if(barrier(t)&&!barrier(s)) delta-=(*_lo)[e]; } return _tol.negative(delta); diff -r c35afa9e89e7 -r ef88c0a30f85 lemon/clp.cc --- a/lemon/clp.cc Mon Jan 12 23:11:39 2009 +0100 +++ b/lemon/clp.cc Thu Nov 05 15:48:01 2009 +0100 @@ -24,7 +24,7 @@ ClpLp::ClpLp() { _prob = new ClpSimplex(); _init_temporals(); - messageLevel(MESSAGE_NO_OUTPUT); + messageLevel(MESSAGE_NOTHING); } ClpLp::ClpLp(const ClpLp& other) { @@ -32,7 +32,7 @@ rows = other.rows; cols = other.cols; _init_temporals(); - messageLevel(MESSAGE_NO_OUTPUT); + messageLevel(MESSAGE_NOTHING); } ClpLp::~ClpLp() { @@ -56,12 +56,12 @@ } } - ClpLp* ClpLp::_newSolver() const { + ClpLp* ClpLp::newSolver() const { ClpLp* newlp = new ClpLp; return newlp; } - ClpLp* ClpLp::_cloneSolver() const { + ClpLp* ClpLp::cloneSolver() const { ClpLp* copylp = new ClpLp(*this); return copylp; } @@ -78,6 +78,19 @@ 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; + } + void ClpLp::_eraseCol(int c) { _col_names_ref.erase(_prob->getColumnName(c)); @@ -430,8 +443,24 @@ _clear_temporals(); } - void ClpLp::messageLevel(MessageLevel m) { - _prob->setLogLevel(static_cast(m)); + void ClpLp::_messageLevel(MessageLevel level) { + switch (level) { + case MESSAGE_NOTHING: + _prob->setLogLevel(0); + break; + case MESSAGE_ERROR: + _prob->setLogLevel(1); + break; + case MESSAGE_WARNING: + _prob->setLogLevel(2); + break; + case MESSAGE_NORMAL: + _prob->setLogLevel(3); + break; + case MESSAGE_VERBOSE: + _prob->setLogLevel(4); + break; + } } } //END OF NAMESPACE LEMON diff -r c35afa9e89e7 -r ef88c0a30f85 lemon/clp.h --- a/lemon/clp.h Mon Jan 12 23:11:39 2009 +0100 +++ b/lemon/clp.h Thu Nov 05 15:48:01 2009 +0100 @@ -56,6 +56,11 @@ /// \e ~ClpLp(); + /// \e + virtual ClpLp* newSolver() const; + /// \e + virtual ClpLp* cloneSolver() const; + protected: mutable double* _primal_ray; @@ -66,13 +71,11 @@ protected: - virtual ClpLp* _newSolver() const; - virtual ClpLp* _cloneSolver() const; - virtual const char* _solverName() const; virtual int _addCol(); virtual int _addRow(); + virtual int _addRow(Value l, ExprIterator b, ExprIterator e, Value u); virtual void _eraseCol(int i); virtual void _eraseRow(int i); @@ -134,6 +137,8 @@ virtual void _clear(); + virtual void _messageLevel(MessageLevel); + public: ///Solves LP with primal simplex method. @@ -151,26 +156,6 @@ ///Returns the variable identifier understood by CLP. int clpCol(Col c) const { return cols(id(c)); } - ///Enum for \c messageLevel() parameter - enum MessageLevel { - /// no output (default value) - MESSAGE_NO_OUTPUT = 0, - /// print final solution - MESSAGE_FINAL_SOLUTION = 1, - /// print factorization - MESSAGE_FACTORIZATION = 2, - /// normal output - MESSAGE_NORMAL_OUTPUT = 3, - /// verbose output - MESSAGE_VERBOSE_OUTPUT = 4 - }; - ///Set the verbosity of the messages - - ///Set the verbosity of the messages - /// - ///\param m is the level of the messages output by the solver routines. - void messageLevel(MessageLevel m); - }; } //END OF NAMESPACE LEMON diff -r c35afa9e89e7 -r ef88c0a30f85 lemon/concepts/digraph.h --- a/lemon/concepts/digraph.h Mon Jan 12 23:11:39 2009 +0100 +++ b/lemon/concepts/digraph.h Thu Nov 05 15:48:01 2009 +0100 @@ -16,8 +16,8 @@ * */ -#ifndef LEMON_CONCEPT_DIGRAPH_H -#define LEMON_CONCEPT_DIGRAPH_H +#ifndef LEMON_CONCEPTS_DIGRAPH_H +#define LEMON_CONCEPTS_DIGRAPH_H ///\ingroup graph_concepts ///\file @@ -35,46 +35,40 @@ /// /// \brief Class describing the concept of directed graphs. /// - /// This class describes the \ref concept "concept" of the - /// immutable directed digraphs. + /// This class describes the common interface of all directed + /// graphs (digraphs). /// - /// Note that actual digraph implementation like @ref ListDigraph or - /// @ref SmartDigraph may have several additional functionality. + /// 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. /// - /// \sa concept + /// \sa Graph class Digraph { private: - ///Digraphs are \e not copy constructible. Use DigraphCopy() instead. + /// 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. + void operator=(const Digraph &) {} - ///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. + public: + /// Default constructor. + Digraph() { } - ///Assignment of \ref Digraph "Digraph"s to another ones are - ///\e not allowed. Use DigraphCopy() instead. - - void operator=(const Digraph &) {} - public: - ///\e - - /// Defalult constructor. - - /// Defalult constructor. - /// - Digraph() { } - /// Class for identifying a node of the digraph + /// The node type of the digraph /// This class identifies a node of the digraph. It also serves /// as a base class of the node iterators, - /// thus they will convert to this type. + /// thus they convert to this type. class Node { public: /// Default constructor - /// @warning The default constructor sets the iterator - /// to an undefined value. + /// Default constructor. + /// \warning It sets the object to an undefined value. Node() { } /// Copy constructor. @@ -82,40 +76,39 @@ /// Node(const Node&) { } - /// Invalid constructor \& conversion. + /// %Invalid constructor \& conversion. - /// This constructor initializes the iterator to be invalid. + /// Initializes the object 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 invalid. + /// same object or both are \c INVALID. bool operator==(Node) const { return true; } /// Inequality operator - /// \sa operator==(Node n) - /// + /// Inequality operator. bool operator!=(Node) const { return true; } /// Artificial ordering operator. - /// To allow the use of digraph descriptors as key type in std::map or - /// similar associative container we require this. + /// Artificial ordering operator. /// - /// \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. + /// \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. bool operator<(Node) const { return false; } - }; - /// This iterator goes through each node. + /// Iterator class for the nodes. - /// This iterator goes through each node. + /// This iterator goes through each node of the digraph. /// Its usage is quite simple, for example you can count the number - /// of nodes in digraph \c g of type \c Digraph like this: + /// of nodes in a digraph \c g of type \c %Digraph like this: ///\code /// int count=0; /// for (Digraph::NodeIt n(g); n!=INVALID; ++n) ++count; @@ -124,30 +117,28 @@ public: /// Default constructor - /// @warning The default constructor sets the iterator - /// to an undefined value. + /// Default constructor. + /// \warning It sets the iterator to an undefined value. NodeIt() { } /// Copy constructor. /// Copy constructor. /// NodeIt(const NodeIt& n) : Node(n) { } - /// Invalid constructor \& conversion. + /// %Invalid constructor \& conversion. - /// Initialize the iterator to be invalid. + /// Initializes 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 \c g. + /// Sets the iterator to the first node of the given digraph. /// - NodeIt(const Digraph&) { } - /// Node -> NodeIt conversion. + explicit NodeIt(const Digraph&) { } + /// Sets the iterator to the given node. - /// 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. + /// Sets the iterator to the given node of the given digraph. + /// NodeIt(const Digraph&, const Node&) { } /// Next node. @@ -157,7 +148,7 @@ }; - /// Class for identifying an arc of the digraph + /// The arc type of the digraph /// This class identifies an arc of the digraph. It also serves /// as a base class of the arc iterators, @@ -166,207 +157,214 @@ public: /// Default constructor - /// @warning The default constructor sets the iterator - /// to an undefined value. + /// Default constructor. + /// \warning It sets the object to an undefined value. Arc() { } /// Copy constructor. /// Copy constructor. /// Arc(const Arc&) { } - /// Initialize the iterator to be invalid. + /// %Invalid constructor \& conversion. - /// Initialize the iterator to be invalid. - /// + /// Initializes the object to be invalid. + /// \sa Invalid for more details. Arc(Invalid) { } /// Equality operator + /// Equality operator. + /// /// Two iterators are equal if and only if they point to the - /// same object or both are invalid. + /// same object or both are \c INVALID. bool operator==(Arc) const { return true; } /// Inequality operator - /// \sa operator==(Arc n) - /// + /// Inequality operator. bool operator!=(Arc) const { return true; } /// Artificial ordering operator. - /// To allow the use of digraph descriptors as key type in std::map or - /// similar associative container we require this. + /// Artificial ordering operator. /// - /// \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. + /// \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. bool operator<(Arc) const { return false; } }; - /// This iterator goes trough the outgoing arcs of a node. + /// Iterator class for 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 /// of outgoing arcs of a node \c n - /// in digraph \c g of type \c Digraph as follows. + /// in a digraph \c g of type \c %Digraph as follows. ///\code /// int count=0; - /// for (Digraph::OutArcIt e(g, n); e!=INVALID; ++e) ++count; + /// for (Digraph::OutArcIt a(g, n); a!=INVALID; ++a) ++count; ///\endcode - class OutArcIt : public Arc { public: /// Default constructor - /// @warning The default constructor sets the iterator - /// to an undefined value. + /// Default constructor. + /// \warning It sets the iterator to an undefined value. OutArcIt() { } /// Copy constructor. /// Copy constructor. /// OutArcIt(const OutArcIt& e) : Arc(e) { } - /// Initialize the iterator to be invalid. + /// %Invalid constructor \& conversion. - /// Initialize the iterator to be invalid. + /// Initializes the iterator to be invalid. + /// \sa Invalid for more details. + OutArcIt(Invalid) { } + /// Sets the iterator to the first outgoing arc. + + /// Sets the iterator to the first outgoing arc of the given node. /// - OutArcIt(Invalid) { } - /// This constructor sets the iterator to the first outgoing arc. + OutArcIt(const Digraph&, const Node&) { } + /// Sets the iterator to the given arc. - /// This constructor sets the iterator to the first outgoing arc of - /// the node. - OutArcIt(const Digraph&, const Node&) { } - /// 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. + /// Sets the iterator to the given arc of the given digraph. + /// OutArcIt(const Digraph&, const Arc&) { } - ///Next outgoing arc + /// Next outgoing arc /// Assign the iterator to the next /// outgoing arc of the corresponding node. OutArcIt& operator++() { return *this; } }; - /// This iterator goes trough the incoming arcs of a node. + /// Iterator class for 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 outgoing arcs of a node \c n - /// in digraph \c g of type \c Digraph as follows. + /// of incoming arcs of a node \c n + /// in a digraph \c g of type \c %Digraph as follows. ///\code /// int count=0; - /// for(Digraph::InArcIt e(g, n); e!=INVALID; ++e) ++count; + /// for(Digraph::InArcIt a(g, n); a!=INVALID; ++a) ++count; ///\endcode - class InArcIt : public Arc { public: /// Default constructor - /// @warning The default constructor sets the iterator - /// to an undefined value. + /// Default constructor. + /// \warning It sets the iterator to an undefined value. InArcIt() { } /// Copy constructor. /// Copy constructor. /// InArcIt(const InArcIt& e) : Arc(e) { } - /// Initialize the iterator to be invalid. + /// %Invalid constructor \& conversion. - /// Initialize the iterator to be invalid. + /// Initializes the iterator to be invalid. + /// \sa Invalid for more details. + InArcIt(Invalid) { } + /// Sets the iterator to the first incoming arc. + + /// Sets the iterator to the first incoming arc of the given node. /// - InArcIt(Invalid) { } - /// This constructor sets the iterator to first incoming arc. + InArcIt(const Digraph&, const Node&) { } + /// Sets the iterator to the given arc. - /// This constructor set the iterator to the first incoming arc of - /// the node. - InArcIt(const Digraph&, const Node&) { } - /// 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. + /// Sets the iterator to the given arc of the given digraph. + /// InArcIt(const Digraph&, const Arc&) { } /// Next incoming arc - /// Assign the iterator to the next inarc of the corresponding node. - /// + /// Assign the iterator to the next + /// incoming arc of the corresponding node. InArcIt& operator++() { return *this; } }; - /// This iterator goes through each arc. - /// This iterator goes through each arc of a digraph. + /// 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: + /// of arcs in a digraph \c g of type \c %Digraph as follows: ///\code /// int count=0; - /// for(Digraph::ArcIt e(g); e!=INVALID; ++e) ++count; + /// for(Digraph::ArcIt a(g); a!=INVALID; ++a) ++count; ///\endcode class ArcIt : public Arc { public: /// Default constructor - /// @warning The default constructor sets the iterator - /// to an undefined value. + /// Default constructor. + /// \warning It sets the iterator to an undefined value. ArcIt() { } /// Copy constructor. /// Copy constructor. /// ArcIt(const ArcIt& e) : Arc(e) { } - /// Initialize the iterator to be invalid. + /// %Invalid constructor \& conversion. - /// Initialize the iterator to be invalid. + /// Initializes the iterator to be invalid. + /// \sa Invalid for more details. + ArcIt(Invalid) { } + /// Sets the iterator to the first arc. + + /// Sets the iterator to the first arc of the given digraph. /// - ArcIt(Invalid) { } - /// This constructor sets the iterator to the first arc. + explicit ArcIt(const Digraph& g) { ignore_unused_variable_warning(g); } + /// Sets the iterator to the given 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. + /// Sets the iterator to the given arc of the given digraph. + /// ArcIt(const Digraph&, const Arc&) { } - ///Next arc + /// Next arc /// Assign the iterator to the next arc. + /// ArcIt& operator++() { return *this; } }; - ///Gives back the target node of an arc. - ///Gives back the target node of an arc. + /// \brief The source node of the arc. /// - Node target(Arc) const { return INVALID; } - ///Gives back the source node of an arc. - - ///Gives back the source node of an arc. - /// + /// Returns the source node of the given arc. Node source(Arc) const { return INVALID; } - /// \brief Returns the ID of the node. + /// \brief The target node of the arc. + /// + /// Returns the target node of the given arc. + Node target(Arc) const { return INVALID; } + + /// \brief The ID of the node. + /// + /// Returns the ID of the given node. int id(Node) const { return -1; } - /// \brief Returns the ID of the arc. + /// \brief The ID of the arc. + /// + /// Returns the ID of the given arc. int id(Arc) const { return -1; } - /// \brief Returns the node with the given ID. + /// \brief The node with the given ID. /// - /// \pre The argument should be a valid node ID in the graph. + /// Returns the node with the given ID. + /// \pre The argument should be a valid node ID in the digraph. Node nodeFromId(int) const { return INVALID; } - /// \brief Returns the arc with the given ID. + /// \brief The arc with the given ID. /// - /// \pre The argument should be a valid arc ID in the graph. + /// Returns the arc with the given ID. + /// \pre The argument should be a valid arc ID in the digraph. Arc arcFromId(int) const { return INVALID; } - /// \brief Returns an upper bound on the node IDs. + /// \brief An upper bound on the node IDs. + /// + /// Returns an upper bound on the node IDs. int maxNodeId() const { return -1; } - /// \brief Returns an upper bound on the arc IDs. + /// \brief An upper bound on the arc IDs. + /// + /// Returns an upper bound on the arc IDs. int maxArcId() const { return -1; } void first(Node&) const {} @@ -392,51 +390,52 @@ // Dummy parameter. 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. /// - /// Gives back the base node of the iterator. - /// It is always the target of the pointed arc. - Node baseNode(const InArcIt&) const { return INVALID; } + /// 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. /// - /// Gives back the running node of the iterator. - /// It is always the source of the pointed arc. - Node runningNode(const InArcIt&) const { return INVALID; } + /// 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. /// - /// Gives back the base node of the iterator. - /// It is always the source of the pointed arc. - Node baseNode(const OutArcIt&) const { return INVALID; } + /// 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. /// - /// Gives back the running node of the iterator. - /// It is always the target of the pointed arc. - Node runningNode(const OutArcIt&) const { return INVALID; } + /// 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 The opposite node on the given arc. + /// \brief Standard graph map type for the nodes. /// - /// Gives back the opposite node on the given arc. - Node oppositeNode(const Node&, const Arc&) const { return INVALID; } - - /// \brief Read write map of the nodes to type \c T. - /// - /// ReadWrite map of the nodes to type \c T. - /// \sa Reference + /// Standard graph map type for the nodes. + /// It conforms to the ReferenceMap concept. template - class NodeMap : public ReadWriteMap< Node, T > { + class NodeMap : public ReferenceMap { public: - ///\e - NodeMap(const Digraph&) { } - ///\e + /// Constructor + explicit NodeMap(const Digraph&) { } + /// Constructor with given initial value NodeMap(const Digraph&, T) { } private: ///Copy constructor - NodeMap(const NodeMap& nm) : ReadWriteMap< Node, T >(nm) { } + NodeMap(const NodeMap& nm) : + ReferenceMap(nm) { } ///Assignment operator template NodeMap& operator=(const CMap&) { @@ -445,21 +444,23 @@ } }; - /// \brief Read write map of the arcs to type \c T. + /// \brief Standard graph map type for the arcs. /// - /// Reference map of the arcs to type \c T. - /// \sa Reference + /// Standard graph map type for the arcs. + /// It conforms to the ReferenceMap concept. template - class ArcMap : public ReadWriteMap { + class ArcMap : public ReferenceMap { public: - ///\e - ArcMap(const Digraph&) { } - ///\e + /// Constructor + explicit ArcMap(const Digraph&) { } + /// Constructor with given initial value ArcMap(const Digraph&, T) { } + private: ///Copy constructor - ArcMap(const ArcMap& em) : ReadWriteMap(em) { } + ArcMap(const ArcMap& em) : + ReferenceMap(em) { } ///Assignment operator template ArcMap& operator=(const CMap&) { @@ -471,6 +472,7 @@ template struct Constraints { void constraints() { + checkConcept(); checkConcept, _Digraph>(); checkConcept, _Digraph>(); checkConcept, _Digraph>(); @@ -484,4 +486,4 @@ -#endif // LEMON_CONCEPT_DIGRAPH_H +#endif diff -r c35afa9e89e7 -r ef88c0a30f85 lemon/concepts/graph.h --- a/lemon/concepts/graph.h Mon Jan 12 23:11:39 2009 +0100 +++ b/lemon/concepts/graph.h Thu Nov 05 15:48:01 2009 +0100 @@ -18,13 +18,14 @@ ///\ingroup graph_concepts ///\file -///\brief The concept of Undirected Graphs. +///\brief The concept of undirected graphs. -#ifndef LEMON_CONCEPT_GRAPH_H -#define LEMON_CONCEPT_GRAPH_H +#ifndef LEMON_CONCEPTS_GRAPH_H +#define LEMON_CONCEPTS_GRAPH_H #include -#include +#include +#include #include namespace lemon { @@ -32,63 +33,74 @@ /// \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. /// - /// 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 + /// 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 /// run properly, of course. + /// An actual graph implementation like \ref ListGraph or + /// \ref SmartGraph may have additional functionality. /// - /// 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. + /// 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. /// - /// 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. + /// 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. /// - /// 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. + /// 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 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: - /// \brief The undirected graph should be tagged by the - /// UndirectedTag. + /// Default constructor. + Graph() {} + + /// \brief Undirected graphs should be tagged with \c UndirectedTag. /// - /// The undirected graph should be tagged by the UndirectedTag. This - /// tag helps the enable_if technics to make compile time + /// Undirected graphs should be tagged with \c UndirectedTag. + /// + /// This tag helps the \c enable_if technics to make compile time /// specializations for undirected graphs. typedef True UndirectedTag; - /// \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. + /// 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. class Node { public: /// Default constructor - /// @warning The default constructor sets the iterator - /// to an undefined value. + /// Default constructor. + /// \warning It sets the object to an undefined value. Node() { } /// Copy constructor. @@ -96,40 +108,40 @@ /// Node(const Node&) { } - /// Invalid constructor \& conversion. + /// %Invalid constructor \& conversion. - /// This constructor initializes the iterator to be invalid. + /// Initializes the object 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 invalid. + /// same object or both are \c INVALID. bool operator==(Node) const { return true; } /// Inequality operator - /// \sa operator==(Node n) - /// + /// Inequality operator. bool operator!=(Node) const { return true; } /// Artificial ordering operator. - /// To allow the use of graph descriptors as key type in std::map or - /// similar associative container we require this. + /// Artificial ordering operator. /// - /// \note This operator only have to define some strict ordering of + /// \note This operator only has 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; } }; - /// This iterator goes through each node. + /// Iterator class for the nodes. - /// This iterator goes through each node. + /// This iterator goes through each node of the graph. /// Its usage is quite simple, for example you can count the number - /// of nodes in graph \c g of type \c Graph like this: + /// of nodes in a graph \c g of type \c %Graph like this: ///\code /// int count=0; /// for (Graph::NodeIt n(g); n!=INVALID; ++n) ++count; @@ -138,30 +150,28 @@ public: /// Default constructor - /// @warning The default constructor sets the iterator - /// to an undefined value. + /// Default constructor. + /// \warning It sets the iterator to an undefined value. NodeIt() { } /// Copy constructor. /// Copy constructor. /// NodeIt(const NodeIt& n) : Node(n) { } - /// Invalid constructor \& conversion. + /// %Invalid constructor \& conversion. - /// Initialize the iterator to be invalid. + /// Initializes 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 \c g. + /// Sets the iterator to the first node of the given digraph. /// - NodeIt(const Graph&) { } - /// Node -> NodeIt conversion. + explicit NodeIt(const Graph&) { } + /// Sets the iterator to the given node. - /// 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. + /// Sets the iterator to the given node of the given digraph. + /// NodeIt(const Graph&, const Node&) { } /// Next node. @@ -171,54 +181,55 @@ }; - /// The base type of the edge iterators. + /// The edge type of the graph - /// The base type of the edge iterators. - /// + /// 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. class Edge { public: /// Default constructor - /// @warning The default constructor sets the iterator - /// to an undefined value. + /// Default constructor. + /// \warning It sets the object to an undefined value. Edge() { } /// Copy constructor. /// Copy constructor. /// Edge(const Edge&) { } - /// Initialize the iterator to be invalid. + /// %Invalid constructor \& conversion. - /// Initialize the iterator to be invalid. - /// + /// Initializes the object to be invalid. + /// \sa Invalid for more details. Edge(Invalid) { } /// Equality operator + /// Equality operator. + /// /// Two iterators are equal if and only if they point to the - /// same object or both are invalid. + /// same object or both are \c INVALID. bool operator==(Edge) const { return true; } /// Inequality operator - /// \sa operator==(Edge n) - /// + /// Inequality operator. bool operator!=(Edge) const { return true; } /// Artificial ordering operator. - /// To allow the use of graph descriptors as key type in std::map or - /// similar associative container we require this. + /// Artificial ordering operator. /// - /// \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. + /// \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. bool operator<(Edge) const { return false; } }; - /// This iterator goes through each edge. + /// Iterator class for the edges. - /// This iterator goes through each edge of a graph. + /// 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: + /// of edges in a graph \c g of type \c %Graph as follows: ///\code /// int count=0; /// for(Graph::EdgeIt e(g); e!=INVALID; ++e) ++count; @@ -227,294 +238,291 @@ public: /// Default constructor - /// @warning The default constructor sets the iterator - /// to an undefined value. + /// Default constructor. + /// \warning It sets the iterator to an undefined value. EdgeIt() { } /// Copy constructor. /// Copy constructor. /// EdgeIt(const EdgeIt& e) : Edge(e) { } - /// Initialize the iterator to be invalid. + /// %Invalid constructor \& conversion. - /// Initialize the iterator to be invalid. + /// Initializes the iterator to be invalid. + /// \sa Invalid for more details. + EdgeIt(Invalid) { } + /// Sets the iterator to the first edge. + + /// Sets the iterator to the first edge of the given graph. /// - EdgeIt(Invalid) { } - /// This constructor sets the iterator to the first edge. + explicit EdgeIt(const Graph&) { } + /// Sets the iterator to the given 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. + /// Sets the iterator to the given edge of the given graph. + /// EdgeIt(const Graph&, const Edge&) { } /// Next edge /// Assign the iterator to the next edge. + /// EdgeIt& operator++() { return *this; } }; - /// \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. - /// + /// 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. count the number of incident arcs of a node \c n - /// in graph \c g of type \c Graph as follows. + /// degree (i.e. the number of incident edges) of a node \c n + /// in a graph \c g of type \c %Graph as follows. /// ///\code /// int count=0; /// 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 - /// @warning The default constructor sets the iterator - /// to an undefined value. + /// Default constructor. + /// \warning It sets the iterator to an undefined value. IncEdgeIt() { } /// Copy constructor. /// Copy constructor. /// IncEdgeIt(const IncEdgeIt& e) : Edge(e) { } - /// Initialize the iterator to be invalid. + /// %Invalid constructor \& conversion. - /// Initialize the iterator to be invalid. + /// Initializes the iterator to be invalid. + /// \sa Invalid for more details. + IncEdgeIt(Invalid) { } + /// Sets the iterator to the first incident edge. + + /// Sets the iterator to the first incident edge of the given node. /// - IncEdgeIt(Invalid) { } - /// This constructor sets the iterator to first incident arc. + IncEdgeIt(const Graph&, const Node&) { } + /// Sets the iterator to the given edge. - /// This constructor set the iterator to the first incident arc of - /// the node. - IncEdgeIt(const Graph&, const Node&) { } - /// Edge -> IncEdgeIt conversion + /// Sets the iterator to the given edge of the given graph. + /// + IncEdgeIt(const Graph&, const Edge&) { } + /// Next incident edge - /// 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 arc - - /// Assign the iterator to the next incident arc + /// Assign the iterator to the next incident edge /// of the corresponding node. IncEdgeIt& operator++() { return *this; } }; - /// The directed arc type. + /// The arc type of the graph - /// The directed arc type. It can be converted to the - /// edge or it should be inherited from the undirected - /// arc. - class Arc : public Edge { + /// This class identifies a directed arc of the graph. It also serves + /// as a base class of the arc iterators, + /// thus they will convert to this type. + class Arc { public: /// Default constructor - /// @warning The default constructor sets the iterator - /// to an undefined value. + /// Default constructor. + /// \warning It sets the object to an undefined value. Arc() { } /// Copy constructor. /// Copy constructor. /// - Arc(const Arc& e) : Edge(e) { } - /// Initialize the iterator to be invalid. + Arc(const Arc&) { } + /// %Invalid constructor \& conversion. - /// Initialize the iterator to be invalid. - /// + /// Initializes the object to be invalid. + /// \sa Invalid for more details. Arc(Invalid) { } /// Equality operator + /// Equality operator. + /// /// Two iterators are equal if and only if they point to the - /// same object or both are invalid. + /// same object or both are \c INVALID. bool operator==(Arc) const { return true; } /// Inequality operator - /// \sa operator==(Arc n) - /// + /// Inequality operator. bool operator!=(Arc) const { return true; } /// Artificial ordering operator. - /// To allow the use of graph descriptors as key type in std::map or - /// similar associative container we require this. + /// Artificial ordering operator. /// - /// \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. + /// \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. bool operator<(Arc) const { return false; } + /// Converison to \c Edge + + /// Converison to \c Edge. + /// + operator Edge() const { return Edge(); } }; - /// This iterator goes through each directed arc. - /// This iterator goes through each arc of a graph. + /// 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: + /// of arcs in a graph \c g of type \c %Graph as follows: ///\code /// int count=0; - /// for(Graph::ArcIt e(g); e!=INVALID; ++e) ++count; + /// for(Graph::ArcIt a(g); a!=INVALID; ++a) ++count; ///\endcode class ArcIt : public Arc { public: /// Default constructor - /// @warning The default constructor sets the iterator - /// to an undefined value. + /// Default constructor. + /// \warning It sets the iterator to an undefined value. ArcIt() { } /// Copy constructor. /// Copy constructor. /// ArcIt(const ArcIt& e) : Arc(e) { } - /// Initialize the iterator to be invalid. + /// %Invalid constructor \& conversion. - /// Initialize the iterator to be invalid. + /// Initializes the iterator to be invalid. + /// \sa Invalid for more details. + ArcIt(Invalid) { } + /// Sets the iterator to the first arc. + + /// Sets the iterator to the first arc of the given graph. /// - ArcIt(Invalid) { } - /// This constructor sets the iterator to the first arc. + explicit ArcIt(const Graph &g) { ignore_unused_variable_warning(g); } + /// Sets the iterator to the given 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. + /// Sets the iterator to the given arc of the given graph. + /// ArcIt(const Graph&, const Arc&) { } - ///Next arc + /// Next arc /// Assign the iterator to the next arc. + /// ArcIt& operator++() { return *this; } }; - /// This iterator goes trough the outgoing directed arcs of a node. + /// Iterator class for the outgoing arcs of a node. - /// This iterator goes trough the \e outgoing arcs of a certain node - /// of a graph. + /// 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 /// of outgoing arcs of a node \c n - /// in graph \c g of type \c Graph as follows. + /// in a graph \c g of type \c %Graph as follows. ///\code /// int count=0; - /// for (Graph::OutArcIt e(g, n); e!=INVALID; ++e) ++count; + /// for (Digraph::OutArcIt a(g, n); a!=INVALID; ++a) ++count; ///\endcode - class OutArcIt : public Arc { public: /// Default constructor - /// @warning The default constructor sets the iterator - /// to an undefined value. + /// Default constructor. + /// \warning It sets the iterator to an undefined value. OutArcIt() { } /// Copy constructor. /// Copy constructor. /// OutArcIt(const OutArcIt& e) : Arc(e) { } - /// Initialize the iterator to be invalid. + /// %Invalid constructor \& conversion. - /// Initialize the iterator to be invalid. + /// Initializes the iterator to be invalid. + /// \sa Invalid for more details. + OutArcIt(Invalid) { } + /// Sets the iterator to the first outgoing arc. + + /// Sets the iterator to the first outgoing arc of the given node. /// - OutArcIt(Invalid) { } - /// 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); } - /// Arc -> OutArcIt conversion + /// Sets the iterator to the given arc. - /// 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. + /// Sets the iterator to the given arc of the given graph. + /// OutArcIt(const Graph&, const Arc&) { } - ///Next outgoing arc + /// Next outgoing arc /// Assign the iterator to the next /// outgoing arc of the corresponding node. OutArcIt& operator++() { return *this; } }; - /// This iterator goes trough the incoming directed arcs of a node. + /// Iterator class for the incoming arcs of a node. - /// This iterator goes trough the \e incoming arcs of a certain node - /// of a graph. + /// 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 outgoing arcs of a node \c n - /// in graph \c g of type \c Graph as follows. + /// of incoming arcs of a node \c n + /// in a graph \c g of type \c %Graph as follows. ///\code /// int count=0; - /// for(Graph::InArcIt e(g, n); e!=INVALID; ++e) ++count; + /// for (Digraph::InArcIt a(g, n); a!=INVALID; ++a) ++count; ///\endcode - class InArcIt : public Arc { public: /// Default constructor - /// @warning The default constructor sets the iterator - /// to an undefined value. + /// Default constructor. + /// \warning It sets the iterator to an undefined value. InArcIt() { } /// Copy constructor. /// Copy constructor. /// InArcIt(const InArcIt& e) : Arc(e) { } - /// Initialize the iterator to be invalid. + /// %Invalid constructor \& conversion. - /// Initialize the iterator to be invalid. + /// Initializes the iterator to be invalid. + /// \sa Invalid for more details. + InArcIt(Invalid) { } + /// Sets the iterator to the first incoming arc. + + /// Sets the iterator to the first incoming arc of the given node. /// - InArcIt(Invalid) { } - /// 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); } - /// Arc -> InArcIt conversion + /// Sets the iterator to the given arc. - /// 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. + /// Sets the iterator to the given arc of the given graph. + /// InArcIt(const Graph&, const Arc&) { } /// Next incoming arc - /// Assign the iterator to the next inarc of the corresponding node. - /// + /// Assign the iterator to the next + /// incoming arc of the corresponding node. InArcIt& operator++() { return *this; } }; - /// \brief Read write map of the nodes to type \c T. + /// \brief Standard graph map type for the nodes. /// - /// ReadWrite map of the nodes to type \c T. - /// \sa Reference + /// Standard graph map type for the nodes. + /// It conforms to the ReferenceMap concept. template - class NodeMap : public ReadWriteMap< Node, T > + class NodeMap : public ReferenceMap { public: - ///\e - NodeMap(const Graph&) { } - ///\e + /// Constructor + explicit NodeMap(const Graph&) { } + /// Constructor with given initial value NodeMap(const Graph&, T) { } private: ///Copy constructor - NodeMap(const NodeMap& nm) : ReadWriteMap< Node, T >(nm) { } + NodeMap(const NodeMap& nm) : + ReferenceMap(nm) { } ///Assignment operator template NodeMap& operator=(const CMap&) { @@ -523,22 +531,24 @@ } }; - /// \brief Read write map of the directed arcs to type \c T. + /// \brief Standard graph map type for the arcs. /// - /// Reference map of the directed arcs to type \c T. - /// \sa Reference + /// Standard graph map type for the arcs. + /// It conforms to the ReferenceMap concept. template - class ArcMap : public ReadWriteMap + class ArcMap : public ReferenceMap { public: - ///\e - ArcMap(const Graph&) { } - ///\e + /// Constructor + explicit ArcMap(const Graph&) { } + /// Constructor with given initial value ArcMap(const Graph&, T) { } + private: ///Copy constructor - ArcMap(const ArcMap& em) : ReadWriteMap(em) { } + ArcMap(const ArcMap& em) : + ReferenceMap(em) { } ///Assignment operator template ArcMap& operator=(const CMap&) { @@ -547,22 +557,24 @@ } }; - /// Read write map of the edges to type \c T. - - /// Reference map of the arcs to type \c T. - /// \sa Reference + /// \brief Standard graph map type for the edges. + /// + /// Standard graph map type for the edges. + /// It conforms to the ReferenceMap concept. template - class EdgeMap : public ReadWriteMap + class EdgeMap : public ReferenceMap { public: - ///\e - EdgeMap(const Graph&) { } - ///\e + /// Constructor + explicit EdgeMap(const Graph&) { } + /// Constructor with given initial value EdgeMap(const Graph&, T) { } + private: ///Copy constructor - EdgeMap(const EdgeMap& em) : ReadWriteMap(em) {} + EdgeMap(const EdgeMap& em) : + ReferenceMap(em) {} ///Assignment operator template EdgeMap& operator=(const CMap&) { @@ -571,95 +583,124 @@ } }; - /// \brief Direct the given edge. + /// \brief The first node of the edge. /// - /// Direct the given edge. The returned arc source - /// will be the given node. - Arc direct(const Edge&, const Node&) const { + /// Returns the first node of the given edge. + /// + /// Edges don't have source and target nodes, however methods + /// u() and v() are used to query the two end-nodes of an edge. + /// The orientation of an edge that arises this way is called + /// the inherent direction, it is used to define the default + /// direction for the corresponding arcs. + /// \sa v() + /// \sa direction() + Node u(Edge) const { return INVALID; } + + /// \brief The second node of the edge. + /// + /// Returns the second node of the given edge. + /// + /// Edges don't have source and target nodes, however methods + /// u() and v() are used to query the two end-nodes of an edge. + /// The orientation of an edge that arises this way is called + /// the inherent direction, it is used to define the default + /// direction for the corresponding arcs. + /// \sa u() + /// \sa direction() + Node v(Edge) const { return INVALID; } + + /// \brief The source node of the arc. + /// + /// Returns the source node of the given arc. + Node source(Arc) const { return INVALID; } + + /// \brief The target node of the arc. + /// + /// Returns the target node of the given arc. + Node target(Arc) const { return INVALID; } + + /// \brief The ID of the node. + /// + /// Returns the ID of the given node. + int id(Node) const { return -1; } + + /// \brief The ID of the edge. + /// + /// Returns the ID of the given edge. + int id(Edge) const { return -1; } + + /// \brief The ID of the arc. + /// + /// Returns the ID of the given arc. + int id(Arc) const { return -1; } + + /// \brief The node with the given ID. + /// + /// Returns the node with the given ID. + /// \pre The argument should be a valid node ID in the graph. + Node nodeFromId(int) const { return INVALID; } + + /// \brief The edge with the given ID. + /// + /// Returns the edge with the given ID. + /// \pre The argument should be a valid edge ID in the graph. + Edge edgeFromId(int) const { return INVALID; } + + /// \brief The arc with the given ID. + /// + /// Returns the arc with the given ID. + /// \pre The argument should be a valid arc ID in the graph. + Arc arcFromId(int) const { return INVALID; } + + /// \brief An upper bound on the node IDs. + /// + /// Returns an upper bound on the node IDs. + int maxNodeId() const { return -1; } + + /// \brief An upper bound on the edge IDs. + /// + /// Returns an upper bound on the edge IDs. + int maxEdgeId() const { return -1; } + + /// \brief An upper bound on the arc IDs. + /// + /// Returns an upper bound on the arc IDs. + int maxArcId() const { return -1; } + + /// \brief The direction of the arc. + /// + /// Returns \c true if the direction of the given arc is the same as + /// the inherent orientation of the represented edge. + bool direction(Arc) const { return true; } + + /// \brief Direct the edge. + /// + /// Direct the given edge. The returned arc + /// represents the given edge and its direction comes + /// from the bool parameter. If it is \c true, then the direction + /// of the arc is the same as the inherent orientation of the edge. + Arc direct(Edge, bool) const { return INVALID; } - /// \brief Direct the given edge. + /// \brief Direct the 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 { + /// 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 Returns true if the arc has default orientation. + /// \brief The oppositely directed arc. /// - /// 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. + /// Returns the oppositely directed arc representing the same edge. Arc oppositeArc(Arc) const { return INVALID; } - /// \brief Opposite node on an arc + /// \brief The opposite node on the edge. /// - /// \return the opposite of the given Node on the given Edge + /// Returns the opposite node on the given edge. Node oppositeNode(Node, Edge) const { return INVALID; } - /// \brief First node of the edge. - /// - /// \return the first node of the given Edge. - /// - /// Naturally edges don't have direction and thus - /// don't have source and target node. But we use these two methods - /// to query the two nodes of the arc. The direction of the arc - /// which arises this way is called the inherent direction of the - /// edge, and is used to define the "default" direction - /// of the directed versions of the arcs. - /// \sa direction - Node u(Edge) const { return INVALID; } - - /// \brief Second node of the edge. - Node v(Edge) const { return INVALID; } - - /// \brief Source node of the directed arc. - Node source(Arc) const { return INVALID; } - - /// \brief Target node of the directed arc. - Node target(Arc) const { return INVALID; } - - /// \brief Returns the id of the node. - int id(Node) const { return -1; } - - /// \brief Returns the id of the edge. - int id(Edge) const { return -1; } - - /// \brief Returns the id of the arc. - int id(Arc) const { return -1; } - - /// \brief Returns the node with the given id. - /// - /// \pre The argument should be a valid node id in the graph. - Node nodeFromId(int) const { return INVALID; } - - /// \brief Returns the edge with the given id. - /// - /// \pre The argument should be a valid edge id in the graph. - Edge edgeFromId(int) const { return INVALID; } - - /// \brief Returns the arc with the given id. - /// - /// \pre The argument should be a valid arc id in the graph. - Arc arcFromId(int) const { return INVALID; } - - /// \brief Returns an upper bound on the node IDs. - int maxNodeId() const { return -1; } - - /// \brief Returns an upper bound on the edge IDs. - int maxEdgeId() const { return -1; } - - /// \brief Returns an upper bound on the arc IDs. - int maxArcId() const { return -1; } - void first(Node&) const {} void next(Node&) const {} @@ -692,51 +733,44 @@ // Dummy parameter. int maxId(Arc) const { return -1; } - /// \brief Base node of the iterator + /// \brief The 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 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 (the target in this case) of the - /// iterator - Node runningNode(OutArcIt e) const { - return target(e); - } + /// Returns the running node of the given incident edge iterator. + Node runningNode(IncEdgeIt) const { return INVALID; } - /// \brief Base node of the iterator + /// \brief The 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 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 (the source in this case) of the - /// iterator - Node runningNode(InArcIt e) const { - return source(e); - } + /// 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 Base node of the iterator + /// \brief The base node of the iterator. /// - /// Returns the base node of the iterator - Node baseNode(IncEdgeIt) const { - return INVALID; - } + /// 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 Running node of the iterator + /// \brief The running node of the iterator. /// - /// Returns the running node of the iterator - Node runningNode(IncEdgeIt) const { - return INVALID; - } + /// 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; } template struct Constraints { void constraints() { + checkConcept(); checkConcept, _Graph>(); checkConcept, _Graph>(); checkConcept, _Graph>(); diff -r c35afa9e89e7 -r ef88c0a30f85 lemon/concepts/graph_components.h --- a/lemon/concepts/graph_components.h Mon Jan 12 23:11:39 2009 +0100 +++ b/lemon/concepts/graph_components.h Thu Nov 05 15:48:01 2009 +0100 @@ -20,9 +20,8 @@ ///\file ///\brief The concept of graph components. - -#ifndef LEMON_CONCEPT_GRAPH_COMPONENTS_H -#define LEMON_CONCEPT_GRAPH_COMPONENTS_H +#ifndef LEMON_CONCEPTS_GRAPH_COMPONENTS_H +#define LEMON_CONCEPTS_GRAPH_COMPONENTS_H #include #include @@ -32,75 +31,83 @@ namespace lemon { namespace concepts { - /// \brief Skeleton class for graph Node and Arc types + /// \brief Concept class for \c Node, \c Arc and \c Edge types. /// - /// This class describes the interface of Node and Arc (and Edge - /// in undirected graphs) subtypes of graph types. + /// This class describes the concept of \c Node, \c Arc and \c Edge + /// subtypes of digraph and graph types. /// /// \note This class is a template class so that we can use it to - /// create graph skeleton classes. The reason for this is than Node - /// and Arc types should \em not derive from the same base class. - /// For Node you should instantiate it with character 'n' and for Arc - /// with 'a'. - + /// create graph skeleton classes. The reason for this is that \c Node + /// and \c Arc (or \c Edge) types should \e not derive from the same + /// base class. For \c Node you should instantiate it with character + /// \c 'n', for \c Arc with \c 'a' and for \c Edge with \c 'e'. #ifndef DOXYGEN - template + template #endif class GraphItem { public: /// \brief Default constructor. /// + /// Default constructor. /// \warning The default constructor is not required to set /// the item to some well-defined value. So you should consider it /// as uninitialized. GraphItem() {} + /// \brief Copy constructor. /// /// Copy constructor. + GraphItem(const GraphItem &) {} + + /// \brief Constructor for conversion from \c INVALID. /// - GraphItem(const GraphItem &) {} - /// \brief Invalid constructor \& conversion. - /// - /// This constructor initializes the item to be invalid. + /// Constructor for conversion from \c INVALID. + /// It initializes the item to be invalid. /// \sa Invalid for more details. GraphItem(Invalid) {} - /// \brief Assign operator for nodes. + + /// \brief Assignment operator. /// - /// The nodes are assignable. + /// Assignment operator for the item. + GraphItem& operator=(const GraphItem&) { return *this; } + + /// \brief Assignment operator for INVALID. /// - GraphItem& operator=(GraphItem const&) { return *this; } + /// This operator makes the item invalid. + GraphItem& operator=(Invalid) { return *this; } + /// \brief Equality operator. /// - /// Two iterators are equal if and only if they represents the - /// same node in the graph or both are invalid. - bool operator==(GraphItem) const { return false; } + /// Equality operator. + bool operator==(const GraphItem&) const { return false; } + /// \brief Inequality operator. /// - /// \sa operator==(const Node& n) + /// Inequality operator. + bool operator!=(const GraphItem&) const { return false; } + + /// \brief Ordering operator. /// - bool operator!=(GraphItem) const { return false; } - - /// \brief Artificial ordering operator. + /// This operator defines an ordering of the items. + /// It makes possible to use graph item types as key types in + /// associative containers (e.g. \c std::map). /// - /// 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 + /// \note This operator only has to define some strict ordering of /// the items; this order has nothing to do with the iteration /// ordering of the items. - bool operator<(GraphItem) const { return false; } + bool operator<(const GraphItem&) const { return false; } template struct Constraints { void constraints() { _GraphItem i1; + i1=INVALID; _GraphItem i2 = i1; _GraphItem i3 = INVALID; i1 = i2 = i3; bool b; - // b = (ia == ib) && (ia != ib) && (ia < ib); b = (ia == ib) && (ia != ib); b = (ia == INVALID) && (ib != INVALID); b = (ia < ib); @@ -111,13 +118,12 @@ }; }; - /// \brief An empty base directed graph class. + /// \brief Base skeleton class for directed graphs. /// - /// This class provides the minimal set of features needed for a - /// directed graph structure. All digraph concepts have to be - /// conform to this base directed graph. It just provides types - /// for nodes and arcs and functions to get the source and the - /// target of the arcs. + /// This class describes the base interface of directed graph types. + /// All digraph %concepts have to conform to this class. + /// It just provides types for nodes and arcs and functions + /// to get the source and the target nodes of arcs. class BaseDigraphComponent { public: @@ -125,31 +131,27 @@ /// \brief Node class of the digraph. /// - /// This class represents the Nodes of the digraph. - /// + /// This class represents the nodes of the digraph. typedef GraphItem<'n'> Node; /// \brief Arc class of the digraph. /// - /// This class represents the Arcs of the digraph. + /// This class represents the arcs of the digraph. + typedef GraphItem<'a'> Arc; + + /// \brief Return the source node of an arc. /// - typedef GraphItem<'e'> Arc; + /// This function returns the source node of an arc. + Node source(const Arc&) const { return INVALID; } - /// \brief Gives back the target node of an arc. + /// \brief Return the target node of an arc. /// - /// Gives back the target node of an arc. + /// This function returns the target node of an arc. + Node target(const Arc&) const { return INVALID; } + + /// \brief Return the opposite node on the given arc. /// - Node target(const Arc&) const { return INVALID;} - - /// \brief Gives back the source node of an arc. - /// - /// Gives back the source node of an arc. - /// - Node source(const Arc&) const { return INVALID;} - - /// \brief Gives back the opposite node on the given arc. - /// - /// Gives back the opposite node on the given arc. + /// This function returns the opposite node on the given arc. Node oppositeNode(const Node&, const Arc&) const { return INVALID; } @@ -175,91 +177,92 @@ }; }; - /// \brief An empty base undirected graph class. + /// \brief Base skeleton class for undirected graphs. /// - /// This class provides the minimal set of features needed for an - /// undirected graph structure. All undirected graph concepts have - /// to be conform to this base graph. It just provides types for - /// nodes, arcs and edges and functions to get the - /// source and the target of the arcs and edges, - /// conversion from arcs to edges and function to get - /// both direction of the edges. + /// This class describes the base interface of undirected graph types. + /// All graph %concepts have to conform to this class. + /// It extends the interface of \ref BaseDigraphComponent with an + /// \c Edge type and functions to get the end nodes of edges, + /// to convert from arcs to edges and to get both direction of edges. class BaseGraphComponent : public BaseDigraphComponent { public: + + typedef BaseGraphComponent Graph; + typedef BaseDigraphComponent::Node Node; typedef BaseDigraphComponent::Arc Arc; - /// \brief Undirected arc class of the graph. + + /// \brief Undirected edge class of the graph. /// - /// This class represents the edges of the graph. - /// The undirected graphs can be used as a directed graph which - /// for each arc contains the opposite arc too so the graph is - /// bidirected. The edge represents two opposite - /// directed arcs. - class Edge : public GraphItem<'u'> { + /// This class represents the undirected edges of the graph. + /// Undirected graphs can be used as directed graphs, each edge is + /// represented by two opposite directed arcs. + class Edge : public GraphItem<'e'> { + typedef GraphItem<'e'> Parent; + public: - typedef GraphItem<'u'> Parent; /// \brief Default constructor. /// + /// Default constructor. /// \warning The default constructor is not required to set /// the item to some well-defined value. So you should consider it /// as uninitialized. Edge() {} + /// \brief Copy constructor. /// /// Copy constructor. + Edge(const Edge &) : Parent() {} + + /// \brief Constructor for conversion from \c INVALID. /// - Edge(const Edge &) : Parent() {} - /// \brief Invalid constructor \& conversion. - /// - /// This constructor initializes the item to be invalid. + /// Constructor for conversion from \c INVALID. + /// It initializes the item to be invalid. /// \sa Invalid for more details. Edge(Invalid) {} - /// \brief Converter from arc to edge. + + /// \brief Constructor for conversion from an arc. /// + /// Constructor for conversion from an arc. /// Besides the core graph item functionality each arc should /// be convertible to the represented edge. Edge(const Arc&) {} - /// \brief Assign arc to edge. - /// - /// Besides the core graph item functionality each arc should - /// be convertible to the represented edge. - Edge& operator=(const Arc&) { return *this; } - }; + }; - /// \brief Returns the direction of the arc. + /// \brief Return one end node of an edge. + /// + /// This function returns one end node of an edge. + Node u(const Edge&) const { return INVALID; } + + /// \brief Return the other end node of an edge. + /// + /// This function returns the other end node of an edge. + Node v(const Edge&) const { return INVALID; } + + /// \brief Return a directed arc related to an edge. + /// + /// This function returns a directed arc from its direction and the + /// represented edge. + Arc direct(const Edge&, bool) const { return INVALID; } + + /// \brief Return a directed arc related to an edge. + /// + /// This function returns a directed arc from its source node and the + /// represented edge. + Arc direct(const Edge&, const Node&) const { return INVALID; } + + /// \brief Return the direction of the arc. /// /// Returns the direction of the arc. Each arc represents an /// edge with a direction. It gives back the /// direction. bool direction(const Arc&) const { return true; } - /// \brief Returns the directed arc. + /// \brief Return the opposite arc. /// - /// Returns the directed arc from its direction and the - /// represented edge. - Arc direct(const Edge&, bool) const { return INVALID;} - - /// \brief Returns the directed arc. - /// - /// Returns the directed arc from its source and the - /// represented edge. - Arc direct(const Edge&, const Node&) const { return INVALID;} - - /// \brief Returns the opposite arc. - /// - /// Returns the opposite arc. It is the arc representing the - /// same edge and has opposite direction. - Arc oppositeArc(const Arc&) const { return INVALID;} - - /// \brief Gives back one ending of an edge. - /// - /// Gives back one ending of an edge. - Node u(const Edge&) const { return INVALID;} - - /// \brief Gives back the other ending of an edge. - /// - /// Gives back the other ending of an edge. - Node v(const Edge&) const { return INVALID;} + /// This function returns the opposite arc, i.e. the arc representing + /// the same edge and has opposite direction. + Arc oppositeArc(const Arc&) const { return INVALID; } template struct Constraints { @@ -269,7 +272,7 @@ void constraints() { checkConcept(); - checkConcept, Edge>(); + checkConcept, Edge>(); { Node n; Edge ue(INVALID); @@ -277,6 +280,7 @@ n = graph.u(ue); n = graph.v(ue); e = graph.direct(ue, true); + e = graph.direct(ue, false); e = graph.direct(ue, n); e = graph.oppositeArc(e); ue = e; @@ -290,59 +294,57 @@ }; - /// \brief An empty idable base digraph class. + /// \brief Skeleton class for \e idable directed graphs. /// - /// This class provides beside the core digraph features - /// core id functions for the digraph structure. - /// The most of the base digraphs should be conform to this concept. - /// The id's are unique and immutable. - template - class IDableDigraphComponent : public _Base { + /// This class describes the interface of \e idable directed graphs. + /// It extends \ref BaseDigraphComponent with the core ID functions. + /// The ids of the items must be unique and immutable. + /// This concept is part of the Digraph concept. + template + class IDableDigraphComponent : public BAS { public: - typedef _Base Base; + typedef BAS Base; typedef typename Base::Node Node; typedef typename Base::Arc Arc; - /// \brief Gives back an unique integer id for the Node. + /// \brief Return a unique integer id for the given node. /// - /// Gives back an unique integer id for the Node. + /// This function returns a unique integer id for the given node. + int id(const Node&) const { return -1; } + + /// \brief Return the node by its unique id. /// - int id(const Node&) const { return -1;} + /// This function returns the node by its unique id. + /// If the digraph does not contain a node with the given id, + /// then the result of the function is undefined. + Node nodeFromId(int) const { return INVALID; } - /// \brief Gives back the node by the unique id. + /// \brief Return a unique integer id for the given arc. /// - /// Gives back the node by the unique id. - /// If the digraph does not contain node with the given id - /// then the result of the function is undetermined. - Node nodeFromId(int) const { return INVALID;} + /// This function returns a unique integer id for the given arc. + int id(const Arc&) const { return -1; } - /// \brief Gives back an unique integer id for the Arc. + /// \brief Return the arc by its unique id. /// - /// Gives back an unique integer id for the Arc. + /// This function returns the arc by its unique id. + /// If the digraph does not contain an arc with the given id, + /// then the result of the function is undefined. + Arc arcFromId(int) const { return INVALID; } + + /// \brief Return an integer greater or equal to the maximum + /// node id. /// - int id(const Arc&) const { return -1;} + /// This function returns an integer greater or equal to the + /// maximum node id. + int maxNodeId() const { return -1; } - /// \brief Gives back the arc by the unique id. + /// \brief Return an integer greater or equal to the maximum + /// arc id. /// - /// Gives back the arc by the unique id. - /// If the digraph does not contain arc with the given id - /// then the result of the function is undetermined. - Arc arcFromId(int) const { return INVALID;} - - /// \brief Gives back an integer greater or equal to the maximum - /// Node id. - /// - /// Gives back an integer greater or equal to the maximum Node - /// id. - int maxNodeId() const { return -1;} - - /// \brief Gives back an integer greater or equal to the maximum - /// Arc id. - /// - /// Gives back an integer greater or equal to the maximum Arc - /// id. - int maxArcId() const { return -1;} + /// This function returns an integer greater or equal to the + /// maximum arc id. + int maxArcId() const { return -1; } template struct Constraints { @@ -350,10 +352,12 @@ void constraints() { checkConcept(); typename _Digraph::Node node; + node=INVALID; int nid = digraph.id(node); nid = digraph.id(node); node = digraph.nodeFromId(nid); typename _Digraph::Arc arc; + arc=INVALID; int eid = digraph.id(arc); eid = digraph.id(arc); arc = digraph.arcFromId(eid); @@ -368,46 +372,45 @@ }; }; - /// \brief An empty idable base undirected graph class. + /// \brief Skeleton class for \e idable undirected graphs. /// - /// This class provides beside the core undirected graph features - /// core id functions for the undirected graph structure. The - /// most of the base undirected graphs should be conform to this - /// concept. The id's are unique and immutable. - template - class IDableGraphComponent : public IDableDigraphComponent<_Base> { + /// This class describes the interface of \e idable undirected + /// graphs. It extends \ref IDableDigraphComponent with the core ID + /// functions of undirected graphs. + /// The ids of the items must be unique and immutable. + /// This concept is part of the Graph concept. + template + class IDableGraphComponent : public IDableDigraphComponent { public: - typedef _Base Base; + typedef BAS Base; typedef typename Base::Edge Edge; - using IDableDigraphComponent<_Base>::id; + using IDableDigraphComponent::id; - /// \brief Gives back an unique integer id for the Edge. + /// \brief Return a unique integer id for the given edge. /// - /// Gives back an unique integer id for the Edge. + /// This function returns a unique integer id for the given edge. + int id(const Edge&) const { return -1; } + + /// \brief Return the edge by its unique id. /// - int id(const Edge&) const { return -1;} + /// This function returns the edge by its unique id. + /// If the graph does not contain an edge with the given id, + /// then the result of the function is undefined. + Edge edgeFromId(int) const { return INVALID; } - /// \brief Gives back the edge by the unique id. + /// \brief Return an integer greater or equal to the maximum + /// edge id. /// - /// Gives back the edge by the unique id. If the - /// graph does not contain arc with the given id then the - /// result of the function is undetermined. - Edge edgeFromId(int) const { return INVALID;} - - /// \brief Gives back an integer greater or equal to the maximum - /// Edge id. - /// - /// Gives back an integer greater or equal to the maximum Edge - /// id. - int maxEdgeId() const { return -1;} + /// This function returns an integer greater or equal to the + /// maximum edge id. + int maxEdgeId() const { return -1; } template struct Constraints { void constraints() { - checkConcept(); checkConcept, _Graph >(); typename _Graph::Edge edge; int ueid = graph.id(edge); @@ -421,231 +424,243 @@ }; }; - /// \brief Skeleton class for graph NodeIt and ArcIt + /// \brief Concept class for \c NodeIt, \c ArcIt and \c EdgeIt types. /// - /// Skeleton class for graph NodeIt and ArcIt. - /// - template - class GraphItemIt : public _Item { + /// This class describes the concept of \c NodeIt, \c ArcIt and + /// \c EdgeIt subtypes of digraph and graph types. + template + class GraphItemIt : public Item { public: /// \brief Default constructor. /// - /// @warning The default constructor sets the iterator - /// to an undefined value. + /// Default constructor. + /// \warning The default constructor is not required to set + /// the iterator to some well-defined value. So you should consider it + /// as uninitialized. GraphItemIt() {} + /// \brief Copy constructor. /// /// Copy constructor. + GraphItemIt(const GraphItemIt& it) : Item(it) {} + + /// \brief Constructor that sets the iterator to the first item. /// - GraphItemIt(const GraphItemIt& ) {} - /// \brief Sets the iterator to the first item. + /// Constructor that sets the iterator to the first item. + explicit GraphItemIt(const GR&) {} + + /// \brief Constructor for conversion from \c INVALID. /// - /// Sets the iterator to the first item of \c the graph. - /// - explicit GraphItemIt(const _Graph&) {} - /// \brief Invalid constructor \& conversion. - /// - /// This constructor initializes the item to be invalid. + /// Constructor for conversion from \c INVALID. + /// It initializes the iterator to be invalid. /// \sa Invalid for more details. GraphItemIt(Invalid) {} - /// \brief Assign operator for items. + + /// \brief Assignment operator. /// - /// The items are assignable. + /// Assignment operator for the iterator. + GraphItemIt& operator=(const GraphItemIt&) { return *this; } + + /// \brief Increment the iterator. /// - GraphItemIt& operator=(const GraphItemIt&) { return *this; } - /// \brief Next item. - /// - /// Assign the iterator to the next item. - /// + /// This operator increments the iterator, i.e. assigns it to the + /// next item. GraphItemIt& operator++() { return *this; } + /// \brief Equality operator /// + /// Equality operator. /// Two iterators are equal if and only if they point to the /// same object or both are invalid. bool operator==(const GraphItemIt&) const { return true;} + /// \brief Inequality operator /// - /// \sa operator==(Node n) - /// + /// Inequality operator. + /// Two iterators are equal if and only if they point to the + /// same object or both are invalid. bool operator!=(const GraphItemIt&) const { return true;} template struct Constraints { void constraints() { + checkConcept, _GraphItemIt>(); _GraphItemIt it1(g); _GraphItemIt it2; + _GraphItemIt it3 = it1; + _GraphItemIt it4 = INVALID; it2 = ++it1; ++it2 = it1; ++(++it1); - _Item bi = it1; + Item bi = it1; bi = it2; } - _Graph& g; + const GR& g; }; }; - /// \brief Skeleton class for graph InArcIt and OutArcIt + /// \brief Concept class for \c InArcIt, \c OutArcIt and + /// \c IncEdgeIt types. /// - /// \note Because InArcIt and OutArcIt may not inherit from the same - /// base class, the _selector is a additional template parameter. For - /// InArcIt you should instantiate it with character 'i' and for - /// OutArcIt with 'o'. - template - class GraphIncIt : public _Item { + /// This class describes the concept of \c InArcIt, \c OutArcIt + /// and \c IncEdgeIt subtypes of digraph and graph types. + /// + /// \note Since these iterator classes do not inherit from the same + /// base class, there is an additional template parameter (selector) + /// \c sel. For \c InArcIt you should instantiate it with character + /// \c 'i', for \c OutArcIt with \c 'o' and for \c IncEdgeIt with \c 'e'. + template + class GraphIncIt : public Item { public: /// \brief Default constructor. /// - /// @warning The default constructor sets the iterator - /// to an undefined value. + /// Default constructor. + /// \warning The default constructor is not required to set + /// the iterator to some well-defined value. So you should consider it + /// as uninitialized. GraphIncIt() {} + /// \brief Copy constructor. /// /// Copy constructor. + GraphIncIt(const GraphIncIt& it) : Item(it) {} + + /// \brief Constructor that sets the iterator to the first + /// incoming or outgoing arc. /// - GraphIncIt(GraphIncIt const& gi) : _Item(gi) {} - /// \brief Sets the iterator to the first arc incoming into or outgoing - /// from the node. + /// Constructor that sets the iterator to the first arc + /// incoming to or outgoing from the given node. + explicit GraphIncIt(const GR&, const Base&) {} + + /// \brief Constructor for conversion from \c INVALID. /// - /// Sets the iterator to the first arc incoming into or outgoing - /// from the node. - /// - explicit GraphIncIt(const _Graph&, const _Base&) {} - /// \brief Invalid constructor \& conversion. - /// - /// This constructor initializes the item to be invalid. + /// Constructor for conversion from \c INVALID. + /// It initializes the iterator to be invalid. /// \sa Invalid for more details. GraphIncIt(Invalid) {} - /// \brief Assign operator for iterators. + + /// \brief Assignment operator. /// - /// The iterators are assignable. + /// Assignment operator for the iterator. + GraphIncIt& operator=(const GraphIncIt&) { return *this; } + + /// \brief Increment the iterator. /// - GraphIncIt& operator=(GraphIncIt const&) { return *this; } - /// \brief Next item. - /// - /// Assign the iterator to the next item. - /// + /// This operator increments the iterator, i.e. assigns it to the + /// next arc incoming to or outgoing from the given node. GraphIncIt& operator++() { return *this; } /// \brief Equality operator /// + /// Equality operator. /// Two iterators are equal if and only if they point to the /// same object or both are invalid. bool operator==(const GraphIncIt&) const { return true;} /// \brief Inequality operator /// - /// \sa operator==(Node n) - /// + /// Inequality operator. + /// Two iterators are equal if and only if they point to the + /// same object or both are invalid. bool operator!=(const GraphIncIt&) const { return true;} template struct Constraints { void constraints() { - checkConcept, _GraphIncIt>(); + checkConcept, _GraphIncIt>(); _GraphIncIt it1(graph, node); _GraphIncIt it2; + _GraphIncIt it3 = it1; + _GraphIncIt it4 = INVALID; it2 = ++it1; ++it2 = it1; ++(++it1); - _Item e = it1; + Item e = it1; e = it2; - } - - _Item arc; - _Base node; - _Graph graph; - _GraphIncIt it; + const Base& node; + const GR& graph; }; }; - - /// \brief An empty iterable digraph class. + /// \brief Skeleton class for iterable directed graphs. /// - /// This class provides beside the core digraph features - /// iterator based iterable interface for the digraph structure. + /// This class describes the interface of iterable directed + /// graphs. It extends \ref BaseDigraphComponent with the core + /// iterable interface. /// This concept is part of the Digraph concept. - template - class IterableDigraphComponent : public _Base { + template + class IterableDigraphComponent : public BAS { public: - typedef _Base Base; + typedef BAS Base; typedef typename Base::Node Node; typedef typename Base::Arc Arc; typedef IterableDigraphComponent Digraph; - /// \name Base iteration + /// \name Base Iteration /// - /// This interface provides functions for iteration on digraph items + /// This interface provides functions for iteration on digraph items. /// /// @{ - /// \brief Gives back the first node in the iterating order. + /// \brief Return the first node. /// - /// Gives back the first node in the iterating order. - /// + /// This function gives back the first node in the iteration order. void first(Node&) const {} - /// \brief Gives back the next node in the iterating order. + /// \brief Return the next node. /// - /// Gives back the next node in the iterating order. - /// + /// This function gives back the next node in the iteration order. void next(Node&) const {} - /// \brief Gives back the first arc in the iterating order. + /// \brief Return the first arc. /// - /// Gives back the first arc in the iterating order. - /// + /// This function gives back the first arc in the iteration order. void first(Arc&) const {} - /// \brief Gives back the next arc in the iterating order. + /// \brief Return the next arc. /// - /// Gives back the next arc in the iterating order. - /// + /// This function gives back the next arc in the iteration order. void next(Arc&) const {} - - /// \brief Gives back the first of the arcs point to the given - /// node. + /// \brief Return the first arc incomming to the given node. /// - /// Gives back the first of the arcs point to the given node. - /// + /// This function gives back the first arc incomming to the + /// given node. void firstIn(Arc&, const Node&) const {} - /// \brief Gives back the next of the arcs points to the given - /// node. + /// \brief Return the next arc incomming to the given node. /// - /// Gives back the next of the arcs points to the given node. - /// + /// This function gives back the next arc incomming to the + /// given node. void nextIn(Arc&) const {} - /// \brief Gives back the first of the arcs start from the + /// \brief Return the first arc outgoing form the given node. + /// + /// This function gives back the first arc outgoing form the /// given node. - /// - /// Gives back the first of the arcs start from the given node. - /// void firstOut(Arc&, const Node&) const {} - /// \brief Gives back the next of the arcs start from the given - /// node. + /// \brief Return the next arc outgoing form the given node. /// - /// Gives back the next of the arcs start from the given node. - /// + /// This function gives back the next arc outgoing form the + /// given node. void nextOut(Arc&) const {} /// @} - /// \name Class based iteration + /// \name Class Based Iteration /// - /// This interface provides functions for iteration on digraph items + /// This interface provides iterator classes for digraph items. /// /// @{ @@ -655,15 +670,15 @@ /// typedef GraphItemIt NodeIt; - /// \brief This iterator goes through each node. + /// \brief This iterator goes through each arc. /// - /// This iterator goes through each node. + /// This iterator goes through each arc. /// typedef GraphItemIt ArcIt; /// \brief This iterator goes trough the incoming arcs of a node. /// - /// This iterator goes trough the \e inccoming arcs of a certain node + /// This iterator goes trough the \e incoming arcs of a certain node /// of a digraph. typedef GraphIncIt InArcIt; @@ -675,26 +690,26 @@ /// \brief The base node of the iterator. /// - /// Gives back the base node of the iterator. - /// It is always the target of the pointed arc. + /// This function gives back the base node of the iterator. + /// It is always the target node of the pointed arc. Node baseNode(const InArcIt&) const { return INVALID; } /// \brief The running node of the iterator. /// - /// Gives back the running node of the iterator. - /// It is always the source of the pointed arc. + /// This function gives back the running node of the iterator. + /// It is always the source node of the pointed arc. Node runningNode(const InArcIt&) const { return INVALID; } /// \brief The base node of the iterator. /// - /// Gives back the base node of the iterator. - /// It is always the source of the pointed arc. + /// This function gives back the base node of the iterator. + /// It is always the source node of the pointed arc. Node baseNode(const OutArcIt&) const { return INVALID; } /// \brief The running node of the iterator. /// - /// Gives back the running node of the iterator. - /// It is always the target of the pointed arc. + /// This function gives back the running node of the iterator. + /// It is always the target node of the pointed arc. Node runningNode(const OutArcIt&) const { return INVALID; } /// @} @@ -736,31 +751,31 @@ typename _Digraph::Node, 'o'>, typename _Digraph::OutArcIt>(); typename _Digraph::Node n; - typename _Digraph::InArcIt ieit(INVALID); - typename _Digraph::OutArcIt oeit(INVALID); - n = digraph.baseNode(ieit); - n = digraph.runningNode(ieit); - n = digraph.baseNode(oeit); - n = digraph.runningNode(oeit); + const typename _Digraph::InArcIt iait(INVALID); + const typename _Digraph::OutArcIt oait(INVALID); + n = digraph.baseNode(iait); + n = digraph.runningNode(iait); + n = digraph.baseNode(oait); + n = digraph.runningNode(oait); ignore_unused_variable_warning(n); } } const _Digraph& digraph; - }; }; - /// \brief An empty iterable undirected graph class. + /// \brief Skeleton class for iterable undirected graphs. /// - /// This class provides beside the core graph features iterator - /// based iterable interface for the undirected graph structure. + /// This class describes the interface of iterable undirected + /// graphs. It extends \ref IterableDigraphComponent with the core + /// iterable interface of undirected graphs. /// This concept is part of the Graph concept. - template - class IterableGraphComponent : public IterableDigraphComponent<_Base> { + template + class IterableGraphComponent : public IterableDigraphComponent { public: - typedef _Base Base; + typedef BAS Base; typedef typename Base::Node Node; typedef typename Base::Arc Arc; typedef typename Base::Edge Edge; @@ -768,75 +783,71 @@ typedef IterableGraphComponent Graph; - /// \name Base iteration + /// \name Base Iteration /// - /// This interface provides functions for iteration on graph items + /// This interface provides functions for iteration on edges. + /// /// @{ - using IterableDigraphComponent<_Base>::first; - using IterableDigraphComponent<_Base>::next; + using IterableDigraphComponent::first; + using IterableDigraphComponent::next; - /// \brief Gives back the first edge in the iterating - /// order. + /// \brief Return the first edge. /// - /// Gives back the first edge in the iterating order. - /// + /// This function gives back the first edge in the iteration order. void first(Edge&) const {} - /// \brief Gives back the next edge in the iterating - /// order. + /// \brief Return the next edge. /// - /// Gives back the next edge in the iterating order. - /// + /// This function gives back the next edge in the iteration order. void next(Edge&) const {} - - /// \brief Gives back the first of the edges from the + /// \brief Return the first edge incident to the given node. + /// + /// This function gives back the first edge incident to the given + /// node. The bool parameter gives back the direction for which the + /// source node of the directed arc representing the edge is the /// given node. - /// - /// Gives back the first of the edges from the given - /// node. The bool parameter gives back that direction which - /// gives a good direction of the edge so the source of the - /// directed arc is the given node. void firstInc(Edge&, bool&, const Node&) const {} /// \brief Gives back the next of the edges from the /// given node. /// - /// Gives back the next of the edges from the given - /// node. The bool parameter should be used as the \c firstInc() - /// use it. + /// This function gives back the next edge incident to the given + /// node. The bool parameter should be used as \c firstInc() use it. void nextInc(Edge&, bool&) const {} - using IterableDigraphComponent<_Base>::baseNode; - using IterableDigraphComponent<_Base>::runningNode; + using IterableDigraphComponent::baseNode; + using IterableDigraphComponent::runningNode; /// @} - /// \name Class based iteration + /// \name Class Based Iteration /// - /// This interface provides functions for iteration on graph items + /// This interface provides iterator classes for edges. /// /// @{ - /// \brief This iterator goes through each node. + /// \brief This iterator goes through each edge. /// - /// This iterator goes through each node. + /// This iterator goes through each edge. typedef GraphItemIt EdgeIt; - /// \brief This iterator goes trough the incident arcs of a + + /// \brief This iterator goes trough the incident edges of a /// node. /// - /// This iterator goes trough the incident arcs of a certain + /// This iterator goes trough the incident edges of a certain /// node of a graph. - typedef GraphIncIt IncEdgeIt; + typedef GraphIncIt IncEdgeIt; + /// \brief The base node of the iterator. /// - /// Gives back the base node of the iterator. + /// This function gives back the base node of the iterator. Node baseNode(const IncEdgeIt&) const { return INVALID; } /// \brief The running node of the iterator. /// - /// Gives back the running node of the iterator. + /// This function gives back the running node of the iterator. Node runningNode(const IncEdgeIt&) const { return INVALID; } /// @} @@ -865,54 +876,54 @@ checkConcept, typename _Graph::EdgeIt >(); checkConcept, typename _Graph::IncEdgeIt>(); + typename _Graph::Node, 'e'>, typename _Graph::IncEdgeIt>(); typename _Graph::Node n; - typename _Graph::IncEdgeIt ueit(INVALID); - n = graph.baseNode(ueit); - n = graph.runningNode(ueit); + const typename _Graph::IncEdgeIt ieit(INVALID); + n = graph.baseNode(ieit); + n = graph.runningNode(ieit); } } const _Graph& graph; - }; }; - /// \brief An empty alteration notifier digraph class. + /// \brief Skeleton class for alterable directed graphs. /// - /// This class provides beside the core digraph features alteration - /// notifier interface for the digraph structure. This implements + /// This class describes the interface of alterable directed + /// graphs. It extends \ref BaseDigraphComponent with the alteration + /// notifier interface. It implements /// an observer-notifier pattern for each digraph item. More /// obsevers can be registered into the notifier and whenever an - /// alteration occured in the digraph all the observers will + /// alteration occured in the digraph all the observers will be /// notified about it. - template - class AlterableDigraphComponent : public _Base { + template + class AlterableDigraphComponent : public BAS { public: - typedef _Base Base; + typedef BAS Base; typedef typename Base::Node Node; typedef typename Base::Arc Arc; - /// The node observer registry. + /// Node alteration notifier class. typedef AlterationNotifier NodeNotifier; - /// The arc observer registry. + /// Arc alteration notifier class. typedef AlterationNotifier ArcNotifier; - /// \brief Gives back the node alteration notifier. + /// \brief Return the node alteration notifier. /// - /// Gives back the node alteration notifier. + /// This function gives back the node alteration notifier. NodeNotifier& notifier(Node) const { - return NodeNotifier(); + return NodeNotifier(); } - /// \brief Gives back the arc alteration notifier. + /// \brief Return the arc alteration notifier. /// - /// Gives back the arc alteration notifier. + /// This function gives back the arc alteration notifier. ArcNotifier& notifier(Arc) const { return ArcNotifier(); } @@ -932,34 +943,33 @@ } const _Digraph& digraph; - }; - }; - /// \brief An empty alteration notifier undirected graph class. + /// \brief Skeleton class for alterable undirected graphs. /// - /// This class provides beside the core graph features alteration - /// notifier interface for the graph structure. This implements - /// an observer-notifier pattern for each graph item. More + /// This class describes the interface of alterable undirected + /// graphs. It extends \ref AlterableDigraphComponent with the alteration + /// notifier interface of undirected graphs. It implements + /// an observer-notifier pattern for the edges. More /// obsevers can be registered into the notifier and whenever an - /// alteration occured in the graph all the observers will + /// alteration occured in the graph all the observers will be /// notified about it. - template - class AlterableGraphComponent : public AlterableDigraphComponent<_Base> { + template + class AlterableGraphComponent : public AlterableDigraphComponent { public: - typedef _Base Base; + typedef BAS Base; typedef typename Base::Edge Edge; - /// The arc observer registry. + /// Edge alteration notifier class. typedef AlterationNotifier EdgeNotifier; - /// \brief Gives back the arc alteration notifier. + /// \brief Return the edge alteration notifier. /// - /// Gives back the arc alteration notifier. + /// This function gives back the edge alteration notifier. EdgeNotifier& notifier(Edge) const { return EdgeNotifier(); } @@ -967,44 +977,48 @@ template struct Constraints { void constraints() { - checkConcept, _Graph>(); + checkConcept, _Graph>(); typename _Graph::EdgeNotifier& uen = graph.notifier(typename _Graph::Edge()); ignore_unused_variable_warning(uen); } const _Graph& graph; - }; - }; - /// \brief Class describing the concept of graph maps + /// \brief Concept class for standard graph maps. /// - /// This class describes the common interface of the graph maps - /// (NodeMap, ArcMap), that is maps that can be used to - /// associate data to graph descriptors (nodes or arcs). - template - class GraphMap : public ReadWriteMap<_Item, _Value> { + /// This class describes the concept of standard graph maps, i.e. + /// the \c NodeMap, \c ArcMap and \c EdgeMap subtypes of digraph and + /// graph types, which can be used for associating data to graph items. + /// The standard graph maps must conform to the ReferenceMap concept. + template + class GraphMap : public ReferenceMap { + typedef ReferenceMap Parent; + public: - typedef ReadWriteMap<_Item, _Value> Parent; + /// The key type of the map. + typedef K Key; + /// The value type of the map. + typedef V Value; + /// The reference type of the map. + typedef Value& Reference; + /// The const reference type of the map. + typedef const Value& ConstReference; - /// The graph type of the map. - typedef _Graph Graph; - /// The key type of the map. - typedef _Item Key; - /// The value type of the map. - typedef _Value Value; + // The reference map tag. + typedef True ReferenceMapTag; /// \brief Construct a new map. /// /// Construct a new map for the graph. - explicit GraphMap(const Graph&) {} + explicit GraphMap(const GR&) {} /// \brief Construct a new map with default value. /// - /// Construct a new map for the graph and initalise the values. - GraphMap(const Graph&, const Value&) {} + /// Construct a new map for the graph and initalize the values. + GraphMap(const GR&, const Value&) {} private: /// \brief Copy constructor. @@ -1012,9 +1026,9 @@ /// Copy Constructor. GraphMap(const GraphMap&) : Parent() {} - /// \brief Assign operator. + /// \brief Assignment operator. /// - /// Assign operator. It does not mofify the underlying graph, + /// Assignment operator. It does not mofify the underlying graph, /// it just iterates on the current item set and set the map /// with the value returned by the assigned map. template @@ -1027,53 +1041,55 @@ template struct Constraints { void constraints() { - checkConcept, _Map >(); - // Construction with a graph parameter - _Map a(g); - // Constructor with a graph and a default value parameter - _Map a2(g,t); - // Copy constructor. - // _Map b(c); + checkConcept + , _Map>(); + _Map m1(g); + _Map m2(g,t); + + // Copy constructor + // _Map m3(m); + // Assignment operator // ReadMap cmap; - // b = cmap; + // m3 = cmap; - ignore_unused_variable_warning(a); - ignore_unused_variable_warning(a2); - // ignore_unused_variable_warning(b); + ignore_unused_variable_warning(m1); + ignore_unused_variable_warning(m2); + // ignore_unused_variable_warning(m3); } - const _Map &c; - const Graph &g; + const _Map &m; + const GR &g; const typename GraphMap::Value &t; }; }; - /// \brief An empty mappable digraph class. + /// \brief Skeleton class for mappable directed graphs. /// - /// This class provides beside the core digraph features - /// map interface for the digraph structure. + /// This class describes the interface of mappable directed graphs. + /// It extends \ref BaseDigraphComponent with the standard digraph + /// map classes, namely \c NodeMap and \c ArcMap. /// This concept is part of the Digraph concept. - template - class MappableDigraphComponent : public _Base { + template + class MappableDigraphComponent : public BAS { public: - typedef _Base Base; + typedef BAS Base; typedef typename Base::Node Node; typedef typename Base::Arc Arc; typedef MappableDigraphComponent Digraph; - /// \brief ReadWrite map of the nodes. + /// \brief Standard graph map for the nodes. /// - /// ReadWrite map of the nodes. - /// - template - class NodeMap : public GraphMap { + /// Standard graph map for the nodes. + /// It conforms to the ReferenceMap concept. + template + class NodeMap : public GraphMap { + typedef GraphMap Parent; + public: - typedef GraphMap Parent; - /// \brief Construct a new map. /// /// Construct a new map for the digraph. @@ -1082,8 +1098,8 @@ /// \brief Construct a new map with default value. /// - /// Construct a new map for the digraph and initalise the values. - NodeMap(const MappableDigraphComponent& digraph, const _Value& value) + /// Construct a new map for the digraph and initalize the values. + NodeMap(const MappableDigraphComponent& digraph, const V& value) : Parent(digraph, value) {} private: @@ -1092,26 +1108,26 @@ /// Copy Constructor. NodeMap(const NodeMap& nm) : Parent(nm) {} - /// \brief Assign operator. + /// \brief Assignment operator. /// - /// Assign operator. + /// Assignment operator. template NodeMap& operator=(const CMap&) { - checkConcept, CMap>(); + checkConcept, CMap>(); return *this; } }; - /// \brief ReadWrite map of the arcs. + /// \brief Standard graph map for the arcs. /// - /// ReadWrite map of the arcs. - /// - template - class ArcMap : public GraphMap { + /// Standard graph map for the arcs. + /// It conforms to the ReferenceMap concept. + template + class ArcMap : public GraphMap { + typedef GraphMap Parent; + public: - typedef GraphMap Parent; - /// \brief Construct a new map. /// /// Construct a new map for the digraph. @@ -1120,8 +1136,8 @@ /// \brief Construct a new map with default value. /// - /// Construct a new map for the digraph and initalise the values. - ArcMap(const MappableDigraphComponent& digraph, const _Value& value) + /// Construct a new map for the digraph and initalize the values. + ArcMap(const MappableDigraphComponent& digraph, const V& value) : Parent(digraph, value) {} private: @@ -1130,12 +1146,12 @@ /// Copy Constructor. ArcMap(const ArcMap& nm) : Parent(nm) {} - /// \brief Assign operator. + /// \brief Assignment operator. /// - /// Assign operator. + /// Assignment operator. template ArcMap& operator=(const CMap&) { - checkConcept, CMap>(); + checkConcept, CMap>(); return *this; } @@ -1182,33 +1198,34 @@ } } - _Digraph& digraph; + const _Digraph& digraph; }; }; - /// \brief An empty mappable base bipartite graph class. + /// \brief Skeleton class for mappable undirected graphs. /// - /// This class provides beside the core graph features - /// map interface for the graph structure. + /// This class describes the interface of mappable undirected graphs. + /// It extends \ref MappableDigraphComponent with the standard graph + /// map class for edges (\c EdgeMap). /// This concept is part of the Graph concept. - template - class MappableGraphComponent : public MappableDigraphComponent<_Base> { + template + class MappableGraphComponent : public MappableDigraphComponent { public: - typedef _Base Base; + typedef BAS Base; typedef typename Base::Edge Edge; typedef MappableGraphComponent Graph; - /// \brief ReadWrite map of the edges. + /// \brief Standard graph map for the edges. /// - /// ReadWrite map of the edges. - /// - template - class EdgeMap : public GraphMap { + /// Standard graph map for the edges. + /// It conforms to the ReferenceMap concept. + template + class EdgeMap : public GraphMap { + typedef GraphMap Parent; + public: - typedef GraphMap Parent; - /// \brief Construct a new map. /// /// Construct a new map for the graph. @@ -1217,8 +1234,8 @@ /// \brief Construct a new map with default value. /// - /// Construct a new map for the graph and initalise the values. - EdgeMap(const MappableGraphComponent& graph, const _Value& value) + /// Construct a new map for the graph and initalize the values. + EdgeMap(const MappableGraphComponent& graph, const V& value) : Parent(graph, value) {} private: @@ -1227,12 +1244,12 @@ /// Copy Constructor. EdgeMap(const EdgeMap& nm) : Parent(nm) {} - /// \brief Assign operator. + /// \brief Assignment operator. /// - /// Assign operator. + /// Assignment operator. template EdgeMap& operator=(const CMap&) { - checkConcept, CMap>(); + checkConcept, CMap>(); return *this; } @@ -1249,7 +1266,7 @@ }; void constraints() { - checkConcept, _Graph>(); + checkConcept, _Graph>(); { // int map test typedef typename _Graph::template EdgeMap IntEdgeMap; @@ -1266,35 +1283,35 @@ } } - _Graph& graph; + const _Graph& graph; }; }; - /// \brief An empty extendable digraph class. + /// \brief Skeleton class for extendable directed graphs. /// - /// This class provides beside the core digraph features digraph - /// extendable interface for the digraph structure. The main - /// difference between the base and this interface is that the - /// digraph alterations should handled already on this level. - template - class ExtendableDigraphComponent : public _Base { + /// This class describes the interface of extendable directed graphs. + /// It extends \ref BaseDigraphComponent with functions for adding + /// nodes and arcs to the digraph. + /// This concept requires \ref AlterableDigraphComponent. + template + class ExtendableDigraphComponent : public BAS { public: - typedef _Base Base; + typedef BAS Base; - typedef typename _Base::Node Node; - typedef typename _Base::Arc Arc; + typedef typename Base::Node Node; + typedef typename Base::Arc Arc; - /// \brief Adds a new node to the digraph. + /// \brief Add a new node to the digraph. /// - /// Adds a new node to the digraph. - /// + /// This function adds a new node to the digraph. Node addNode() { return INVALID; } - /// \brief Adds a new arc connects the given two nodes. + /// \brief Add a new arc connecting the given two nodes. /// - /// Adds a new arc connects the the given two nodes. + /// This function adds a new arc connecting the given two nodes + /// of the digraph. Arc addArc(const Node&, const Node&) { return INVALID; } @@ -1314,33 +1331,32 @@ }; }; - /// \brief An empty extendable base undirected graph class. + /// \brief Skeleton class for extendable undirected graphs. /// - /// This class provides beside the core undirected graph features - /// core undircted graph extend interface for the graph structure. - /// The main difference between the base and this interface is - /// that the graph alterations should handled already on this - /// level. - template - class ExtendableGraphComponent : public _Base { + /// This class describes the interface of extendable undirected graphs. + /// It extends \ref BaseGraphComponent with functions for adding + /// nodes and edges to the graph. + /// This concept requires \ref AlterableGraphComponent. + template + class ExtendableGraphComponent : public BAS { public: - typedef _Base Base; - typedef typename _Base::Node Node; - typedef typename _Base::Edge Edge; + typedef BAS Base; + typedef typename Base::Node Node; + typedef typename Base::Edge Edge; - /// \brief Adds a new node to the graph. + /// \brief Add a new node to the digraph. /// - /// Adds a new node to the graph. - /// + /// This function adds a new node to the digraph. Node addNode() { return INVALID; } - /// \brief Adds a new arc connects the given two nodes. + /// \brief Add a new edge connecting the given two nodes. /// - /// Adds a new arc connects the the given two nodes. - Edge addArc(const Node&, const Node&) { + /// This function adds a new edge connecting the given two nodes + /// of the graph. + Edge addEdge(const Node&, const Node&) { return INVALID; } @@ -1359,39 +1375,38 @@ }; }; - /// \brief An empty erasable digraph class. + /// \brief Skeleton class for erasable directed graphs. /// - /// This class provides beside the core digraph features core erase - /// functions for the digraph structure. The main difference between - /// the base and this interface is that the digraph alterations - /// should handled already on this level. - template - class ErasableDigraphComponent : public _Base { + /// This class describes the interface of erasable directed graphs. + /// It extends \ref BaseDigraphComponent with functions for removing + /// nodes and arcs from the digraph. + /// This concept requires \ref AlterableDigraphComponent. + template + class ErasableDigraphComponent : public BAS { public: - typedef _Base Base; + typedef BAS Base; typedef typename Base::Node Node; typedef typename Base::Arc Arc; /// \brief Erase a node from the digraph. /// - /// Erase a node from the digraph. This function should - /// erase all arcs connecting to the node. + /// This function erases the given node from the digraph and all arcs + /// connected to the node. void erase(const Node&) {} /// \brief Erase an arc from the digraph. /// - /// Erase an arc from the digraph. - /// + /// This function erases the given arc from the digraph. void erase(const Arc&) {} template struct Constraints { void constraints() { checkConcept(); - typename _Digraph::Node node; + const typename _Digraph::Node node(INVALID); digraph.erase(node); - typename _Digraph::Arc arc; + const typename _Digraph::Arc arc(INVALID); digraph.erase(arc); } @@ -1399,39 +1414,38 @@ }; }; - /// \brief An empty erasable base undirected graph class. + /// \brief Skeleton class for erasable undirected graphs. /// - /// This class provides beside the core undirected graph features - /// core erase functions for the undirceted graph structure. The - /// main difference between the base and this interface is that - /// the graph alterations should handled already on this level. - template - class ErasableGraphComponent : public _Base { + /// This class describes the interface of erasable undirected graphs. + /// It extends \ref BaseGraphComponent with functions for removing + /// nodes and edges from the graph. + /// This concept requires \ref AlterableGraphComponent. + template + class ErasableGraphComponent : public BAS { public: - typedef _Base Base; + typedef BAS Base; typedef typename Base::Node Node; typedef typename Base::Edge Edge; /// \brief Erase a node from the graph. /// - /// Erase a node from the graph. This function should erase - /// arcs connecting to the node. + /// This function erases the given node from the graph and all edges + /// connected to the node. void erase(const Node&) {} - /// \brief Erase an arc from the graph. + /// \brief Erase an edge from the digraph. /// - /// Erase an arc from the graph. - /// + /// This function erases the given edge from the digraph. void erase(const Edge&) {} template struct Constraints { void constraints() { checkConcept(); - typename _Graph::Node node; + const typename _Graph::Node node(INVALID); graph.erase(node); - typename _Graph::Edge edge; + const typename _Graph::Edge edge(INVALID); graph.erase(edge); } @@ -1439,22 +1453,21 @@ }; }; - /// \brief An empty clearable base digraph class. + /// \brief Skeleton class for clearable directed graphs. /// - /// This class provides beside the core digraph features core clear - /// functions for the digraph structure. The main difference between - /// the base and this interface is that the digraph alterations - /// should handled already on this level. - template - class ClearableDigraphComponent : public _Base { + /// This class describes the interface of clearable directed graphs. + /// It extends \ref BaseDigraphComponent with a function for clearing + /// the digraph. + /// This concept requires \ref AlterableDigraphComponent. + template + class ClearableDigraphComponent : public BAS { public: - typedef _Base Base; + typedef BAS Base; /// \brief Erase all nodes and arcs from the digraph. /// - /// Erase all nodes and arcs from the digraph. - /// + /// This function erases all nodes and arcs from the digraph. void clear() {} template @@ -1464,29 +1477,35 @@ digraph.clear(); } - _Digraph digraph; + _Digraph& digraph; }; }; - /// \brief An empty clearable base undirected graph class. + /// \brief Skeleton class for clearable undirected graphs. /// - /// This class provides beside the core undirected graph features - /// core clear functions for the undirected graph structure. The - /// main difference between the base and this interface is that - /// the graph alterations should handled already on this level. - template - class ClearableGraphComponent : public ClearableDigraphComponent<_Base> { + /// This class describes the interface of clearable undirected graphs. + /// It extends \ref BaseGraphComponent with a function for clearing + /// the graph. + /// This concept requires \ref AlterableGraphComponent. + template + class ClearableGraphComponent : public ClearableDigraphComponent { public: - typedef _Base Base; + typedef BAS Base; + + /// \brief Erase all nodes and edges from the graph. + /// + /// This function erases all nodes and edges from the graph. + void clear() {} template struct Constraints { void constraints() { - checkConcept, _Graph>(); + checkConcept(); + graph.clear(); } - _Graph graph; + _Graph& graph; }; }; diff -r c35afa9e89e7 -r ef88c0a30f85 lemon/concepts/heap.h --- a/lemon/concepts/heap.h Mon Jan 12 23:11:39 2009 +0100 +++ b/lemon/concepts/heap.h Thu Nov 05 15:48:01 2009 +0100 @@ -16,14 +16,15 @@ * */ +#ifndef LEMON_CONCEPTS_HEAP_H +#define LEMON_CONCEPTS_HEAP_H + ///\ingroup concept ///\file ///\brief The concept of heaps. -#ifndef LEMON_CONCEPT_HEAP_H -#define LEMON_CONCEPT_HEAP_H - #include +#include namespace lemon { @@ -34,123 +35,160 @@ /// \brief The heap concept. /// - /// Concept class describing the main interface of heaps. - template + /// This concept class describes the main interface of heaps. + /// The various \ref heaps "heap structures" are efficient + /// implementations of the abstract data type \e priority \e queue. + /// They store items with specified values called \e priorities + /// in such a way that finding and removing the item with minimum + /// priority are efficient. The basic operations are adding and + /// erasing items, changing the priority of an item, etc. + /// + /// Heaps are crucial in several algorithms, such as Dijkstra and Prim. + /// Any class that conforms to this concept can be used easily in such + /// algorithms. + /// + /// \tparam PR Type of the priorities of the items. + /// \tparam IM A read-writable item map with \c int values, used + /// internally to handle the cross references. + /// \tparam CMP A functor class for comparing the priorities. + /// The default is \c std::less. +#ifdef DOXYGEN + template +#else + template > +#endif class Heap { public: + /// Type of the item-int map. + typedef IM ItemIntMap; + /// Type of the priorities. + typedef PR Prio; /// Type of the items stored in the heap. typedef typename ItemIntMap::Key Item; - /// Type of the priorities. - typedef Priority Prio; - /// \brief Type to represent the states of the items. /// /// Each item has a state associated to it. It can be "in heap", - /// "pre heap" or "post heap". The later two are indifferent - /// from the point of view of the heap, but may be useful for - /// the user. + /// "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 \c ItemIntMap must be initialized in such a way, that it - /// assigns \c PRE_HEAP (-1) to every item. + /// 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, - PRE_HEAP = -1, - POST_HEAP = -2 + 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. }; - /// \brief The constructor. + /// \brief Constructor. /// - /// The 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 every item. + /// \c PRE_HEAP (-1) for each item. explicit Heap(ItemIntMap &map) {} + /// \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. + explicit Heap(ItemIntMap &map, const CMP &comp) {} + /// \brief The number of items stored in the heap. /// - /// Returns the number of items stored in the heap. + /// This function returns the number of items stored in the heap. int size() const { return 0; } - /// \brief Checks if the heap is empty. + /// \brief Check if the heap is empty. /// - /// Returns \c true if the heap is empty. + /// This function returns \c true if the heap is empty. bool empty() const { return false; } - /// \brief Makes the heap empty. + /// \brief Make the heap empty. /// - /// Makes the heap empty. - void clear(); + /// 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 Inserts an item into the heap with the given priority. + /// \brief Insert an item into the heap with the given priority. /// - /// Inserts the given item into the heap with the given priority. + /// This function inserts the given item into the heap with the + /// given priority. /// \param i The item to insert. /// \param p The priority of the item. + /// \pre \e i must not be stored in the heap. void push(const Item &i, const Prio &p) {} - /// \brief Returns the item having minimum priority. + /// \brief Return the item having minimum priority. /// - /// Returns the item having minimum priority. + /// This function returns the item having minimum priority. /// \pre The heap must be non-empty. Item top() const {} /// \brief The minimum priority. /// - /// Returns the minimum priority. + /// This function returns the minimum priority. /// \pre The heap must be non-empty. Prio prio() const {} - /// \brief Removes the item having minimum priority. + /// \brief Remove the item having minimum priority. /// - /// Removes the item having minimum priority. + /// This function removes the item having minimum priority. /// \pre The heap must be non-empty. void pop() {} - /// \brief Removes an item from the heap. + /// \brief Remove the given item from the heap. /// - /// Removes the given item from the heap if it is already stored. + /// 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) {} - /// \brief The priority of an item. + /// \brief The priority of the given item. /// - /// Returns the priority of the given item. - /// \pre \c i must be in the heap. + /// This function returns the priority of the given item. /// \param i The item. + /// \pre \e i must be in the heap. Prio operator[](const Item &i) const {} - /// \brief Sets the priority of an item or inserts it, if it is + /// \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 with the given priority. + /// already stored in the heap. Otherwise it inserts the given + /// item into the heap with the given priority. /// /// \param i The item. /// \param p The priority. void set(const Item &i, const Prio &p) {} - /// \brief Decreases the priority of an item to the given value. + /// \brief Decrease the priority of an item to the given value. /// - /// Decreases the priority of an item to the given value. - /// \pre \c i must be stored in the heap with priority at least \c p. + /// This function decreases the priority of an item to the given value. /// \param i The item. /// \param p The priority. + /// \pre \e i must be stored in the heap with priority at least \e p. void decrease(const Item &i, const Prio &p) {} - /// \brief Increases the priority of an item to the given value. + /// \brief Increase the priority of an item to the given value. /// - /// Increases the priority of an item to the given value. - /// \pre \c i must be stored in the heap with priority at most \c p. + /// This function increases the priority of an item to the given value. /// \param i The item. /// \param p The priority. + /// \pre \e i must be stored in the heap with priority at most \e p. void increase(const Item &i, const Prio &p) {} - /// \brief Returns if an item is in, has already been in, or has - /// never been in the heap. + /// \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, @@ -160,11 +198,11 @@ /// \param i The item. State state(const Item &i) const {} - /// \brief Sets the state of an item in the heap. + /// \brief Set 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. + /// 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) {} @@ -242,4 +280,4 @@ /// @} } // namespace lemon } -#endif // LEMON_CONCEPT_PATH_H +#endif diff -r c35afa9e89e7 -r ef88c0a30f85 lemon/concepts/maps.h --- a/lemon/concepts/maps.h Mon Jan 12 23:11:39 2009 +0100 +++ b/lemon/concepts/maps.h Thu Nov 05 15:48:01 2009 +0100 @@ -16,8 +16,8 @@ * */ -#ifndef LEMON_CONCEPT_MAPS_H -#define LEMON_CONCEPT_MAPS_H +#ifndef LEMON_CONCEPTS_MAPS_H +#define LEMON_CONCEPTS_MAPS_H #include #include @@ -182,7 +182,8 @@ template struct Constraints { - void constraints() { + typename enable_if::type + constraints() { checkConcept, _ReferenceMap >(); ref = m[key]; m[key] = val; @@ -213,4 +214,4 @@ } //namespace lemon -#endif // LEMON_CONCEPT_MAPS_H +#endif diff -r c35afa9e89e7 -r ef88c0a30f85 lemon/concepts/path.h --- a/lemon/concepts/path.h Mon Jan 12 23:11:39 2009 +0100 +++ b/lemon/concepts/path.h Thu Nov 05 15:48:01 2009 +0100 @@ -21,8 +21,8 @@ ///\brief Classes for representing paths in digraphs. /// -#ifndef LEMON_CONCEPT_PATH_H -#define LEMON_CONCEPT_PATH_H +#ifndef LEMON_CONCEPTS_PATH_H +#define LEMON_CONCEPTS_PATH_H #include #include @@ -38,19 +38,19 @@ /// /// A skeleton structure for representing directed paths in a /// digraph. - /// \tparam _Digraph The digraph type in which the path is. + /// \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 + template class Path { public: /// Type of the underlying digraph. - typedef _Digraph Digraph; + typedef GR Digraph; /// Arc type of the underlying digraph. typedef typename Digraph::Arc Arc; @@ -205,18 +205,17 @@ /// 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 _Digraph The digraph type in which the path is. + /// + /// \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 + template class PathDumper { public: /// Type of the underlying digraph. - typedef _Digraph Digraph; + typedef GR Digraph; /// Arc type of the underlying digraph. typedef typename Digraph::Arc Arc; @@ -305,4 +304,4 @@ } // namespace lemon -#endif // LEMON_CONCEPT_PATH_H +#endif diff -r c35afa9e89e7 -r ef88c0a30f85 lemon/config.h.cmake --- /dev/null Thu Jan 01 00:00:00 1970 +0000 +++ b/lemon/config.h.cmake Thu Nov 05 15:48:01 2009 +0100 @@ -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 diff -r c35afa9e89e7 -r ef88c0a30f85 lemon/config.h.in --- a/lemon/config.h.in Mon Jan 12 23:11:39 2009 +0100 +++ b/lemon/config.h.in Thu Nov 05 15:48:01 2009 +0100 @@ -1,17 +1,26 @@ +/* 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 HAVE_LP +#undef LEMON_HAVE_LP /* Define to 1 if you have any MIP solver. */ -#undef HAVE_MIP +#undef LEMON_HAVE_MIP /* Define to 1 if you have CPLEX. */ -#undef HAVE_CPLEX +#undef LEMON_HAVE_CPLEX /* Define to 1 if you have GLPK. */ -#undef HAVE_GLPK +#undef LEMON_HAVE_GLPK /* Define to 1 if you have SOPLEX */ -#undef HAVE_SOPLEX +#undef LEMON_HAVE_SOPLEX /* Define to 1 if you have CLP */ -#undef HAVE_CLP +#undef LEMON_HAVE_CLP + +/* Define to 1 if you have CBC */ +#undef LEMON_HAVE_CBC diff -r c35afa9e89e7 -r ef88c0a30f85 lemon/connectivity.h --- a/lemon/connectivity.h Mon Jan 12 23:11:39 2009 +0100 +++ b/lemon/connectivity.h Thu Nov 05 15:48:01 2009 +0100 @@ -32,7 +32,7 @@ #include #include -/// \ingroup connectivity +/// \ingroup graph_properties /// \file /// \brief Connectivity algorithms /// @@ -40,14 +40,18 @@ namespace lemon { - /// \ingroup connectivity + /// \ingroup graph_properties /// - /// \brief Check whether the given undirected graph is connected. + /// \brief Check whether an undirected graph is connected. /// - /// Check whether the given undirected graph is connected. - /// \param graph The undirected graph. - /// \return %True when there is path between any two nodes in the graph. + /// This function checks whether the given undirected graph is connected, + /// i.e. there is a path between any two nodes in the graph. + /// + /// \return \c true if the graph is connected. /// \note By definition, the empty graph is connected. + /// + /// \see countConnectedComponents(), connectedComponents() + /// \see stronglyConnected() template bool connected(const Graph& graph) { checkConcept(); @@ -63,16 +67,22 @@ return true; } - /// \ingroup connectivity + /// \ingroup graph_properties /// /// \brief Count the number of connected components of an undirected graph /// - /// Count the number of connected components of an undirected graph + /// This function counts the number of connected components of the given + /// undirected graph. /// - /// \param graph The graph. It must be undirected. - /// \return The number of components + /// The connected components are the classes of an equivalence relation + /// on the nodes of an undirected graph. Two nodes are in the same class + /// if they are connected with a path. + /// + /// \return The number of connected components. /// \note By definition, the empty graph consists /// of zero connected components. + /// + /// \see connected(), connectedComponents() template int countConnectedComponents(const Graph &graph) { checkConcept(); @@ -105,19 +115,30 @@ return compNum; } - /// \ingroup connectivity + /// \ingroup graph_properties /// /// \brief Find the connected components of an undirected graph /// - /// Find the connected components of an undirected graph. + /// This function finds the connected components of the given undirected + /// graph. /// - /// \param graph The graph. It must be undirected. + /// The connected components are the classes of an equivalence relation + /// on the nodes of an undirected graph. Two nodes are in the same class + /// if they are connected with a path. + /// + /// \image html connected_components.png + /// \image latex connected_components.eps "Connected components" width=\textwidth + /// + /// \param graph The undirected graph. /// \retval compMap A writable node map. The values will be set from 0 to - /// the number of the connected components minus one. Each values of the map - /// will be set exactly once, the values of a certain component will be + /// the number of the connected components minus one. Each value of the map + /// will be set exactly once, and the values of a certain component will be /// set continuously. - /// \return The number of components + /// \return The number of connected components. + /// \note By definition, the empty graph consists + /// of zero connected components. /// + /// \see connected(), countConnectedComponents() template int connectedComponents(const Graph &graph, NodeMap &compMap) { checkConcept(); @@ -227,17 +248,19 @@ } - /// \ingroup connectivity + /// \ingroup graph_properties /// - /// \brief Check whether the given directed graph is strongly connected. + /// \brief Check whether a directed graph is strongly connected. /// - /// Check whether the given directed graph is strongly connected. The - /// graph is strongly connected when any two nodes of the graph are + /// This function checks whether the given directed graph is strongly + /// connected, i.e. any two nodes of the digraph are /// connected with directed paths in both direction. - /// \return %False when the graph is not strongly connected. - /// \see connected /// - /// \note By definition, the empty graph is strongly connected. + /// \return \c true if the digraph is strongly connected. + /// \note By definition, the empty digraph is strongly connected. + /// + /// \see countStronglyConnectedComponents(), stronglyConnectedComponents() + /// \see connected() template bool stronglyConnected(const Digraph& digraph) { checkConcept(); @@ -268,7 +291,7 @@ typedef typename RDigraph::NodeIt RNodeIt; RDigraph rdigraph(digraph); - typedef DfsVisitor RVisitor; + typedef DfsVisitor RVisitor; RVisitor rvisitor; DfsVisit rdfs(rdigraph, rvisitor); @@ -285,20 +308,24 @@ return true; } - /// \ingroup connectivity + /// \ingroup graph_properties /// - /// \brief Count the strongly connected components of a directed graph + /// \brief Count the number of strongly connected components of a + /// directed graph /// - /// Count the strongly connected components of a directed graph. + /// This function counts the number of strongly connected components of + /// the given directed graph. + /// /// The strongly connected components are the classes of an - /// equivalence relation on the nodes of the graph. Two nodes are in + /// equivalence relation on the nodes of a digraph. Two nodes are in /// the same class if they are connected with directed paths in both /// direction. /// - /// \param digraph The graph. - /// \return The number of components - /// \note By definition, the empty graph has zero + /// \return The number of strongly connected components. + /// \note By definition, the empty digraph has zero /// strongly connected components. + /// + /// \see stronglyConnected(), stronglyConnectedComponents() template int countStronglyConnectedComponents(const Digraph& digraph) { checkConcept(); @@ -349,25 +376,33 @@ return compNum; } - /// \ingroup connectivity + /// \ingroup graph_properties /// /// \brief Find the strongly connected components of a directed graph /// - /// Find the strongly connected components of a directed graph. The - /// strongly connected components are the classes of an equivalence - /// relation on the nodes of the graph. Two nodes are in - /// relationship when there are directed paths between them in both - /// direction. In addition, the numbering of components will satisfy - /// that there is no arc going from a higher numbered component to - /// a lower. + /// This function finds the strongly connected components of the given + /// directed graph. In addition, the numbering of the components will + /// satisfy that there is no arc going from a higher numbered component + /// to a lower one (i.e. it provides a topological order of the components). + /// + /// The strongly connected components are the classes of an + /// equivalence relation on the nodes of a digraph. Two nodes are in + /// the same class if they are connected with directed paths in both + /// direction. + /// + /// \image html strongly_connected_components.png + /// \image latex strongly_connected_components.eps "Strongly connected components" width=\textwidth /// /// \param digraph The digraph. /// \retval compMap A writable node map. The values will be set from 0 to /// the number of the strongly connected components minus one. Each value - /// of the map will be set exactly once, the values of a certain component - /// will be set continuously. - /// \return The number of components + /// of the map will be set exactly once, and the values of a certain + /// component will be set continuously. + /// \return The number of strongly connected components. + /// \note By definition, the empty digraph has zero + /// strongly connected components. /// + /// \see stronglyConnected(), countStronglyConnectedComponents() template int stronglyConnectedComponents(const Digraph& digraph, NodeMap& compMap) { checkConcept(); @@ -416,23 +451,28 @@ return compNum; } - /// \ingroup connectivity + /// \ingroup graph_properties /// /// \brief Find the cut arcs of the strongly connected components. /// - /// Find the cut arcs of the strongly connected components. - /// The strongly connected components are the classes of an equivalence - /// relation on the nodes of the graph. Two nodes are in relationship - /// when there are directed paths between them in both direction. + /// This function finds the cut arcs of the strongly connected components + /// of the given digraph. + /// + /// The strongly connected components are the classes of an + /// equivalence relation on the nodes of a digraph. Two nodes are in + /// the same class if they are connected with directed paths in both + /// direction. /// The strongly connected components are separated by the cut arcs. /// - /// \param graph The graph. - /// \retval cutMap A writable node map. The values will be set true when the - /// arc is a cut arc. + /// \param digraph The digraph. + /// \retval cutMap A writable arc map. The values will be set to \c true + /// for the cut arcs (exactly once for each cut arc), and will not be + /// changed for other arcs. + /// \return The number of cut arcs. /// - /// \return The number of cut arcs + /// \see stronglyConnected(), stronglyConnectedComponents() template - int stronglyConnectedCutArcs(const Digraph& graph, ArcMap& cutMap) { + int stronglyConnectedCutArcs(const Digraph& digraph, ArcMap& cutMap) { checkConcept(); typedef typename Digraph::Node Node; typedef typename Digraph::Arc Arc; @@ -444,13 +484,13 @@ typedef std::vector Container; typedef typename Container::iterator Iterator; - Container nodes(countNodes(graph)); + Container nodes(countNodes(digraph)); typedef LeaveOrderVisitor Visitor; Visitor visitor(nodes.begin()); - DfsVisit dfs(graph, visitor); + DfsVisit dfs(digraph, visitor); dfs.init(); - for (NodeIt it(graph); it != INVALID; ++it) { + for (NodeIt it(digraph); it != INVALID; ++it) { if (!dfs.reached(it)) { dfs.addSource(it); dfs.start(); @@ -460,14 +500,14 @@ typedef typename Container::reverse_iterator RIterator; typedef ReverseDigraph RDigraph; - RDigraph rgraph(graph); + RDigraph rdigraph(digraph); int cutNum = 0; typedef StronglyConnectedCutArcsVisitor RVisitor; - RVisitor rvisitor(rgraph, cutMap, cutNum); + RVisitor rvisitor(rdigraph, cutMap, cutNum); - DfsVisit rdfs(rgraph, rvisitor); + DfsVisit rdfs(rdigraph, rvisitor); rdfs.init(); for (RIterator it = nodes.rbegin(); it != nodes.rend(); ++it) { @@ -700,32 +740,37 @@ template int countBiNodeConnectedComponents(const Graph& graph); - /// \ingroup connectivity + /// \ingroup graph_properties /// - /// \brief Checks the graph is bi-node-connected. + /// \brief Check whether an undirected graph is bi-node-connected. /// - /// This function checks that the undirected graph is bi-node-connected - /// graph. The graph is bi-node-connected if any two undirected edge is - /// on same circle. + /// This function checks whether the given undirected graph is + /// bi-node-connected, i.e. any two edges are on same circle. /// - /// \param graph The graph. - /// \return %True when the graph bi-node-connected. + /// \return \c true if the graph bi-node-connected. + /// \note By definition, the empty graph is bi-node-connected. + /// + /// \see countBiNodeConnectedComponents(), biNodeConnectedComponents() template bool biNodeConnected(const Graph& graph) { return countBiNodeConnectedComponents(graph) <= 1; } - /// \ingroup connectivity + /// \ingroup graph_properties /// - /// \brief Count the biconnected components. + /// \brief Count the number of bi-node-connected components of an + /// undirected graph. /// - /// This function finds the bi-node-connected components in an undirected - /// graph. The biconnected components are the classes of an equivalence - /// relation on the undirected edges. Two undirected edge is in relationship - /// when they are on same circle. + /// This function counts the number of bi-node-connected components of + /// the given undirected graph. /// - /// \param graph The graph. - /// \return The number of components. + /// The bi-node-connected components are the classes of an equivalence + /// relation on the edges of a undirected graph. Two edges are in the + /// same class if they are on same circle. + /// + /// \return The number of bi-node-connected components. + /// + /// \see biNodeConnected(), biNodeConnectedComponents() template int countBiNodeConnectedComponents(const Graph& graph) { checkConcept(); @@ -750,22 +795,28 @@ return compNum; } - /// \ingroup connectivity + /// \ingroup graph_properties /// - /// \brief Find the bi-node-connected components. + /// \brief Find the bi-node-connected components of an undirected graph. /// - /// This function finds the bi-node-connected components in an undirected - /// graph. The bi-node-connected components are the classes of an equivalence - /// relation on the undirected edges. Two undirected edge are in relationship - /// when they are on same circle. + /// This function finds the bi-node-connected components of the given + /// undirected graph. /// - /// \param graph The graph. - /// \retval compMap A writable uedge map. The values will be set from 0 - /// to the number of the biconnected components minus one. Each values - /// of the map will be set exactly once, the values of a certain component - /// will be set continuously. - /// \return The number of components. + /// The bi-node-connected components are the classes of an equivalence + /// relation on the edges of a undirected graph. Two edges are in the + /// same class if they are on same circle. /// + /// \image html node_biconnected_components.png + /// \image latex node_biconnected_components.eps "bi-node-connected components" width=\textwidth + /// + /// \param graph The undirected graph. + /// \retval compMap A writable edge map. The values will be set from 0 + /// to the number of the bi-node-connected components minus one. Each + /// value of the map will be set exactly once, and the values of a + /// certain component will be set continuously. + /// \return The number of bi-node-connected components. + /// + /// \see biNodeConnected(), countBiNodeConnectedComponents() template int biNodeConnectedComponents(const Graph& graph, EdgeMap& compMap) { @@ -793,20 +844,27 @@ return compNum; } - /// \ingroup connectivity + /// \ingroup graph_properties /// - /// \brief Find the bi-node-connected cut nodes. + /// \brief Find the bi-node-connected cut nodes in an undirected graph. /// - /// This function finds the bi-node-connected cut nodes in an undirected - /// graph. The bi-node-connected components are the classes of an equivalence - /// relation on the undirected edges. Two undirected edges are in - /// relationship when they are on same circle. The biconnected components - /// are separted by nodes which are the cut nodes of the components. + /// This function finds the bi-node-connected cut nodes in the given + /// undirected graph. /// - /// \param graph The graph. - /// \retval cutMap A writable edge map. The values will be set true when - /// the node separate two or more components. + /// The bi-node-connected components are the classes of an equivalence + /// relation on the edges of a undirected graph. Two edges are in the + /// same class if they are on same circle. + /// The bi-node-connected components are separted by the cut nodes of + /// the components. + /// + /// \param graph The undirected graph. + /// \retval cutMap A writable node map. The values will be set to + /// \c true for the nodes that separate two or more components + /// (exactly once for each cut node), and will not be changed for + /// other nodes. /// \return The number of the cut nodes. + /// + /// \see biNodeConnected(), biNodeConnectedComponents() template int biNodeConnectedCutNodes(const Graph& graph, NodeMap& cutMap) { checkConcept(); @@ -1023,32 +1081,39 @@ template int countBiEdgeConnectedComponents(const Graph& graph); - /// \ingroup connectivity + /// \ingroup graph_properties /// - /// \brief Checks that the graph is bi-edge-connected. + /// \brief Check whether an undirected graph is bi-edge-connected. /// - /// This function checks that the graph is bi-edge-connected. The undirected - /// graph is bi-edge-connected when any two nodes are connected with two - /// edge-disjoint paths. + /// 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. /// - /// \param graph The undirected graph. - /// \return The number of components. + /// \return \c true if the graph is bi-edge-connected. + /// \note By definition, the empty graph is bi-edge-connected. + /// + /// \see countBiEdgeConnectedComponents(), biEdgeConnectedComponents() template bool biEdgeConnected(const Graph& graph) { return countBiEdgeConnectedComponents(graph) <= 1; } - /// \ingroup connectivity + /// \ingroup graph_properties /// - /// \brief Count the bi-edge-connected components. + /// \brief Count the number of bi-edge-connected components of an + /// undirected graph. /// - /// This function count the bi-edge-connected components in an undirected - /// graph. The bi-edge-connected components are the classes of an equivalence - /// relation on the nodes. Two nodes are in relationship when they are - /// connected with at least two edge-disjoint paths. + /// This function counts the number of bi-edge-connected components of + /// the given undirected graph. /// - /// \param graph The undirected graph. - /// \return The number of components. + /// The bi-edge-connected components are the classes of an equivalence + /// relation on the nodes of an undirected graph. Two nodes are in the + /// same class if they are connected with at least two edge-disjoint + /// paths. + /// + /// \return The number of bi-edge-connected components. + /// + /// \see biEdgeConnected(), biEdgeConnectedComponents() template int countBiEdgeConnectedComponents(const Graph& graph) { checkConcept(); @@ -1073,22 +1138,29 @@ return compNum; } - /// \ingroup connectivity + /// \ingroup graph_properties /// - /// \brief Find the bi-edge-connected components. + /// \brief Find the bi-edge-connected components of an undirected graph. /// - /// This function finds the bi-edge-connected components in an undirected - /// graph. The bi-edge-connected components are the classes of an equivalence - /// relation on the nodes. Two nodes are in relationship when they are - /// connected at least two edge-disjoint paths. + /// This function finds the bi-edge-connected components of the given + /// undirected graph. /// - /// \param graph The graph. + /// The bi-edge-connected components are the classes of an equivalence + /// relation on the nodes of an undirected graph. Two nodes are in the + /// same class if they are connected with at least two edge-disjoint + /// paths. + /// + /// \image html edge_biconnected_components.png + /// \image latex edge_biconnected_components.eps "bi-edge-connected components" width=\textwidth + /// + /// \param graph The undirected graph. /// \retval compMap A writable node map. The values will be set from 0 to - /// the number of the biconnected components minus one. Each values - /// of the map will be set exactly once, the values of a certain component - /// will be set continuously. - /// \return The number of components. + /// the number of the bi-edge-connected components minus one. Each value + /// of the map will be set exactly once, and the values of a certain + /// component will be set continuously. + /// \return The number of bi-edge-connected components. /// + /// \see biEdgeConnected(), countBiEdgeConnectedComponents() template int biEdgeConnectedComponents(const Graph& graph, NodeMap& compMap) { checkConcept(); @@ -1115,21 +1187,27 @@ return compNum; } - /// \ingroup connectivity + /// \ingroup graph_properties /// - /// \brief Find the bi-edge-connected cut edges. + /// \brief Find the bi-edge-connected cut edges in an undirected graph. /// - /// This function finds the bi-edge-connected components in an undirected - /// graph. The bi-edge-connected components are the classes of an equivalence - /// relation on the nodes. Two nodes are in relationship when they are - /// connected with at least two edge-disjoint paths. The bi-edge-connected - /// components are separted by edges which are the cut edges of the - /// components. + /// This function finds the bi-edge-connected cut edges in the given + /// undirected graph. /// - /// \param graph The graph. - /// \retval cutMap A writable node map. The values will be set true when the - /// edge is a cut edge. + /// The bi-edge-connected components are the classes of an equivalence + /// relation on the nodes of an undirected graph. Two nodes are in the + /// same class if they are connected with at least two edge-disjoint + /// paths. + /// The bi-edge-connected components are separted by the cut edges of + /// the components. + /// + /// \param graph The undirected graph. + /// \retval cutMap A writable edge map. The values will be set to \c true + /// for the cut edges (exactly once for each cut edge), and will not be + /// changed for other edges. /// \return The number of cut edges. + /// + /// \see biEdgeConnected(), biEdgeConnectedComponents() template int biEdgeConnectedCutEdges(const Graph& graph, EdgeMap& cutMap) { checkConcept(); @@ -1179,21 +1257,64 @@ } - /// \ingroup connectivity + /// \ingroup graph_properties + /// + /// \brief Check whether a digraph is DAG. + /// + /// This function checks whether the given digraph is DAG, i.e. + /// \e Directed \e Acyclic \e Graph. + /// \return \c true if there is no directed cycle in the digraph. + /// \see acyclic() + template + bool dag(const Digraph& digraph) { + + checkConcept(); + + typedef typename Digraph::Node Node; + typedef typename Digraph::NodeIt NodeIt; + typedef typename Digraph::Arc Arc; + + typedef typename Digraph::template NodeMap ProcessedMap; + + typename Dfs::template SetProcessedMap:: + Create dfs(digraph); + + ProcessedMap processed(digraph); + dfs.processedMap(processed); + + dfs.init(); + for (NodeIt it(digraph); it != INVALID; ++it) { + if (!dfs.reached(it)) { + dfs.addSource(it); + while (!dfs.emptyQueue()) { + Arc arc = dfs.nextArc(); + Node target = digraph.target(arc); + if (dfs.reached(target) && !processed[target]) { + return false; + } + dfs.processNextArc(); + } + } + } + return true; + } + + /// \ingroup graph_properties /// /// \brief Sort the nodes of a DAG into topolgical order. /// - /// Sort the nodes of a DAG into topolgical order. + /// This function sorts the nodes of the given acyclic digraph (DAG) + /// into topolgical order. /// - /// \param graph The graph. It must be directed and acyclic. + /// \param digraph The digraph, which must be DAG. /// \retval order A writable node map. The values will be set from 0 to - /// the number of the nodes in the graph minus one. Each values of the map - /// will be set exactly once, the values will be set descending order. + /// the number of the nodes in the digraph minus one. Each value of the + /// map will be set exactly once, and the values will be set descending + /// order. /// - /// \see checkedTopologicalSort - /// \see dag + /// \see dag(), checkedTopologicalSort() template - void topologicalSort(const Digraph& graph, NodeMap& order) { + void topologicalSort(const Digraph& digraph, NodeMap& order) { using namespace _connectivity_bits; checkConcept(); @@ -1204,13 +1325,13 @@ typedef typename Digraph::Arc Arc; TopologicalSortVisitor - visitor(order, countNodes(graph)); + visitor(order, countNodes(digraph)); DfsVisit > - dfs(graph, visitor); + dfs(digraph, visitor); dfs.init(); - for (NodeIt it(graph); it != INVALID; ++it) { + for (NodeIt it(digraph); it != INVALID; ++it) { if (!dfs.reached(it)) { dfs.addSource(it); dfs.start(); @@ -1218,22 +1339,22 @@ } } - /// \ingroup connectivity + /// \ingroup graph_properties /// /// \brief Sort the nodes of a DAG into topolgical order. /// - /// Sort the nodes of a DAG into topolgical order. It also checks - /// that the given graph is DAG. + /// This function sorts the nodes of the given acyclic digraph (DAG) + /// into topolgical order and also checks whether the given digraph + /// is DAG. /// - /// \param digraph The graph. It must be directed and acyclic. - /// \retval order A readable - writable node map. The values will be set - /// from 0 to the number of the nodes in the graph minus one. Each values - /// of the map will be set exactly once, the values will be set descending - /// order. - /// \return %False when the graph is not DAG. + /// \param digraph The digraph. + /// \retval order A readable and writable node map. The values will be + /// set from 0 to the number of the nodes in the digraph minus one. + /// Each value of the map will be set exactly once, and the values will + /// be set descending order. + /// \return \c false if the digraph is not DAG. /// - /// \see topologicalSort - /// \see dag + /// \see dag(), topologicalSort() template bool checkedTopologicalSort(const Digraph& digraph, NodeMap& order) { using namespace _connectivity_bits; @@ -1273,56 +1394,13 @@ return true; } - /// \ingroup connectivity + /// \ingroup graph_properties /// - /// \brief Check that the given directed graph is a DAG. + /// \brief Check whether an undirected graph is acyclic. /// - /// Check that the given directed graph is a DAG. The DAG is - /// an Directed Acyclic Digraph. - /// \return %False when the graph is not DAG. - /// \see acyclic - template - bool dag(const Digraph& digraph) { - - checkConcept(); - - typedef typename Digraph::Node Node; - typedef typename Digraph::NodeIt NodeIt; - typedef typename Digraph::Arc Arc; - - typedef typename Digraph::template NodeMap ProcessedMap; - - typename Dfs::template SetProcessedMap:: - Create dfs(digraph); - - ProcessedMap processed(digraph); - dfs.processedMap(processed); - - dfs.init(); - for (NodeIt it(digraph); it != INVALID; ++it) { - if (!dfs.reached(it)) { - dfs.addSource(it); - while (!dfs.emptyQueue()) { - Arc edge = dfs.nextArc(); - Node target = digraph.target(edge); - if (dfs.reached(target) && !processed[target]) { - return false; - } - dfs.processNextArc(); - } - } - } - return true; - } - - /// \ingroup connectivity - /// - /// \brief Check that the given undirected graph is acyclic. - /// - /// Check that the given undirected graph acyclic. - /// \param graph The undirected graph. - /// \return %True when there is no circle in the graph. - /// \see dag + /// This function checks whether the given undirected graph is acyclic. + /// \return \c true if there is no cycle in the graph. + /// \see dag() template bool acyclic(const Graph& graph) { checkConcept(); @@ -1335,11 +1413,11 @@ if (!dfs.reached(it)) { dfs.addSource(it); while (!dfs.emptyQueue()) { - Arc edge = dfs.nextArc(); - Node source = graph.source(edge); - Node target = graph.target(edge); + Arc arc = dfs.nextArc(); + Node source = graph.source(arc); + Node target = graph.target(arc); if (dfs.reached(target) && - dfs.predArc(source) != graph.oppositeArc(edge)) { + dfs.predArc(source) != graph.oppositeArc(arc)) { return false; } dfs.processNextArc(); @@ -1349,28 +1427,29 @@ return true; } - /// \ingroup connectivity + /// \ingroup graph_properties /// - /// \brief Check that the given undirected graph is tree. + /// \brief Check whether an undirected graph is tree. /// - /// Check that the given undirected graph is tree. - /// \param graph The undirected graph. - /// \return %True when the graph is acyclic and connected. + /// This function checks whether the given undirected graph is tree. + /// \return \c true if the graph is acyclic and connected. + /// \see acyclic(), connected() template bool tree(const Graph& graph) { checkConcept(); typedef typename Graph::Node Node; typedef typename Graph::NodeIt NodeIt; typedef typename Graph::Arc Arc; + if (NodeIt(graph) == INVALID) return true; Dfs dfs(graph); dfs.init(); dfs.addSource(NodeIt(graph)); while (!dfs.emptyQueue()) { - Arc edge = dfs.nextArc(); - Node source = graph.source(edge); - Node target = graph.target(edge); + Arc arc = dfs.nextArc(); + Node source = graph.source(arc); + Node target = graph.target(arc); if (dfs.reached(target) && - dfs.predArc(source) != graph.oppositeArc(edge)) { + dfs.predArc(source) != graph.oppositeArc(arc)) { return false; } dfs.processNextArc(); @@ -1441,17 +1520,16 @@ }; } - /// \ingroup connectivity + /// \ingroup graph_properties /// - /// \brief Check if the given undirected graph is bipartite or not + /// \brief Check whether an undirected graph is bipartite. /// - /// The function checks if the given undirected \c graph graph is bipartite - /// or not. The \ref Bfs algorithm is used to calculate the result. - /// \param graph The undirected graph. - /// \return %True if \c graph is bipartite, %false otherwise. - /// \sa bipartitePartitions + /// The function checks whether the given undirected graph is bipartite. + /// \return \c true if the graph is bipartite. + /// + /// \see bipartitePartitions() template - inline bool bipartite(const Graph &graph){ + bool bipartite(const Graph &graph){ using namespace _connectivity_bits; checkConcept(); @@ -1478,23 +1556,29 @@ return true; } - /// \ingroup connectivity + /// \ingroup graph_properties /// - /// \brief Check if the given undirected graph is bipartite or not + /// \brief Find the bipartite partitions of an undirected graph. /// - /// The function checks if the given undirected graph is bipartite - /// or not. The \ref Bfs algorithm is used to calculate the result. - /// During the execution, the \c partMap will be set as the two - /// partitions of the graph. + /// This function checks whether the given undirected graph is bipartite + /// and gives back the bipartite partitions. + /// + /// \image html bipartite_partitions.png + /// \image latex bipartite_partitions.eps "Bipartite partititions" width=\textwidth + /// /// \param graph The undirected graph. - /// \retval partMap A writable bool map of nodes. It will be set as the - /// two partitions of the graph. - /// \return %True if \c graph is bipartite, %false otherwise. + /// \retval partMap A writable node map of \c bool (or convertible) value + /// type. The values will be set to \c true for one component and + /// \c false for the other one. + /// \return \c true if the graph is bipartite, \c false otherwise. + /// + /// \see bipartite() template - inline bool bipartitePartitions(const Graph &graph, NodeMap &partMap){ + bool bipartitePartitions(const Graph &graph, NodeMap &partMap){ using namespace _connectivity_bits; checkConcept(); + checkConcept, NodeMap>(); typedef typename Graph::Node Node; typedef typename Graph::NodeIt NodeIt; @@ -1519,53 +1603,59 @@ return true; } - /// \brief Returns true when there are not loop edges in the graph. + /// \ingroup graph_properties /// - /// Returns true when there are not loop edges in the graph. - template - bool loopFree(const Digraph& digraph) { - for (typename Digraph::ArcIt it(digraph); it != INVALID; ++it) { - if (digraph.source(it) == digraph.target(it)) return false; + /// \brief Check whether the given graph contains no loop arcs/edges. + /// + /// This function returns \c true if there are no loop arcs/edges in + /// the given graph. It works for both directed and undirected graphs. + template + bool loopFree(const Graph& graph) { + for (typename Graph::ArcIt it(graph); it != INVALID; ++it) { + if (graph.source(it) == graph.target(it)) return false; } return true; } - /// \brief Returns true when there are not parallel edges in the graph. + /// \ingroup graph_properties /// - /// Returns true when there are not parallel edges in the graph. - template - bool parallelFree(const Digraph& digraph) { - typename Digraph::template NodeMap reached(digraph, false); - for (typename Digraph::NodeIt n(digraph); n != INVALID; ++n) { - for (typename Digraph::OutArcIt a(digraph, n); a != INVALID; ++a) { - if (reached[digraph.target(a)]) return false; - reached.set(digraph.target(a), true); + /// \brief Check whether the given graph contains no parallel arcs/edges. + /// + /// This function returns \c true if there are no parallel arcs/edges in + /// the given graph. It works for both directed and undirected graphs. + template + bool parallelFree(const Graph& graph) { + typename Graph::template NodeMap reached(graph, 0); + int cnt = 1; + for (typename Graph::NodeIt n(graph); n != INVALID; ++n) { + for (typename Graph::OutArcIt a(graph, n); a != INVALID; ++a) { + if (reached[graph.target(a)] == cnt) return false; + reached[graph.target(a)] = cnt; } - for (typename Digraph::OutArcIt a(digraph, n); a != INVALID; ++a) { - reached.set(digraph.target(a), false); - } + ++cnt; } return true; } - /// \brief Returns true when there are not loop edges and parallel - /// edges in the graph. + /// \ingroup graph_properties /// - /// Returns true when there are not loop edges and parallel edges in - /// the graph. - template - bool simpleDigraph(const Digraph& digraph) { - typename Digraph::template NodeMap reached(digraph, false); - for (typename Digraph::NodeIt n(digraph); n != INVALID; ++n) { - reached.set(n, true); - for (typename Digraph::OutArcIt a(digraph, n); a != INVALID; ++a) { - if (reached[digraph.target(a)]) return false; - reached.set(digraph.target(a), true); + /// \brief Check whether the given graph is simple. + /// + /// This function returns \c true if the given graph is simple, i.e. + /// it contains no loop arcs/edges and no parallel arcs/edges. + /// The function works for both directed and undirected graphs. + /// \see loopFree(), parallelFree() + template + bool simpleGraph(const Graph& graph) { + typename Graph::template NodeMap reached(graph, 0); + int cnt = 1; + for (typename Graph::NodeIt n(graph); n != INVALID; ++n) { + reached[n] = cnt; + for (typename Graph::OutArcIt a(graph, n); a != INVALID; ++a) { + if (reached[graph.target(a)] == cnt) return false; + reached[graph.target(a)] = cnt; } - for (typename Digraph::OutArcIt a(digraph, n); a != INVALID; ++a) { - reached.set(digraph.target(a), false); - } - reached.set(n, false); + ++cnt; } return true; } diff -r c35afa9e89e7 -r ef88c0a30f85 lemon/core.h --- a/lemon/core.h Mon Jan 12 23:11:39 2009 +0100 +++ b/lemon/core.h Thu Nov 05 15:48:01 2009 +0100 @@ -22,10 +22,21 @@ #include #include +#include #include #include #include +// Disable the following warnings when compiling with MSVC: +// C4250: 'class1' : inherits 'class2::member' via dominance +// C4355: 'this' : used in base member initializer list +// C4503: 'function' : decorated name length exceeded, name was truncated +// C4800: 'type' : forcing value to bool 'true' or 'false' (performance warning) +// C4996: 'function': was declared deprecated +#ifdef _MSC_VER +#pragma warning( disable : 4250 4355 4503 4800 4996 ) +#endif + ///\file ///\brief LEMON core utilities. /// @@ -1033,28 +1044,27 @@ /// ///\sa findArc() ///\sa ArcLookUp, AllArcLookUp, DynArcLookUp - template - class ConArcIt : public _Graph::Arc { + template + class ConArcIt : public GR::Arc { + typedef typename GR::Arc Parent; + public: - typedef _Graph Graph; - typedef typename Graph::Arc Parent; - - typedef typename Graph::Arc Arc; - typedef typename Graph::Node Node; + typedef typename GR::Arc Arc; + typedef typename GR::Node Node; /// \brief Constructor. /// /// Construct a new ConArcIt iterating on the arcs that /// connects nodes \c u and \c v. - ConArcIt(const Graph& g, Node u, Node v) : _graph(g) { + ConArcIt(const GR& g, Node u, Node v) : _graph(g) { Parent::operator=(findArc(_graph, u, v)); } /// \brief Constructor. /// /// Construct a new ConArcIt that continues the iterating from arc \c a. - ConArcIt(const Graph& g, Arc a) : Parent(a), _graph(g) {} + ConArcIt(const GR& g, Arc a) : Parent(a), _graph(g) {} /// \brief Increment operator. /// @@ -1065,7 +1075,7 @@ return *this; } private: - const Graph& _graph; + const GR& _graph; }; namespace _core_bits { @@ -1156,28 +1166,27 @@ ///\endcode /// ///\sa findEdge() - template - class ConEdgeIt : public _Graph::Edge { + template + class ConEdgeIt : public GR::Edge { + typedef typename GR::Edge Parent; + public: - typedef _Graph Graph; - typedef typename Graph::Edge Parent; - - typedef typename Graph::Edge Edge; - typedef typename Graph::Node Node; + typedef typename GR::Edge Edge; + typedef typename GR::Node Node; /// \brief Constructor. /// /// Construct a new ConEdgeIt iterating on the edges that /// connects nodes \c u and \c v. - ConEdgeIt(const Graph& g, Node u, Node v) : _graph(g), _u(u), _v(v) { + ConEdgeIt(const GR& g, Node u, Node v) : _graph(g), _u(u), _v(v) { Parent::operator=(findEdge(_graph, _u, _v)); } /// \brief Constructor. /// /// Construct a new ConEdgeIt that continues iterating from edge \c e. - ConEdgeIt(const Graph& g, Edge e) : Parent(e), _graph(g) {} + ConEdgeIt(const GR& g, Edge e) : Parent(e), _graph(g) {} /// \brief Increment operator. /// @@ -1187,7 +1196,7 @@ return *this; } private: - const Graph& _graph; + const GR& _graph; Node _u, _v; }; @@ -1210,29 +1219,32 @@ ///optimal time bound in a constant factor for any distribution of ///queries. /// - ///\tparam G The type of the underlying digraph. + ///\tparam GR The type of the underlying digraph. /// ///\sa ArcLookUp ///\sa AllArcLookUp - template + template class DynArcLookUp - : protected ItemSetTraits::ItemNotifier::ObserverBase + : protected ItemSetTraits::ItemNotifier::ObserverBase { - public: - typedef typename ItemSetTraits + typedef typename ItemSetTraits ::ItemNotifier::ObserverBase Parent; - TEMPLATE_DIGRAPH_TYPEDEFS(G); - typedef G Digraph; + TEMPLATE_DIGRAPH_TYPEDEFS(GR); + + public: + + /// The Digraph type + typedef GR Digraph; protected: - class AutoNodeMap : public ItemSetTraits::template Map::Type { + class AutoNodeMap : public ItemSetTraits::template Map::Type { + typedef typename ItemSetTraits::template Map::Type Parent; + public: - typedef typename ItemSetTraits::template Map::Type Parent; - - AutoNodeMap(const G& digraph) : Parent(digraph, INVALID) {} + AutoNodeMap(const GR& digraph) : Parent(digraph, INVALID) {} virtual void add(const Node& node) { Parent::add(node); @@ -1256,12 +1268,6 @@ } }; - const Digraph &_g; - AutoNodeMap _head; - typename Digraph::template ArcMap _parent; - typename Digraph::template ArcMap _left; - typename Digraph::template ArcMap _right; - class ArcLess { const Digraph &g; public: @@ -1272,6 +1278,14 @@ } }; + protected: + + const Digraph &_g; + AutoNodeMap _head; + typename Digraph::template ArcMap _parent; + typename Digraph::template ArcMap _left; + typename Digraph::template ArcMap _right; + public: ///Constructor @@ -1314,27 +1328,27 @@ virtual void clear() { for(NodeIt n(_g);n!=INVALID;++n) { - _head.set(n, INVALID); + _head[n] = INVALID; } } void insert(Arc arc) { Node s = _g.source(arc); Node t = _g.target(arc); - _left.set(arc, INVALID); - _right.set(arc, INVALID); + _left[arc] = INVALID; + _right[arc] = INVALID; Arc e = _head[s]; if (e == INVALID) { - _head.set(s, arc); - _parent.set(arc, INVALID); + _head[s] = arc; + _parent[arc] = INVALID; return; } while (true) { if (t < _g.target(e)) { if (_left[e] == INVALID) { - _left.set(e, arc); - _parent.set(arc, e); + _left[e] = arc; + _parent[arc] = e; splay(arc); return; } else { @@ -1342,8 +1356,8 @@ } } else { if (_right[e] == INVALID) { - _right.set(e, arc); - _parent.set(arc, e); + _right[e] = arc; + _parent[arc] = e; splay(arc); return; } else { @@ -1356,27 +1370,27 @@ void remove(Arc arc) { if (_left[arc] == INVALID) { if (_right[arc] != INVALID) { - _parent.set(_right[arc], _parent[arc]); + _parent[_right[arc]] = _parent[arc]; } if (_parent[arc] != INVALID) { if (_left[_parent[arc]] == arc) { - _left.set(_parent[arc], _right[arc]); + _left[_parent[arc]] = _right[arc]; } else { - _right.set(_parent[arc], _right[arc]); + _right[_parent[arc]] = _right[arc]; } } else { - _head.set(_g.source(arc), _right[arc]); + _head[_g.source(arc)] = _right[arc]; } } else if (_right[arc] == INVALID) { - _parent.set(_left[arc], _parent[arc]); + _parent[_left[arc]] = _parent[arc]; if (_parent[arc] != INVALID) { if (_left[_parent[arc]] == arc) { - _left.set(_parent[arc], _left[arc]); + _left[_parent[arc]] = _left[arc]; } else { - _right.set(_parent[arc], _left[arc]); + _right[_parent[arc]] = _left[arc]; } } else { - _head.set(_g.source(arc), _left[arc]); + _head[_g.source(arc)] = _left[arc]; } } else { Arc e = _left[arc]; @@ -1386,38 +1400,38 @@ e = _right[e]; } Arc s = _parent[e]; - _right.set(_parent[e], _left[e]); + _right[_parent[e]] = _left[e]; if (_left[e] != INVALID) { - _parent.set(_left[e], _parent[e]); + _parent[_left[e]] = _parent[e]; } - _left.set(e, _left[arc]); - _parent.set(_left[arc], e); - _right.set(e, _right[arc]); - _parent.set(_right[arc], e); + _left[e] = _left[arc]; + _parent[_left[arc]] = e; + _right[e] = _right[arc]; + _parent[_right[arc]] = e; - _parent.set(e, _parent[arc]); + _parent[e] = _parent[arc]; if (_parent[arc] != INVALID) { if (_left[_parent[arc]] == arc) { - _left.set(_parent[arc], e); + _left[_parent[arc]] = e; } else { - _right.set(_parent[arc], e); + _right[_parent[arc]] = e; } } splay(s); } else { - _right.set(e, _right[arc]); - _parent.set(_right[arc], e); - _parent.set(e, _parent[arc]); + _right[e] = _right[arc]; + _parent[_right[arc]] = e; + _parent[e] = _parent[arc]; if (_parent[arc] != INVALID) { if (_left[_parent[arc]] == arc) { - _left.set(_parent[arc], e); + _left[_parent[arc]] = e; } else { - _right.set(_parent[arc], e); + _right[_parent[arc]] = e; } } else { - _head.set(_g.source(arc), e); + _head[_g.source(arc)] = e; } } } @@ -1429,17 +1443,17 @@ Arc me=v[m]; if (a < m) { Arc left = refreshRec(v,a,m-1); - _left.set(me, left); - _parent.set(left, me); + _left[me] = left; + _parent[left] = me; } else { - _left.set(me, INVALID); + _left[me] = INVALID; } if (m < b) { Arc right = refreshRec(v,m+1,b); - _right.set(me, right); - _parent.set(right, me); + _right[me] = right; + _parent[right] = me; } else { - _right.set(me, INVALID); + _right[me] = INVALID; } return me; } @@ -1451,46 +1465,46 @@ if (!v.empty()) { std::sort(v.begin(),v.end(),ArcLess(_g)); Arc head = refreshRec(v,0,v.size()-1); - _head.set(n, head); - _parent.set(head, INVALID); + _head[n] = head; + _parent[head] = INVALID; } - else _head.set(n, INVALID); + else _head[n] = INVALID; } } void zig(Arc v) { Arc w = _parent[v]; - _parent.set(v, _parent[w]); - _parent.set(w, v); - _left.set(w, _right[v]); - _right.set(v, w); + _parent[v] = _parent[w]; + _parent[w] = v; + _left[w] = _right[v]; + _right[v] = w; if (_parent[v] != INVALID) { if (_right[_parent[v]] == w) { - _right.set(_parent[v], v); + _right[_parent[v]] = v; } else { - _left.set(_parent[v], v); + _left[_parent[v]] = v; } } if (_left[w] != INVALID){ - _parent.set(_left[w], w); + _parent[_left[w]] = w; } } void zag(Arc v) { Arc w = _parent[v]; - _parent.set(v, _parent[w]); - _parent.set(w, v); - _right.set(w, _left[v]); - _left.set(v, w); + _parent[v] = _parent[w]; + _parent[w] = v; + _right[w] = _left[v]; + _left[v] = w; if (_parent[v] != INVALID){ if (_left[_parent[v]] == w) { - _left.set(_parent[v], v); + _left[_parent[v]] = v; } else { - _right.set(_parent[v], v); + _right[_parent[v]] = v; } } if (_right[w] != INVALID){ - _parent.set(_right[w], w); + _parent[_right[w]] = w; } } @@ -1622,16 +1636,19 @@ ///digraph changes. This is a time consuming (superlinearly proportional ///(O(m logm)) to the number of arcs). /// - ///\tparam G The type of the underlying digraph. + ///\tparam GR The type of the underlying digraph. /// ///\sa DynArcLookUp ///\sa AllArcLookUp - template + template class ArcLookUp { + TEMPLATE_DIGRAPH_TYPEDEFS(GR); + public: - TEMPLATE_DIGRAPH_TYPEDEFS(G); - typedef G Digraph; + + /// The Digraph type + typedef GR Digraph; protected: const Digraph &_g; @@ -1732,22 +1749,21 @@ ///digraph changes. This is a time consuming (superlinearly proportional ///(O(m logm)) to the number of arcs). /// - ///\tparam G The type of the underlying digraph. + ///\tparam GR The type of the underlying digraph. /// ///\sa DynArcLookUp ///\sa ArcLookUp - template - class AllArcLookUp : public ArcLookUp + template + class AllArcLookUp : public ArcLookUp { - using ArcLookUp::_g; - using ArcLookUp::_right; - using ArcLookUp::_left; - using ArcLookUp::_head; + using ArcLookUp::_g; + using ArcLookUp::_right; + using ArcLookUp::_left; + using ArcLookUp::_head; - TEMPLATE_DIGRAPH_TYPEDEFS(G); - typedef G Digraph; + TEMPLATE_DIGRAPH_TYPEDEFS(GR); - typename Digraph::template ArcMap _next; + typename GR::template ArcMap _next; Arc refreshNext(Arc head,Arc next=INVALID) { @@ -1766,13 +1782,17 @@ } public: + + /// The Digraph type + typedef GR Digraph; + ///Constructor ///Constructor. /// ///It builds up the search database, which remains valid until the digraph ///changes. - AllArcLookUp(const Digraph &g) : ArcLookUp(g), _next(g) {refreshNext();} + AllArcLookUp(const Digraph &g) : ArcLookUp(g), _next(g) {refreshNext();} ///Refresh the data structure at a node. @@ -1782,7 +1802,7 @@ ///the number of the outgoing arcs of \c n. void refresh(Node n) { - ArcLookUp::refresh(n); + ArcLookUp::refresh(n); refreshNext(_head[n]); } @@ -1829,7 +1849,7 @@ #ifdef DOXYGEN Arc operator()(Node s, Node t, Arc prev=INVALID) const {} #else - using ArcLookUp::operator() ; + using ArcLookUp::operator() ; Arc operator()(Node s, Node t, Arc prev) const { return prev==INVALID?(*this)(s,t):_next[prev]; diff -r c35afa9e89e7 -r ef88c0a30f85 lemon/cplex.cc --- a/lemon/cplex.cc Mon Jan 12 23:11:39 2009 +0100 +++ b/lemon/cplex.cc Thu Nov 05 15:48:01 2009 +0100 @@ -2,7 +2,7 @@ * * This file is a part of LEMON, a generic C++ optimization library. * - * Copyright (C) 2003-2008 + * Copyright (C) 2003-2009 * Egervary Jeno Kombinatorikus Optimalizalasi Kutatocsoport * (Egervary Research Group on Combinatorial Optimization, EGRES). * @@ -72,12 +72,14 @@ CplexBase::CplexBase() : LpBase() { int status; _prob = CPXcreateprob(cplexEnv(), &status, "Cplex problem"); + messageLevel(MESSAGE_NOTHING); } CplexBase::CplexBase(const CplexEnv& env) : LpBase(), _env(env) { int status; _prob = CPXcreateprob(cplexEnv(), &status, "Cplex problem"); + messageLevel(MESSAGE_NOTHING); } CplexBase::CplexBase(const CplexBase& cplex) @@ -86,6 +88,7 @@ _prob = CPXcloneprob(cplexEnv(), cplex._prob, &status); rows = cplex.rows; cols = cplex.cols; + messageLevel(MESSAGE_NOTHING); } CplexBase::~CplexBase() { @@ -108,6 +111,39 @@ return i; } + int CplexBase::_addRow(Value lb, ExprIterator b, + ExprIterator e, Value ub) { + int i = CPXgetnumrows(cplexEnv(), _prob); + if (lb == -INF) { + const char s = 'L'; + CPXnewrows(cplexEnv(), _prob, 1, &ub, &s, 0, 0); + } else if (ub == INF) { + const char s = 'G'; + CPXnewrows(cplexEnv(), _prob, 1, &lb, &s, 0, 0); + } else if (lb == ub){ + const char s = 'E'; + CPXnewrows(cplexEnv(), _prob, 1, &lb, &s, 0, 0); + } else { + const char s = 'R'; + double len = ub - lb; + CPXnewrows(cplexEnv(), _prob, 1, &lb, &s, &len, 0); + } + + std::vector 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) { CPXdelcols(cplexEnv(), _prob, i, i); @@ -438,21 +474,40 @@ cols.clear(); } + void CplexBase::_messageLevel(MessageLevel level) { + switch (level) { + case MESSAGE_NOTHING: + _message_enabled = false; + break; + case MESSAGE_ERROR: + case MESSAGE_WARNING: + case MESSAGE_NORMAL: + case MESSAGE_VERBOSE: + _message_enabled = true; + break; + } + } + + void CplexBase::_applyMessageLevel() { + CPXsetintparam(cplexEnv(), CPX_PARAM_SCRIND, + _message_enabled ? CPX_ON : CPX_OFF); + } + // CplexLp members CplexLp::CplexLp() - : LpBase(), CplexBase(), LpSolver() {} + : LpBase(), LpSolver(), CplexBase() {} CplexLp::CplexLp(const CplexEnv& env) - : LpBase(), CplexBase(env), LpSolver() {} + : LpBase(), LpSolver(), CplexBase(env) {} CplexLp::CplexLp(const CplexLp& other) - : LpBase(), CplexBase(other), LpSolver() {} + : LpBase(), LpSolver(), CplexBase(other) {} CplexLp::~CplexLp() {} - CplexLp* CplexLp::_newSolver() const { return new CplexLp; } - CplexLp* CplexLp::_cloneSolver() const {return new CplexLp(*this); } + CplexLp* CplexLp::newSolver() const { return new CplexLp; } + CplexLp* CplexLp::cloneSolver() const {return new CplexLp(*this); } const char* CplexLp::_solverName() const { return "CplexLp"; } @@ -507,21 +562,25 @@ CplexLp::SolveExitStatus CplexLp::_solve() { _clear_temporals(); + _applyMessageLevel(); return convertStatus(CPXlpopt(cplexEnv(), _prob)); } CplexLp::SolveExitStatus CplexLp::solvePrimal() { _clear_temporals(); + _applyMessageLevel(); return convertStatus(CPXprimopt(cplexEnv(), _prob)); } CplexLp::SolveExitStatus CplexLp::solveDual() { _clear_temporals(); + _applyMessageLevel(); return convertStatus(CPXdualopt(cplexEnv(), _prob)); } CplexLp::SolveExitStatus CplexLp::solveBarrier() { _clear_temporals(); + _applyMessageLevel(); return convertStatus(CPXbaropt(cplexEnv(), _prob)); } @@ -600,7 +659,7 @@ return _dual_ray[i]; } - //7.5-os cplex statusai (Vigyazat: a 9.0-asei masok!) + // Cplex 7.0 status values // This table lists the statuses, returned by the CPXgetstat() // routine, for solutions to LP problems or mixed integer problems. If // no solution exists, the return value is zero. @@ -647,7 +706,7 @@ // 20 CPX_PIVOT // User pivot used // - // Ezeket hova tegyem: + // Pending return values // ??case CPX_ABORT_DUAL_INFEAS // ??case CPX_ABORT_CROSSOVER // ??case CPX_INForUNBD @@ -718,7 +777,6 @@ #else statusSwitch(cplexEnv(),stat); //CPXgetstat(cplexEnv(), _prob); - //printf("A primal status: %d, CPX_OPTIMAL=%d \n",stat,CPX_OPTIMAL); switch (stat) { case 0: return UNDEFINED; //Undefined @@ -751,7 +809,7 @@ #endif } - //9.0-as cplex verzio statusai + // Cplex 9.0 status values // CPX_STAT_ABORT_DUAL_OBJ_LIM // CPX_STAT_ABORT_IT_LIM // CPX_STAT_ABORT_OBJ_LIM @@ -798,7 +856,7 @@ // CplexMip members CplexMip::CplexMip() - : LpBase(), CplexBase(), MipSolver() { + : LpBase(), MipSolver(), CplexBase() { #if CPX_VERSION < 800 CPXchgprobtype(cplexEnv(), _prob, CPXPROB_MIP); @@ -808,7 +866,7 @@ } CplexMip::CplexMip(const CplexEnv& env) - : LpBase(), CplexBase(env), MipSolver() { + : LpBase(), MipSolver(), CplexBase(env) { #if CPX_VERSION < 800 CPXchgprobtype(cplexEnv(), _prob, CPXPROB_MIP); @@ -819,12 +877,12 @@ } CplexMip::CplexMip(const CplexMip& other) - : LpBase(), CplexBase(other), MipSolver() {} + : LpBase(), MipSolver(), CplexBase(other) {} CplexMip::~CplexMip() {} - CplexMip* CplexMip::_newSolver() const { return new CplexMip; } - CplexMip* CplexMip::_cloneSolver() const {return new CplexMip(*this); } + CplexMip* CplexMip::newSolver() const { return new CplexMip; } + CplexMip* CplexMip::cloneSolver() const {return new CplexMip(*this); } const char* CplexMip::_solverName() const { return "CplexMip"; } @@ -864,6 +922,7 @@ CplexMip::SolveExitStatus CplexMip::_solve() { int status; + _applyMessageLevel(); status = CPXmipopt (cplexEnv(), _prob); if (status==0) return SOLVED; diff -r c35afa9e89e7 -r ef88c0a30f85 lemon/cplex.h --- a/lemon/cplex.h Mon Jan 12 23:11:39 2009 +0100 +++ b/lemon/cplex.h Thu Nov 05 15:48:01 2009 +0100 @@ -2,7 +2,7 @@ * * This file is a part of LEMON, a generic C++ optimization library. * - * Copyright (C) 2003-2008 + * Copyright (C) 2003-2009 * Egervary Jeno Kombinatorikus Optimalizalasi Kutatocsoport * (Egervary Research Group on Combinatorial Optimization, EGRES). * @@ -78,7 +78,7 @@ /// \brief Base interface for the CPLEX LP and MIP solver /// /// This class implements the common interface of the CPLEX LP and - /// MIP solvers. + /// MIP solvers. /// \ingroup lp_group class CplexBase : virtual public LpBase { protected: @@ -93,6 +93,7 @@ virtual int _addCol(); virtual int _addRow(); + virtual int _addRow(Value l, ExprIterator b, ExprIterator e, Value u); virtual void _eraseCol(int i); virtual void _eraseRow(int i); @@ -144,14 +145,29 @@ virtual void _clear(); + virtual void _messageLevel(MessageLevel level); + void _applyMessageLevel(); + + bool _message_enabled; + public: /// Returns the used \c CplexEnv instance const CplexEnv& env() const { return _env; } + + /// \brief Returns the const cpxenv pointer /// + /// \note The cpxenv might be destructed with the solver. const cpxenv* cplexEnv() const { return _env.cplexEnv(); } + /// \brief Returns the const cpxenv pointer + /// + /// \note The cpxenv might be destructed with the solver. + cpxenv* cplexEnv() { return _env.cplexEnv(); } + + /// Returns the cplex problem object cpxlp* cplexLp() { return _prob; } + /// Returns the cplex problem object const cpxlp* cplexLp() const { return _prob; } }; @@ -160,7 +176,7 @@ /// /// This class implements an interface for the CPLEX LP solver. ///\ingroup lp_group - class CplexLp : public CplexBase, public LpSolver { + class CplexLp : public LpSolver, public CplexBase { public: /// \e CplexLp(); @@ -171,6 +187,11 @@ /// \e virtual ~CplexLp(); + /// \e + virtual CplexLp* cloneSolver() const; + /// \e + virtual CplexLp* newSolver() const; + private: // these values cannot retrieved element by element @@ -186,9 +207,6 @@ protected: - virtual CplexLp* _cloneSolver() const; - virtual CplexLp* _newSolver() const; - virtual const char* _solverName() const; virtual SolveExitStatus _solve(); @@ -222,7 +240,7 @@ /// /// This class implements an interface for the CPLEX MIP solver. ///\ingroup lp_group - class CplexMip : public CplexBase, public MipSolver { + class CplexMip : public MipSolver, public CplexBase { public: /// \e CplexMip(); @@ -233,10 +251,13 @@ /// \e virtual ~CplexMip(); + /// \e + virtual CplexMip* cloneSolver() const; + /// \e + virtual CplexMip* newSolver() const; + protected: - virtual CplexMip* _cloneSolver() const; - virtual CplexMip* _newSolver() const; virtual const char* _solverName() const; diff -r c35afa9e89e7 -r ef88c0a30f85 lemon/dfs.h --- a/lemon/dfs.h Mon Jan 12 23:11:39 2009 +0100 +++ b/lemon/dfs.h Thu Nov 05 15:48:01 2009 +0100 @@ -47,13 +47,13 @@ /// ///The type of the map that stores the predecessor ///arcs of the %DFS paths. - ///It must meet the \ref concepts::WriteMap "WriteMap" concept. + ///It must conform to the \ref concepts::WriteMap "WriteMap" concept. typedef typename Digraph::template NodeMap PredMap; - ///Instantiates a PredMap. + ///Instantiates a \c PredMap. - ///This function instantiates a PredMap. + ///This function instantiates a \ref PredMap. ///\param g is the digraph, to which we would like to define the - ///PredMap. + ///\ref PredMap. static PredMap *createPredMap(const Digraph &g) { return new PredMap(g); @@ -62,13 +62,14 @@ ///The type of the map that indicates which nodes are processed. ///The type of the map that indicates which nodes are processed. - ///It must meet the \ref concepts::WriteMap "WriteMap" concept. + ///It must conform to the \ref concepts::WriteMap "WriteMap" concept. + ///By default it is a NullMap. typedef NullMap ProcessedMap; - ///Instantiates a ProcessedMap. + ///Instantiates a \c ProcessedMap. - ///This function instantiates a ProcessedMap. + ///This function instantiates a \ref ProcessedMap. ///\param g is the digraph, to which - ///we would like to define the ProcessedMap + ///we would like to define the \ref ProcessedMap. #ifdef DOXYGEN static ProcessedMap *createProcessedMap(const Digraph &g) #else @@ -81,13 +82,13 @@ ///The type of the map that indicates which nodes are reached. ///The type of the map that indicates which nodes are reached. - ///It must meet the \ref concepts::ReadWriteMap "ReadWriteMap" concept. + ///It must conform to the \ref concepts::ReadWriteMap "ReadWriteMap" concept. typedef typename Digraph::template NodeMap ReachedMap; - ///Instantiates a ReachedMap. + ///Instantiates a \c ReachedMap. - ///This function instantiates a ReachedMap. + ///This function instantiates a \ref ReachedMap. ///\param g is the digraph, to which - ///we would like to define the ReachedMap. + ///we would like to define the \ref ReachedMap. static ReachedMap *createReachedMap(const Digraph &g) { return new ReachedMap(g); @@ -96,13 +97,13 @@ ///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 meet the \ref concepts::WriteMap "WriteMap" concept. + ///It must conform to the \ref concepts::WriteMap "WriteMap" concept. typedef typename Digraph::template NodeMap DistMap; - ///Instantiates a DistMap. + ///Instantiates a \c DistMap. - ///This function instantiates a DistMap. + ///This function instantiates a \ref DistMap. ///\param g is the digraph, to which we would like to define the - ///DistMap. + ///\ref DistMap. static DistMap *createDistMap(const Digraph &g) { return new DistMap(g); @@ -206,7 +207,7 @@ typedef Dfs Create; - ///\name Named template parameters + ///\name Named Template Parameters ///@{ @@ -220,11 +221,11 @@ } }; ///\brief \ref named-templ-param "Named parameter" for setting - ///PredMap type. + ///\c PredMap type. /// ///\ref named-templ-param "Named parameter" for setting - ///PredMap type. - ///It must meet the \ref concepts::WriteMap "WriteMap" concept. + ///\c PredMap type. + ///It must conform to the \ref concepts::WriteMap "WriteMap" concept. template struct SetPredMap : public Dfs > { typedef Dfs > Create; @@ -240,11 +241,11 @@ } }; ///\brief \ref named-templ-param "Named parameter" for setting - ///DistMap type. + ///\c DistMap type. /// ///\ref named-templ-param "Named parameter" for setting - ///DistMap type. - ///It must meet the \ref concepts::WriteMap "WriteMap" concept. + ///\c DistMap type. + ///It must conform to the \ref concepts::WriteMap "WriteMap" concept. template struct SetDistMap : public Dfs< Digraph, SetDistMapTraits > { typedef Dfs > Create; @@ -260,11 +261,11 @@ } }; ///\brief \ref named-templ-param "Named parameter" for setting - ///ReachedMap type. + ///\c ReachedMap type. /// ///\ref named-templ-param "Named parameter" for setting - ///ReachedMap type. - ///It must meet the \ref concepts::ReadWriteMap "ReadWriteMap" concept. + ///\c ReachedMap type. + ///It must conform to the \ref concepts::ReadWriteMap "ReadWriteMap" concept. template struct SetReachedMap : public Dfs< Digraph, SetReachedMapTraits > { typedef Dfs< Digraph, SetReachedMapTraits > Create; @@ -280,11 +281,11 @@ } }; ///\brief \ref named-templ-param "Named parameter" for setting - ///ProcessedMap type. + ///\c ProcessedMap type. /// ///\ref named-templ-param "Named parameter" for setting - ///ProcessedMap type. - ///It must meet the \ref concepts::WriteMap "WriteMap" concept. + ///\c ProcessedMap type. + ///It must conform to the \ref concepts::WriteMap "WriteMap" concept. template struct SetProcessedMap : public Dfs< Digraph, SetProcessedMapTraits > { typedef Dfs< Digraph, SetProcessedMapTraits > Create; @@ -298,10 +299,10 @@ } }; ///\brief \ref named-templ-param "Named parameter" for setting - ///ProcessedMap type to be Digraph::NodeMap. + ///\c ProcessedMap type to be Digraph::NodeMap. /// ///\ref named-templ-param "Named parameter" for setting - ///ProcessedMap type to be Digraph::NodeMap. + ///\c ProcessedMap type to be Digraph::NodeMap. ///If you don't set it explicitly, it will be automatically allocated. struct SetStandardProcessedMap : public Dfs< Digraph, SetStandardProcessedMapTraits > { @@ -411,8 +412,8 @@ ///\name Execution Control ///The simplest way to execute the DFS algorithm is to use one of the ///member functions called \ref run(Node) "run()".\n - ///If you need more control on the execution, first you have to call - ///\ref init(), then you can add a source node with \ref addSource() + ///If you need better control on the execution, you have to call + ///\ref init() first, then you can add a source node with \ref addSource() ///and perform the actual computation with \ref start(). ///This procedure can be repeated if there are nodes that have not ///been reached. @@ -669,9 +670,9 @@ ///@{ - ///The DFS path to a node. + ///The DFS path to the given node. - ///Returns the DFS path to a node. + ///Returns the DFS path to the given node from the root(s). /// ///\warning \c t should be reached from the root(s). /// @@ -679,9 +680,9 @@ ///must be called before using this function. Path path(Node t) const { return Path(*G, *_pred, t); } - ///The distance of a node from the root(s). + ///The distance of the given node from the root(s). - ///Returns the distance of a 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. @@ -690,7 +691,7 @@ ///must be called before using this function. int dist(Node v) const { return (*_dist)[v]; } - ///Returns the 'previous arc' of the %DFS tree for a node. + ///Returns the 'previous arc' of the %DFS tree for the given node. ///This function returns the 'previous arc' of the %DFS tree for the ///node \c v, i.e. it returns the last arc of a %DFS path from a @@ -698,21 +699,21 @@ ///root(s) or if \c v is a root. /// ///The %DFS tree used here is equal to the %DFS tree used in - ///\ref predNode(). + ///\ref predNode() and \ref predMap(). /// ///\pre Either \ref run(Node) "run()" or \ref init() ///must be called before using this function. Arc predArc(Node v) const { return (*_pred)[v];} - ///Returns the 'previous node' of the %DFS tree. + ///Returns the 'previous node' of the %DFS tree for the given node. ///This function returns the 'previous node' of the %DFS ///tree for the node \c v, i.e. it returns the last but one node - ///from a %DFS path from a root to \c v. It is \c INVALID + ///of a %DFS path from a root to \c v. It is \c INVALID ///if \c v is not reached from the root(s) or if \c v is a root. /// ///The %DFS tree used here is equal to the %DFS tree used in - ///\ref predArc(). + ///\ref predArc() and \ref predMap(). /// ///\pre Either \ref run(Node) "run()" or \ref init() ///must be called before using this function. @@ -733,13 +734,13 @@ ///predecessor arcs. /// ///Returns a const reference to the node map that stores the predecessor - ///arcs, which form the DFS tree. + ///arcs, which form the DFS tree (forest). /// ///\pre Either \ref run(Node) "run()" or \ref init() ///must be called before using this function. const PredMap &predMap() const { return *_pred;} - ///Checks if a node is reached from the root(s). + ///Checks if the given node. node is reached from the root(s). ///Returns \c true if \c v is reached from the root(s). /// @@ -765,7 +766,7 @@ /// ///The type of the map that stores the predecessor ///arcs of the %DFS paths. - ///It must meet the \ref concepts::WriteMap "WriteMap" concept. + ///It must conform to the \ref concepts::WriteMap "WriteMap" concept. typedef typename Digraph::template NodeMap PredMap; ///Instantiates a PredMap. @@ -780,7 +781,7 @@ ///The type of the map that indicates which nodes are processed. ///The type of the map that indicates which nodes are processed. - ///It must meet the \ref concepts::WriteMap "WriteMap" concept. + ///It must conform to the \ref concepts::WriteMap "WriteMap" concept. ///By default it is a NullMap. typedef NullMap ProcessedMap; ///Instantiates a ProcessedMap. @@ -800,7 +801,7 @@ ///The type of the map that indicates which nodes are reached. ///The type of the map that indicates which nodes are reached. - ///It must meet the \ref concepts::ReadWriteMap "ReadWriteMap" concept. + ///It must conform to the \ref concepts::ReadWriteMap "ReadWriteMap" concept. typedef typename Digraph::template NodeMap ReachedMap; ///Instantiates a ReachedMap. @@ -815,7 +816,7 @@ ///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 meet the \ref concepts::WriteMap "WriteMap" concept. + ///It must conform to the \ref concepts::WriteMap "WriteMap" concept. typedef typename Digraph::template NodeMap DistMap; ///Instantiates a DistMap. @@ -830,18 +831,14 @@ ///The type of the DFS paths. ///The type of the DFS paths. - ///It must meet the \ref concepts::Path "Path" concept. + ///It must conform to the \ref concepts::Path "Path" concept. typedef lemon::Path Path; }; /// Default traits class used by DfsWizard - /// 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. + /// Default traits class used by DfsWizard. + /// \tparam GR The type of the digraph. template class DfsWizardBase : public DfsWizardDefaultTraits { @@ -869,7 +866,7 @@ public: /// Constructor. - /// This constructor does not require parameters, therefore it initiates + /// This constructor does not require parameters, it initiates /// all of the attributes to \c 0. DfsWizardBase() : _g(0), _reached(0), _processed(0), _pred(0), _dist(0), _path(0), _di(0) {} @@ -899,7 +896,6 @@ { typedef TR Base; - ///The type of the digraph the algorithm runs on. typedef typename TR::Digraph Digraph; typedef typename Digraph::Node Node; @@ -907,16 +903,10 @@ typedef typename Digraph::Arc Arc; 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; public: @@ -999,11 +989,12 @@ static PredMap *createPredMap(const Digraph &) { return 0; }; SetPredMapBase(const TR &b) : TR(b) {} }; - ///\brief \ref named-func-param "Named parameter" - ///for setting PredMap object. + + ///\brief \ref named-templ-param "Named parameter" for setting + ///the predecessor map. /// - ///\ref named-func-param "Named parameter" - ///for setting PredMap object. + ///\ref named-templ-param "Named parameter" function for setting + ///the map that stores the predecessor arcs of the nodes. template DfsWizard > predMap(const T &t) { @@ -1017,11 +1008,12 @@ static ReachedMap *createReachedMap(const Digraph &) { return 0; }; SetReachedMapBase(const TR &b) : TR(b) {} }; - ///\brief \ref named-func-param "Named parameter" - ///for setting ReachedMap object. + + ///\brief \ref named-templ-param "Named parameter" for setting + ///the reached map. /// - /// \ref named-func-param "Named parameter" - ///for setting ReachedMap object. + ///\ref named-templ-param "Named parameter" function for setting + ///the map that indicates which nodes are reached. template DfsWizard > reachedMap(const T &t) { @@ -1035,11 +1027,13 @@ static DistMap *createDistMap(const Digraph &) { return 0; }; SetDistMapBase(const TR &b) : TR(b) {} }; - ///\brief \ref named-func-param "Named parameter" - ///for setting DistMap object. + + ///\brief \ref named-templ-param "Named parameter" for setting + ///the distance map. /// - /// \ref named-func-param "Named parameter" - ///for setting DistMap object. + ///\ref named-templ-param "Named parameter" function for setting + ///the map that stores the distances of the nodes calculated + ///by the algorithm. template DfsWizard > distMap(const T &t) { @@ -1053,11 +1047,12 @@ static ProcessedMap *createProcessedMap(const Digraph &) { return 0; }; SetProcessedMapBase(const TR &b) : TR(b) {} }; - ///\brief \ref named-func-param "Named parameter" - ///for setting ProcessedMap object. + + ///\brief \ref named-func-param "Named parameter" for setting + ///the processed map. /// - /// \ref named-func-param "Named parameter" - ///for setting ProcessedMap object. + ///\ref named-templ-param "Named parameter" function for setting + ///the map that indicates which nodes are processed. template DfsWizard > processedMap(const T &t) { @@ -1126,9 +1121,9 @@ /// /// This class defines the interface of the DfsVisit events, and /// it could be the base of a real visitor class. - template + template struct DfsVisitor { - typedef _Digraph Digraph; + typedef GR Digraph; typedef typename Digraph::Arc Arc; typedef typename Digraph::Node Node; /// \brief Called for the source node of the DFS. @@ -1164,9 +1159,9 @@ void backtrack(const Arc& arc) {} }; #else - template + template struct DfsVisitor { - typedef _Digraph Digraph; + typedef GR Digraph; typedef typename Digraph::Arc Arc; typedef typename Digraph::Node Node; void start(const Node&) {} @@ -1199,16 +1194,16 @@ /// /// Default traits class of DfsVisit class. /// \tparam _Digraph The type of the digraph the algorithm runs on. - template + template struct DfsVisitDefaultTraits { /// \brief The type of the digraph the algorithm runs on. - typedef _Digraph Digraph; + typedef GR Digraph; /// \brief The type of the map that indicates which nodes are reached. /// /// The type of the map that indicates which nodes are reached. - /// It must meet the \ref concepts::ReadWriteMap "ReadWriteMap" concept. + /// It must conform to the \ref concepts::ReadWriteMap "ReadWriteMap" concept. typedef typename Digraph::template NodeMap ReachedMap; /// \brief Instantiates a ReachedMap. @@ -1224,12 +1219,12 @@ /// \ingroup search /// - /// \brief %DFS algorithm class with visitor interface. + /// \brief DFS algorithm class with visitor interface. /// - /// This class provides an efficient implementation of the %DFS algorithm + /// This class provides an efficient implementation of the DFS algorithm /// with visitor interface. /// - /// The %DfsVisit class provides an alternative interface to the Dfs + /// The DfsVisit class provides an alternative interface to the Dfs /// class. It works with callback mechanism, the DfsVisit object calls /// the member functions of the \c Visitor class on every DFS event. /// @@ -1238,37 +1233,37 @@ /// events of the DFS algorithm. Otherwise consider to use Dfs or dfs() /// instead. /// - /// \tparam _Digraph The type of the digraph the algorithm runs on. - /// The default value is - /// \ref ListDigraph. The value of _Digraph is not used directly by - /// \ref DfsVisit, it is only passed to \ref DfsVisitDefaultTraits. - /// \tparam _Visitor The Visitor type that is used by the algorithm. - /// \ref DfsVisitor "DfsVisitor<_Digraph>" is an empty visitor, which + /// \tparam GR The type of the digraph the algorithm runs on. + /// The default type is \ref ListDigraph. + /// The value of GR is not used directly by \ref DfsVisit, + /// it is only passed to \ref DfsVisitDefaultTraits. + /// \tparam VS The Visitor type that is used by the algorithm. + /// \ref DfsVisitor "DfsVisitor" is an empty visitor, which /// does not observe the DFS events. If you want to observe the DFS /// events, you should implement your own visitor class. - /// \tparam _Traits Traits class to set various data types used by the + /// \tparam TR Traits class to set various data types used by the /// algorithm. The default traits class is - /// \ref DfsVisitDefaultTraits "DfsVisitDefaultTraits<_Digraph>". + /// \ref DfsVisitDefaultTraits "DfsVisitDefaultTraits". /// See \ref DfsVisitDefaultTraits for the documentation of /// a DFS visit traits class. #ifdef DOXYGEN - template + template #else - template , - typename _Traits = DfsVisitDefaultTraits<_Digraph> > + template , + typename TR = DfsVisitDefaultTraits > #endif class DfsVisit { public: ///The traits class. - typedef _Traits Traits; + typedef TR Traits; ///The type of the digraph the algorithm runs on. typedef typename Traits::Digraph Digraph; ///The visitor type used by the algorithm. - typedef _Visitor Visitor; + typedef VS Visitor; ///The type of the map that indicates which nodes are reached. typedef typename Traits::ReachedMap ReachedMap; @@ -1369,8 +1364,8 @@ /// \name Execution Control /// The simplest way to execute the DFS algorithm is to use one of the /// member functions called \ref run(Node) "run()".\n - /// If you need more control on the execution, first you have to call - /// \ref init(), then you can add a source node with \ref addSource() + /// If you need better control on the execution, you have to call + /// \ref init() first, then you can add a source node with \ref addSource() /// and perform the actual computation with \ref start(). /// This procedure can be repeated if there are nodes that have not /// been reached. @@ -1620,7 +1615,7 @@ ///@{ - /// \brief Checks if a node is reached from the root(s). + /// \brief Checks if the given node is reached from the root(s). /// /// Returns \c true if \c v is reached from the root(s). /// diff -r c35afa9e89e7 -r ef88c0a30f85 lemon/dijkstra.h --- a/lemon/dijkstra.h Mon Jan 12 23:11:39 2009 +0100 +++ b/lemon/dijkstra.h Thu Nov 05 15:48:01 2009 +0100 @@ -38,8 +38,10 @@ /// /// This operation traits class defines all computational operations and /// constants which are used in the Dijkstra algorithm. - template + template struct DijkstraDefaultOperationTraits { + /// \e + typedef V Value; /// \brief Gives back the zero value of the type. static Value zero() { return static_cast(0); @@ -58,8 +60,8 @@ ///Default traits class of Dijkstra class. ///\tparam GR The type of the digraph. - ///\tparam LM The type of the length map. - template + ///\tparam LEN The type of the length map. + template struct DijkstraDefaultTraits { ///The type of the digraph the algorithm runs on. @@ -68,12 +70,12 @@ ///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 LM LengthMap; - ///The type of the length of the arcs. - typedef typename LM::Value Value; + ///It must conform to the \ref concepts::ReadMap "ReadMap" concept. + typedef LEN LengthMap; + ///The type of the arc lengths. + typedef typename LEN::Value Value; - /// Operation traits for Dijkstra algorithm. + /// Operation traits for %Dijkstra algorithm. /// This class defines the operations that are used in the algorithm. /// \see DijkstraDefaultOperationTraits @@ -84,7 +86,7 @@ /// The cross reference type used by the heap. /// Usually it is \c Digraph::NodeMap. typedef typename Digraph::template NodeMap HeapCrossRef; - ///Instantiates a \ref HeapCrossRef. + ///Instantiates a \c HeapCrossRef. ///This function instantiates a \ref HeapCrossRef. /// \param g is the digraph, to which we would like to define the @@ -94,14 +96,14 @@ return new HeapCrossRef(g); } - ///The heap type used by the Dijkstra algorithm. + ///The heap type used by the %Dijkstra algorithm. ///The heap type used by the Dijkstra algorithm. /// ///\sa BinHeap ///\sa Dijkstra - typedef BinHeap > Heap; - ///Instantiates a \ref Heap. + typedef BinHeap > Heap; + ///Instantiates a \c Heap. ///This function instantiates a \ref Heap. static Heap *createHeap(HeapCrossRef& r) @@ -114,13 +116,13 @@ /// ///The type of the map that stores the predecessor ///arcs of the shortest paths. - ///It must meet the \ref concepts::WriteMap "WriteMap" concept. + ///It must conform to the \ref concepts::WriteMap "WriteMap" concept. typedef typename Digraph::template NodeMap PredMap; - ///Instantiates a PredMap. + ///Instantiates a \c PredMap. - ///This function instantiates a PredMap. + ///This function instantiates a \ref PredMap. ///\param g is the digraph, to which we would like to define the - ///PredMap. + ///\ref PredMap. static PredMap *createPredMap(const Digraph &g) { return new PredMap(g); @@ -129,14 +131,14 @@ ///The type of the map that indicates which nodes are processed. ///The type of the map that indicates which nodes are processed. - ///It must meet the \ref concepts::WriteMap "WriteMap" concept. + ///It must conform to the \ref concepts::WriteMap "WriteMap" concept. ///By default it is a NullMap. typedef NullMap ProcessedMap; - ///Instantiates a ProcessedMap. + ///Instantiates a \c ProcessedMap. - ///This function instantiates a ProcessedMap. + ///This function instantiates a \ref ProcessedMap. ///\param g is the digraph, to which - ///we would like to define the ProcessedMap + ///we would like to define the \ref ProcessedMap. #ifdef DOXYGEN static ProcessedMap *createProcessedMap(const Digraph &g) #else @@ -149,13 +151,13 @@ ///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 meet the \ref concepts::WriteMap "WriteMap" concept. - typedef typename Digraph::template NodeMap DistMap; - ///Instantiates a DistMap. + ///It must conform to the \ref concepts::WriteMap "WriteMap" concept. + typedef typename Digraph::template NodeMap DistMap; + ///Instantiates a \c DistMap. - ///This function instantiates a DistMap. + ///This function instantiates a \ref DistMap. ///\param g is the digraph, to which we would like to define - ///the DistMap + ///the \ref DistMap. static DistMap *createDistMap(const Digraph &g) { return new DistMap(g); @@ -167,6 +169,10 @@ /// \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 ///\ref concepts::ReadMap "ReadMap", ///so it is easy to change it to any kind of length. @@ -180,18 +186,18 @@ /// ///\tparam GR The type of the digraph the algorithm runs on. ///The default type is \ref ListDigraph. - ///\tparam LM A \ref concepts::ReadMap "readable" arc map that specifies + ///\tparam LEN A \ref concepts::ReadMap "readable" arc map that specifies ///the lengths of the arcs. ///It is read once for each arc, so the map may involve in ///relatively time consuming process to compute the arc lengths if ///it is necessary. The default map type is \ref ///concepts::Digraph::ArcMap "GR::ArcMap". #ifdef DOXYGEN - template + template #else template , - typename TR=DijkstraDefaultTraits > + typename LEN=typename GR::template ArcMap, + typename TR=DijkstraDefaultTraits > #endif class Dijkstra { public: @@ -199,7 +205,7 @@ ///The type of the digraph the algorithm runs on. typedef typename TR::Digraph Digraph; - ///The type of the length of the arcs. + ///The type of the arc lengths. typedef typename TR::LengthMap::Value Value; ///The type of the map that stores the arc lengths. typedef typename TR::LengthMap LengthMap; @@ -216,7 +222,8 @@ typedef typename TR::HeapCrossRef HeapCrossRef; ///The heap type used by the algorithm. typedef typename TR::Heap Heap; - ///The operation traits class. + ///\brief The \ref DijkstraDefaultOperationTraits "operation traits class" + ///of the algorithm. typedef typename TR::OperationTraits OperationTraits; ///The \ref DijkstraDefaultTraits "traits class" of the algorithm. @@ -232,7 +239,7 @@ //Pointer to the underlying digraph. const Digraph *G; //Pointer to the length map. - const LengthMap *length; + const LengthMap *_length; //Pointer to the map of predecessors arcs. PredMap *_pred; //Indicates if _pred is locally allocated (true) or not. @@ -283,7 +290,7 @@ typedef Dijkstra Create; - ///\name Named template parameters + ///\name Named Template Parameters ///@{ @@ -297,11 +304,11 @@ } }; ///\brief \ref named-templ-param "Named parameter" for setting - ///PredMap type. + ///\c PredMap type. /// ///\ref named-templ-param "Named parameter" for setting - ///PredMap type. - ///It must meet the \ref concepts::WriteMap "WriteMap" concept. + ///\c PredMap type. + ///It must conform to the \ref concepts::WriteMap "WriteMap" concept. template struct SetPredMap : public Dijkstra< Digraph, LengthMap, SetPredMapTraits > { @@ -318,11 +325,11 @@ } }; ///\brief \ref named-templ-param "Named parameter" for setting - ///DistMap type. + ///\c DistMap type. /// ///\ref named-templ-param "Named parameter" for setting - ///DistMap type. - ///It must meet the \ref concepts::WriteMap "WriteMap" concept. + ///\c DistMap type. + ///It must conform to the \ref concepts::WriteMap "WriteMap" concept. template struct SetDistMap : public Dijkstra< Digraph, LengthMap, SetDistMapTraits > { @@ -339,11 +346,11 @@ } }; ///\brief \ref named-templ-param "Named parameter" for setting - ///ProcessedMap type. + ///\c ProcessedMap type. /// ///\ref named-templ-param "Named parameter" for setting - ///ProcessedMap type. - ///It must meet the \ref concepts::WriteMap "WriteMap" concept. + ///\c ProcessedMap type. + ///It must conform to the \ref concepts::WriteMap "WriteMap" concept. template struct SetProcessedMap : public Dijkstra< Digraph, LengthMap, SetProcessedMapTraits > { @@ -358,10 +365,10 @@ } }; ///\brief \ref named-templ-param "Named parameter" for setting - ///ProcessedMap type to be Digraph::NodeMap. + ///\c ProcessedMap type to be Digraph::NodeMap. /// ///\ref named-templ-param "Named parameter" for setting - ///ProcessedMap type to be Digraph::NodeMap. + ///\c ProcessedMap type to be Digraph::NodeMap. ///If you don't set it explicitly, it will be automatically allocated. struct SetStandardProcessedMap : public Dijkstra< Digraph, LengthMap, SetStandardProcessedMapTraits > { @@ -439,7 +446,8 @@ ///\c OperationTraits type /// ///\ref named-templ-param "Named parameter" for setting - ///\ref OperationTraits type. + ///\c OperationTraits type. + /// For more information see \ref DijkstraDefaultOperationTraits. template struct SetOperationTraits : public Dijkstra > { @@ -458,10 +466,10 @@ ///Constructor. ///Constructor. - ///\param _g The digraph the algorithm runs on. - ///\param _length The length map used by the algorithm. - Dijkstra(const Digraph& _g, const LengthMap& _length) : - G(&_g), length(&_length), + ///\param g The digraph the algorithm runs on. + ///\param length The length map used by the algorithm. + Dijkstra(const Digraph& g, const LengthMap& length) : + G(&g), _length(&length), _pred(NULL), local_pred(false), _dist(NULL), local_dist(false), _processed(NULL), local_processed(false), @@ -485,7 +493,7 @@ ///\return (*this) Dijkstra &lengthMap(const LengthMap &m) { - length = &m; + _length = &m; return *this; } @@ -581,8 +589,8 @@ ///\name Execution Control ///The simplest way to execute the %Dijkstra algorithm is to use ///one of the member functions called \ref run(Node) "run()".\n - ///If you need more control on the execution, first you have to call - ///\ref init(), then you can add several source nodes with + ///If you need better control on the execution, you have to call + ///\ref init() first, then you can add several source nodes with ///\ref addSource(). Finally the actual path computation can be ///performed with one of the \ref start() functions. @@ -638,12 +646,12 @@ Node w=G->target(e); switch(_heap->state(w)) { case Heap::PRE_HEAP: - _heap->push(w,OperationTraits::plus(oldvalue, (*length)[e])); + _heap->push(w,OperationTraits::plus(oldvalue, (*_length)[e])); _pred->set(w,e); break; case Heap::IN_HEAP: { - Value newvalue = OperationTraits::plus(oldvalue, (*length)[e]); + Value newvalue = OperationTraits::plus(oldvalue, (*_length)[e]); if ( OperationTraits::less(newvalue, (*_heap)[w]) ) { _heap->decrease(w, newvalue); _pred->set(w,e); @@ -798,14 +806,14 @@ ///\name Query Functions ///The results of the %Dijkstra algorithm can be obtained using these ///functions.\n - ///Either \ref run(Node) "run()" or \ref start() should be called + ///Either \ref run(Node) "run()" or \ref init() should be called ///before using them. ///@{ - ///The shortest path to a node. + ///The shortest path to the given node. - ///Returns the shortest path to a node. + ///Returns the shortest path to the given node from the root(s). /// ///\warning \c t should be reached from the root(s). /// @@ -813,9 +821,9 @@ ///must be called before using this function. Path path(Node t) const { return Path(*G, *_pred, t); } - ///The distance of a node from the root(s). + ///The distance of the given node from the root(s). - ///Returns the distance of a 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. @@ -824,29 +832,31 @@ ///must be called before using this function. Value dist(Node v) const { return (*_dist)[v]; } - ///Returns the 'previous arc' of the shortest path tree for a node. - + ///\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 the node \c v, i.e. it returns the last arc of a ///shortest path from a root to \c v. It is \c INVALID if \c v ///is not reached from the root(s) or if \c v is a root. /// ///The shortest path tree used here is equal to the shortest path - ///tree used in \ref predNode(). + ///tree used in \ref predNode() and \ref predMap(). /// ///\pre Either \ref run(Node) "run()" or \ref init() ///must be called before using this function. Arc predArc(Node v) const { return (*_pred)[v]; } - ///Returns the 'previous node' of the shortest path tree for a node. - + ///\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 the node \c v, i.e. it returns the last but one node - ///from a shortest path from a root to \c v. It is \c INVALID + ///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(). + ///tree used in \ref predArc() and \ref predMap(). /// ///\pre Either \ref run(Node) "run()" or \ref init() ///must be called before using this function. @@ -867,13 +877,13 @@ ///predecessor arcs. /// ///Returns a const reference to the node map that stores the predecessor - ///arcs, which form the shortest path tree. + ///arcs, which form the shortest path tree (forest). /// ///\pre Either \ref run(Node) "run()" or \ref init() ///must be called before using this function. const PredMap &predMap() const { return *_pred;} - ///Checks if a node is reached from the root(s). + ///Checks if the given node is reached from the root(s). ///Returns \c true if \c v is reached from the root(s). /// @@ -892,9 +902,9 @@ bool processed(Node v) const { return (*_heap_cross_ref)[v] == Heap::POST_HEAP; } - ///The current distance of a node from the root(s). + ///The current distance of the given node from the root(s). - ///Returns the current distance of a node from the root(s). + ///Returns the current distance of the given node from the root(s). ///It may be decreased in the following processes. /// ///\pre Either \ref run(Node) "run()" or \ref init() @@ -912,8 +922,8 @@ ///Default traits class of dijkstra() function. ///\tparam GR The type of the digraph. - ///\tparam LM The type of the length map. - template + ///\tparam LEN The type of the length map. + template struct DijkstraWizardDefaultTraits { ///The type of the digraph the algorithm runs on. @@ -921,10 +931,10 @@ ///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 LM LengthMap; - ///The type of the length of the arcs. - typedef typename LM::Value Value; + ///It must conform to the \ref concepts::ReadMap "ReadMap" concept. + typedef LEN LengthMap; + ///The type of the arc lengths. + typedef typename LEN::Value Value; /// Operation traits for Dijkstra algorithm. @@ -970,7 +980,7 @@ /// ///The type of the map that stores the predecessor ///arcs of the shortest paths. - ///It must meet the \ref concepts::WriteMap "WriteMap" concept. + ///It must conform to the \ref concepts::WriteMap "WriteMap" concept. typedef typename Digraph::template NodeMap PredMap; ///Instantiates a PredMap. @@ -985,7 +995,7 @@ ///The type of the map that indicates which nodes are processed. ///The type of the map that indicates which nodes are processed. - ///It must meet the \ref concepts::WriteMap "WriteMap" concept. + ///It must conform to the \ref concepts::WriteMap "WriteMap" concept. ///By default it is a NullMap. typedef NullMap ProcessedMap; ///Instantiates a ProcessedMap. @@ -1005,8 +1015,8 @@ ///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 meet the \ref concepts::WriteMap "WriteMap" concept. - typedef typename Digraph::template NodeMap DistMap; + ///It must conform to the \ref concepts::WriteMap "WriteMap" concept. + typedef typename Digraph::template NodeMap DistMap; ///Instantiates a DistMap. ///This function instantiates a DistMap. @@ -1020,22 +1030,19 @@ ///The type of the shortest paths. ///The type of the shortest paths. - ///It must meet the \ref concepts::Path "Path" concept. + ///It must conform to the \ref concepts::Path "Path" concept. typedef lemon::Path Path; }; /// Default traits class used by DijkstraWizard - /// 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 + /// Default traits class used by DijkstraWizard. + /// \tparam GR The type of the digraph. + /// \tparam LEN The type of the length map. + template + class DijkstraWizardBase : public DijkstraWizardDefaultTraits { - typedef DijkstraWizardDefaultTraits Base; + typedef DijkstraWizardDefaultTraits Base; protected: //The type of the nodes in the digraph. typedef typename Base::Digraph::Node Node; @@ -1069,9 +1076,9 @@ /// others are initiated to \c 0. /// \param g The digraph the algorithm runs on. /// \param l The length map. - DijkstraWizardBase(const GR &g,const LM &l) : + DijkstraWizardBase(const GR &g,const LEN &l) : _g(reinterpret_cast(const_cast(&g))), - _length(reinterpret_cast(const_cast(&l))), + _length(reinterpret_cast(const_cast(&l))), _processed(0), _pred(0), _dist(0), _path(0), _di(0) {} }; @@ -1090,7 +1097,6 @@ { typedef TR Base; - ///The type of the digraph the algorithm runs on. typedef typename TR::Digraph Digraph; typedef typename Digraph::Node Node; @@ -1098,20 +1104,12 @@ typedef typename Digraph::Arc Arc; 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; public: @@ -1183,11 +1181,12 @@ static PredMap *createPredMap(const Digraph &) { return 0; }; SetPredMapBase(const TR &b) : TR(b) {} }; - ///\brief \ref named-func-param "Named parameter" - ///for setting PredMap object. + + ///\brief \ref named-templ-param "Named parameter" for setting + ///the predecessor map. /// - ///\ref named-func-param "Named parameter" - ///for setting PredMap object. + ///\ref named-templ-param "Named parameter" function for setting + ///the map that stores the predecessor arcs of the nodes. template DijkstraWizard > predMap(const T &t) { @@ -1201,11 +1200,13 @@ static DistMap *createDistMap(const Digraph &) { return 0; }; SetDistMapBase(const TR &b) : TR(b) {} }; - ///\brief \ref named-func-param "Named parameter" - ///for setting DistMap object. + + ///\brief \ref named-templ-param "Named parameter" for setting + ///the distance map. /// - ///\ref named-func-param "Named parameter" - ///for setting DistMap object. + ///\ref named-templ-param "Named parameter" function for setting + ///the map that stores the distances of the nodes calculated + ///by the algorithm. template DijkstraWizard > distMap(const T &t) { @@ -1219,11 +1220,12 @@ static ProcessedMap *createProcessedMap(const Digraph &) { return 0; }; SetProcessedMapBase(const TR &b) : TR(b) {} }; - ///\brief \ref named-func-param "Named parameter" - ///for setting ProcessedMap object. + + ///\brief \ref named-func-param "Named parameter" for setting + ///the processed map. /// - /// \ref named-func-param "Named parameter" - ///for setting ProcessedMap object. + ///\ref named-templ-param "Named parameter" function for setting + ///the map that indicates which nodes are processed. template DijkstraWizard > processedMap(const T &t) { @@ -1236,6 +1238,7 @@ 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. /// @@ -1280,11 +1283,11 @@ ///to the end of the parameter list. ///\sa DijkstraWizard ///\sa Dijkstra - template - DijkstraWizard > - dijkstra(const GR &digraph, const LM &length) + template + DijkstraWizard > + dijkstra(const GR &digraph, const LEN &length) { - return DijkstraWizard >(digraph,length); + return DijkstraWizard >(digraph,length); } } //END OF NAMESPACE LEMON diff -r c35afa9e89e7 -r ef88c0a30f85 lemon/dim2.h --- a/lemon/dim2.h Mon Jan 12 23:11:39 2009 +0100 +++ b/lemon/dim2.h Thu Nov 05 15:48:01 2009 +0100 @@ -21,16 +21,9 @@ #include -///\ingroup misc +///\ingroup geomdat ///\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 { @@ -40,7 +33,7 @@ ///tools for handling two dimensional coordinates namespace dim2 { - /// \addtogroup misc + /// \addtogroup geomdat /// @{ /// Two dimensional vector (plain vector) diff -r c35afa9e89e7 -r ef88c0a30f85 lemon/dimacs.h --- a/lemon/dimacs.h Mon Jan 12 23:11:39 2009 +0100 +++ b/lemon/dimacs.h Thu Nov 05 15:48:01 2009 +0100 @@ -22,9 +22,9 @@ #include #include #include +#include #include #include - /// \ingroup dimacs_group /// \file /// \brief DIMACS file format reader. @@ -37,11 +37,16 @@ /// DIMACS file type descriptor. struct DimacsDescriptor { - ///File type enum - enum Type - { - NONE, MIN, MAX, SP, MAT - }; + ///\brief DIMACS file type enum + /// + ///DIMACS file type enum. + enum Type { + NONE, ///< Undefined type. + MIN, ///< DIMACS file type for minimum cost flow problems. + MAX, ///< DIMACS file type for maximum flow problems. + SP, ///< DIMACS file type for shostest path problems. + MAT ///< DIMACS file type for plain graphs and matching problems. + }; ///The file type Type type; ///The number of nodes in the graph @@ -49,16 +54,16 @@ ///The number of edges in the graph int edgeNum; int lineShift; - /// Constructor. Sets the type to NONE. + ///Constructor. It sets the type to \c NONE. DimacsDescriptor() : type(NONE) {} }; ///Discover the type of a DIMACS file - ///It starts seeking the begining of the file for the problem type - ///and size info. The found data is returned in a special struct - ///that can be evaluated and passed to the appropriate reader - ///function. + ///This function starts seeking the beginning of the given file for the + ///problem type and size info. + ///The found data is returned in a special struct that can be evaluated + ///and passed to the appropriate reader function. DimacsDescriptor dimacsType(std::istream& is) { DimacsDescriptor r; @@ -96,8 +101,7 @@ } - - /// DIMACS minimum cost flow reader function. + /// \brief DIMACS minimum cost flow reader function. /// /// This function reads a minimum cost flow instance from DIMACS format, /// i.e. from a DIMACS file having a line starting with @@ -105,9 +109,17 @@ /// p min /// \endcode /// At the beginning, \c g is cleared by \c g.clear(). The supply - /// amount of the nodes are written to \c supply (signed). The - /// lower bounds, capacities and costs of the arcs are written to - /// \c lower, \c capacity and \c cost. + /// amount of the nodes are written to the \c supply node map + /// (they are signed values). The lower bounds, capacities and costs + /// of the arcs are written to the \c lower, \c capacity and \c cost + /// arc maps. + /// + /// If the capacity of an arc is less than the lower bound, it will + /// be set to "infinite" instead. The actual value of "infinite" is + /// contolled by the \c infty parameter. If it is 0 (the default value), + /// \c std::numeric_limits::infinity() will be used if available, + /// \c std::numeric_limits::max() otherwise. If \c infty is set to + /// a non-zero value, that value will be used as "infinite". /// /// If the file type was previously evaluated by dimacsType(), then /// the descriptor struct should be given by the \c dest parameter. @@ -120,6 +132,7 @@ CapacityMap& capacity, CostMap& cost, SupplyMap& supply, + typename CapacityMap::Value infty = 0, DimacsDescriptor desc=DimacsDescriptor()) { g.clear(); @@ -142,6 +155,12 @@ typename CapacityMap::Value low; typename CapacityMap::Value cap; typename CostMap::Value co; + typedef typename CapacityMap::Value Capacity; + if(infty==0) + infty = std::numeric_limits::has_infinity ? + std::numeric_limits::infinity() : + std::numeric_limits::max(); + while (is >> c) { switch (c) { case 'c': // comment line @@ -152,15 +171,15 @@ getline(is, str); supply.set(nodes[i], sup); break; - case 'a': // arc (arc) definition line + case 'a': // arc definition line is >> i >> j >> low >> cap >> co; getline(is, str); e = g.addArc(nodes[i], nodes[j]); lower.set(e, low); - if (cap >= 0) + if (cap >= low) capacity.set(e, cap); else - capacity.set(e, -1); + capacity.set(e, infty); cost.set(e, co); break; } @@ -173,6 +192,7 @@ CapacityMap& capacity, typename Digraph::Node &s, typename Digraph::Node &t, + typename CapacityMap::Value infty = 0, DimacsDescriptor desc=DimacsDescriptor()) { g.clear(); s=t=INVALID; @@ -186,7 +206,13 @@ for (int k = 1; k <= desc.nodeNum; ++k) { nodes[k] = g.addNode(); } + typedef typename CapacityMap::Value Capacity; + if(infty==0) + infty = std::numeric_limits::has_infinity ? + std::numeric_limits::infinity() : + std::numeric_limits::max(); + while (is >> c) { switch (c) { case 'c': // comment line @@ -205,14 +231,23 @@ if (d == 't') t = nodes[i]; } break; - case 'a': // arc (arc) definition line - if (desc.type==DimacsDescriptor::SP || - desc.type==DimacsDescriptor::MAX) { + case 'a': // arc definition line + if (desc.type==DimacsDescriptor::SP) { is >> i >> j >> _cap; getline(is, str); e = g.addArc(nodes[i], nodes[j]); capacity.set(e, _cap); - } else { + } + else if (desc.type==DimacsDescriptor::MAX) { + is >> i >> j >> _cap; + getline(is, str); + e = g.addArc(nodes[i], nodes[j]); + if (_cap >= 0) + capacity.set(e, _cap); + else + capacity.set(e, infty); + } + else { is >> i >> j; getline(is, str); g.addArc(nodes[i], nodes[j]); @@ -222,7 +257,7 @@ } } - /// DIMACS maximum flow reader function. + /// \brief DIMACS maximum flow reader function. /// /// This function reads a maximum flow instance from DIMACS format, /// i.e. from a DIMACS file having a line starting with @@ -230,8 +265,15 @@ /// p max /// \endcode /// At the beginning, \c g is cleared by \c g.clear(). The arc - /// capacities are written to \c capacity and \c s and \c t are - /// set to the source and the target nodes. + /// capacities are written to the \c capacity arc map and \c s and + /// \c t are set to the source and the target nodes. + /// + /// If the capacity of an arc is negative, it will + /// be set to "infinite" instead. The actual value of "infinite" is + /// contolled by the \c infty parameter. If it is 0 (the default value), + /// \c std::numeric_limits::infinity() will be used if available, + /// \c std::numeric_limits::max() otherwise. If \c infty is set to + /// a non-zero value, that value will be used as "infinite". /// /// If the file type was previously evaluated by dimacsType(), then /// the descriptor struct should be given by the \c dest parameter. @@ -241,14 +283,15 @@ CapacityMap& capacity, typename Digraph::Node &s, typename Digraph::Node &t, + typename CapacityMap::Value infty = 0, DimacsDescriptor desc=DimacsDescriptor()) { if(desc.type==DimacsDescriptor::NONE) desc=dimacsType(is); if(desc.type!=DimacsDescriptor::MAX) throw FormatError("Problem type mismatch"); - _readDimacs(is,g,capacity,s,t,desc); + _readDimacs(is,g,capacity,s,t,infty,desc); } - /// DIMACS shortest path reader function. + /// \brief DIMACS shortest path reader function. /// /// This function reads a shortest path instance from DIMACS format, /// i.e. from a DIMACS file having a line starting with @@ -256,7 +299,7 @@ /// p sp /// \endcode /// At the beginning, \c g is cleared by \c g.clear(). The arc - /// lengths are written to \c length and \c s is set to the + /// lengths are written to the \c length arc map and \c s is set to the /// source node. /// /// If the file type was previously evaluated by dimacsType(), then @@ -271,15 +314,24 @@ if(desc.type==DimacsDescriptor::NONE) desc=dimacsType(is); if(desc.type!=DimacsDescriptor::SP) throw FormatError("Problem type mismatch"); - _readDimacs(is, g, length, s, t,desc); + _readDimacs(is, g, length, s, t, 0, desc); } - /// DIMACS capacitated digraph reader function. + /// \brief DIMACS capacitated digraph reader function. /// /// This function reads an arc capacitated digraph instance from - /// DIMACS 'mat' or 'sp' format. + /// DIMACS 'max' or 'sp' format. /// At the beginning, \c g is cleared by \c g.clear() - /// and the arc capacities/lengths are written to \c capacity. + /// and the arc capacities/lengths are written to the \c capacity + /// arc map. + /// + /// In case of the 'max' format, if the capacity of an arc is negative, + /// it will + /// be set to "infinite" instead. The actual value of "infinite" is + /// contolled by the \c infty parameter. If it is 0 (the default value), + /// \c std::numeric_limits::infinity() will be used if available, + /// \c std::numeric_limits::max() otherwise. If \c infty is set to + /// a non-zero value, that value will be used as "infinite". /// /// If the file type was previously evaluated by dimacsType(), then /// the descriptor struct should be given by the \c dest parameter. @@ -287,19 +339,35 @@ void readDimacsCap(std::istream& is, Digraph &g, CapacityMap& capacity, + typename CapacityMap::Value infty = 0, DimacsDescriptor desc=DimacsDescriptor()) { typename Digraph::Node u,v; if(desc.type==DimacsDescriptor::NONE) desc=dimacsType(is); if(desc.type!=DimacsDescriptor::MAX || desc.type!=DimacsDescriptor::SP) throw FormatError("Problem type mismatch"); - _readDimacs(is, g, capacity, u, v, desc); + _readDimacs(is, g, capacity, u, v, infty, desc); } - /// DIMACS plain digraph reader function. + template + typename enable_if,void>::type + _addArcEdge(Graph &g, typename Graph::Node s, typename Graph::Node t, + dummy<0> = 0) + { + g.addEdge(s,t); + } + template + typename disable_if,void>::type + _addArcEdge(Graph &g, typename Graph::Node s, typename Graph::Node t, + dummy<1> = 1) + { + g.addArc(s,t); + } + + /// \brief DIMACS plain (di)graph reader function. /// - /// This function reads a digraph without any designated nodes and - /// maps from DIMACS format, i.e. from DIMACS files having a line - /// starting with + /// This function reads a plain (di)graph without any designated nodes + /// and maps (e.g. a matching instance) from DIMACS format, i.e. from + /// DIMACS files having a line starting with /// \code /// p mat /// \endcode @@ -307,15 +375,38 @@ /// /// If the file type was previously evaluated by dimacsType(), then /// the descriptor struct should be given by the \c dest parameter. - template - void readDimacsMat(std::istream& is, Digraph &g, - DimacsDescriptor desc=DimacsDescriptor()) { - typename Digraph::Node u,v; - NullMap n; + template + void readDimacsMat(std::istream& is, Graph &g, + DimacsDescriptor desc=DimacsDescriptor()) + { if(desc.type==DimacsDescriptor::NONE) desc=dimacsType(is); if(desc.type!=DimacsDescriptor::MAT) throw FormatError("Problem type mismatch"); - _readDimacs(is, g, n, u, v, desc); + + g.clear(); + std::vector nodes; + char c; + int i, j; + std::string str; + nodes.resize(desc.nodeNum + 1); + for (int k = 1; k <= desc.nodeNum; ++k) { + nodes[k] = g.addNode(); + } + + while (is >> c) { + switch (c) { + case 'c': // comment line + getline(is, str); + break; + case 'n': // node definition line + break; + case 'a': // arc definition line + is >> i >> j; + getline(is, str); + _addArcEdge(g,nodes[i], nodes[j]); + break; + } + } } /// DIMACS plain digraph writer function. diff -r c35afa9e89e7 -r ef88c0a30f85 lemon/edge_set.h --- a/lemon/edge_set.h Mon Jan 12 23:11:39 2009 +0100 +++ b/lemon/edge_set.h Thu Nov 05 15:48:01 2009 +0100 @@ -22,20 +22,19 @@ #include #include -/// \ingroup semi_adaptors +/// \ingroup graphs /// \file /// \brief ArcSet and EdgeSet classes. /// /// Graphs which use another graph's node-set as own. namespace lemon { - template + template class ListArcSetBase { public: - typedef _Graph Graph; - typedef typename Graph::Node Node; - typedef typename Graph::NodeIt NodeIt; + typedef typename GR::Node Node; + typedef typename GR::NodeIt NodeIt; protected: @@ -44,10 +43,10 @@ NodeT() : first_out(-1), first_in(-1) {} }; - typedef typename ItemSetTraits:: + typedef typename ItemSetTraits:: template Map::Type NodesImplBase; - NodesImplBase* nodes; + NodesImplBase* _nodes; struct ArcT { Node source, target; @@ -61,17 +60,17 @@ int first_arc; int first_free_arc; - const Graph* graph; + const GR* _graph; - void initalize(const Graph& _graph, NodesImplBase& _nodes) { - graph = &_graph; - nodes = &_nodes; + void initalize(const GR& graph, NodesImplBase& nodes) { + _graph = &graph; + _nodes = &nodes; } public: class Arc { - friend class ListArcSetBase; + friend class ListArcSetBase; protected: Arc(int _id) : id(_id) {} int id; @@ -85,6 +84,12 @@ ListArcSetBase() : first_arc(-1), first_free_arc(-1) {} + Node addNode() { + LEMON_ASSERT(false, + "This graph structure does not support node insertion"); + return INVALID; // avoid warning + } + Arc addArc(const Node& u, const Node& v) { int n; if (first_free_arc == -1) { @@ -94,16 +99,16 @@ n = first_free_arc; first_free_arc = arcs[first_free_arc].next_in; } - arcs[n].next_in = (*nodes)[v].first_in; - if ((*nodes)[v].first_in != -1) { - arcs[(*nodes)[v].first_in].prev_in = n; + arcs[n].next_in = (*_nodes)[v].first_in; + if ((*_nodes)[v].first_in != -1) { + arcs[(*_nodes)[v].first_in].prev_in = n; } - (*nodes)[v].first_in = n; - arcs[n].next_out = (*nodes)[u].first_out; - if ((*nodes)[u].first_out != -1) { - arcs[(*nodes)[u].first_out].prev_out = n; + (*_nodes)[v].first_in = n; + arcs[n].next_out = (*_nodes)[u].first_out; + if ((*_nodes)[u].first_out != -1) { + arcs[(*_nodes)[u].first_out].prev_out = n; } - (*nodes)[u].first_out = n; + (*_nodes)[u].first_out = n; arcs[n].source = u; arcs[n].target = v; return Arc(n); @@ -114,7 +119,7 @@ if (arcs[n].prev_in != -1) { arcs[arcs[n].prev_in].next_in = arcs[n].next_in; } else { - (*nodes)[arcs[n].target].first_in = arcs[n].next_in; + (*_nodes)[arcs[n].target].first_in = arcs[n].next_in; } if (arcs[n].next_in != -1) { arcs[arcs[n].next_in].prev_in = arcs[n].prev_in; @@ -123,7 +128,7 @@ if (arcs[n].prev_out != -1) { arcs[arcs[n].prev_out].next_out = arcs[n].next_out; } else { - (*nodes)[arcs[n].source].first_out = arcs[n].next_out; + (*_nodes)[arcs[n].source].first_out = arcs[n].next_out; } if (arcs[n].next_out != -1) { arcs[arcs[n].next_out].prev_out = arcs[n].prev_out; @@ -134,8 +139,8 @@ void clear() { Node node; for (first(node); node != INVALID; next(node)) { - (*nodes)[node].first_in = -1; - (*nodes)[node].first_out = -1; + (*_nodes)[node].first_in = -1; + (*_nodes)[node].first_out = -1; } arcs.clear(); first_arc = -1; @@ -143,20 +148,20 @@ } void first(Node& node) const { - graph->first(node); + _graph->first(node); } void next(Node& node) const { - graph->next(node); + _graph->next(node); } void first(Arc& arc) const { Node node; first(node); - while (node != INVALID && (*nodes)[node].first_in == -1) { + while (node != INVALID && (*_nodes)[node].first_in == -1) { next(node); } - arc.id = (node == INVALID) ? -1 : (*nodes)[node].first_in; + arc.id = (node == INVALID) ? -1 : (*_nodes)[node].first_in; } void next(Arc& arc) const { @@ -165,15 +170,15 @@ } else { Node node = arcs[arc.id].target; next(node); - while (node != INVALID && (*nodes)[node].first_in == -1) { + while (node != INVALID && (*_nodes)[node].first_in == -1) { next(node); } - arc.id = (node == INVALID) ? -1 : (*nodes)[node].first_in; + arc.id = (node == INVALID) ? -1 : (*_nodes)[node].first_in; } } void firstOut(Arc& arc, const Node& node) const { - arc.id = (*nodes)[node].first_out; + arc.id = (*_nodes)[node].first_out; } void nextOut(Arc& arc) const { @@ -181,42 +186,42 @@ } void firstIn(Arc& arc, const Node& node) const { - arc.id = (*nodes)[node].first_in; + arc.id = (*_nodes)[node].first_in; } void nextIn(Arc& arc) const { arc.id = arcs[arc.id].next_in; } - int id(const Node& node) const { return graph->id(node); } + int id(const Node& node) const { return _graph->id(node); } int id(const Arc& arc) const { return arc.id; } - Node nodeFromId(int ix) const { return graph->nodeFromId(ix); } + Node nodeFromId(int ix) const { return _graph->nodeFromId(ix); } Arc arcFromId(int ix) const { return Arc(ix); } - int maxNodeId() const { return graph->maxNodeId(); }; + int maxNodeId() const { return _graph->maxNodeId(); }; int maxArcId() const { return arcs.size() - 1; } Node source(const Arc& arc) const { return arcs[arc.id].source;} Node target(const Arc& arc) const { return arcs[arc.id].target;} - typedef typename ItemSetTraits::ItemNotifier NodeNotifier; + typedef typename ItemSetTraits::ItemNotifier NodeNotifier; NodeNotifier& notifier(Node) const { - return graph->notifier(Node()); + return _graph->notifier(Node()); } - template - class NodeMap : public Graph::template NodeMap<_Value> { + template + class NodeMap : public GR::template NodeMap { + typedef typename GR::template NodeMap Parent; + public: - typedef typename _Graph::template NodeMap<_Value> Parent; + explicit NodeMap(const ListArcSetBase& arcset) + : Parent(*arcset._graph) {} - explicit NodeMap(const ListArcSetBase& arcset) - : Parent(*arcset.graph) {} - - NodeMap(const ListArcSetBase& arcset, const _Value& value) - : Parent(*arcset.graph, value) {} + NodeMap(const ListArcSetBase& arcset, const V& value) + : Parent(*arcset._graph, value) {} NodeMap& operator=(const NodeMap& cmap) { return operator=(cmap); @@ -231,7 +236,7 @@ }; - /// \ingroup semi_adaptors + /// \ingroup graphs /// /// \brief Digraph using a node set of another digraph or graph and /// an own arc set. @@ -250,26 +255,22 @@ /// that node can be removed from the underlying graph, in this case /// all arcs incident to the given node is erased from the arc set. /// - /// \param _Graph The type of the graph which shares its node set with + /// \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 is fully conform to the \ref concepts::Digraph + /// This class fully conforms to the \ref concepts::Digraph /// "Digraph" concept. - template - class ListArcSet : public ArcSetExtender > { + template + class ListArcSet : public ArcSetExtender > { + typedef ArcSetExtender > Parent; public: - typedef ArcSetExtender > Parent; - typedef typename Parent::Node Node; typedef typename Parent::Arc Arc; - typedef _Graph Graph; - - typedef typename Parent::NodesImplBase NodesImplBase; void eraseNode(const Node& node) { @@ -292,10 +293,10 @@ } class NodesImpl : public NodesImplBase { - public: typedef NodesImplBase Parent; - NodesImpl(const Graph& graph, ListArcSet& arcset) + public: + NodesImpl(const GR& graph, ListArcSet& arcset) : Parent(graph), _arcset(arcset) {} virtual ~NodesImpl() {} @@ -321,22 +322,22 @@ ListArcSet& _arcset; }; - NodesImpl nodes; + NodesImpl _nodes; public: /// \brief Constructor of the ArcSet. /// /// Constructor of the ArcSet. - ListArcSet(const Graph& graph) : nodes(graph, *this) { - Parent::initalize(graph, nodes); + ListArcSet(const GR& graph) : _nodes(graph, *this) { + Parent::initalize(graph, _nodes); } /// \brief Add a new arc to the digraph. /// /// Add a new arc to the digraph with source node \c s /// and target node \c t. - /// \return the new arc. + /// \return The new arc. Arc addArc(const Node& s, const Node& t) { return Parent::addArc(s, t); } @@ -350,13 +351,12 @@ }; - template + template class ListEdgeSetBase { public: - typedef _Graph Graph; - typedef typename Graph::Node Node; - typedef typename Graph::NodeIt NodeIt; + typedef typename GR::Node Node; + typedef typename GR::NodeIt NodeIt; protected: @@ -365,10 +365,10 @@ NodeT() : first_out(-1) {} }; - typedef typename ItemSetTraits:: + typedef typename ItemSetTraits:: template Map::Type NodesImplBase; - NodesImplBase* nodes; + NodesImplBase* _nodes; struct ArcT { Node target; @@ -381,11 +381,11 @@ int first_arc; int first_free_arc; - const Graph* graph; + const GR* _graph; - void initalize(const Graph& _graph, NodesImplBase& _nodes) { - graph = &_graph; - nodes = &_nodes; + void initalize(const GR& graph, NodesImplBase& nodes) { + _graph = &graph; + _nodes = &nodes; } public: @@ -422,6 +422,12 @@ ListEdgeSetBase() : first_arc(-1), first_free_arc(-1) {} + Node addNode() { + LEMON_ASSERT(false, + "This graph structure does not support node insertion"); + return INVALID; // avoid warning + } + Edge addEdge(const Node& u, const Node& v) { int n; @@ -437,18 +443,18 @@ arcs[n].target = u; arcs[n | 1].target = v; - arcs[n].next_out = (*nodes)[v].first_out; - if ((*nodes)[v].first_out != -1) { - arcs[(*nodes)[v].first_out].prev_out = n; + arcs[n].next_out = (*_nodes)[v].first_out; + if ((*_nodes)[v].first_out != -1) { + arcs[(*_nodes)[v].first_out].prev_out = n; } - (*nodes)[v].first_out = n; + (*_nodes)[v].first_out = n; arcs[n].prev_out = -1; - if ((*nodes)[u].first_out != -1) { - arcs[(*nodes)[u].first_out].prev_out = (n | 1); + if ((*_nodes)[u].first_out != -1) { + arcs[(*_nodes)[u].first_out].prev_out = (n | 1); } - arcs[n | 1].next_out = (*nodes)[u].first_out; - (*nodes)[u].first_out = (n | 1); + arcs[n | 1].next_out = (*_nodes)[u].first_out; + (*_nodes)[u].first_out = (n | 1); arcs[n | 1].prev_out = -1; return Edge(n / 2); @@ -464,7 +470,7 @@ if (arcs[n].prev_out != -1) { arcs[arcs[n].prev_out].next_out = arcs[n].next_out; } else { - (*nodes)[arcs[n | 1].target].first_out = arcs[n].next_out; + (*_nodes)[arcs[n | 1].target].first_out = arcs[n].next_out; } if (arcs[n | 1].next_out != -1) { @@ -474,7 +480,7 @@ if (arcs[n | 1].prev_out != -1) { arcs[arcs[n | 1].prev_out].next_out = arcs[n | 1].next_out; } else { - (*nodes)[arcs[n].target].first_out = arcs[n | 1].next_out; + (*_nodes)[arcs[n].target].first_out = arcs[n | 1].next_out; } arcs[n].next_out = first_free_arc; @@ -485,7 +491,7 @@ void clear() { Node node; for (first(node); node != INVALID; next(node)) { - (*nodes)[node].first_out = -1; + (*_nodes)[node].first_out = -1; } arcs.clear(); first_arc = -1; @@ -493,20 +499,20 @@ } void first(Node& node) const { - graph->first(node); + _graph->first(node); } void next(Node& node) const { - graph->next(node); + _graph->next(node); } void first(Arc& arc) const { Node node; first(node); - while (node != INVALID && (*nodes)[node].first_out == -1) { + while (node != INVALID && (*_nodes)[node].first_out == -1) { next(node); } - arc.id = (node == INVALID) ? -1 : (*nodes)[node].first_out; + arc.id = (node == INVALID) ? -1 : (*_nodes)[node].first_out; } void next(Arc& arc) const { @@ -515,10 +521,10 @@ } else { Node node = arcs[arc.id ^ 1].target; next(node); - while(node != INVALID && (*nodes)[node].first_out == -1) { + while(node != INVALID && (*_nodes)[node].first_out == -1) { next(node); } - arc.id = (node == INVALID) ? -1 : (*nodes)[node].first_out; + arc.id = (node == INVALID) ? -1 : (*_nodes)[node].first_out; } } @@ -526,7 +532,7 @@ Node node; first(node); while (node != INVALID) { - edge.id = (*nodes)[node].first_out; + edge.id = (*_nodes)[node].first_out; while ((edge.id & 1) != 1) { edge.id = arcs[edge.id].next_out; } @@ -551,7 +557,7 @@ } next(node); while (node != INVALID) { - edge.id = (*nodes)[node].first_out; + edge.id = (*_nodes)[node].first_out; while ((edge.id & 1) != 1) { edge.id = arcs[edge.id].next_out; } @@ -565,7 +571,7 @@ } void firstOut(Arc& arc, const Node& node) const { - arc.id = (*nodes)[node].first_out; + arc.id = (*_nodes)[node].first_out; } void nextOut(Arc& arc) const { @@ -573,7 +579,7 @@ } void firstIn(Arc& arc, const Node& node) const { - arc.id = (((*nodes)[node].first_out) ^ 1); + arc.id = (((*_nodes)[node].first_out) ^ 1); if (arc.id == -2) arc.id = -1; } @@ -583,7 +589,7 @@ } void firstInc(Edge &arc, bool& dir, const Node& node) const { - int de = (*nodes)[node].first_out; + int de = (*_nodes)[node].first_out; if (de != -1 ) { arc.id = de / 2; dir = ((de & 1) == 1); @@ -611,15 +617,15 @@ return Arc(edge.id * 2 + (dir ? 1 : 0)); } - int id(const Node& node) const { return graph->id(node); } + int id(const Node& node) const { return _graph->id(node); } static int id(Arc e) { return e.id; } static int id(Edge e) { return e.id; } - Node nodeFromId(int id) const { return graph->nodeFromId(id); } + Node nodeFromId(int id) const { return _graph->nodeFromId(id); } static Arc arcFromId(int id) { return Arc(id);} static Edge edgeFromId(int id) { return Edge(id);} - int maxNodeId() const { return graph->maxNodeId(); }; + int maxNodeId() const { return _graph->maxNodeId(); }; int maxEdgeId() const { return arcs.size() / 2 - 1; } int maxArcId() const { return arcs.size()-1; } @@ -629,23 +635,23 @@ Node u(Edge e) const { return arcs[2 * e.id].target; } Node v(Edge e) const { return arcs[2 * e.id + 1].target; } - typedef typename ItemSetTraits::ItemNotifier NodeNotifier; + typedef typename ItemSetTraits::ItemNotifier NodeNotifier; NodeNotifier& notifier(Node) const { - return graph->notifier(Node()); + return _graph->notifier(Node()); } - template - class NodeMap : public Graph::template NodeMap<_Value> { + template + class NodeMap : public GR::template NodeMap { + typedef typename GR::template NodeMap Parent; + public: - typedef typename _Graph::template NodeMap<_Value> Parent; + explicit NodeMap(const ListEdgeSetBase& arcset) + : Parent(*arcset._graph) {} - explicit NodeMap(const ListEdgeSetBase& arcset) - : Parent(*arcset.graph) {} - - NodeMap(const ListEdgeSetBase& arcset, const _Value& value) - : Parent(*arcset.graph, value) {} + NodeMap(const ListEdgeSetBase& arcset, const V& value) + : Parent(*arcset._graph, value) {} NodeMap& operator=(const NodeMap& cmap) { return operator=(cmap); @@ -660,7 +666,7 @@ }; - /// \ingroup semi_adaptors + /// \ingroup graphs /// /// \brief Graph using a node set of another digraph or graph and an /// own edge set. @@ -679,27 +685,23 @@ /// be removed from the underlying graph, in this case all edges /// incident to the given node is erased from the arc set. /// - /// \param _Graph The type of the graph which shares its node set + /// \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 is fully conform to the \ref concepts::Graph "Graph" + /// This class fully conforms to the \ref concepts::Graph "Graph" /// concept. - template - class ListEdgeSet : public EdgeSetExtender > { + template + class ListEdgeSet : public EdgeSetExtender > { + typedef EdgeSetExtender > Parent; public: - typedef EdgeSetExtender > Parent; - typedef typename Parent::Node Node; typedef typename Parent::Arc Arc; typedef typename Parent::Edge Edge; - typedef _Graph Graph; - - typedef typename Parent::NodesImplBase NodesImplBase; void eraseNode(const Node& node) { @@ -717,10 +719,10 @@ } class NodesImpl : public NodesImplBase { - public: typedef NodesImplBase Parent; - NodesImpl(const Graph& graph, ListEdgeSet& arcset) + public: + NodesImpl(const GR& graph, ListEdgeSet& arcset) : Parent(graph), _arcset(arcset) {} virtual ~NodesImpl() {} @@ -746,22 +748,22 @@ ListEdgeSet& _arcset; }; - NodesImpl nodes; + NodesImpl _nodes; public: /// \brief Constructor of the EdgeSet. /// /// Constructor of the EdgeSet. - ListEdgeSet(const Graph& graph) : nodes(graph, *this) { - Parent::initalize(graph, nodes); + ListEdgeSet(const GR& graph) : _nodes(graph, *this) { + Parent::initalize(graph, _nodes); } /// \brief Add a new edge to the graph. /// /// Add a new edge to the graph with node \c u /// and node \c v endpoints. - /// \return the new edge. + /// \return The new edge. Edge addEdge(const Node& u, const Node& v) { return Parent::addEdge(u, v); } @@ -775,13 +777,12 @@ }; - template + template class SmartArcSetBase { public: - typedef _Graph Graph; - typedef typename Graph::Node Node; - typedef typename Graph::NodeIt NodeIt; + typedef typename GR::Node Node; + typedef typename GR::NodeIt NodeIt; protected: @@ -790,10 +791,10 @@ NodeT() : first_out(-1), first_in(-1) {} }; - typedef typename ItemSetTraits:: + typedef typename ItemSetTraits:: template Map::Type NodesImplBase; - NodesImplBase* nodes; + NodesImplBase* _nodes; struct ArcT { Node source, target; @@ -803,17 +804,17 @@ std::vector arcs; - const Graph* graph; + const GR* _graph; - void initalize(const Graph& _graph, NodesImplBase& _nodes) { - graph = &_graph; - nodes = &_nodes; + void initalize(const GR& graph, NodesImplBase& nodes) { + _graph = &graph; + _nodes = &nodes; } public: class Arc { - friend class SmartArcSetBase; + friend class SmartArcSetBase; protected: Arc(int _id) : id(_id) {} int id; @@ -827,13 +828,19 @@ SmartArcSetBase() {} + Node addNode() { + LEMON_ASSERT(false, + "This graph structure does not support node insertion"); + return INVALID; // avoid warning + } + Arc addArc(const Node& u, const Node& v) { int n = arcs.size(); arcs.push_back(ArcT()); - arcs[n].next_in = (*nodes)[v].first_in; - (*nodes)[v].first_in = n; - arcs[n].next_out = (*nodes)[u].first_out; - (*nodes)[u].first_out = n; + arcs[n].next_in = (*_nodes)[v].first_in; + (*_nodes)[v].first_in = n; + arcs[n].next_out = (*_nodes)[u].first_out; + (*_nodes)[u].first_out = n; arcs[n].source = u; arcs[n].target = v; return Arc(n); @@ -842,30 +849,30 @@ void clear() { Node node; for (first(node); node != INVALID; next(node)) { - (*nodes)[node].first_in = -1; - (*nodes)[node].first_out = -1; + (*_nodes)[node].first_in = -1; + (*_nodes)[node].first_out = -1; } arcs.clear(); } void first(Node& node) const { - graph->first(node); + _graph->first(node); } void next(Node& node) const { - graph->next(node); + _graph->next(node); } void first(Arc& arc) const { arc.id = arcs.size() - 1; } - void next(Arc& arc) const { + static void next(Arc& arc) { --arc.id; } void firstOut(Arc& arc, const Node& node) const { - arc.id = (*nodes)[node].first_out; + arc.id = (*_nodes)[node].first_out; } void nextOut(Arc& arc) const { @@ -873,42 +880,42 @@ } void firstIn(Arc& arc, const Node& node) const { - arc.id = (*nodes)[node].first_in; + arc.id = (*_nodes)[node].first_in; } void nextIn(Arc& arc) const { arc.id = arcs[arc.id].next_in; } - int id(const Node& node) const { return graph->id(node); } + int id(const Node& node) const { return _graph->id(node); } int id(const Arc& arc) const { return arc.id; } - Node nodeFromId(int ix) const { return graph->nodeFromId(ix); } + Node nodeFromId(int ix) const { return _graph->nodeFromId(ix); } Arc arcFromId(int ix) const { return Arc(ix); } - int maxNodeId() const { return graph->maxNodeId(); }; + int maxNodeId() const { return _graph->maxNodeId(); }; int maxArcId() const { return arcs.size() - 1; } Node source(const Arc& arc) const { return arcs[arc.id].source;} Node target(const Arc& arc) const { return arcs[arc.id].target;} - typedef typename ItemSetTraits::ItemNotifier NodeNotifier; + typedef typename ItemSetTraits::ItemNotifier NodeNotifier; NodeNotifier& notifier(Node) const { - return graph->notifier(Node()); + return _graph->notifier(Node()); } - template - class NodeMap : public Graph::template NodeMap<_Value> { + template + class NodeMap : public GR::template NodeMap { + typedef typename GR::template NodeMap Parent; + public: - typedef typename _Graph::template NodeMap<_Value> Parent; + explicit NodeMap(const SmartArcSetBase& arcset) + : Parent(*arcset._graph) { } - explicit NodeMap(const SmartArcSetBase& arcset) - : Parent(*arcset.graph) { } - - NodeMap(const SmartArcSetBase& arcset, const _Value& value) - : Parent(*arcset.graph, value) { } + NodeMap(const SmartArcSetBase& arcset, const V& value) + : Parent(*arcset._graph, value) { } NodeMap& operator=(const NodeMap& cmap) { return operator=(cmap); @@ -924,7 +931,7 @@ }; - /// \ingroup semi_adaptors + /// \ingroup graphs /// /// \brief Digraph using a node set of another digraph or graph and /// an own arc set. @@ -937,7 +944,7 @@ /// class. The node handling functions (id handling, observing, and /// iterators) works equivalently as in the original graph. /// - /// \param _Graph The type of the graph which shares its node set with + /// \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. @@ -952,20 +959,17 @@ /// the arc set is invalidated, and it cannot be used anymore. The /// validity can be checked with the \c valid() member function. /// - /// This class is fully conform to the \ref concepts::Digraph + /// This class fully conforms to the \ref concepts::Digraph /// "Digraph" concept. - template - class SmartArcSet : public ArcSetExtender > { + template + class SmartArcSet : public ArcSetExtender > { + typedef ArcSetExtender > Parent; public: - typedef ArcSetExtender > Parent; - typedef typename Parent::Node Node; typedef typename Parent::Arc Arc; - typedef _Graph Graph; - protected: typedef typename Parent::NodesImplBase NodesImplBase; @@ -983,10 +987,10 @@ } class NodesImpl : public NodesImplBase { - public: typedef NodesImplBase Parent; - NodesImpl(const Graph& graph, SmartArcSet& arcset) + public: + NodesImpl(const GR& graph, SmartArcSet& arcset) : Parent(graph), _arcset(arcset) {} virtual ~NodesImpl() {} @@ -1026,22 +1030,22 @@ SmartArcSet& _arcset; }; - NodesImpl nodes; + NodesImpl _nodes; public: /// \brief Constructor of the ArcSet. /// /// Constructor of the ArcSet. - SmartArcSet(const Graph& graph) : nodes(graph, *this) { - Parent::initalize(graph, nodes); + SmartArcSet(const GR& graph) : _nodes(graph, *this) { + Parent::initalize(graph, _nodes); } /// \brief Add a new arc to the digraph. /// /// Add a new arc to the digraph with source node \c s /// and target node \c t. - /// \return the new arc. + /// \return The new arc. Arc addArc(const Node& s, const Node& t) { return Parent::addArc(s, t); } @@ -1052,19 +1056,18 @@ /// invalidated. It occurs when a node in the underlying graph is /// erased and it is not isolated in the ArcSet. bool valid() const { - return nodes.attached(); + return _nodes.attached(); } }; - template + template class SmartEdgeSetBase { public: - typedef _Graph Graph; - typedef typename Graph::Node Node; - typedef typename Graph::NodeIt NodeIt; + typedef typename GR::Node Node; + typedef typename GR::NodeIt NodeIt; protected: @@ -1073,10 +1076,10 @@ NodeT() : first_out(-1) {} }; - typedef typename ItemSetTraits:: + typedef typename ItemSetTraits:: template Map::Type NodesImplBase; - NodesImplBase* nodes; + NodesImplBase* _nodes; struct ArcT { Node target; @@ -1086,11 +1089,11 @@ std::vector arcs; - const Graph* graph; + const GR* _graph; - void initalize(const Graph& _graph, NodesImplBase& _nodes) { - graph = &_graph; - nodes = &_nodes; + void initalize(const GR& graph, NodesImplBase& nodes) { + _graph = &graph; + _nodes = &nodes; } public: @@ -1127,6 +1130,12 @@ SmartEdgeSetBase() {} + Node addNode() { + LEMON_ASSERT(false, + "This graph structure does not support node insertion"); + return INVALID; // avoid warning + } + Edge addEdge(const Node& u, const Node& v) { int n = arcs.size(); arcs.push_back(ArcT()); @@ -1135,11 +1144,11 @@ arcs[n].target = u; arcs[n | 1].target = v; - arcs[n].next_out = (*nodes)[v].first_out; - (*nodes)[v].first_out = n; + arcs[n].next_out = (*_nodes)[v].first_out; + (*_nodes)[v].first_out = n; - arcs[n | 1].next_out = (*nodes)[u].first_out; - (*nodes)[u].first_out = (n | 1); + arcs[n | 1].next_out = (*_nodes)[u].first_out; + (*_nodes)[u].first_out = (n | 1); return Edge(n / 2); } @@ -1147,24 +1156,24 @@ void clear() { Node node; for (first(node); node != INVALID; next(node)) { - (*nodes)[node].first_out = -1; + (*_nodes)[node].first_out = -1; } arcs.clear(); } void first(Node& node) const { - graph->first(node); + _graph->first(node); } void next(Node& node) const { - graph->next(node); + _graph->next(node); } void first(Arc& arc) const { arc.id = arcs.size() - 1; } - void next(Arc& arc) const { + static void next(Arc& arc) { --arc.id; } @@ -1172,12 +1181,12 @@ arc.id = arcs.size() / 2 - 1; } - void next(Edge& arc) const { + static void next(Edge& arc) { --arc.id; } void firstOut(Arc& arc, const Node& node) const { - arc.id = (*nodes)[node].first_out; + arc.id = (*_nodes)[node].first_out; } void nextOut(Arc& arc) const { @@ -1185,7 +1194,7 @@ } void firstIn(Arc& arc, const Node& node) const { - arc.id = (((*nodes)[node].first_out) ^ 1); + arc.id = (((*_nodes)[node].first_out) ^ 1); if (arc.id == -2) arc.id = -1; } @@ -1195,7 +1204,7 @@ } void firstInc(Edge &arc, bool& dir, const Node& node) const { - int de = (*nodes)[node].first_out; + int de = (*_nodes)[node].first_out; if (de != -1 ) { arc.id = de / 2; dir = ((de & 1) == 1); @@ -1223,15 +1232,15 @@ return Arc(edge.id * 2 + (dir ? 1 : 0)); } - int id(Node node) const { return graph->id(node); } + int id(Node node) const { return _graph->id(node); } static int id(Arc arc) { return arc.id; } static int id(Edge arc) { return arc.id; } - Node nodeFromId(int id) const { return graph->nodeFromId(id); } + Node nodeFromId(int id) const { return _graph->nodeFromId(id); } static Arc arcFromId(int id) { return Arc(id); } static Edge edgeFromId(int id) { return Edge(id);} - int maxNodeId() const { return graph->maxNodeId(); }; + int maxNodeId() const { return _graph->maxNodeId(); }; int maxArcId() const { return arcs.size() - 1; } int maxEdgeId() const { return arcs.size() / 2 - 1; } @@ -1241,23 +1250,23 @@ Node u(Edge e) const { return arcs[2 * e.id].target; } Node v(Edge e) const { return arcs[2 * e.id + 1].target; } - typedef typename ItemSetTraits::ItemNotifier NodeNotifier; + typedef typename ItemSetTraits::ItemNotifier NodeNotifier; NodeNotifier& notifier(Node) const { - return graph->notifier(Node()); + return _graph->notifier(Node()); } - template - class NodeMap : public Graph::template NodeMap<_Value> { + template + class NodeMap : public GR::template NodeMap { + typedef typename GR::template NodeMap Parent; + public: - typedef typename _Graph::template NodeMap<_Value> Parent; + explicit NodeMap(const SmartEdgeSetBase& arcset) + : Parent(*arcset._graph) { } - explicit NodeMap(const SmartEdgeSetBase& arcset) - : Parent(*arcset.graph) { } - - NodeMap(const SmartEdgeSetBase& arcset, const _Value& value) - : Parent(*arcset.graph, value) { } + NodeMap(const SmartEdgeSetBase& arcset, const V& value) + : Parent(*arcset._graph, value) { } NodeMap& operator=(const NodeMap& cmap) { return operator=(cmap); @@ -1272,7 +1281,7 @@ }; - /// \ingroup semi_adaptors + /// \ingroup graphs /// /// \brief Graph using a node set of another digraph or graph and an /// own edge set. @@ -1285,7 +1294,7 @@ /// node handling functions (id handling, observing, and iterators) /// works equivalently as in the original graph. /// - /// \param _Graph The type of the graph which shares its node set + /// \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. @@ -1300,21 +1309,18 @@ /// is invalidated, and it cannot be used anymore. The validity can /// be checked with the \c valid() member function. /// - /// This class is fully conform to the \ref concepts::Graph + /// This class fully conforms to the \ref concepts::Graph /// "Graph" concept. - template - class SmartEdgeSet : public EdgeSetExtender > { + template + class SmartEdgeSet : public EdgeSetExtender > { + typedef EdgeSetExtender > Parent; public: - typedef EdgeSetExtender > Parent; - typedef typename Parent::Node Node; typedef typename Parent::Arc Arc; typedef typename Parent::Edge Edge; - typedef _Graph Graph; - protected: typedef typename Parent::NodesImplBase NodesImplBase; @@ -1331,10 +1337,10 @@ } class NodesImpl : public NodesImplBase { - public: typedef NodesImplBase Parent; - NodesImpl(const Graph& graph, SmartEdgeSet& arcset) + public: + NodesImpl(const GR& graph, SmartEdgeSet& arcset) : Parent(graph), _arcset(arcset) {} virtual ~NodesImpl() {} @@ -1374,22 +1380,22 @@ SmartEdgeSet& _arcset; }; - NodesImpl nodes; + NodesImpl _nodes; public: /// \brief Constructor of the EdgeSet. /// /// Constructor of the EdgeSet. - SmartEdgeSet(const Graph& graph) : nodes(graph, *this) { - Parent::initalize(graph, nodes); + SmartEdgeSet(const GR& graph) : _nodes(graph, *this) { + Parent::initalize(graph, _nodes); } /// \brief Add a new edge to the graph. /// /// Add a new edge to the graph with node \c u /// and node \c v endpoints. - /// \return the new edge. + /// \return The new edge. Edge addEdge(const Node& u, const Node& v) { return Parent::addEdge(u, v); } @@ -1400,7 +1406,7 @@ /// invalidated. It occurs when a node in the underlying graph is /// erased and it is not isolated in the EdgeSet. bool valid() const { - return nodes.attached(); + return _nodes.attached(); } }; diff -r c35afa9e89e7 -r ef88c0a30f85 lemon/elevator.h --- a/lemon/elevator.h Mon Jan 12 23:11:39 2009 +0100 +++ b/lemon/elevator.h Thu Nov 05 15:48:01 2009 +0100 @@ -27,6 +27,7 @@ ///for labeling items in push-relabel type algorithms. /// +#include #include namespace lemon { @@ -45,10 +46,10 @@ /// ///\sa LinkedElevator /// - ///\param Graph Type of the underlying graph. - ///\param Item Type of the items the data is assigned to (Graph::Node, - ///Graph::Arc, Graph::Edge). - template + ///\param GR Type of the underlying graph. + ///\param Item Type of the items the data is assigned to (\c GR::Node, + ///\c GR::Arc or \c GR::Edge). + template class Elevator { public: @@ -59,10 +60,10 @@ private: typedef Item *Vit; - typedef typename ItemSetTraits::template Map::Type VitMap; - typedef typename ItemSetTraits::template Map::Type IntMap; + typedef typename ItemSetTraits::template Map::Type VitMap; + typedef typename ItemSetTraits::template Map::Type IntMap; - const Graph &_g; + const GR &_g; int _max_level; int _item_num; VitMap _where; @@ -75,7 +76,7 @@ void copy(Item i, Vit p) { - _where.set(*p=i,p); + _where[*p=i] = p; } void copy(Vit s, Vit p) { @@ -83,15 +84,15 @@ { Item i=*s; *p=i; - _where.set(i,p); + _where[i] = p; } } void swap(Vit i, Vit j) { Item ti=*i; Vit ct = _where[ti]; - _where.set(ti,_where[*i=*j]); - _where.set(*j,ct); + _where[ti] = _where[*i=*j]; + _where[*j] = ct; *j=ti; } @@ -104,7 +105,7 @@ ///\param graph The underlying graph. ///\param max_level The maximum allowed level. ///Set the range of the possible labels to [0..max_level]. - Elevator(const Graph &graph,int max_level) : + Elevator(const GR &graph,int max_level) : _g(graph), _max_level(max_level), _item_num(_max_level), @@ -121,9 +122,9 @@ ///\param graph The underlying graph. ///Set the range of the possible labels to [0..max_level], ///where \c max_level is equal to the number of labeled items in the graph. - Elevator(const Graph &graph) : + Elevator(const GR &graph) : _g(graph), - _max_level(countItems(graph)), + _max_level(countItems(graph)), _item_num(_max_level), _where(graph), _level(graph,0), @@ -225,7 +226,7 @@ void liftHighestActive() { Item it = *_last_active[_highest_active]; - _level.set(it,_level[it]+1); + ++_level[it]; swap(_last_active[_highest_active]--,_last_active[_highest_active+1]); --_first[++_highest_active]; } @@ -248,7 +249,7 @@ --_last_active[l]; } copy(li,_first[new_level]); - _level.set(li,new_level); + _level[li] = new_level; _highest_active=new_level; } @@ -268,7 +269,7 @@ } copy(li,_first[_max_level]); --_last_active[_max_level]; - _level.set(li,_max_level); + _level[li] = _max_level; while(_highest_active>=0 && _last_active[_highest_active]<_first[_highest_active]) @@ -298,7 +299,7 @@ Item liftActiveOn(int level) { Item it =*_last_active[level]; - _level.set(it,_level[it]+1); + ++_level[it]; swap(_last_active[level]--, --_first[level+1]); if (level+1>_highest_active) ++_highest_active; } @@ -318,7 +319,7 @@ copy(--_first[l+1], _last_active[l]--); } copy(ai,_first[new_level]); - _level.set(ai,new_level); + _level[ai] = new_level; if (new_level>_highest_active) _highest_active=new_level; } @@ -338,7 +339,7 @@ } copy(ai,_first[_max_level]); --_last_active[_max_level]; - _level.set(ai,_max_level); + _level[ai] = _max_level; if (_highest_active==level) { while(_highest_active>=0 && @@ -369,7 +370,7 @@ copy(--_first[l+1],_last_active[l]--); } copy(i,_first[new_level]); - _level.set(i,new_level); + _level[i] = new_level; if(new_level>_highest_active) _highest_active=new_level; } @@ -381,7 +382,7 @@ ///only if you really know what it is for. ///\pre The item is on the top level. void dirtyTopButOne(Item i) { - _level.set(i,_max_level - 1); + _level[i] = _max_level - 1; } ///Lift all items on and above the given level to the top level. @@ -393,7 +394,7 @@ const Vit f=_first[l]; const Vit tl=_first[_max_level]; for(Vit i=f;i!=tl;++i) - _level.set(*i,_max_level); + _level[*i] = _max_level; for(int i=l;i<=_max_level;i++) { _first[i]=f; @@ -429,11 +430,11 @@ _first[0]=&_items[0]; _last_active[0]=&_items[0]-1; Vit n=&_items[0]; - for(typename ItemSetTraits::ItemIt i(_g);i!=INVALID;++i) + for(typename ItemSetTraits::ItemIt i(_g);i!=INVALID;++i) { *n=i; - _where.set(i,n); - _level.set(i,_max_level); + _where[i] = n; + _level[i] = _max_level; ++n; } } @@ -442,7 +443,7 @@ void initAddItem(Item i) { swap(_where[i],_init_num); - _level.set(i,_init_lev); + _level[i] = _init_lev; ++_init_num; } @@ -488,10 +489,10 @@ /// ///\sa Elevator /// - ///\param Graph Type of the underlying graph. - ///\param Item Type of the items the data is assigned to (Graph::Node, - ///Graph::Arc, Graph::Edge). - template + ///\param GR Type of the underlying graph. + ///\param Item Type of the items the data is assigned to (\c GR::Node, + ///\c GR::Arc or \c GR::Edge). + template class LinkedElevator { public: @@ -500,14 +501,14 @@ private: - typedef typename ItemSetTraits:: + typedef typename ItemSetTraits:: template Map::Type ItemMap; - typedef typename ItemSetTraits:: + typedef typename ItemSetTraits:: template Map::Type IntMap; - typedef typename ItemSetTraits:: + typedef typename ItemSetTraits:: template Map::Type BoolMap; - const Graph &_graph; + const GR &_graph; int _max_level; int _item_num; std::vector _first, _last; @@ -524,7 +525,7 @@ ///\param graph The underlying graph. ///\param max_level The maximum allowed level. ///Set the range of the possible labels to [0..max_level]. - LinkedElevator(const Graph& graph, int max_level) + LinkedElevator(const GR& graph, int max_level) : _graph(graph), _max_level(max_level), _item_num(_max_level), _first(_max_level + 1), _last(_max_level + 1), _prev(graph), _next(graph), @@ -537,8 +538,8 @@ ///\param graph The underlying graph. ///Set the range of the possible labels to [0..max_level], ///where \c max_level is equal to the number of labeled items in the graph. - LinkedElevator(const Graph& graph) - : _graph(graph), _max_level(countItems(graph)), + LinkedElevator(const GR& graph) + : _graph(graph), _max_level(countItems(graph)), _item_num(_max_level), _first(_max_level + 1), _last(_max_level + 1), _prev(graph, INVALID), _next(graph, INVALID), @@ -550,7 +551,7 @@ ///Activate item \c i. ///\pre Item \c i shouldn't be active before. void activate(Item i) { - _active.set(i, true); + _active[i] = true; int level = _level[i]; if (level > _highest_active) { @@ -559,16 +560,16 @@ if (_prev[i] == INVALID || _active[_prev[i]]) return; //unlace - _next.set(_prev[i], _next[i]); + _next[_prev[i]] = _next[i]; if (_next[i] != INVALID) { - _prev.set(_next[i], _prev[i]); + _prev[_next[i]] = _prev[i]; } else { _last[level] = _prev[i]; } //lace - _next.set(i, _first[level]); - _prev.set(_first[level], i); - _prev.set(i, INVALID); + _next[i] = _first[level]; + _prev[_first[level]] = i; + _prev[i] = INVALID; _first[level] = i; } @@ -578,23 +579,23 @@ ///Deactivate item \c i. ///\pre Item \c i must be active before. void deactivate(Item i) { - _active.set(i, false); + _active[i] = false; int level = _level[i]; if (_next[i] == INVALID || !_active[_next[i]]) goto find_highest_level; //unlace - _prev.set(_next[i], _prev[i]); + _prev[_next[i]] = _prev[i]; if (_prev[i] != INVALID) { - _next.set(_prev[i], _next[i]); + _next[_prev[i]] = _next[i]; } else { _first[_level[i]] = _next[i]; } //lace - _prev.set(i, _last[level]); - _next.set(_last[level], i); - _next.set(i, INVALID); + _prev[i] = _last[level]; + _next[_last[level]] = i; + _next[i] = INVALID; _last[level] = i; find_highest_level: @@ -684,21 +685,21 @@ void liftHighestActive() { Item i = _first[_highest_active]; if (_next[i] != INVALID) { - _prev.set(_next[i], INVALID); + _prev[_next[i]] = INVALID; _first[_highest_active] = _next[i]; } else { _first[_highest_active] = INVALID; _last[_highest_active] = INVALID; } - _level.set(i, ++_highest_active); + _level[i] = ++_highest_active; if (_first[_highest_active] == INVALID) { _first[_highest_active] = i; _last[_highest_active] = i; - _prev.set(i, INVALID); - _next.set(i, INVALID); + _prev[i] = INVALID; + _next[i] = INVALID; } else { - _prev.set(_first[_highest_active], i); - _next.set(i, _first[_highest_active]); + _prev[_first[_highest_active]] = i; + _next[i] = _first[_highest_active]; _first[_highest_active] = i; } } @@ -713,20 +714,20 @@ void liftHighestActive(int new_level) { Item i = _first[_highest_active]; if (_next[i] != INVALID) { - _prev.set(_next[i], INVALID); + _prev[_next[i]] = INVALID; _first[_highest_active] = _next[i]; } else { _first[_highest_active] = INVALID; _last[_highest_active] = INVALID; } - _level.set(i, _highest_active = new_level); + _level[i] = _highest_active = new_level; if (_first[_highest_active] == INVALID) { _first[_highest_active] = _last[_highest_active] = i; - _prev.set(i, INVALID); - _next.set(i, INVALID); + _prev[i] = INVALID; + _next[i] = INVALID; } else { - _prev.set(_first[_highest_active], i); - _next.set(i, _first[_highest_active]); + _prev[_first[_highest_active]] = i; + _next[i] = _first[_highest_active]; _first[_highest_active] = i; } } @@ -737,9 +738,9 @@ ///deactivate it. void liftHighestActiveToTop() { Item i = _first[_highest_active]; - _level.set(i, _max_level); + _level[i] = _max_level; if (_next[i] != INVALID) { - _prev.set(_next[i], INVALID); + _prev[_next[i]] = INVALID; _first[_highest_active] = _next[i]; } else { _first[_highest_active] = INVALID; @@ -773,20 +774,20 @@ { Item i = _first[l]; if (_next[i] != INVALID) { - _prev.set(_next[i], INVALID); + _prev[_next[i]] = INVALID; _first[l] = _next[i]; } else { _first[l] = INVALID; _last[l] = INVALID; } - _level.set(i, ++l); + _level[i] = ++l; if (_first[l] == INVALID) { _first[l] = _last[l] = i; - _prev.set(i, INVALID); - _next.set(i, INVALID); + _prev[i] = INVALID; + _next[i] = INVALID; } else { - _prev.set(_first[l], i); - _next.set(i, _first[l]); + _prev[_first[l]] = i; + _next[i] = _first[l]; _first[l] = i; } if (_highest_active < l) { @@ -802,20 +803,20 @@ { Item i = _first[l]; if (_next[i] != INVALID) { - _prev.set(_next[i], INVALID); + _prev[_next[i]] = INVALID; _first[l] = _next[i]; } else { _first[l] = INVALID; _last[l] = INVALID; } - _level.set(i, l = new_level); + _level[i] = l = new_level; if (_first[l] == INVALID) { _first[l] = _last[l] = i; - _prev.set(i, INVALID); - _next.set(i, INVALID); + _prev[i] = INVALID; + _next[i] = INVALID; } else { - _prev.set(_first[l], i); - _next.set(i, _first[l]); + _prev[_first[l]] = i; + _next[i] = _first[l]; _first[l] = i; } if (_highest_active < l) { @@ -831,13 +832,13 @@ { Item i = _first[l]; if (_next[i] != INVALID) { - _prev.set(_next[i], INVALID); + _prev[_next[i]] = INVALID; _first[l] = _next[i]; } else { _first[l] = INVALID; _last[l] = INVALID; } - _level.set(i, _max_level); + _level[i] = _max_level; if (l == _highest_active) { while (_highest_active >= 0 && activeFree(_highest_active)) --_highest_active; @@ -855,23 +856,23 @@ /// void lift(Item i, int new_level) { if (_next[i] != INVALID) { - _prev.set(_next[i], _prev[i]); + _prev[_next[i]] = _prev[i]; } else { _last[new_level] = _prev[i]; } if (_prev[i] != INVALID) { - _next.set(_prev[i], _next[i]); + _next[_prev[i]] = _next[i]; } else { _first[new_level] = _next[i]; } - _level.set(i, new_level); + _level[i] = new_level; if (_first[new_level] == INVALID) { _first[new_level] = _last[new_level] = i; - _prev.set(i, INVALID); - _next.set(i, INVALID); + _prev[i] = INVALID; + _next[i] = INVALID; } else { - _prev.set(_first[new_level], i); - _next.set(i, _first[new_level]); + _prev[_first[new_level]] = i; + _next[i] = _first[new_level]; _first[new_level] = i; } if (_highest_active < new_level) { @@ -887,7 +888,7 @@ ///only if you really know what it is for. ///\pre The item is on the top level. void dirtyTopButOne(Item i) { - _level.set(i, _max_level - 1); + _level[i] = _max_level - 1; } ///Lift all items on and above the given level to the top level. @@ -898,7 +899,7 @@ for (int i = l + 1; _first[i] != INVALID; ++i) { Item n = _first[i]; while (n != INVALID) { - _level.set(n, _max_level); + _level[n] = _max_level; n = _next[n]; } _first[i] = INVALID; @@ -934,25 +935,25 @@ _first[i] = _last[i] = INVALID; } _init_level = 0; - for(typename ItemSetTraits::ItemIt i(_graph); + for(typename ItemSetTraits::ItemIt i(_graph); i != INVALID; ++i) { - _level.set(i, _max_level); - _active.set(i, false); + _level[i] = _max_level; + _active[i] = false; } } ///Add an item to the current level. void initAddItem(Item i) { - _level.set(i, _init_level); + _level[i] = _init_level; if (_last[_init_level] == INVALID) { _first[_init_level] = i; _last[_init_level] = i; - _prev.set(i, INVALID); - _next.set(i, INVALID); + _prev[i] = INVALID; + _next[i] = INVALID; } else { - _prev.set(i, _last[_init_level]); - _next.set(i, INVALID); - _next.set(_last[_init_level], i); + _prev[i] = _last[_init_level]; + _next[i] = INVALID; + _next[_last[_init_level]] = i; _last[_init_level] = i; } } diff -r c35afa9e89e7 -r ef88c0a30f85 lemon/euler.h --- /dev/null Thu Jan 01 00:00:00 1970 +0000 +++ b/lemon/euler.h Thu Nov 05 15:48:01 2009 +0100 @@ -0,0 +1,287 @@ +/* -*- 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_EULER_H +#define LEMON_EULER_H + +#include +#include +#include +#include + +/// \ingroup graph_properties +/// \file +/// \brief Euler tour iterators and a function for checking the \e Eulerian +/// property. +/// +///This file provides Euler tour iterators and a function to check +///if a (di)graph is \e Eulerian. + +namespace lemon { + + ///Euler tour iterator for digraphs. + + /// \ingroup graph_prop + ///This iterator provides an Euler tour (Eulerian circuit) of a \e directed + ///graph (if there exists) and it converts to the \c Arc type of the digraph. + /// + ///For example, if the given digraph has an Euler tour (i.e it has only one + ///non-trivial component and the in-degree is equal to the out-degree + ///for all nodes), then the following code will put the arcs of \c g + ///to the vector \c et according to an Euler tour of \c g. + ///\code + /// std::vector et; + /// for(DiEulerIt e(g); e!=INVALID; ++e) + /// et.push_back(e); + ///\endcode + ///If \c g has no Euler tour, then the resulted walk will not be closed + ///or not contain all arcs. + ///\sa EulerIt + template + class DiEulerIt + { + typedef typename GR::Node Node; + typedef typename GR::NodeIt NodeIt; + typedef typename GR::Arc Arc; + typedef typename GR::ArcIt ArcIt; + typedef typename GR::OutArcIt OutArcIt; + typedef typename GR::InArcIt InArcIt; + + const GR &g; + typename GR::template NodeMap narc; + std::list euler; + + public: + + ///Constructor + + ///Constructor. + ///\param gr A digraph. + ///\param start The starting point of the tour. If it is not given, + ///the tour will start from the first node that has an outgoing arc. + DiEulerIt(const GR &gr, typename GR::Node start = INVALID) + : g(gr), narc(g) + { + if (start==INVALID) { + NodeIt n(g); + while (n!=INVALID && OutArcIt(g,n)==INVALID) ++n; + start=n; + } + if (start!=INVALID) { + for (NodeIt n(g); n!=INVALID; ++n) narc[n]=OutArcIt(g,n); + while (narc[start]!=INVALID) { + euler.push_back(narc[start]); + Node next=g.target(narc[start]); + ++narc[start]; + start=next; + } + } + } + + ///Arc conversion + operator Arc() { return euler.empty()?INVALID:euler.front(); } + ///Compare with \c INVALID + bool operator==(Invalid) { return euler.empty(); } + ///Compare with \c INVALID + bool operator!=(Invalid) { return !euler.empty(); } + + ///Next arc of the tour + + ///Next arc of the tour + /// + DiEulerIt &operator++() { + Node s=g.target(euler.front()); + euler.pop_front(); + typename std::list::iterator next=euler.begin(); + while(narc[s]!=INVALID) { + euler.insert(next,narc[s]); + Node n=g.target(narc[s]); + ++narc[s]; + s=n; + } + return *this; + } + ///Postfix incrementation + + /// Postfix incrementation. + /// + ///\warning This incrementation + ///returns an \c Arc, not a \ref DiEulerIt, as one may + ///expect. + Arc operator++(int) + { + Arc e=*this; + ++(*this); + return e; + } + }; + + ///Euler tour iterator for graphs. + + /// \ingroup graph_properties + ///This iterator provides an Euler tour (Eulerian circuit) of an + ///\e undirected graph (if there exists) and it converts to the \c Arc + ///and \c Edge types of the graph. + /// + ///For example, if the given graph has an Euler tour (i.e it has only one + ///non-trivial component and the degree of each node is even), + ///the following code will print the arc IDs according to an + ///Euler tour of \c g. + ///\code + /// for(EulerIt e(g); e!=INVALID; ++e) { + /// std::cout << g.id(Edge(e)) << std::eol; + /// } + ///\endcode + ///Although this iterator is for undirected graphs, it still returns + ///arcs in order to indicate the direction of the tour. + ///(But arcs convert to edges, of course.) + /// + ///If \c g has no Euler tour, then the resulted walk will not be closed + ///or not contain all edges. + template + class EulerIt + { + typedef typename GR::Node Node; + typedef typename GR::NodeIt NodeIt; + typedef typename GR::Arc Arc; + typedef typename GR::Edge Edge; + typedef typename GR::ArcIt ArcIt; + typedef typename GR::OutArcIt OutArcIt; + typedef typename GR::InArcIt InArcIt; + + const GR &g; + typename GR::template NodeMap narc; + typename GR::template EdgeMap visited; + std::list euler; + + public: + + ///Constructor + + ///Constructor. + ///\param gr A graph. + ///\param start The starting point of the tour. If it is not given, + ///the tour will start from the first node that has an incident edge. + EulerIt(const GR &gr, typename GR::Node start = INVALID) + : g(gr), narc(g), visited(g, false) + { + if (start==INVALID) { + NodeIt n(g); + while (n!=INVALID && OutArcIt(g,n)==INVALID) ++n; + start=n; + } + if (start!=INVALID) { + for (NodeIt n(g); n!=INVALID; ++n) narc[n]=OutArcIt(g,n); + while(narc[start]!=INVALID) { + euler.push_back(narc[start]); + visited[narc[start]]=true; + Node next=g.target(narc[start]); + ++narc[start]; + start=next; + while(narc[start]!=INVALID && visited[narc[start]]) ++narc[start]; + } + } + } + + ///Arc conversion + operator Arc() const { return euler.empty()?INVALID:euler.front(); } + ///Edge conversion + operator Edge() const { return euler.empty()?INVALID:euler.front(); } + ///Compare with \c INVALID + bool operator==(Invalid) const { return euler.empty(); } + ///Compare with \c INVALID + bool operator!=(Invalid) const { return !euler.empty(); } + + ///Next arc of the tour + + ///Next arc of the tour + /// + EulerIt &operator++() { + Node s=g.target(euler.front()); + euler.pop_front(); + typename std::list::iterator next=euler.begin(); + while(narc[s]!=INVALID) { + while(narc[s]!=INVALID && visited[narc[s]]) ++narc[s]; + if(narc[s]==INVALID) break; + else { + euler.insert(next,narc[s]); + visited[narc[s]]=true; + Node n=g.target(narc[s]); + ++narc[s]; + s=n; + } + } + return *this; + } + + ///Postfix incrementation + + /// Postfix incrementation. + /// + ///\warning This incrementation returns an \c Arc (which converts to + ///an \c Edge), not an \ref EulerIt, as one may expect. + Arc operator++(int) + { + Arc e=*this; + ++(*this); + return e; + } + }; + + + ///Check if the given graph is Eulerian + + /// \ingroup graph_properties + ///This function checks if the given graph is Eulerian. + ///It works for both directed and undirected graphs. + /// + ///By definition, a digraph is called \e Eulerian if + ///and only if it is connected and the number of incoming and outgoing + ///arcs are the same for each node. + ///Similarly, an undirected graph is called \e Eulerian if + ///and only if it is connected and the number of incident edges is even + ///for each node. + /// + ///\note There are (di)graphs that are not Eulerian, but still have an + /// Euler tour, since they may contain isolated nodes. + /// + ///\sa DiEulerIt, EulerIt + template +#ifdef DOXYGEN + bool +#else + typename enable_if,bool>::type + eulerian(const GR &g) + { + for(typename GR::NodeIt n(g);n!=INVALID;++n) + if(countIncEdges(g,n)%2) return false; + return connected(g); + } + template + typename disable_if,bool>::type +#endif + eulerian(const GR &g) + { + for(typename GR::NodeIt n(g);n!=INVALID;++n) + if(countInArcs(g,n)!=countOutArcs(g,n)) return false; + return connected(undirector(g)); + } + +} + +#endif diff -r c35afa9e89e7 -r ef88c0a30f85 lemon/fib_heap.h --- /dev/null Thu Jan 01 00:00:00 1970 +0000 +++ b/lemon/fib_heap.h Thu Nov 05 15:48:01 2009 +0100 @@ -0,0 +1,475 @@ +/* -*- mode: C++; indent-tabs-mode: nil; -*- + * + * This file is a part of LEMON, a generic C++ optimization library. + * + * Copyright (C) 2003-2009 + * Egervary Jeno Kombinatorikus Optimalizalasi Kutatocsoport + * (Egervary Research Group on Combinatorial Optimization, EGRES). + * + * Permission to use, modify and distribute this software is granted + * provided that this copyright notice appears in all copies. For + * precise terms see the accompanying LICENSE file. + * + * This software is provided "AS IS" with no warranty of any kind, + * express or implied, and with no claim as to its suitability for any + * purpose. + * + */ + +#ifndef LEMON_FIB_HEAP_H +#define LEMON_FIB_HEAP_H + +///\file +///\ingroup heaps +///\brief Fibonacci heap implementation. + +#include +#include +#include +#include + +namespace lemon { + + /// \ingroup heaps + /// + /// \brief Fibonacci heap data structure. + /// + /// This class implements the \e Fibonacci \e heap data structure. + /// It fully conforms to the \ref concepts::Heap "heap concept". + /// + /// The methods \ref increase() and \ref erase() are not efficient in a + /// Fibonacci heap. In case of many calls of these operations, it is + /// better to use other heap structure, e.g. \ref BinHeap "binary heap". + /// + /// \tparam PR Type of the priorities of the items. + /// \tparam IM A read-writable item map with \c int values, used + /// internally to handle the cross references. + /// \tparam CMP A functor class for comparing the priorities. + /// The default is \c std::less. +#ifdef DOXYGEN + template +#else + template > +#endif + class FibHeap { + public: + + /// Type of the item-int map. + typedef IM ItemIntMap; + /// Type of the priorities. + typedef PR Prio; + /// Type of the items stored in the heap. + typedef typename ItemIntMap::Key Item; + /// Type of the item-priority pairs. + typedef std::pair Pair; + /// Functor type for comparing the priorities. + typedef CMP Compare; + + private: + class Store; + + std::vector _data; + int _minimum; + ItemIntMap &_iim; + Compare _comp; + int _num; + + public: + + /// \brief Type to represent the states of the items. + /// + /// Each item has a state associated to it. It can be "in heap", + /// "pre-heap" or "post-heap". The latter two are indifferent from the + /// heap's point of view, but may be useful to the user. + /// + /// The item-int map must be initialized in such way that it assigns + /// \c PRE_HEAP (-1) to any element to be put in the heap. + enum State { + IN_HEAP = 0, ///< = 0. + PRE_HEAP = -1, ///< = -1. + POST_HEAP = -2 ///< = -2. + }; + + /// \brief Constructor. + /// + /// Constructor. + /// \param map A map that assigns \c int values to the items. + /// It is used internally to handle the cross references. + /// The assigned value must be \c PRE_HEAP (-1) for each item. + explicit FibHeap(ItemIntMap &map) + : _minimum(0), _iim(map), _num() {} + + /// \brief Constructor. + /// + /// Constructor. + /// \param map A map that assigns \c int values to the items. + /// It is used internally to handle the cross references. + /// The assigned value must be \c PRE_HEAP (-1) for each item. + /// \param comp The function object used for comparing the priorities. + FibHeap(ItemIntMap &map, const Compare &comp) + : _minimum(0), _iim(map), _comp(comp), _num() {} + + /// \brief The number of items stored in the heap. + /// + /// This function returns the number of items stored in the heap. + int size() const { return _num; } + + /// \brief Check if the heap is empty. + /// + /// This function returns \c true if the heap is empty. + bool empty() const { return _num==0; } + + /// \brief Make the heap empty. + /// + /// This functon makes the heap empty. + /// It does not change the cross reference map. If you want to reuse + /// a heap that is not surely empty, you should first clear it and + /// then you should set the cross reference map to \c PRE_HEAP + /// for each item. + void clear() { + _data.clear(); _minimum = 0; _num = 0; + } + + /// \brief Insert an item into the heap with the given priority. + /// + /// This function inserts the given item into the heap with the + /// given priority. + /// \param item The item to insert. + /// \param prio The priority of the item. + /// \pre \e item must not be stored in the heap. + void push (const Item& item, const Prio& prio) { + int i=_iim[item]; + if ( i < 0 ) { + int s=_data.size(); + _iim.set( item, s ); + Store st; + st.name=item; + _data.push_back(st); + i=s; + } else { + _data[i].parent=_data[i].child=-1; + _data[i].degree=0; + _data[i].in=true; + _data[i].marked=false; + } + + if ( _num ) { + _data[_data[_minimum].right_neighbor].left_neighbor=i; + _data[i].right_neighbor=_data[_minimum].right_neighbor; + _data[_minimum].right_neighbor=i; + _data[i].left_neighbor=_minimum; + if ( _comp( prio, _data[_minimum].prio) ) _minimum=i; + } else { + _data[i].right_neighbor=_data[i].left_neighbor=i; + _minimum=i; + } + _data[i].prio=prio; + ++_num; + } + + /// \brief Return the item having minimum priority. + /// + /// This function returns the item having minimum priority. + /// \pre The heap must be non-empty. + Item top() const { return _data[_minimum].name; } + + /// \brief The minimum priority. + /// + /// This function returns the minimum priority. + /// \pre The heap must be non-empty. + Prio prio() const { return _data[_minimum].prio; } + + /// \brief Remove the item having minimum priority. + /// + /// This function removes the item having minimum priority. + /// \pre The heap must be non-empty. + void pop() { + /*The first case is that there are only one root.*/ + if ( _data[_minimum].left_neighbor==_minimum ) { + _data[_minimum].in=false; + if ( _data[_minimum].degree!=0 ) { + makeRoot(_data[_minimum].child); + _minimum=_data[_minimum].child; + balance(); + } + } else { + int right=_data[_minimum].right_neighbor; + unlace(_minimum); + _data[_minimum].in=false; + if ( _data[_minimum].degree > 0 ) { + int left=_data[_minimum].left_neighbor; + int child=_data[_minimum].child; + int last_child=_data[child].left_neighbor; + + makeRoot(child); + + _data[left].right_neighbor=child; + _data[child].left_neighbor=left; + _data[right].left_neighbor=last_child; + _data[last_child].right_neighbor=right; + } + _minimum=right; + balance(); + } // the case where there are more roots + --_num; + } + + /// \brief Remove the given item from the heap. + /// + /// This function removes the given item from the heap if it is + /// already stored. + /// \param item The item to delete. + /// \pre \e item must be in the heap. + void erase (const Item& item) { + int i=_iim[item]; + + if ( i >= 0 && _data[i].in ) { + if ( _data[i].parent!=-1 ) { + int p=_data[i].parent; + cut(i,p); + cascade(p); + } + _minimum=i; //As if its prio would be -infinity + pop(); + } + } + + /// \brief The priority of the given item. + /// + /// This function returns the priority of the given item. + /// \param item The item. + /// \pre \e item must be in the heap. + Prio operator[](const Item& item) const { + return _data[_iim[item]].prio; + } + + /// \brief Set the priority of an item or insert it, if it is + /// not stored in the heap. + /// + /// This method sets the priority of the given item if it is + /// already stored in the heap. Otherwise it inserts the given + /// item into the heap with the given priority. + /// \param item The item. + /// \param prio The priority. + void set (const Item& item, const Prio& prio) { + int i=_iim[item]; + if ( i >= 0 && _data[i].in ) { + if ( _comp(prio, _data[i].prio) ) decrease(item, prio); + if ( _comp(_data[i].prio, prio) ) increase(item, prio); + } else push(item, prio); + } + + /// \brief Decrease the priority of an item to the given value. + /// + /// This function decreases the priority of an item to the given value. + /// \param item The item. + /// \param prio The priority. + /// \pre \e item must be stored in the heap with priority at least \e prio. + void decrease (const Item& item, const Prio& prio) { + int i=_iim[item]; + _data[i].prio=prio; + int p=_data[i].parent; + + if ( p!=-1 && _comp(prio, _data[p].prio) ) { + cut(i,p); + cascade(p); + } + if ( _comp(prio, _data[_minimum].prio) ) _minimum=i; + } + + /// \brief Increase the priority of an item to the given value. + /// + /// This function increases the priority of an item to the given value. + /// \param item The item. + /// \param prio The priority. + /// \pre \e item must be stored in the heap with priority at most \e prio. + void increase (const Item& item, const Prio& prio) { + erase(item); + push(item, prio); + } + + /// \brief Return the state of an item. + /// + /// This method returns \c PRE_HEAP if the given item has never + /// been in the heap, \c IN_HEAP if it is in the heap at the moment, + /// and \c POST_HEAP otherwise. + /// In the latter case it is possible that the item will get back + /// to the heap again. + /// \param item The item. + State state(const Item &item) const { + int i=_iim[item]; + if( i>=0 ) { + if ( _data[i].in ) i=0; + else i=-2; + } + return State(i); + } + + /// \brief Set the state of an item in the heap. + /// + /// This function sets the state of the given item in the heap. + /// It can be used to manually clear the heap when it is important + /// to achive better time complexity. + /// \param i The item. + /// \param st The state. It should not be \c IN_HEAP. + void state(const Item& i, State st) { + switch (st) { + case POST_HEAP: + case PRE_HEAP: + if (state(i) == IN_HEAP) { + erase(i); + } + _iim[i] = st; + break; + case IN_HEAP: + break; + } + } + + private: + + void balance() { + + int maxdeg=int( std::floor( 2.08*log(double(_data.size()))))+1; + + std::vector A(maxdeg,-1); + + /* + *Recall that now minimum does not point to the minimum prio element. + *We set minimum to this during balance(). + */ + int anchor=_data[_minimum].left_neighbor; + int next=_minimum; + bool end=false; + + do { + int active=next; + if ( anchor==active ) end=true; + int d=_data[active].degree; + next=_data[active].right_neighbor; + + while (A[d]!=-1) { + if( _comp(_data[active].prio, _data[A[d]].prio) ) { + fuse(active,A[d]); + } else { + fuse(A[d],active); + active=A[d]; + } + A[d]=-1; + ++d; + } + A[d]=active; + } while ( !end ); + + + while ( _data[_minimum].parent >=0 ) + _minimum=_data[_minimum].parent; + int s=_minimum; + int m=_minimum; + do { + if ( _comp(_data[s].prio, _data[_minimum].prio) ) _minimum=s; + s=_data[s].right_neighbor; + } while ( s != m ); + } + + void makeRoot(int c) { + int s=c; + do { + _data[s].parent=-1; + s=_data[s].right_neighbor; + } while ( s != c ); + } + + void cut(int a, int b) { + /* + *Replacing a from the children of b. + */ + --_data[b].degree; + + if ( _data[b].degree !=0 ) { + int child=_data[b].child; + if ( child==a ) + _data[b].child=_data[child].right_neighbor; + unlace(a); + } + + + /*Lacing a to the roots.*/ + int right=_data[_minimum].right_neighbor; + _data[_minimum].right_neighbor=a; + _data[a].left_neighbor=_minimum; + _data[a].right_neighbor=right; + _data[right].left_neighbor=a; + + _data[a].parent=-1; + _data[a].marked=false; + } + + void cascade(int a) { + if ( _data[a].parent!=-1 ) { + int p=_data[a].parent; + + if ( _data[a].marked==false ) _data[a].marked=true; + else { + cut(a,p); + cascade(p); + } + } + } + + void fuse(int a, int b) { + unlace(b); + + /*Lacing b under a.*/ + _data[b].parent=a; + + if (_data[a].degree==0) { + _data[b].left_neighbor=b; + _data[b].right_neighbor=b; + _data[a].child=b; + } else { + int child=_data[a].child; + int last_child=_data[child].left_neighbor; + _data[child].left_neighbor=b; + _data[b].right_neighbor=child; + _data[last_child].right_neighbor=b; + _data[b].left_neighbor=last_child; + } + + ++_data[a].degree; + + _data[b].marked=false; + } + + /* + *It is invoked only if a has siblings. + */ + void unlace(int a) { + int leftn=_data[a].left_neighbor; + int rightn=_data[a].right_neighbor; + _data[leftn].right_neighbor=rightn; + _data[rightn].left_neighbor=leftn; + } + + + class Store { + friend class FibHeap; + + Item name; + int parent; + int left_neighbor; + int right_neighbor; + int child; + int degree; + bool marked; + bool in; + Prio prio; + + Store() : parent(-1), child(-1), degree(), marked(false), in(true) {} + }; + }; + +} //namespace lemon + +#endif //LEMON_FIB_HEAP_H + diff -r c35afa9e89e7 -r ef88c0a30f85 lemon/fourary_heap.h --- /dev/null Thu Jan 01 00:00:00 1970 +0000 +++ b/lemon/fourary_heap.h Thu Nov 05 15:48:01 2009 +0100 @@ -0,0 +1,342 @@ +/* -*- 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_FOURARY_HEAP_H +#define LEMON_FOURARY_HEAP_H + +///\ingroup heaps +///\file +///\brief Fourary heap implementation. + +#include +#include +#include + +namespace lemon { + + /// \ingroup heaps + /// + ///\brief Fourary heap data structure. + /// + /// This class implements the \e fourary \e heap data structure. + /// It fully conforms to the \ref concepts::Heap "heap concept". + /// + /// The fourary heap is a specialization of the \ref KaryHeap "K-ary heap" + /// for K=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 KaryHeap +#ifdef DOXYGEN + template +#else + template > +#endif + class FouraryHeap { + 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 FouraryHeap(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. + FouraryHeap(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 FouraryHeap + +} // namespace lemon + +#endif // LEMON_FOURARY_HEAP_H diff -r c35afa9e89e7 -r ef88c0a30f85 lemon/full_graph.h --- a/lemon/full_graph.h Mon Jan 12 23:11:39 2009 +0100 +++ b/lemon/full_graph.h Thu Nov 05 15:48:01 2009 +0100 @@ -24,14 +24,14 @@ ///\ingroup graphs ///\file -///\brief FullGraph and FullDigraph classes. +///\brief FullDigraph and FullGraph classes. namespace lemon { class FullDigraphBase { public: - typedef FullDigraphBase Graph; + typedef FullDigraphBase Digraph; class Node; class Arc; @@ -51,7 +51,7 @@ typedef True ArcNumTag; Node operator()(int ix) const { return Node(ix); } - int index(const Node& node) const { return node._id; } + static int index(const Node& node) { return node._id; } Arc arc(const Node& s, const Node& t) const { return Arc(s._id * _node_num + t._id); @@ -148,33 +148,36 @@ /// \ingroup graphs /// - /// \brief A full digraph class. + /// \brief A directed full graph 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. + /// 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 class conforms to the \ref concepts::Digraph "Digraph" concept - /// and it also has an important extra feature that its maps are - /// real \ref concepts::ReferenceMap "reference map"s. + /// This type fully conforms to the \ref concepts::Digraph "Digraph concept". + /// Most of its member functions and nested classes are documented + /// only in the concept class. /// - /// The \c FullDigraph and \c FullGraph classes are very similar, + /// \note FullDigraph and FullGraph classes are very similar, /// but there are two differences. While this class conforms only - /// to the \ref concepts::Digraph "Digraph" concept, 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. + /// to the \ref concepts::Digraph "Digraph" concept, FullGraph + /// conforms to the \ref concepts::Graph "Graph" concept, + /// moreover FullGraph does not contain a loop for each + /// node as this class does. /// /// \sa FullGraph class FullDigraph : public ExtendedFullDigraphBase { + typedef ExtendedFullDigraphBase Parent; + public: - typedef ExtendedFullDigraphBase Parent; - - /// \brief Constructor + /// \brief Default constructor. + /// + /// Default constructor. The number of nodes and arcs will be zero. FullDigraph() { construct(0); } /// \brief Constructor @@ -185,8 +188,8 @@ /// \brief Resizes the digraph /// - /// Resizes the digraph. The function will fully destroy and - /// rebuild the digraph. This cause that the maps of the digraph will + /// This function resizes the digraph. It fully destroys and + /// rebuilds the structure, therefore the maps of the digraph will be /// reallocated automatically and the previous values will be lost. void resize(int n) { Parent::notifier(Arc()).clear(); @@ -198,24 +201,24 @@ /// \brief Returns the node with the given index. /// - /// 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]. + /// 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]. /// \sa index() Node operator()(int ix) const { return Parent::operator()(ix); } /// \brief Returns the index of the given node. /// - /// Returns the index of the given node. Since 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); } + /// 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]. + /// \sa operator()() + static int index(const Node& node) { return Parent::index(node); } /// \brief Returns the arc connecting the given nodes. /// /// Returns the arc connecting the given nodes. - Arc arc(const Node& u, const Node& v) const { + Arc arc(Node u, Node v) const { return Parent::arc(u, v); } @@ -227,8 +230,6 @@ class FullGraphBase { - int _node_num; - int _edge_num; public: typedef FullGraphBase Graph; @@ -239,6 +240,9 @@ protected: + int _node_num; + int _edge_num; + FullGraphBase() {} void construct(int n) { _node_num = n; _edge_num = n * (n - 1) / 2; } @@ -283,7 +287,7 @@ public: Node operator()(int ix) const { return Node(ix); } - int index(const Node& node) const { return node._id; } + static int index(const Node& node) { return node._id; } Edge edge(const Node& u, const Node& v) const { if (u._id < v._id) { @@ -520,31 +524,33 @@ /// /// \brief An undirected full graph class. /// - /// 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. + /// 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 class conforms to the \ref concepts::Graph "Graph" concept - /// and it also has an important extra feature that its maps are - /// real \ref concepts::ReferenceMap "reference map"s. + /// 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. /// - /// The \c FullGraph and \c FullDigraph classes are very similar, - /// but there are two differences. While the \c FullDigraph class + /// \note FullDigraph and FullGraph classes are very similar, + /// but there are two differences. While FullDigraph /// conforms only to the \ref concepts::Digraph "Digraph" concept, /// this class conforms to the \ref concepts::Graph "Graph" concept, - /// moreover \c FullGraph does not contain a loop arc for each - /// node as \c FullDigraph does. + /// moreover this class does not contain a loop for each + /// node as FullDigraph does. /// /// \sa FullDigraph class FullGraph : public ExtendedFullGraphBase { + typedef ExtendedFullGraphBase Parent; + public: - typedef ExtendedFullGraphBase Parent; - - /// \brief Constructor + /// \brief Default constructor. + /// + /// Default constructor. The number of nodes and edges will be zero. FullGraph() { construct(0); } /// \brief Constructor @@ -555,8 +561,8 @@ /// \brief Resizes the graph /// - /// Resizes the graph. The function will fully destroy and - /// rebuild the graph. This cause that the maps of the graph will + /// This function resizes the graph. It fully destroys and + /// rebuilds the structure, therefore the maps of the graph will be /// reallocated automatically and the previous values will be lost. void resize(int n) { Parent::notifier(Arc()).clear(); @@ -570,31 +576,31 @@ /// \brief Returns the node with the given index. /// - /// 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]. + /// 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]. /// \sa index() Node operator()(int ix) const { return Parent::operator()(ix); } /// \brief Returns the index of the given node. /// - /// Returns the index of the given node. Since 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); } + /// 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]. + /// \sa operator()() + static int index(const Node& node) { return Parent::index(node); } /// \brief Returns the arc connecting the given nodes. /// /// Returns the arc connecting the given nodes. - Arc arc(const Node& s, const Node& t) const { + Arc arc(Node s, Node t) const { return Parent::arc(s, t); } - /// \brief Returns the edge connects the given nodes. + /// \brief Returns the edge connecting the given nodes. /// - /// Returns the edge connects the given nodes. - Edge edge(const Node& u, const Node& v) const { + /// Returns the edge connecting the given nodes. + Edge edge(Node u, Node v) const { return Parent::edge(u, v); } diff -r c35afa9e89e7 -r ef88c0a30f85 lemon/glpk.cc --- a/lemon/glpk.cc Mon Jan 12 23:11:39 2009 +0100 +++ b/lemon/glpk.cc Thu Nov 05 15:48:01 2009 +0100 @@ -2,7 +2,7 @@ * * This file is a part of LEMON, a generic C++ optimization library. * - * Copyright (C) 2003-2008 + * Copyright (C) 2003-2009 * Egervary Jeno Kombinatorikus Optimalizalasi Kutatocsoport * (Egervary Research Group on Combinatorial Optimization, EGRES). * @@ -31,6 +31,7 @@ GlpkBase::GlpkBase() : LpBase() { lp = glp_create_prob(); glp_create_index(lp); + messageLevel(MESSAGE_NOTHING); } GlpkBase::GlpkBase(const GlpkBase &other) : LpBase() { @@ -39,6 +40,7 @@ glp_create_index(lp); rows = other.rows; cols = other.cols; + messageLevel(MESSAGE_NOTHING); } GlpkBase::~GlpkBase() { @@ -57,6 +59,42 @@ 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; + } + void GlpkBase::_eraseCol(int i) { int ca[2]; ca[1] = i; @@ -522,20 +560,46 @@ cols.clear(); } + void GlpkBase::freeEnv() { + glp_free_env(); + } + + void GlpkBase::_messageLevel(MessageLevel level) { + switch (level) { + case MESSAGE_NOTHING: + _message_level = GLP_MSG_OFF; + break; + case MESSAGE_ERROR: + _message_level = GLP_MSG_ERR; + break; + case MESSAGE_WARNING: + _message_level = GLP_MSG_ERR; + break; + case MESSAGE_NORMAL: + _message_level = GLP_MSG_ON; + break; + case MESSAGE_VERBOSE: + _message_level = GLP_MSG_ALL; + break; + } + } + + GlpkBase::FreeEnvHelper GlpkBase::freeEnvHelper; + // GlpkLp members GlpkLp::GlpkLp() - : LpBase(), GlpkBase(), LpSolver() { - messageLevel(MESSAGE_NO_OUTPUT); + : LpBase(), LpSolver(), GlpkBase() { + presolver(false); } GlpkLp::GlpkLp(const GlpkLp& other) - : LpBase(other), GlpkBase(other), LpSolver(other) { - messageLevel(MESSAGE_NO_OUTPUT); + : LpBase(other), LpSolver(other), GlpkBase(other) { + presolver(false); } - GlpkLp* GlpkLp::_newSolver() const { return new GlpkLp; } - GlpkLp* GlpkLp::_cloneSolver() const { return new GlpkLp(*this); } + GlpkLp* GlpkLp::newSolver() const { return new GlpkLp; } + GlpkLp* GlpkLp::cloneSolver() const { return new GlpkLp(*this); } const char* GlpkLp::_solverName() const { return "GlpkLp"; } @@ -554,22 +618,26 @@ glp_smcp smcp; glp_init_smcp(&smcp); - switch (_message_level) { - case MESSAGE_NO_OUTPUT: - smcp.msg_lev = GLP_MSG_OFF; + smcp.msg_lev = _message_level; + smcp.presolve = _presolve; + + // If the basis is not valid we get an error return value. + // In this case we can try to create a new basis. + switch (glp_simplex(lp, &smcp)) { + case 0: break; - case MESSAGE_ERROR_MESSAGE: - smcp.msg_lev = GLP_MSG_ERR; + case GLP_EBADB: + case GLP_ESING: + case GLP_ECOND: + glp_term_out(false); + glp_adv_basis(lp, 0); + glp_term_out(true); + if (glp_simplex(lp, &smcp) != 0) return UNSOLVED; break; - case MESSAGE_NORMAL_OUTPUT: - smcp.msg_lev = GLP_MSG_ON; - break; - case MESSAGE_FULL_OUTPUT: - smcp.msg_lev = GLP_MSG_ALL; - break; + default: + return UNSOLVED; } - if (glp_simplex(lp, &smcp) != 0) return UNSOLVED; return SOLVED; } @@ -579,23 +647,26 @@ glp_smcp smcp; glp_init_smcp(&smcp); - switch (_message_level) { - case MESSAGE_NO_OUTPUT: - smcp.msg_lev = GLP_MSG_OFF; + smcp.msg_lev = _message_level; + smcp.meth = GLP_DUAL; + smcp.presolve = _presolve; + + // If the basis is not valid we get an error return value. + // In this case we can try to create a new basis. + switch (glp_simplex(lp, &smcp)) { + case 0: break; - case MESSAGE_ERROR_MESSAGE: - smcp.msg_lev = GLP_MSG_ERR; + case GLP_EBADB: + case GLP_ESING: + case GLP_ECOND: + glp_term_out(false); + glp_adv_basis(lp, 0); + glp_term_out(true); + if (glp_simplex(lp, &smcp) != 0) return UNSOLVED; break; - case MESSAGE_NORMAL_OUTPUT: - smcp.msg_lev = GLP_MSG_ON; - break; - case MESSAGE_FULL_OUTPUT: - smcp.msg_lev = GLP_MSG_ALL; - break; + default: + return UNSOLVED; } - smcp.meth = GLP_DUAL; - - if (glp_simplex(lp, &smcp) != 0) return UNSOLVED; return SOLVED; } @@ -813,24 +884,18 @@ } } - void GlpkLp::presolver(bool b) { - lpx_set_int_parm(lp, LPX_K_PRESOL, b ? 1 : 0); - } - - void GlpkLp::messageLevel(MessageLevel m) { - _message_level = m; + void GlpkLp::presolver(bool presolve) { + _presolve = presolve; } // GlpkMip members GlpkMip::GlpkMip() - : LpBase(), GlpkBase(), MipSolver() { - messageLevel(MESSAGE_NO_OUTPUT); + : LpBase(), MipSolver(), GlpkBase() { } GlpkMip::GlpkMip(const GlpkMip& other) - : LpBase(), GlpkBase(other), MipSolver() { - messageLevel(MESSAGE_NO_OUTPUT); + : LpBase(), MipSolver(), GlpkBase(other) { } void GlpkMip::_setColType(int i, GlpkMip::ColTypes col_type) { @@ -859,42 +924,32 @@ glp_smcp smcp; glp_init_smcp(&smcp); - switch (_message_level) { - case MESSAGE_NO_OUTPUT: - smcp.msg_lev = GLP_MSG_OFF; - break; - case MESSAGE_ERROR_MESSAGE: - smcp.msg_lev = GLP_MSG_ERR; - break; - case MESSAGE_NORMAL_OUTPUT: - smcp.msg_lev = GLP_MSG_ON; - break; - case MESSAGE_FULL_OUTPUT: - smcp.msg_lev = GLP_MSG_ALL; - break; - } + smcp.msg_lev = _message_level; smcp.meth = GLP_DUAL; - if (glp_simplex(lp, &smcp) != 0) return UNSOLVED; + // If the basis is not valid we get an error return value. + // In this case we can try to create a new basis. + switch (glp_simplex(lp, &smcp)) { + case 0: + break; + case GLP_EBADB: + case GLP_ESING: + case GLP_ECOND: + glp_term_out(false); + glp_adv_basis(lp, 0); + glp_term_out(true); + if (glp_simplex(lp, &smcp) != 0) return UNSOLVED; + break; + default: + return UNSOLVED; + } + if (glp_get_status(lp) != GLP_OPT) return SOLVED; glp_iocp iocp; glp_init_iocp(&iocp); - switch (_message_level) { - case MESSAGE_NO_OUTPUT: - iocp.msg_lev = GLP_MSG_OFF; - break; - case MESSAGE_ERROR_MESSAGE: - iocp.msg_lev = GLP_MSG_ERR; - break; - case MESSAGE_NORMAL_OUTPUT: - iocp.msg_lev = GLP_MSG_ON; - break; - case MESSAGE_FULL_OUTPUT: - iocp.msg_lev = GLP_MSG_ALL; - break; - } + iocp.msg_lev = _message_level; if (glp_intopt(lp, &iocp) != 0) return UNSOLVED; return SOLVED; @@ -940,13 +995,9 @@ return glp_mip_obj_val(lp); } - GlpkMip* GlpkMip::_newSolver() const { return new GlpkMip; } - GlpkMip* GlpkMip::_cloneSolver() const {return new GlpkMip(*this); } + GlpkMip* GlpkMip::newSolver() const { return new GlpkMip; } + GlpkMip* GlpkMip::cloneSolver() const {return new GlpkMip(*this); } const char* GlpkMip::_solverName() const { return "GlpkMip"; } - void GlpkMip::messageLevel(MessageLevel m) { - _message_level = m; - } - } //END OF NAMESPACE LEMON diff -r c35afa9e89e7 -r ef88c0a30f85 lemon/glpk.h --- a/lemon/glpk.h Mon Jan 12 23:11:39 2009 +0100 +++ b/lemon/glpk.h Thu Nov 05 15:48:01 2009 +0100 @@ -26,9 +26,10 @@ #include // forward declaration -#ifndef _GLP_PROB +#if !defined _GLP_PROB && !defined GLP_PROB #define _GLP_PROB -typedef struct { double _prob; } glp_prob; +#define GLP_PROB +typedef struct { double _opaque_prob; } glp_prob; /* LP/MIP problem object */ #endif @@ -53,6 +54,7 @@ virtual int _addCol(); virtual int _addRow(); + virtual int _addRow(Value l, ExprIterator b, ExprIterator e, Value u); virtual void _eraseCol(int i); virtual void _eraseRow(int i); @@ -100,6 +102,24 @@ virtual void _clear(); + virtual void _messageLevel(MessageLevel level); + + private: + + static void freeEnv(); + + struct FreeEnvHelper { + ~FreeEnvHelper() { + freeEnv(); + } + }; + + static FreeEnvHelper freeEnvHelper; + + protected: + + int _message_level; + public: ///Pointer to the underlying GLPK data structure. @@ -119,7 +139,7 @@ /// /// This class implements an interface for the GLPK LP solver. ///\ingroup lp_group - class GlpkLp : public GlpkBase, public LpSolver { + class GlpkLp : public LpSolver, public GlpkBase { public: ///\e @@ -127,6 +147,11 @@ ///\e GlpkLp(const GlpkLp&); + ///\e + virtual GlpkLp* cloneSolver() const; + ///\e + virtual GlpkLp* newSolver() const; + private: mutable std::vector _primal_ray; @@ -136,9 +161,6 @@ protected: - virtual GlpkLp* _cloneSolver() const; - virtual GlpkLp* _newSolver() const; - virtual const char* _solverName() const; virtual SolveExitStatus _solve(); @@ -153,8 +175,6 @@ virtual Value _getPrimalRay(int i) const; virtual Value _getDualRay(int i) const; - ///\todo It should be clarified - /// virtual ProblemType _getPrimalType() const; virtual ProblemType _getDualType() const; @@ -166,44 +186,26 @@ ///Solve with dual simplex SolveExitStatus solveDual(); + private: + + bool _presolve; + + public: + ///Turns on or off the presolver ///Turns on (\c b is \c true) or off (\c b is \c false) the presolver /// ///The presolver is off by default. - void presolver(bool b); + void presolver(bool presolve); - ///Enum for \c messageLevel() parameter - enum MessageLevel { - /// no output (default value) - MESSAGE_NO_OUTPUT = 0, - /// error messages only - MESSAGE_ERROR_MESSAGE = 1, - /// normal output - MESSAGE_NORMAL_OUTPUT = 2, - /// full output (includes informational messages) - MESSAGE_FULL_OUTPUT = 3 - }; - - private: - - MessageLevel _message_level; - - public: - - ///Set the verbosity of the messages - - ///Set the verbosity of the messages - /// - ///\param m is the level of the messages output by the solver routines. - void messageLevel(MessageLevel m); }; /// \brief Interface for the GLPK MIP solver /// /// This class implements an interface for the GLPK MIP solver. ///\ingroup lp_group - class GlpkMip : public GlpkBase, public MipSolver { + class GlpkMip : public MipSolver, public GlpkBase { public: ///\e @@ -211,11 +213,11 @@ ///\e GlpkMip(const GlpkMip&); + virtual GlpkMip* cloneSolver() const; + virtual GlpkMip* newSolver() const; + protected: - virtual GlpkMip* _cloneSolver() const; - virtual GlpkMip* _newSolver() const; - virtual const char* _solverName() const; virtual ColTypes _getColType(int col) const; @@ -226,30 +228,6 @@ virtual Value _getSol(int i) const; virtual Value _getSolValue() const; - ///Enum for \c messageLevel() parameter - enum MessageLevel { - /// no output (default value) - MESSAGE_NO_OUTPUT = 0, - /// error messages only - MESSAGE_ERROR_MESSAGE = 1, - /// normal output - MESSAGE_NORMAL_OUTPUT = 2, - /// full output (includes informational messages) - MESSAGE_FULL_OUTPUT = 3 - }; - - private: - - MessageLevel _message_level; - - public: - - ///Set the verbosity of the messages - - ///Set the verbosity of the messages - /// - ///\param m is the level of the messages output by the solver routines. - void messageLevel(MessageLevel m); }; diff -r c35afa9e89e7 -r ef88c0a30f85 lemon/gomory_hu.h --- /dev/null Thu Jan 01 00:00:00 1970 +0000 +++ b/lemon/gomory_hu.h Thu Nov 05 15:48:01 2009 +0100 @@ -0,0 +1,570 @@ +/* -*- C++ -*- + * + * This file is a part of LEMON, a generic C++ optimization library + * + * Copyright (C) 2003-2008 + * Egervary Jeno Kombinatorikus Optimalizalasi Kutatocsoport + * (Egervary Research Group on Combinatorial Optimization, EGRES). + * + * Permission to use, modify and distribute this software is granted + * provided that this copyright notice appears in all copies. For + * precise terms see the accompanying LICENSE file. + * + * This software is provided "AS IS" with no warranty of any kind, + * express or implied, and with no claim as to its suitability for any + * purpose. + * + */ + +#ifndef LEMON_GOMORY_HU_TREE_H +#define LEMON_GOMORY_HU_TREE_H + +#include + +#include +#include +#include +#include + +/// \ingroup min_cut +/// \file +/// \brief Gomory-Hu cut tree in graphs. + +namespace lemon { + + /// \ingroup min_cut + /// + /// \brief Gomory-Hu cut tree algorithm + /// + /// The Gomory-Hu tree is a tree on the node set of a given graph, but it + /// may contain edges which are not in the original graph. It has the + /// property that the minimum capacity edge of the path between two nodes + /// in this tree has the same weight as the minimum cut in the graph + /// between these nodes. Moreover the components obtained by removing + /// this edge from the tree determine the corresponding minimum cut. + /// Therefore once this tree is computed, the minimum cut between any pair + /// of nodes can easily be obtained. + /// + /// The algorithm calculates \e n-1 distinct minimum cuts (currently with + /// the \ref Preflow algorithm), thus it has \f$O(n^3\sqrt{e})\f$ overall + /// time complexity. It calculates a rooted Gomory-Hu tree. + /// The structure of the tree and the edge weights can be + /// obtained using \c predNode(), \c predValue() and \c rootDist(). + /// The functions \c minCutMap() and \c minCutValue() calculate + /// the minimum cut and the minimum cut value between any two nodes + /// in the graph. You can also list (iterate on) the nodes and the + /// edges of the cuts using \c MinCutNodeIt and \c MinCutEdgeIt. + /// + /// \tparam GR The type of the undirected graph the algorithm runs on. + /// \tparam CAP The type of the edge map containing the capacities. + /// The default map type is \ref concepts::Graph::EdgeMap "GR::EdgeMap". +#ifdef DOXYGEN + template +#else + template > +#endif + class GomoryHu { + public: + + /// The graph type of the algorithm + typedef GR Graph; + /// The capacity map type of the algorithm + typedef CAP Capacity; + /// The value type of capacities + typedef typename Capacity::Value Value; + + private: + + TEMPLATE_GRAPH_TYPEDEFS(Graph); + + const Graph& _graph; + const Capacity& _capacity; + + Node _root; + typename Graph::template NodeMap* _pred; + typename Graph::template NodeMap* _weight; + typename Graph::template NodeMap* _order; + + void createStructures() { + if (!_pred) { + _pred = new typename Graph::template NodeMap(_graph); + } + if (!_weight) { + _weight = new typename Graph::template NodeMap(_graph); + } + if (!_order) { + _order = new typename Graph::template NodeMap(_graph); + } + } + + void destroyStructures() { + if (_pred) { + delete _pred; + } + if (_weight) { + delete _weight; + } + if (_order) { + delete _order; + } + } + + public: + + /// \brief Constructor + /// + /// Constructor. + /// \param graph The undirected graph the algorithm runs on. + /// \param capacity The edge capacity map. + GomoryHu(const Graph& graph, const Capacity& capacity) + : _graph(graph), _capacity(capacity), + _pred(0), _weight(0), _order(0) + { + checkConcept, Capacity>(); + } + + + /// \brief Destructor + /// + /// Destructor. + ~GomoryHu() { + destroyStructures(); + } + + private: + + // Initialize the internal data structures + void init() { + createStructures(); + + _root = NodeIt(_graph); + for (NodeIt n(_graph); n != INVALID; ++n) { + (*_pred)[n] = _root; + (*_order)[n] = -1; + } + (*_pred)[_root] = INVALID; + (*_weight)[_root] = std::numeric_limits::max(); + } + + + // Start the algorithm + void start() { + Preflow fa(_graph, _capacity, _root, INVALID); + + for (NodeIt n(_graph); n != INVALID; ++n) { + if (n == _root) continue; + + Node pn = (*_pred)[n]; + fa.source(n); + fa.target(pn); + + fa.runMinCut(); + + (*_weight)[n] = fa.flowValue(); + + for (NodeIt nn(_graph); nn != INVALID; ++nn) { + if (nn != n && fa.minCut(nn) && (*_pred)[nn] == pn) { + (*_pred)[nn] = n; + } + } + if ((*_pred)[pn] != INVALID && fa.minCut((*_pred)[pn])) { + (*_pred)[n] = (*_pred)[pn]; + (*_pred)[pn] = n; + (*_weight)[n] = (*_weight)[pn]; + (*_weight)[pn] = fa.flowValue(); + } + } + + (*_order)[_root] = 0; + int index = 1; + + for (NodeIt n(_graph); n != INVALID; ++n) { + std::vector st; + Node nn = n; + while ((*_order)[nn] == -1) { + st.push_back(nn); + nn = (*_pred)[nn]; + } + while (!st.empty()) { + (*_order)[st.back()] = index++; + st.pop_back(); + } + } + } + + public: + + ///\name Execution Control + + ///@{ + + /// \brief Run the Gomory-Hu algorithm. + /// + /// This function runs the Gomory-Hu algorithm. + void run() { + init(); + start(); + } + + /// @} + + ///\name Query Functions + ///The results of the algorithm can be obtained using these + ///functions.\n + ///\ref run() should be called before using them.\n + ///See also \ref MinCutNodeIt and \ref MinCutEdgeIt. + + ///@{ + + /// \brief Return the predecessor node in the Gomory-Hu tree. + /// + /// This function returns the predecessor node of the given node + /// in the Gomory-Hu tree. + /// If \c node is the root of the tree, then it returns \c INVALID. + /// + /// \pre \ref run() must be called before using this function. + Node predNode(const Node& node) const { + return (*_pred)[node]; + } + + /// \brief Return the weight of the predecessor edge in the + /// Gomory-Hu tree. + /// + /// This function returns the weight of the predecessor edge of the + /// given node in the Gomory-Hu tree. + /// If \c node is the root of the tree, the result is undefined. + /// + /// \pre \ref run() must be called before using this function. + Value predValue(const Node& node) const { + return (*_weight)[node]; + } + + /// \brief Return the distance from the root node in the Gomory-Hu tree. + /// + /// This function returns the distance of the given node from the root + /// node in the Gomory-Hu tree. + /// + /// \pre \ref run() must be called before using this function. + int rootDist(const Node& node) const { + return (*_order)[node]; + } + + /// \brief Return the minimum cut value between two nodes + /// + /// This function returns the minimum cut value between the nodes + /// \c s and \c t. + /// It finds the nearest common ancestor of the given nodes in the + /// Gomory-Hu tree and calculates the minimum weight edge on the + /// paths to the ancestor. + /// + /// \pre \ref run() must be called before using this function. + Value minCutValue(const Node& s, const Node& t) const { + Node sn = s, tn = t; + Value value = std::numeric_limits::max(); + + while (sn != tn) { + if ((*_order)[sn] < (*_order)[tn]) { + if ((*_weight)[tn] <= value) value = (*_weight)[tn]; + tn = (*_pred)[tn]; + } else { + if ((*_weight)[sn] <= value) value = (*_weight)[sn]; + sn = (*_pred)[sn]; + } + } + return value; + } + + /// \brief Return the minimum cut between two nodes + /// + /// This function returns the minimum cut between the nodes \c s and \c t + /// in the \c cutMap parameter by setting the nodes in the component of + /// \c s to \c true and the other nodes to \c false. + /// + /// For higher level interfaces see MinCutNodeIt and MinCutEdgeIt. + /// + /// \param s The base node. + /// \param t The node you want to separate from node \c s. + /// \param cutMap The cut will be returned in this map. + /// It must be a \c bool (or convertible) \ref concepts::ReadWriteMap + /// "ReadWriteMap" on the graph nodes. + /// + /// \return The value of the minimum cut between \c s and \c t. + /// + /// \pre \ref run() must be called before using this function. + template + Value minCutMap(const Node& s, ///< + const Node& t, + ///< + CutMap& cutMap + ///< + ) const { + Node sn = s, tn = t; + bool s_root=false; + Node rn = INVALID; + Value value = std::numeric_limits::max(); + + while (sn != tn) { + if ((*_order)[sn] < (*_order)[tn]) { + if ((*_weight)[tn] <= value) { + rn = tn; + s_root = false; + value = (*_weight)[tn]; + } + tn = (*_pred)[tn]; + } else { + if ((*_weight)[sn] <= value) { + rn = sn; + s_root = true; + value = (*_weight)[sn]; + } + sn = (*_pred)[sn]; + } + } + + typename Graph::template NodeMap reached(_graph, false); + reached[_root] = true; + cutMap.set(_root, !s_root); + reached[rn] = true; + cutMap.set(rn, s_root); + + std::vector st; + for (NodeIt n(_graph); n != INVALID; ++n) { + st.clear(); + Node nn = n; + while (!reached[nn]) { + st.push_back(nn); + nn = (*_pred)[nn]; + } + while (!st.empty()) { + cutMap.set(st.back(), cutMap[nn]); + st.pop_back(); + } + } + + return value; + } + + ///@} + + friend class MinCutNodeIt; + + /// Iterate on the nodes of a minimum cut + + /// This iterator class lists the nodes of a minimum cut found by + /// GomoryHu. Before using it, you must allocate a GomoryHu class + /// and call its \ref GomoryHu::run() "run()" method. + /// + /// This example counts the nodes in the minimum cut separating \c s from + /// \c t. + /// \code + /// GomoryHu gom(g, capacities); + /// gom.run(); + /// int cnt=0; + /// for(GomoryHu::MinCutNodeIt n(gom,s,t); n!=INVALID; ++n) ++cnt; + /// \endcode + class MinCutNodeIt + { + bool _side; + typename Graph::NodeIt _node_it; + typename Graph::template NodeMap _cut; + public: + /// Constructor + + /// Constructor. + /// + MinCutNodeIt(GomoryHu const &gomory, + ///< The GomoryHu class. You must call its + /// run() method + /// before initializing this iterator. + const Node& s, ///< The base node. + const Node& t, + ///< The node you want to separate from node \c s. + bool side=true + ///< If it is \c true (default) then the iterator lists + /// the nodes of the component containing \c s, + /// otherwise it lists the other component. + /// \note As the minimum cut is not always unique, + /// \code + /// MinCutNodeIt(gomory, s, t, true); + /// \endcode + /// and + /// \code + /// MinCutNodeIt(gomory, t, s, false); + /// \endcode + /// does not necessarily give the same set of nodes. + /// However it is ensured that + /// \code + /// MinCutNodeIt(gomory, s, t, true); + /// \endcode + /// and + /// \code + /// MinCutNodeIt(gomory, s, t, false); + /// \endcode + /// together list each node exactly once. + ) + : _side(side), _cut(gomory._graph) + { + gomory.minCutMap(s,t,_cut); + for(_node_it=typename Graph::NodeIt(gomory._graph); + _node_it!=INVALID && _cut[_node_it]!=_side; + ++_node_it) {} + } + /// Conversion to \c Node + + /// Conversion to \c Node. + /// + operator typename Graph::Node() const + { + return _node_it; + } + bool operator==(Invalid) { return _node_it==INVALID; } + bool operator!=(Invalid) { return _node_it!=INVALID; } + /// Next node + + /// Next node. + /// + MinCutNodeIt &operator++() + { + for(++_node_it;_node_it!=INVALID&&_cut[_node_it]!=_side;++_node_it) {} + return *this; + } + /// Postfix incrementation + + /// Postfix incrementation. + /// + /// \warning This incrementation + /// returns a \c Node, not a \c MinCutNodeIt, as one may + /// expect. + typename Graph::Node operator++(int) + { + typename Graph::Node n=*this; + ++(*this); + return n; + } + }; + + friend class MinCutEdgeIt; + + /// Iterate on the edges of a minimum cut + + /// This iterator class lists the edges of a minimum cut found by + /// GomoryHu. Before using it, you must allocate a GomoryHu class + /// and call its \ref GomoryHu::run() "run()" method. + /// + /// This example computes the value of the minimum cut separating \c s from + /// \c t. + /// \code + /// GomoryHu gom(g, capacities); + /// gom.run(); + /// int value=0; + /// for(GomoryHu::MinCutEdgeIt e(gom,s,t); e!=INVALID; ++e) + /// value+=capacities[e]; + /// \endcode + /// The result will be the same as the value returned by + /// \ref GomoryHu::minCutValue() "gom.minCutValue(s,t)". + class MinCutEdgeIt + { + bool _side; + const Graph &_graph; + typename Graph::NodeIt _node_it; + typename Graph::OutArcIt _arc_it; + typename Graph::template NodeMap _cut; + void step() + { + ++_arc_it; + while(_node_it!=INVALID && _arc_it==INVALID) + { + for(++_node_it;_node_it!=INVALID&&!_cut[_node_it];++_node_it) {} + if(_node_it!=INVALID) + _arc_it=typename Graph::OutArcIt(_graph,_node_it); + } + } + + public: + /// Constructor + + /// Constructor. + /// + MinCutEdgeIt(GomoryHu const &gomory, + ///< The GomoryHu class. You must call its + /// run() method + /// before initializing this iterator. + const Node& s, ///< The base node. + const Node& t, + ///< The node you want to separate from node \c s. + bool side=true + ///< If it is \c true (default) then the listed arcs + /// will be oriented from the + /// nodes of the component containing \c s, + /// otherwise they will be oriented in the opposite + /// direction. + ) + : _graph(gomory._graph), _cut(_graph) + { + gomory.minCutMap(s,t,_cut); + if(!side) + for(typename Graph::NodeIt n(_graph);n!=INVALID;++n) + _cut[n]=!_cut[n]; + + for(_node_it=typename Graph::NodeIt(_graph); + _node_it!=INVALID && !_cut[_node_it]; + ++_node_it) {} + _arc_it = _node_it!=INVALID ? + typename Graph::OutArcIt(_graph,_node_it) : INVALID; + while(_node_it!=INVALID && _arc_it == INVALID) + { + for(++_node_it; _node_it!=INVALID&&!_cut[_node_it]; ++_node_it) {} + if(_node_it!=INVALID) + _arc_it= typename Graph::OutArcIt(_graph,_node_it); + } + while(_arc_it!=INVALID && _cut[_graph.target(_arc_it)]) step(); + } + /// Conversion to \c Arc + + /// Conversion to \c Arc. + /// + operator typename Graph::Arc() const + { + return _arc_it; + } + /// Conversion to \c Edge + + /// Conversion to \c Edge. + /// + operator typename Graph::Edge() const + { + return _arc_it; + } + bool operator==(Invalid) { return _node_it==INVALID; } + bool operator!=(Invalid) { return _node_it!=INVALID; } + /// Next edge + + /// Next edge. + /// + MinCutEdgeIt &operator++() + { + step(); + while(_arc_it!=INVALID && _cut[_graph.target(_arc_it)]) step(); + return *this; + } + /// Postfix incrementation + + /// Postfix incrementation. + /// + /// \warning This incrementation + /// returns an \c Arc, not a \c MinCutEdgeIt, as one may expect. + typename Graph::Arc operator++(int) + { + typename Graph::Arc e=*this; + ++(*this); + return e; + } + }; + + }; + +} + +#endif diff -r c35afa9e89e7 -r ef88c0a30f85 lemon/graph_to_eps.h --- a/lemon/graph_to_eps.h Mon Jan 12 23:11:39 2009 +0100 +++ b/lemon/graph_to_eps.h Thu Nov 05 15:48:01 2009 +0100 @@ -29,9 +29,7 @@ #include #include #else -#define WIN32_LEAN_AND_MEAN -#define NOMINMAX -#include +#include #endif #include @@ -66,11 +64,12 @@ ///Default traits class of \ref GraphToEps. /// -///\c G is the type of the underlying graph. -template +///\param GR is the type of the underlying graph. +template struct DefaultGraphToEpsTraits { - typedef G Graph; + typedef GR Graph; + typedef GR Digraph; typedef typename Graph::Node Node; typedef typename Graph::NodeIt NodeIt; typedef typename Graph::Arc Arc; @@ -141,15 +140,14 @@ ///Constructor ///Constructor - ///\param _g Reference to the graph to be printed. - ///\param _os Reference to the output stream. - ///\param _os Reference to the output stream. + ///\param gr Reference to the graph to be printed. + ///\param ost Reference to the output stream. ///By default it is std::cout. - ///\param _pros If it is \c true, then the \c ostream referenced by \c _os + ///\param pros If it is \c true, then the \c ostream referenced by \c os ///will be explicitly deallocated by the destructor. - DefaultGraphToEpsTraits(const G &_g,std::ostream& _os=std::cout, - bool _pros=false) : - g(_g), os(_os), + DefaultGraphToEpsTraits(const GR &gr, std::ostream& ost = std::cout, + bool pros = false) : + g(gr), os(ost), _coords(dim2::Point(1,1)), _nodeSizes(1), _nodeShapes(0), _nodeColors(WHITE), _arcColors(BLACK), _arcWidths(1.0), _arcWidthScale(0.003), @@ -160,8 +158,8 @@ _enableParallel(false), _parArcDist(1), _showNodeText(false), _nodeTexts(false), _nodeTextSize(1), _showNodePsText(false), _nodePsTexts(false), _nodePsTextsPreamble(0), - _undirected(lemon::UndirectedTagIndicator::value), - _pleaseRemoveOsStream(_pros), _scaleToA4(false), + _undirected(lemon::UndirectedTagIndicator::value), + _pleaseRemoveOsStream(pros), _scaleToA4(false), _nodeTextColorType(SAME_COL), _nodeTextColors(BLACK), _autoNodeScale(false), _autoArcWidthScale(false), @@ -244,6 +242,7 @@ // dradnats ++C eht yb deriuqer si ti eveileb t'naC typedef typename T::Graph Graph; + typedef typename T::Digraph Digraph; typedef typename Graph::Node Node; typedef typename Graph::NodeIt NodeIt; typedef typename Graph::Arc Arc; @@ -271,22 +270,18 @@ /// = 1 ///\image html nodeshape_1.png ///\image latex nodeshape_1.eps "SQUARE shape (1)" width=2cm - /// SQUARE=1, /// = 2 ///\image html nodeshape_2.png ///\image latex nodeshape_2.eps "DIAMOND shape (2)" width=2cm - /// DIAMOND=2, /// = 3 ///\image html nodeshape_3.png - ///\image latex nodeshape_2.eps "MALE shape (4)" width=2cm - /// + ///\image latex nodeshape_3.eps "MALE shape (3)" width=2cm MALE=3, /// = 4 ///\image html nodeshape_4.png - ///\image latex nodeshape_2.eps "FEMALE shape (4)" width=2cm - /// + ///\image latex nodeshape_4.eps "FEMALE shape (4)" width=2cm FEMALE=4 }; @@ -679,29 +674,19 @@ os << "%%Creator: LEMON, graphToEps()\n"; { + os << "%%CreationDate: "; #ifndef WIN32 timeval tv; gettimeofday(&tv, 0); char cbuf[26]; ctime_r(&tv.tv_sec,cbuf); - os << "%%CreationDate: " << cbuf; + os << cbuf; #else - SYSTEMTIME time; - char buf1[11], buf2[9], buf3[5]; - - GetSystemTime(&time); - if (GetDateFormat(LOCALE_USER_DEFAULT, 0, &time, - "ddd MMM dd", buf1, 11) && - GetTimeFormat(LOCALE_USER_DEFAULT, 0, &time, - "HH':'mm':'ss", buf2, 9) && - GetDateFormat(LOCALE_USER_DEFAULT, 0, &time, - "yyyy", buf3, 5)) { - os << "%%CreationDate: " << buf1 << ' ' - << buf2 << ' ' << buf3 << std::endl; - } + os << bits::getWinFormattedDate(); #endif } + os << std::endl; if (_autoArcWidthScale) { double max_w=0; @@ -1146,55 +1131,55 @@ ///\warning Don't forget to put the \ref GraphToEps::run() "run()" ///to the end of the parameter list. ///\sa GraphToEps -///\sa graphToEps(G &g, const char *file_name) -template -GraphToEps > -graphToEps(G &g, std::ostream& os=std::cout) +///\sa graphToEps(GR &g, const char *file_name) +template +GraphToEps > +graphToEps(GR &g, std::ostream& os=std::cout) { return - GraphToEps >(DefaultGraphToEpsTraits(g,os)); + GraphToEps >(DefaultGraphToEpsTraits(g,os)); } ///Generates an EPS file from a graph ///\ingroup eps_io ///This function does the same as -///\ref graphToEps(G &g,std::ostream& os) +///\ref graphToEps(GR &g,std::ostream& os) ///but it writes its output into the file \c file_name ///instead of a stream. -///\sa graphToEps(G &g, std::ostream& os) -template -GraphToEps > -graphToEps(G &g,const char *file_name) +///\sa graphToEps(GR &g, std::ostream& os) +template +GraphToEps > +graphToEps(GR &g,const char *file_name) { std::ostream* os = new std::ofstream(file_name); if (!(*os)) { delete os; throw IoError("Cannot write file", file_name); } - return GraphToEps > - (DefaultGraphToEpsTraits(g,*os,true)); + return GraphToEps > + (DefaultGraphToEpsTraits(g,*os,true)); } ///Generates an EPS file from a graph ///\ingroup eps_io ///This function does the same as -///\ref graphToEps(G &g,std::ostream& os) +///\ref graphToEps(GR &g,std::ostream& os) ///but it writes its output into the file \c file_name ///instead of a stream. -///\sa graphToEps(G &g, std::ostream& os) -template -GraphToEps > -graphToEps(G &g,const std::string& file_name) +///\sa graphToEps(GR &g, std::ostream& os) +template +GraphToEps > +graphToEps(GR &g,const std::string& file_name) { std::ostream* os = new std::ofstream(file_name.c_str()); if (!(*os)) { delete os; throw IoError("Cannot write file", file_name); } - return GraphToEps > - (DefaultGraphToEpsTraits(g,*os,true)); + return GraphToEps > + (DefaultGraphToEpsTraits(g,*os,true)); } } //END OF NAMESPACE LEMON diff -r c35afa9e89e7 -r ef88c0a30f85 lemon/grid_graph.h --- a/lemon/grid_graph.h Mon Jan 12 23:11:39 2009 +0100 +++ b/lemon/grid_graph.h Thu Nov 05 15:48:01 2009 +0100 @@ -470,18 +470,22 @@ /// /// \brief Grid graph class /// - /// 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 + /// 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 /// arcs can be retrieved with the \c right(), \c up(), \c left() /// and \c down() functions, where the bottom-left corner is the /// origin. /// + /// This class is completely static and it needs constant memory space. + /// Thus you can neither add nor delete nodes or edges, however + /// the structure can be resized using resize(). + /// /// \image html grid_graph.png /// \image latex grid_graph.eps "Grid graph" width=\textwidth /// @@ -496,18 +500,19 @@ /// } ///\endcode /// - /// This graph type is fully conform to the \ref concepts::Graph - /// "Graph" concept, and it also has an important extra feature - /// that its maps are real \ref concepts::ReferenceMap - /// "reference map"s. + /// 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. class GridGraph : public ExtendedGridGraphBase { + typedef ExtendedGridGraphBase Parent; + public: - typedef ExtendedGridGraphBase Parent; - - /// \brief Map to get the indices of the nodes as dim2::Point. + /// \brief Map to get the indices of the nodes as \ref dim2::Point + /// "dim2::Point". /// - /// Map to get the indices of the nodes as dim2::Point. + /// Map to get the indices of the nodes as \ref dim2::Point + /// "dim2::Point". class IndexMap { public: /// \brief The key type of the map @@ -516,13 +521,9 @@ typedef dim2::Point Value; /// \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); } @@ -542,13 +543,9 @@ typedef int Value; /// \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,13 +565,9 @@ typedef int Value; /// \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); } @@ -585,15 +578,14 @@ /// \brief Constructor /// - /// Construct a grid graph with given size. + /// Construct a grid graph with the given size. GridGraph(int width, int height) { construct(width, height); } - /// \brief Resize the graph + /// \brief Resizes 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. + /// This function resizes the graph. It fully destroys and + /// rebuilds the structure, therefore the maps of the graph will be + /// reallocated automatically and the previous values will be lost. void resize(int width, int height) { Parent::notifier(Arc()).clear(); Parent::notifier(Edge()).clear(); @@ -611,42 +603,42 @@ return Parent::operator()(i, j); } - /// \brief Gives back the column index of the node. + /// \brief The column index of the node. /// /// Gives back the column index of the node. int col(Node n) const { return Parent::col(n); } - /// \brief Gives back the row index of the node. + /// \brief The row index of the node. /// /// Gives back the row index of the node. int row(Node n) const { return Parent::row(n); } - /// \brief Gives back the position of the node. + /// \brief The position of the node. /// /// Gives back the position of the node, ie. the (col,row) pair. dim2::Point pos(Node n) const { return Parent::pos(n); } - /// \brief Gives back the number of the columns. + /// \brief The number of the columns. /// /// Gives back the number of the columns. int width() const { return Parent::width(); } - /// \brief Gives back the number of the rows. + /// \brief The number of the rows. /// /// Gives back the number of the rows. int height() const { return Parent::height(); } - /// \brief Gives back the arc goes right from the node. + /// \brief The arc goes right from the node. /// /// Gives back the arc goes right from the node. If there is not /// outgoing arc then it gives back INVALID. @@ -654,7 +646,7 @@ return Parent::right(n); } - /// \brief Gives back the arc goes left from the node. + /// \brief The arc goes left from the node. /// /// Gives back the arc goes left from the node. If there is not /// outgoing arc then it gives back INVALID. @@ -662,7 +654,7 @@ return Parent::left(n); } - /// \brief Gives back the arc goes up from the node. + /// \brief The arc goes up from the node. /// /// Gives back the arc goes up from the node. If there is not /// outgoing arc then it gives back INVALID. @@ -670,7 +662,7 @@ return Parent::up(n); } - /// \brief Gives back the arc goes down from the node. + /// \brief The arc goes down from the node. /// /// Gives back the arc goes down from the node. If there is not /// outgoing arc then it gives back INVALID. diff -r c35afa9e89e7 -r ef88c0a30f85 lemon/hao_orlin.h --- a/lemon/hao_orlin.h Mon Jan 12 23:11:39 2009 +0100 +++ b/lemon/hao_orlin.h Thu Nov 05 15:48:01 2009 +0100 @@ -31,57 +31,64 @@ /// \ingroup min_cut /// \brief Implementation of the Hao-Orlin algorithm. /// -/// Implementation of the Hao-Orlin algorithm class for testing network -/// reliability. +/// Implementation of the Hao-Orlin algorithm for finding a minimum cut +/// in a digraph. namespace lemon { /// \ingroup min_cut /// - /// \brief %Hao-Orlin algorithm to find a minimum cut in directed graphs. + /// \brief Hao-Orlin algorithm for finding a minimum cut in a digraph. /// - /// Hao-Orlin calculates a minimum cut in a directed graph - /// \f$D=(V,A)\f$. It takes a fixed node \f$ source \in V \f$ and + /// This class implements the Hao-Orlin algorithm for finding a minimum + /// value cut in a directed graph \f$D=(V,A)\f$. + /// It takes a fixed node \f$ source \in V \f$ and /// consists of two phases: in the first phase it determines a /// minimum cut with \f$ source \f$ on the source-side (i.e. a set - /// \f$ X\subsetneq V \f$ with \f$ source \in X \f$ and minimal - /// out-degree) and in the second phase it determines a minimum cut + /// \f$ X\subsetneq V \f$ with \f$ source \in X \f$ and minimal outgoing + /// capacity) and in the second phase it determines a minimum cut /// with \f$ source \f$ on the sink-side (i.e. a set - /// \f$ X\subsetneq V \f$ with \f$ source \notin X \f$ and minimal - /// out-degree). Obviously, the smaller of these two cuts will be a + /// \f$ X\subsetneq V \f$ with \f$ source \notin X \f$ and minimal outgoing + /// capacity). Obviously, the smaller of these two cuts will be a /// minimum cut of \f$ D \f$. The algorithm is a modified - /// push-relabel preflow algorithm and our implementation calculates + /// preflow push-relabel algorithm. Our implementation calculates /// the minimum cut in \f$ O(n^2\sqrt{m}) \f$ time (we use the /// highest-label rule), or in \f$O(nm)\f$ for unit capacities. The - /// purpose of such algorithm is testing network reliability. For an - /// undirected graph you can run just the first phase of the - /// algorithm or you can use the algorithm of Nagamochi and Ibaraki - /// which solves the undirected problem in - /// \f$ O(nm + n^2 \log(n)) \f$ time: it is implemented in the - /// NagamochiIbaraki algorithm class. + /// purpose of such algorithm is e.g. testing network reliability. /// - /// \param _Digraph is the graph type of the algorithm. - /// \param _CapacityMap is an edge map of capacities which should - /// be any numreric type. The default type is _Digraph::ArcMap. - /// \param _Tolerance is the handler of the inexact computation. The - /// default type for this is Tolerance. + /// For an undirected graph you can run just the first phase of the + /// algorithm or you can use the algorithm of Nagamochi and Ibaraki, + /// which solves the undirected problem in \f$ O(nm + n^2 \log n) \f$ + /// time. It is implemented in the NagamochiIbaraki algorithm class. + /// + /// \tparam GR The type of the digraph the algorithm runs on. + /// \tparam CAP The type of the arc map containing the capacities, + /// which can be any numreric type. The default map type is + /// \ref concepts::Digraph::ArcMap "GR::ArcMap". + /// \tparam TOL Tolerance class for handling inexact computations. The + /// default tolerance type is \ref Tolerance "Tolerance". #ifdef DOXYGEN - template + template #else - template , - typename _Tolerance = Tolerance > + template , + typename TOL = Tolerance > #endif class HaoOrlin { + public: + + /// The digraph type of the algorithm + typedef GR Digraph; + /// The capacity map type of the algorithm + typedef CAP CapacityMap; + /// The tolerance type of the algorithm + typedef TOL Tolerance; + private: - typedef _Digraph Digraph; - typedef _CapacityMap CapacityMap; - typedef _Tolerance Tolerance; - typedef typename CapacityMap::Value Value; - TEMPLATE_GRAPH_TYPEDEFS(Digraph); + TEMPLATE_DIGRAPH_TYPEDEFS(Digraph); const Digraph& _graph; const CapacityMap* _capacity; @@ -161,56 +168,56 @@ private: void activate(const Node& i) { - _active->set(i, true); + (*_active)[i] = true; int bucket = (*_bucket)[i]; if ((*_prev)[i] == INVALID || (*_active)[(*_prev)[i]]) return; //unlace - _next->set((*_prev)[i], (*_next)[i]); + (*_next)[(*_prev)[i]] = (*_next)[i]; if ((*_next)[i] != INVALID) { - _prev->set((*_next)[i], (*_prev)[i]); + (*_prev)[(*_next)[i]] = (*_prev)[i]; } else { _last[bucket] = (*_prev)[i]; } //lace - _next->set(i, _first[bucket]); - _prev->set(_first[bucket], i); - _prev->set(i, INVALID); + (*_next)[i] = _first[bucket]; + (*_prev)[_first[bucket]] = i; + (*_prev)[i] = INVALID; _first[bucket] = i; } void deactivate(const Node& i) { - _active->set(i, false); + (*_active)[i] = false; int bucket = (*_bucket)[i]; if ((*_next)[i] == INVALID || !(*_active)[(*_next)[i]]) return; //unlace - _prev->set((*_next)[i], (*_prev)[i]); + (*_prev)[(*_next)[i]] = (*_prev)[i]; if ((*_prev)[i] != INVALID) { - _next->set((*_prev)[i], (*_next)[i]); + (*_next)[(*_prev)[i]] = (*_next)[i]; } else { _first[bucket] = (*_next)[i]; } //lace - _prev->set(i, _last[bucket]); - _next->set(_last[bucket], i); - _next->set(i, INVALID); + (*_prev)[i] = _last[bucket]; + (*_next)[_last[bucket]] = i; + (*_next)[i] = INVALID; _last[bucket] = i; } void addItem(const Node& i, int bucket) { (*_bucket)[i] = bucket; if (_last[bucket] != INVALID) { - _prev->set(i, _last[bucket]); - _next->set(_last[bucket], i); - _next->set(i, INVALID); + (*_prev)[i] = _last[bucket]; + (*_next)[_last[bucket]] = i; + (*_next)[i] = INVALID; _last[bucket] = i; } else { - _prev->set(i, INVALID); + (*_prev)[i] = INVALID; _first[bucket] = i; - _next->set(i, INVALID); + (*_next)[i] = INVALID; _last[bucket] = i; } } @@ -218,11 +225,12 @@ void findMinCutOut() { for (NodeIt n(_graph); n != INVALID; ++n) { - _excess->set(n, 0); + (*_excess)[n] = 0; + (*_source_set)[n] = false; } for (ArcIt a(_graph); a != INVALID; ++a) { - _flow->set(a, 0); + (*_flow)[a] = 0; } int bucket_num = 0; @@ -232,7 +240,7 @@ { typename Digraph::template NodeMap reached(_graph, false); - reached.set(_source, true); + reached[_source] = true; bool first_set = true; for (NodeIt t(_graph); t != INVALID; ++t) { @@ -240,7 +248,7 @@ _sets.push_front(std::list()); queue[qlast++] = t; - reached.set(t, true); + reached[t] = true; while (qfirst != qlast) { if (qsep == qfirst) { @@ -257,7 +265,7 @@ for (InArcIt a(_graph, n); a != INVALID; ++a) { Node u = _graph.source(a); if (!reached[u] && _tolerance.positive((*_capacity)[a])) { - reached.set(u, true); + reached[u] = true; queue[qlast++] = u; } } @@ -266,18 +274,18 @@ } ++bucket_num; - _bucket->set(_source, 0); + (*_bucket)[_source] = 0; _dormant[0] = true; } - _source_set->set(_source, true); + (*_source_set)[_source] = true; Node target = _last[_sets.back().back()]; { for (OutArcIt a(_graph, _source); a != INVALID; ++a) { if (_tolerance.positive((*_capacity)[a])) { Node u = _graph.target(a); - _flow->set(a, (*_capacity)[a]); - _excess->set(u, (*_excess)[u] + (*_capacity)[a]); + (*_flow)[a] = (*_capacity)[a]; + (*_excess)[u] += (*_capacity)[a]; if (!(*_active)[u] && u != _source) { activate(u); } @@ -318,14 +326,14 @@ activate(v); } if (!_tolerance.less(rem, excess)) { - _flow->set(a, (*_flow)[a] + excess); - _excess->set(v, (*_excess)[v] + excess); + (*_flow)[a] += excess; + (*_excess)[v] += excess; excess = 0; goto no_more_push; } else { excess -= rem; - _excess->set(v, (*_excess)[v] + rem); - _flow->set(a, (*_capacity)[a]); + (*_excess)[v] += rem; + (*_flow)[a] = (*_capacity)[a]; } } else if (next_bucket > (*_bucket)[v]) { next_bucket = (*_bucket)[v]; @@ -342,14 +350,14 @@ activate(v); } if (!_tolerance.less(rem, excess)) { - _flow->set(a, (*_flow)[a] - excess); - _excess->set(v, (*_excess)[v] + excess); + (*_flow)[a] -= excess; + (*_excess)[v] += excess; excess = 0; goto no_more_push; } else { excess -= rem; - _excess->set(v, (*_excess)[v] + rem); - _flow->set(a, 0); + (*_excess)[v] += rem; + (*_flow)[a] = 0; } } else if (next_bucket > (*_bucket)[v]) { next_bucket = (*_bucket)[v]; @@ -358,7 +366,7 @@ no_more_push: - _excess->set(n, excess); + (*_excess)[n] = excess; if (excess != 0) { if ((*_next)[n] == INVALID) { @@ -376,16 +384,16 @@ } } else if (next_bucket == _node_num) { _first[(*_bucket)[n]] = (*_next)[n]; - _prev->set((*_next)[n], INVALID); + (*_prev)[(*_next)[n]] = INVALID; std::list >::iterator new_set = _sets.insert(--_sets.end(), std::list()); new_set->push_front(bucket_num); - _bucket->set(n, bucket_num); + (*_bucket)[n] = bucket_num; _first[bucket_num] = _last[bucket_num] = n; - _next->set(n, INVALID); - _prev->set(n, INVALID); + (*_next)[n] = INVALID; + (*_prev)[n] = INVALID; _dormant[bucket_num] = true; ++bucket_num; @@ -395,7 +403,7 @@ } } else { _first[*_highest] = (*_next)[n]; - _prev->set((*_next)[n], INVALID); + (*_prev)[(*_next)[n]] = INVALID; while (next_bucket != *_highest) { --_highest; @@ -409,10 +417,10 @@ } --_highest; - _bucket->set(n, *_highest); - _next->set(n, _first[*_highest]); + (*_bucket)[n] = *_highest; + (*_next)[n] = _first[*_highest]; if (_first[*_highest] != INVALID) { - _prev->set(_first[*_highest], n); + (*_prev)[_first[*_highest]] = n; } else { _last[*_highest] = n; } @@ -434,13 +442,13 @@ if ((*_excess)[target] < _min_cut) { _min_cut = (*_excess)[target]; for (NodeIt i(_graph); i != INVALID; ++i) { - _min_cut_map->set(i, true); + (*_min_cut_map)[i] = true; } for (std::list::iterator it = _sets.back().begin(); it != _sets.back().end(); ++it) { Node n = _first[*it]; while (n != INVALID) { - _min_cut_map->set(n, false); + (*_min_cut_map)[n] = false; n = (*_next)[n]; } } @@ -453,13 +461,13 @@ _last[(*_bucket)[target]] = (*_prev)[target]; new_target = (*_prev)[target]; } else { - _prev->set((*_next)[target], (*_prev)[target]); + (*_prev)[(*_next)[target]] = (*_prev)[target]; new_target = (*_next)[target]; } if ((*_prev)[target] == INVALID) { _first[(*_bucket)[target]] = (*_next)[target]; } else { - _next->set((*_prev)[target], (*_next)[target]); + (*_next)[(*_prev)[target]] = (*_next)[target]; } } else { _sets.back().pop_back(); @@ -475,9 +483,9 @@ new_target = _last[_sets.back().back()]; } - _bucket->set(target, 0); + (*_bucket)[target] = 0; - _source_set->set(target, true); + (*_source_set)[target] = true; for (OutArcIt a(_graph, target); a != INVALID; ++a) { Value rem = (*_capacity)[a] - (*_flow)[a]; if (!_tolerance.positive(rem)) continue; @@ -485,8 +493,8 @@ if (!(*_active)[v] && !(*_source_set)[v]) { activate(v); } - _excess->set(v, (*_excess)[v] + rem); - _flow->set(a, (*_capacity)[a]); + (*_excess)[v] += rem; + (*_flow)[a] = (*_capacity)[a]; } for (InArcIt a(_graph, target); a != INVALID; ++a) { @@ -496,8 +504,8 @@ if (!(*_active)[v] && !(*_source_set)[v]) { activate(v); } - _excess->set(v, (*_excess)[v] + rem); - _flow->set(a, 0); + (*_excess)[v] += rem; + (*_flow)[a] = 0; } target = new_target; @@ -517,11 +525,12 @@ void findMinCutIn() { for (NodeIt n(_graph); n != INVALID; ++n) { - _excess->set(n, 0); + (*_excess)[n] = 0; + (*_source_set)[n] = false; } for (ArcIt a(_graph); a != INVALID; ++a) { - _flow->set(a, 0); + (*_flow)[a] = 0; } int bucket_num = 0; @@ -531,7 +540,7 @@ { typename Digraph::template NodeMap reached(_graph, false); - reached.set(_source, true); + reached[_source] = true; bool first_set = true; @@ -540,7 +549,7 @@ _sets.push_front(std::list()); queue[qlast++] = t; - reached.set(t, true); + reached[t] = true; while (qfirst != qlast) { if (qsep == qfirst) { @@ -557,7 +566,7 @@ for (OutArcIt a(_graph, n); a != INVALID; ++a) { Node u = _graph.target(a); if (!reached[u] && _tolerance.positive((*_capacity)[a])) { - reached.set(u, true); + reached[u] = true; queue[qlast++] = u; } } @@ -566,18 +575,18 @@ } ++bucket_num; - _bucket->set(_source, 0); + (*_bucket)[_source] = 0; _dormant[0] = true; } - _source_set->set(_source, true); + (*_source_set)[_source] = true; Node target = _last[_sets.back().back()]; { for (InArcIt a(_graph, _source); a != INVALID; ++a) { if (_tolerance.positive((*_capacity)[a])) { Node u = _graph.source(a); - _flow->set(a, (*_capacity)[a]); - _excess->set(u, (*_excess)[u] + (*_capacity)[a]); + (*_flow)[a] = (*_capacity)[a]; + (*_excess)[u] += (*_capacity)[a]; if (!(*_active)[u] && u != _source) { activate(u); } @@ -618,14 +627,14 @@ activate(v); } if (!_tolerance.less(rem, excess)) { - _flow->set(a, (*_flow)[a] + excess); - _excess->set(v, (*_excess)[v] + excess); + (*_flow)[a] += excess; + (*_excess)[v] += excess; excess = 0; goto no_more_push; } else { excess -= rem; - _excess->set(v, (*_excess)[v] + rem); - _flow->set(a, (*_capacity)[a]); + (*_excess)[v] += rem; + (*_flow)[a] = (*_capacity)[a]; } } else if (next_bucket > (*_bucket)[v]) { next_bucket = (*_bucket)[v]; @@ -642,14 +651,14 @@ activate(v); } if (!_tolerance.less(rem, excess)) { - _flow->set(a, (*_flow)[a] - excess); - _excess->set(v, (*_excess)[v] + excess); + (*_flow)[a] -= excess; + (*_excess)[v] += excess; excess = 0; goto no_more_push; } else { excess -= rem; - _excess->set(v, (*_excess)[v] + rem); - _flow->set(a, 0); + (*_excess)[v] += rem; + (*_flow)[a] = 0; } } else if (next_bucket > (*_bucket)[v]) { next_bucket = (*_bucket)[v]; @@ -658,7 +667,7 @@ no_more_push: - _excess->set(n, excess); + (*_excess)[n] = excess; if (excess != 0) { if ((*_next)[n] == INVALID) { @@ -676,16 +685,16 @@ } } else if (next_bucket == _node_num) { _first[(*_bucket)[n]] = (*_next)[n]; - _prev->set((*_next)[n], INVALID); + (*_prev)[(*_next)[n]] = INVALID; std::list >::iterator new_set = _sets.insert(--_sets.end(), std::list()); new_set->push_front(bucket_num); - _bucket->set(n, bucket_num); + (*_bucket)[n] = bucket_num; _first[bucket_num] = _last[bucket_num] = n; - _next->set(n, INVALID); - _prev->set(n, INVALID); + (*_next)[n] = INVALID; + (*_prev)[n] = INVALID; _dormant[bucket_num] = true; ++bucket_num; @@ -695,7 +704,7 @@ } } else { _first[*_highest] = (*_next)[n]; - _prev->set((*_next)[n], INVALID); + (*_prev)[(*_next)[n]] = INVALID; while (next_bucket != *_highest) { --_highest; @@ -708,10 +717,10 @@ } --_highest; - _bucket->set(n, *_highest); - _next->set(n, _first[*_highest]); + (*_bucket)[n] = *_highest; + (*_next)[n] = _first[*_highest]; if (_first[*_highest] != INVALID) { - _prev->set(_first[*_highest], n); + (*_prev)[_first[*_highest]] = n; } else { _last[*_highest] = n; } @@ -733,13 +742,13 @@ if ((*_excess)[target] < _min_cut) { _min_cut = (*_excess)[target]; for (NodeIt i(_graph); i != INVALID; ++i) { - _min_cut_map->set(i, false); + (*_min_cut_map)[i] = false; } for (std::list::iterator it = _sets.back().begin(); it != _sets.back().end(); ++it) { Node n = _first[*it]; while (n != INVALID) { - _min_cut_map->set(n, true); + (*_min_cut_map)[n] = true; n = (*_next)[n]; } } @@ -752,13 +761,13 @@ _last[(*_bucket)[target]] = (*_prev)[target]; new_target = (*_prev)[target]; } else { - _prev->set((*_next)[target], (*_prev)[target]); + (*_prev)[(*_next)[target]] = (*_prev)[target]; new_target = (*_next)[target]; } if ((*_prev)[target] == INVALID) { _first[(*_bucket)[target]] = (*_next)[target]; } else { - _next->set((*_prev)[target], (*_next)[target]); + (*_next)[(*_prev)[target]] = (*_next)[target]; } } else { _sets.back().pop_back(); @@ -774,9 +783,9 @@ new_target = _last[_sets.back().back()]; } - _bucket->set(target, 0); + (*_bucket)[target] = 0; - _source_set->set(target, true); + (*_source_set)[target] = true; for (InArcIt a(_graph, target); a != INVALID; ++a) { Value rem = (*_capacity)[a] - (*_flow)[a]; if (!_tolerance.positive(rem)) continue; @@ -784,8 +793,8 @@ if (!(*_active)[v] && !(*_source_set)[v]) { activate(v); } - _excess->set(v, (*_excess)[v] + rem); - _flow->set(a, (*_capacity)[a]); + (*_excess)[v] += rem; + (*_flow)[a] = (*_capacity)[a]; } for (OutArcIt a(_graph, target); a != INVALID; ++a) { @@ -795,8 +804,8 @@ if (!(*_active)[v] && !(*_source_set)[v]) { activate(v); } - _excess->set(v, (*_excess)[v] + rem); - _flow->set(a, 0); + (*_excess)[v] += rem; + (*_flow)[a] = 0; } target = new_target; @@ -815,31 +824,32 @@ public: - /// \name Execution control + /// \name Execution Control /// The simplest way to execute the algorithm is to use - /// one of the member functions called \c run(...). + /// one of the member functions called \ref run(). /// \n - /// If you need more control on the execution, - /// first you must call \ref init(), then the \ref calculateIn() or - /// \ref calculateOut() functions. + /// If you need better control on the execution, + /// you have to call one of the \ref init() functions first, then + /// \ref calculateOut() and/or \ref calculateIn(). /// @{ - /// \brief Initializes the internal data structures. + /// \brief Initialize the internal data structures. /// - /// Initializes the internal data structures. It creates - /// the maps, residual graph adaptors and some bucket structures - /// for the algorithm. + /// This function initializes the internal data structures. It creates + /// the maps and some bucket structures for the algorithm. + /// The first node is used as the source node for the push-relabel + /// algorithm. void init() { init(NodeIt(_graph)); } - /// \brief Initializes the internal data structures. + /// \brief Initialize the internal data structures. /// - /// Initializes the internal data structures. It creates - /// the maps, residual graph adaptor and some bucket structures - /// for the algorithm. Node \c source is used as the push-relabel - /// algorithm's source. + /// This function initializes the internal data structures. It creates + /// the maps and some bucket structures for the algorithm. + /// The given node is used as the source node for the push-relabel + /// algorithm. void init(const Node& source) { _source = source; @@ -879,31 +889,35 @@ } - /// \brief Calculates a minimum cut with \f$ source \f$ on the + /// \brief Calculate a minimum cut with \f$ source \f$ on the /// source-side. /// - /// Calculates a minimum cut with \f$ source \f$ on the + /// This function calculates a minimum cut with \f$ source \f$ on the /// source-side (i.e. a set \f$ X\subsetneq V \f$ with - /// \f$ source \in X \f$ and minimal out-degree). + /// \f$ source \in X \f$ and minimal outgoing capacity). + /// + /// \pre \ref init() must be called before using this function. void calculateOut() { findMinCutOut(); } - /// \brief Calculates a minimum cut with \f$ source \f$ on the - /// target-side. + /// \brief Calculate a minimum cut with \f$ source \f$ on the + /// sink-side. /// - /// Calculates a minimum cut with \f$ source \f$ on the - /// target-side (i.e. a set \f$ X\subsetneq V \f$ with - /// \f$ source \in X \f$ and minimal out-degree). + /// This function calculates a minimum cut with \f$ source \f$ on the + /// sink-side (i.e. a set \f$ X\subsetneq V \f$ with + /// \f$ source \notin X \f$ and minimal outgoing capacity). + /// + /// \pre \ref init() must be called before using this function. void calculateIn() { findMinCutIn(); } - /// \brief Runs the algorithm. + /// \brief Run the algorithm. /// - /// Runs the algorithm. It finds nodes \c source and \c target - /// arbitrarily and then calls \ref init(), \ref calculateOut() + /// This function runs the algorithm. It finds nodes \c source and + /// \c target arbitrarily and then calls \ref init(), \ref calculateOut() /// and \ref calculateIn(). void run() { init(); @@ -911,11 +925,11 @@ calculateIn(); } - /// \brief Runs the algorithm. + /// \brief Run the algorithm. /// - /// Runs the algorithm. It uses the given \c source node, finds a - /// proper \c target and then calls the \ref init(), \ref - /// calculateOut() and \ref calculateIn(). + /// This function runs the algorithm. It uses the given \c source node, + /// finds a proper \c target node and then calls the \ref init(), + /// \ref calculateOut() and \ref calculateIn(). void run(const Node& s) { init(s); calculateOut(); @@ -926,32 +940,41 @@ /// \name Query Functions /// The result of the %HaoOrlin algorithm - /// can be obtained using these functions. - /// \n - /// Before using these functions, either \ref run(), \ref - /// calculateOut() or \ref calculateIn() must be called. + /// can be obtained using these functions.\n + /// \ref run(), \ref calculateOut() or \ref calculateIn() + /// should be called before using them. /// @{ - /// \brief Returns the value of the minimum value cut. + /// \brief Return the value of the minimum cut. /// - /// Returns the value of the minimum value cut. + /// This function returns the value of the minimum cut. + /// + /// \pre \ref run(), \ref calculateOut() or \ref calculateIn() + /// must be called before using this function. Value minCutValue() const { return _min_cut; } - /// \brief Returns a minimum cut. + /// \brief Return a minimum cut. /// - /// Sets \c nodeMap to the characteristic vector of a minimum - /// value cut: it will give a nonempty set \f$ X\subsetneq V \f$ - /// with minimal out-degree (i.e. \c nodeMap will be true exactly - /// for the nodes of \f$ X \f$). \pre nodeMap should be a - /// bool-valued node-map. - template - Value minCutMap(NodeMap& nodeMap) const { + /// This function sets \c cutMap to the characteristic vector of a + /// minimum value cut: it will give a non-empty set \f$ X\subsetneq V \f$ + /// with minimal outgoing capacity (i.e. \c cutMap will be \c true exactly + /// for the nodes of \f$ X \f$). + /// + /// \param cutMap A \ref concepts::WriteMap "writable" node map with + /// \c bool (or convertible) value type. + /// + /// \return The value of the minimum cut. + /// + /// \pre \ref run(), \ref calculateOut() or \ref calculateIn() + /// must be called before using this function. + template + Value minCutMap(CutMap& cutMap) const { for (NodeIt it(_graph); it != INVALID; ++it) { - nodeMap.set(it, (*_min_cut_map)[it]); + cutMap.set(it, (*_min_cut_map)[it]); } return _min_cut; } @@ -960,7 +983,6 @@ }; //class HaoOrlin - } //namespace lemon #endif //LEMON_HAO_ORLIN_H diff -r c35afa9e89e7 -r ef88c0a30f85 lemon/hartmann_orlin.h --- /dev/null Thu Jan 01 00:00:00 1970 +0000 +++ b/lemon/hartmann_orlin.h Thu Nov 05 15:48:01 2009 +0100 @@ -0,0 +1,640 @@ +/* -*- C++ -*- + * + * This file is a part of LEMON, a generic C++ optimization library + * + * Copyright (C) 2003-2008 + * Egervary Jeno Kombinatorikus Optimalizalasi Kutatocsoport + * (Egervary Research Group on Combinatorial Optimization, EGRES). + * + * Permission to use, modify and distribute this software is granted + * provided that this copyright notice appears in all copies. For + * precise terms see the accompanying LICENSE file. + * + * This software is provided "AS IS" with no warranty of any kind, + * express or implied, and with no claim as to its suitability for any + * purpose. + * + */ + +#ifndef LEMON_HARTMANN_ORLIN_H +#define LEMON_HARTMANN_ORLIN_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 HartmannOrlin algorithm. + /// + /// Default traits class of HartmannOrlin algorithm. + /// \tparam GR The type of the digraph. + /// \tparam LEN The type of the length map. + /// It must conform to the \ref concepts::Rea_data "Rea_data" concept. +#ifdef DOXYGEN + template +#else + template ::is_integer> +#endif + struct HartmannOrlinDefaultTraits + { + /// The type of the digraph + typedef GR Digraph; + /// The type of the length map + typedef LEN LengthMap; + /// The type of the arc lengths + typedef typename LengthMap::Value Value; + + /// \brief The large value type used for internal computations + /// + /// The large value type used for internal computations. + /// It is \c long \c long if the \c Value type is integer, + /// otherwise it is \c double. + /// \c Value must be convertible to \c LargeValue. + typedef double LargeValue; + + /// 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 value types + template + struct HartmannOrlinDefaultTraits + { + typedef GR Digraph; + typedef LEN LengthMap; + typedef typename LengthMap::Value Value; +#ifdef LEMON_HAVE_LONG_LONG + typedef long long LargeValue; +#else + typedef long LargeValue; +#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 length (cost) in a digraph + /// \ref amo93networkflows, \ref dasdan98minmeancycle. + /// It is an improved version of \ref Karp "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 LEN The type of the length map. The default + /// map type is \ref concepts::Digraph::ArcMap "GR::ArcMap". +#ifdef DOXYGEN + template +#else + template < typename GR, + typename LEN = typename GR::template ArcMap, + typename TR = HartmannOrlinDefaultTraits > +#endif + class HartmannOrlin + { + public: + + /// The type of the digraph + typedef typename TR::Digraph Digraph; + /// The type of the length map + typedef typename TR::LengthMap LengthMap; + /// The type of the arc lengths + typedef typename TR::Value Value; + + /// \brief The large value type + /// + /// The large value type used for internal computations. + /// Using the \ref HartmannOrlinDefaultTraits "default traits class", + /// it is \c long \c long if the \c Value type is integer, + /// otherwise it is \c double. + typedef typename TR::LargeValue LargeValue; + + /// 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 HartmannOrlinDefaultTraits "default traits class", + /// it is \ref lemon::Path "Path". + typedef typename TR::Path Path; + + /// The \ref HartmannOrlinDefaultTraits "traits class" of the algorithm + typedef TR Traits; + + private: + + TEMPLATE_DIGRAPH_TYPEDEFS(Digraph); + + // Data sturcture for path data + struct PathData + { + LargeValue dist; + Arc pred; + PathData(LargeValue 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 length of the arcs + const LengthMap &_length; + + // 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; + LargeValue _curr_length, _best_length; + 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 LargeValue INF; + + public: + + /// \name Named Template Parameters + /// @{ + + template + struct SetLargeValueTraits : public Traits { + typedef T LargeValue; + typedef lemon::Tolerance Tolerance; + }; + + /// \brief \ref named-templ-param "Named parameter" for setting + /// \c LargeValue type. + /// + /// \ref named-templ-param "Named parameter" for setting \c LargeValue + /// type. It is used for internal computations in the algorithm. + template + struct SetLargeValue + : public HartmannOrlin > { + typedef HartmannOrlin > 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 HartmannOrlin > { + typedef HartmannOrlin > Create; + }; + + /// @} + + public: + + /// \brief Constructor. + /// + /// The constructor of the class. + /// + /// \param digraph The digraph the algorithm runs on. + /// \param length The lengths (costs) of the arcs. + HartmannOrlin( const Digraph &digraph, + const LengthMap &length ) : + _gr(digraph), _length(length), _comp(digraph), _out_arcs(digraph), + _best_found(false), _best_length(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. + ~HartmannOrlin() { + 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 findMinMean(), 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) + HartmannOrlin& 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) + HartmannOrlin& 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 length, you may call + /// \ref findMinMean(). + + /// @{ + + /// \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 lengths 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.findMinMean() && mmc.findCycle(); + /// \endcode + bool run() { + return findMinMean() && findCycle(); + } + + /// \brief Find the minimum cycle mean. + /// + /// This function finds the minimum mean length of the directed + /// cycles in the digraph. + /// + /// \return \c true if a directed cycle exists in the digraph. + bool findMinMean() { + // 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_length * _best_size < _best_length * _curr_size) ) { + _best_found = true; + _best_length = _curr_length; + _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 length + /// in the digraph using the data computed by findMinMean(). + /// + /// \return \c true if a directed cycle exists in the digraph. + /// + /// \pre \ref findMinMean() 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_length = _length[e]; + _best_size = 1; + Node v; + while ((v = _gr.source(e)) != u) { + e = _data[v][--r].pred; + _cycle_path->addFront(e); + _best_length += _length[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 length of the found cycle. + /// + /// This function returns the total length of the found cycle. + /// + /// \pre \ref run() or \ref findMinMean() must be called before + /// using this function. + LargeValue cycleLength() const { + return _best_length; + } + + /// \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 findMinMean() must be called before + /// using this function. + int cycleArcNum() const { + return _best_size; + } + + /// \brief Return the mean length of the found cycle. + /// + /// This function returns the mean length of the found cycle. + /// + /// \note alg.cycleMean() is just a shortcut of the + /// following code. + /// \code + /// return static_cast(alg.cycleLength()) / alg.cycleArcNum(); + /// \endcode + /// + /// \pre \ref run() or \ref findMinMean() must be called before + /// using this function. + double cycleMean() const { + return static_cast(_best_length) / _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_length = 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 length 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; + LargeValue 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 + _length[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; + LargeValue 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 + _length[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(); + LargeValue length; + 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 + length = _data[u][level[u].second].dist - _data[u][j].dist; + size = level[u].second - j; + if (!_curr_found || length * _curr_size < _curr_length * size) { + _curr_length = length; + _curr_size = size; + _curr_node = u; + _curr_level = level[u].second; + _curr_found = true; + } + } + level[u] = Pair(i, j); + u = _gr.source(_data[u][j].pred); + } + } + + // If at least one cycle is found, check the optimality condition + LargeValue 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_length; + 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(_length[a] * _curr_size - _curr_length, + pi[_gr.target(a)] - pi[_gr.source(a)]) ) { + done = false; + break; + } + } + return done; + } + return (k == n); + } + + }; //class HartmannOrlin + + ///@} + +} //namespace lemon + +#endif //LEMON_HARTMANN_ORLIN_H diff -r c35afa9e89e7 -r ef88c0a30f85 lemon/howard.h --- /dev/null Thu Jan 01 00:00:00 1970 +0000 +++ b/lemon/howard.h Thu Nov 05 15:48:01 2009 +0100 @@ -0,0 +1,597 @@ +/* -*- C++ -*- + * + * This file is a part of LEMON, a generic C++ optimization library + * + * Copyright (C) 2003-2008 + * Egervary Jeno Kombinatorikus Optimalizalasi Kutatocsoport + * (Egervary Research Group on Combinatorial Optimization, EGRES). + * + * Permission to use, modify and distribute this software is granted + * provided that this copyright notice appears in all copies. For + * precise terms see the accompanying LICENSE file. + * + * This software is provided "AS IS" with no warranty of any kind, + * express or implied, and with no claim as to its suitability for any + * purpose. + * + */ + +#ifndef LEMON_HOWARD_H +#define LEMON_HOWARD_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 Howard class. + /// + /// Default traits class of Howard class. + /// \tparam GR The type of the digraph. + /// \tparam LEN The type of the length map. + /// It must conform to the \ref concepts::ReadMap "ReadMap" concept. +#ifdef DOXYGEN + template +#else + template ::is_integer> +#endif + struct HowardDefaultTraits + { + /// The type of the digraph + typedef GR Digraph; + /// The type of the length map + typedef LEN LengthMap; + /// The type of the arc lengths + typedef typename LengthMap::Value Value; + + /// \brief The large value type used for internal computations + /// + /// The large value type used for internal computations. + /// It is \c long \c long if the \c Value type is integer, + /// otherwise it is \c double. + /// \c Value must be convertible to \c LargeValue. + typedef double LargeValue; + + /// 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 value types + template + struct HowardDefaultTraits + { + typedef GR Digraph; + typedef LEN LengthMap; + typedef typename LengthMap::Value Value; +#ifdef LEMON_HAVE_LONG_LONG + typedef long long LargeValue; +#else + typedef long LargeValue; +#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 length (cost) in a digraph + /// \ref amo93networkflows, \ref dasdan98minmeancycle. + /// This class provides the most efficient algorithm for the + /// minimum mean cycle problem, though the best known theoretical + /// bound on its running time is exponential. + /// + /// \tparam GR The type of the digraph the algorithm runs on. + /// \tparam LEN The type of the length map. The default + /// map type is \ref concepts::Digraph::ArcMap "GR::ArcMap". +#ifdef DOXYGEN + template +#else + template < typename GR, + typename LEN = typename GR::template ArcMap, + typename TR = HowardDefaultTraits > +#endif + class Howard + { + public: + + /// The type of the digraph + typedef typename TR::Digraph Digraph; + /// The type of the length map + typedef typename TR::LengthMap LengthMap; + /// The type of the arc lengths + typedef typename TR::Value Value; + + /// \brief The large value type + /// + /// The large value type used for internal computations. + /// Using the \ref HowardDefaultTraits "default traits class", + /// it is \c long \c long if the \c Value type is integer, + /// otherwise it is \c double. + typedef typename TR::LargeValue LargeValue; + + /// 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 HowardDefaultTraits "default traits class", + /// it is \ref lemon::Path "Path". + typedef typename TR::Path Path; + + /// The \ref HowardDefaultTraits "traits class" of the algorithm + typedef TR Traits; + + private: + + TEMPLATE_DIGRAPH_TYPEDEFS(Digraph); + + // The digraph the algorithm runs on + const Digraph &_gr; + // The length of the arcs + const LengthMap &_length; + + // Data for the found cycles + bool _curr_found, _best_found; + LargeValue _curr_length, _best_length; + 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 LargeValue INF; + + public: + + /// \name Named Template Parameters + /// @{ + + template + struct SetLargeValueTraits : public Traits { + typedef T LargeValue; + typedef lemon::Tolerance Tolerance; + }; + + /// \brief \ref named-templ-param "Named parameter" for setting + /// \c LargeValue type. + /// + /// \ref named-templ-param "Named parameter" for setting \c LargeValue + /// type. It is used for internal computations in the algorithm. + template + struct SetLargeValue + : public Howard > { + typedef Howard > 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 Howard > { + typedef Howard > Create; + }; + + /// @} + + public: + + /// \brief Constructor. + /// + /// The constructor of the class. + /// + /// \param digraph The digraph the algorithm runs on. + /// \param length The lengths (costs) of the arcs. + Howard( const Digraph &digraph, + const LengthMap &length ) : + _gr(digraph), _length(length), _best_found(false), + _best_length(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. + ~Howard() { + 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 findMinMean(), 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) + Howard& 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) + Howard& 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 length, you may call + /// \ref findMinMean(). + + /// @{ + + /// \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 lengths 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.findMinMean() && mmc.findCycle(); + /// \endcode + bool run() { + return findMinMean() && findCycle(); + } + + /// \brief Find the minimum cycle mean. + /// + /// This function finds the minimum mean length of the directed + /// cycles in the digraph. + /// + /// \return \c true if a directed cycle exists in the digraph. + bool findMinMean() { + // 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_length * _best_size < _best_length * _curr_size) ) { + _best_found = true; + _best_length = _curr_length; + _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 length + /// in the digraph using the data computed by findMinMean(). + /// + /// \return \c true if a directed cycle exists in the digraph. + /// + /// \pre \ref findMinMean() 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 length of the found cycle. + /// + /// This function returns the total length of the found cycle. + /// + /// \pre \ref run() or \ref findMinMean() must be called before + /// using this function. + LargeValue cycleLength() const { + return _best_length; + } + + /// \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 findMinMean() must be called before + /// using this function. + int cycleArcNum() const { + return _best_size; + } + + /// \brief Return the mean length of the found cycle. + /// + /// This function returns the mean length of the found cycle. + /// + /// \note alg.cycleMean() is just a shortcut of the + /// following code. + /// \code + /// return static_cast(alg.cycleLength()) / alg.cycleArcNum(); + /// \endcode + /// + /// \pre \ref run() or \ref findMinMean() must be called before + /// using this function. + double cycleMean() const { + return static_cast(_best_length) / _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_length = 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 (_length[e] < _dist[u]) { + _dist[u] = _length[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; + } + LargeValue clength; + 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 + clength = _length[_policy[u]]; + csize = 1; + for (v = u; (v = _gr.target(_policy[v])) != u; ) { + clength += _length[_policy[v]]; + ++csize; + } + if ( !_curr_found || + (clength * _curr_size < _curr_length * csize) ) { + _curr_found = true; + _curr_length = clength; + _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] + _length[e] * _curr_size - _curr_length; + _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] + _length[e] * _curr_size - _curr_length; + _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); + LargeValue delta = _dist[v] + _length[e] * _curr_size - _curr_length; + if (_tolerance.less(delta, _dist[u])) { + _dist[u] = delta; + _policy[u] = e; + improved = true; + } + } + } + return improved; + } + + }; //class Howard + + ///@} + +} //namespace lemon + +#endif //LEMON_HOWARD_H diff -r c35afa9e89e7 -r ef88c0a30f85 lemon/hypercube_graph.h --- a/lemon/hypercube_graph.h Mon Jan 12 23:11:39 2009 +0100 +++ b/lemon/hypercube_graph.h Thu Nov 05 15:48:01 2009 +0100 @@ -262,7 +262,7 @@ return arc._id >> _dim; } - int index(Node node) const { + static int index(Node node) { return node._id; } @@ -282,29 +282,46 @@ /// /// \brief Hypercube graph class /// - /// This class implements a special graph type. The nodes of the graph - /// are indiced with integers with at most \c dim binary digits. + /// HypercubeGraph implements a special graph type. The nodes of the + /// graph are indexed with integers having at most \c dim binary digits. /// Two nodes are connected in the graph if and only if their indices /// differ only on one position in the binary form. + /// This class is completely static and it needs constant memory space. + /// Thus you can neither add nor delete nodes or edges, however + /// the structure can be resized using resize(). + /// + /// This type fully conforms to the \ref concepts::Graph "Graph concept". + /// Most of its member functions and nested classes are documented + /// only in the concept class. /// /// \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 is fully conform to the \ref concepts::Graph - /// "Graph" concept, and it also has an important extra feature - /// that its maps are real \ref concepts::ReferenceMap - /// "reference map"s. class HypercubeGraph : public ExtendedHypercubeGraphBase { + typedef ExtendedHypercubeGraphBase Parent; + public: - typedef ExtendedHypercubeGraphBase Parent; - /// \brief Constructs a hypercube graph with \c dim dimensions. /// /// Constructs a hypercube graph with \c dim dimensions. HypercubeGraph(int dim) { construct(dim); } + /// \brief Resizes the graph + /// + /// This function resizes the graph. It fully destroys and + /// rebuilds the structure, therefore the maps of the graph will be + /// reallocated automatically and the previous values will be lost. + void resize(int dim) { + Parent::notifier(Arc()).clear(); + Parent::notifier(Edge()).clear(); + Parent::notifier(Node()).clear(); + construct(dim); + Parent::notifier(Node()).build(); + Parent::notifier(Edge()).build(); + Parent::notifier(Arc()).build(); + } + /// \brief The number of dimensions. /// /// Gives back the number of dimensions. @@ -322,7 +339,7 @@ /// \brief The dimension id of an edge. /// /// Gives back the dimension id of the given edge. - /// It is in the [0..dim-1] range. + /// It is in the range [0..dim-1]. int dimension(Edge edge) const { return Parent::dimension(edge); } @@ -330,7 +347,7 @@ /// \brief The dimension id of an arc. /// /// Gives back the dimension id of the given arc. - /// It is in the [0..dim-1] range. + /// It is in the range [0..dim-1]. int dimension(Arc arc) const { return Parent::dimension(arc); } @@ -339,7 +356,7 @@ /// /// Gives back the index of the given node. /// The lower bits of the integer describes the node. - int index(Node node) const { + static int index(Node node) { return Parent::index(node); } diff -r c35afa9e89e7 -r ef88c0a30f85 lemon/karp.h --- /dev/null Thu Jan 01 00:00:00 1970 +0000 +++ b/lemon/karp.h Thu Nov 05 15:48:01 2009 +0100 @@ -0,0 +1,582 @@ +/* -*- C++ -*- + * + * This file is a part of LEMON, a generic C++ optimization library + * + * Copyright (C) 2003-2008 + * Egervary Jeno Kombinatorikus Optimalizalasi Kutatocsoport + * (Egervary Research Group on Combinatorial Optimization, EGRES). + * + * Permission to use, modify and distribute this software is granted + * provided that this copyright notice appears in all copies. For + * precise terms see the accompanying LICENSE file. + * + * This software is provided "AS IS" with no warranty of any kind, + * express or implied, and with no claim as to its suitability for any + * purpose. + * + */ + +#ifndef LEMON_KARP_H +#define LEMON_KARP_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 Karp algorithm. + /// + /// Default traits class of Karp algorithm. + /// \tparam GR The type of the digraph. + /// \tparam LEN The type of the length map. + /// It must conform to the \ref concepts::ReadMap "ReadMap" concept. +#ifdef DOXYGEN + template +#else + template ::is_integer> +#endif + struct KarpDefaultTraits + { + /// The type of the digraph + typedef GR Digraph; + /// The type of the length map + typedef LEN LengthMap; + /// The type of the arc lengths + typedef typename LengthMap::Value Value; + + /// \brief The large value type used for internal computations + /// + /// The large value type used for internal computations. + /// It is \c long \c long if the \c Value type is integer, + /// otherwise it is \c double. + /// \c Value must be convertible to \c LargeValue. + typedef double LargeValue; + + /// 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 value types + template + struct KarpDefaultTraits + { + typedef GR Digraph; + typedef LEN LengthMap; + typedef typename LengthMap::Value Value; +#ifdef LEMON_HAVE_LONG_LONG + typedef long long LargeValue; +#else + typedef long LargeValue; +#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 length (cost) in a digraph + /// \ref amo93networkflows, \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 LEN The type of the length map. The default + /// map type is \ref concepts::Digraph::ArcMap "GR::ArcMap". +#ifdef DOXYGEN + template +#else + template < typename GR, + typename LEN = typename GR::template ArcMap, + typename TR = KarpDefaultTraits > +#endif + class Karp + { + public: + + /// The type of the digraph + typedef typename TR::Digraph Digraph; + /// The type of the length map + typedef typename TR::LengthMap LengthMap; + /// The type of the arc lengths + typedef typename TR::Value Value; + + /// \brief The large value type + /// + /// The large value type used for internal computations. + /// Using the \ref KarpDefaultTraits "default traits class", + /// it is \c long \c long if the \c Value type is integer, + /// otherwise it is \c double. + typedef typename TR::LargeValue LargeValue; + + /// 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 KarpDefaultTraits "default traits class", + /// it is \ref lemon::Path "Path". + typedef typename TR::Path Path; + + /// The \ref KarpDefaultTraits "traits class" of the algorithm + typedef TR Traits; + + private: + + TEMPLATE_DIGRAPH_TYPEDEFS(Digraph); + + // Data sturcture for path data + struct PathData + { + LargeValue dist; + Arc pred; + PathData(LargeValue 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 length of the arcs + const LengthMap &_length; + + // 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 + LargeValue _cycle_length; + 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 LargeValue INF; + + public: + + /// \name Named Template Parameters + /// @{ + + template + struct SetLargeValueTraits : public Traits { + typedef T LargeValue; + typedef lemon::Tolerance Tolerance; + }; + + /// \brief \ref named-templ-param "Named parameter" for setting + /// \c LargeValue type. + /// + /// \ref named-templ-param "Named parameter" for setting \c LargeValue + /// type. It is used for internal computations in the algorithm. + template + struct SetLargeValue + : public Karp > { + typedef Karp > 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 Karp > { + typedef Karp > Create; + }; + + /// @} + + public: + + /// \brief Constructor. + /// + /// The constructor of the class. + /// + /// \param digraph The digraph the algorithm runs on. + /// \param length The lengths (costs) of the arcs. + Karp( const Digraph &digraph, + const LengthMap &length ) : + _gr(digraph), _length(length), _comp(digraph), _out_arcs(digraph), + _cycle_length(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. + ~Karp() { + 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 findMinMean(), 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) + Karp& 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) + Karp& 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 length, you may call + /// \ref findMinMean(). + + /// @{ + + /// \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 lengths 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.findMinMean() && mmc.findCycle(); + /// \endcode + bool run() { + return findMinMean() && findCycle(); + } + + /// \brief Find the minimum cycle mean. + /// + /// This function finds the minimum mean length of the directed + /// cycles in the digraph. + /// + /// \return \c true if a directed cycle exists in the digraph. + bool findMinMean() { + // 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 length + /// in the digraph using the data computed by findMinMean(). + /// + /// \return \c true if a directed cycle exists in the digraph. + /// + /// \pre \ref findMinMean() 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_length = _length[e]; + _cycle_size = 1; + Node v; + while ((v = _gr.source(e)) != u) { + e = _data[v][--r].pred; + _cycle_path->addFront(e); + _cycle_length += _length[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 length of the found cycle. + /// + /// This function returns the total length of the found cycle. + /// + /// \pre \ref run() or \ref findMinMean() must be called before + /// using this function. + LargeValue cycleLength() const { + return _cycle_length; + } + + /// \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 findMinMean() must be called before + /// using this function. + int cycleArcNum() const { + return _cycle_size; + } + + /// \brief Return the mean length of the found cycle. + /// + /// This function returns the mean length of the found cycle. + /// + /// \note alg.cycleMean() is just a shortcut of the + /// following code. + /// \code + /// return static_cast(alg.cycleLength()) / alg.cycleArcNum(); + /// \endcode + /// + /// \pre \ref run() or \ref findMinMean() must be called before + /// using this function. + double cycleMean() const { + return static_cast(_cycle_length) / _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_length = 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 length 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; + LargeValue 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 + _length[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; + LargeValue 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 + _length[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; + LargeValue length, max_length = 0; + int size, max_size = 1; + bool found_curr = false; + for (int k = 0; k < n; ++k) { + if (_data[u][k].dist == INF) continue; + length = _data[u][n].dist - _data[u][k].dist; + size = n - k; + if (!found_curr || length * max_size > max_length * size) { + found_curr = true; + max_length = length; + max_size = size; + } + } + if ( found_curr && (_cycle_node == INVALID || + max_length * _cycle_size < _cycle_length * max_size) ) { + _cycle_length = max_length; + _cycle_size = max_size; + _cycle_node = u; + } + } + } + + }; //class Karp + + ///@} + +} //namespace lemon + +#endif //LEMON_KARP_H diff -r c35afa9e89e7 -r ef88c0a30f85 lemon/kary_heap.h --- /dev/null Thu Jan 01 00:00:00 1970 +0000 +++ b/lemon/kary_heap.h Thu Nov 05 15:48:01 2009 +0100 @@ -0,0 +1,352 @@ +/* -*- 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_KARY_HEAP_H +#define LEMON_KARY_HEAP_H + +///\ingroup heaps +///\file +///\brief Fourary heap implementation. + +#include +#include +#include + +namespace lemon { + + /// \ingroup heaps + /// + ///\brief K-ary heap data structure. + /// + /// This class implements the \e K-ary \e heap data structure. + /// It fully conforms to the \ref concepts::Heap "heap concept". + /// + /// The \ref KaryHeap "K-ary heap" is a generalization of the + /// \ref BinHeap "binary heap" structure, its nodes have at most + /// \c K children, instead of two. + /// \ref BinHeap and \ref FouraryHeap are specialized implementations + /// of this structure for K=2 and K=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 K The degree of the heap, each node have at most \e K + /// 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 KaryHeap { + 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 KaryHeap(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. + KaryHeap(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)/K; } + int firstChild(int i) { return K*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+K<=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 KaryHeap + +} // namespace lemon + +#endif // LEMON_KARY_HEAP_H diff -r c35afa9e89e7 -r ef88c0a30f85 lemon/kruskal.h --- a/lemon/kruskal.h Mon Jan 12 23:11:39 2009 +0100 +++ b/lemon/kruskal.h Thu Nov 05 15:48:01 2009 +0100 @@ -248,11 +248,11 @@ /// \ingroup spantree /// - /// \brief Kruskal algorithm to find a minimum cost spanning tree of + /// \brief Kruskal's algorithm for finding a minimum cost spanning tree of /// a graph. /// /// This function runs Kruskal's algorithm to find a minimum cost - /// spanning tree. + /// spanning tree of a graph. /// Due to some C++ hacking, it accepts various input and output types. /// /// \param g The graph the algorithm runs on. @@ -264,17 +264,17 @@ /// \param in This object is used to describe the arc/edge costs. /// It can be one of the following choices. /// - An STL compatible 'Forward Container' with - /// std::pair or - /// std::pair as its value_type, where - /// \c X is the type of the costs. The pairs indicates the arcs/edges + /// std::pair or + /// std::pair as its value_type, where + /// \c C is the type of the costs. The pairs indicates the arcs/edges /// along with the assigned cost. They must be in a /// cost-ascending order. /// - Any readable arc/edge map. The values of the map indicate the /// arc/edge costs. /// /// \retval out Here we also have a choice. - /// - It can be a writable \c bool arc/edge map. After running the - /// algorithm it will contain the found minimum cost spanning + /// - It can be a writable arc/edge map with \c bool value type. After + /// running the algorithm it will contain the found minimum cost spanning /// tree: the value of an arc/edge will be set to \c true if it belongs /// to the tree, otherwise it will be set to \c false. The value of /// each arc/edge will be set exactly once. @@ -301,8 +301,8 @@ /// forest is calculated instead of a spanning tree. #ifdef DOXYGEN - template - Value kruskal(GR const& g, const In& in, Out& out) + template + Value kruskal(const Graph& g, const In& in, Out& out) #else template inline typename _kruskal_bits::KruskalValueSelector::Value @@ -314,8 +314,6 @@ } - - template inline typename _kruskal_bits::KruskalValueSelector::Value kruskal(const Graph& graph, const In& in, const Out& out) diff -r c35afa9e89e7 -r ef88c0a30f85 lemon/lemon.pc.in --- a/lemon/lemon.pc.in Mon Jan 12 23:11:39 2009 +0100 +++ b/lemon/lemon.pc.in Thu Nov 05 15:48:01 2009 +0100 @@ -4,7 +4,7 @@ includedir=@includedir@ Name: @PACKAGE_NAME@ -Description: Library of Efficient Models and Optimization in Networks +Description: Library for Efficient Modeling and Optimization in Networks Version: @PACKAGE_VERSION@ -Libs: -L${libdir} -lemon +Libs: -L${libdir} -lemon @GLPK_LIBS@ @CPLEX_LIBS@ @SOPLEX_LIBS@ @CLP_LIBS@ @CBC_LIBS@ Cflags: -I${includedir} diff -r c35afa9e89e7 -r ef88c0a30f85 lemon/lgf_reader.h --- a/lemon/lgf_reader.h Mon Jan 12 23:11:39 2009 +0100 +++ b/lemon/lgf_reader.h Thu Nov 05 15:48:01 2009 +0100 @@ -101,23 +101,23 @@ } }; - template > - class GraphArcMapStorage : public MapStorageBase { + class GraphArcMapStorage : public MapStorageBase { public: typedef _Map Map; typedef _Converter Converter; - typedef _Graph Graph; - typedef typename Graph::Edge Item; + typedef _GR GR; + typedef typename GR::Edge Item; static const bool dir = _dir; private: - const Graph& _graph; + const GR& _graph; Map& _map; Converter _converter; public: - GraphArcMapStorage(const Graph& graph, Map& map, + GraphArcMapStorage(const GR& graph, Map& map, const Converter& converter = Converter()) : _graph(graph), _map(map), _converter(converter) {} virtual ~GraphArcMapStorage() {} @@ -173,21 +173,21 @@ } }; - template + template struct GraphArcLookUpConverter { - const Graph& _graph; - const std::map& _map; - - GraphArcLookUpConverter(const Graph& graph, + const GR& _graph; + const std::map& _map; + + GraphArcLookUpConverter(const GR& graph, const std::map& map) + typename GR::Edge>& map) : _graph(graph), _map(map) {} - typename Graph::Arc operator()(const std::string& str) { + typename GR::Arc operator()(const std::string& str) { if (str.empty() || (str[0] != '+' && str[0] != '-')) { throw FormatError("Item must start with '+' or '-'"); } - typename std::map + typename std::map ::const_iterator it = _map.find(str.substr(1)); if (it == _map.end()) { throw FormatError("Item not found"); @@ -387,40 +387,15 @@ } - template + template class DigraphReader; - /// \brief Return a \ref DigraphReader class - /// - /// This function just returns a \ref DigraphReader class. - /// \relates DigraphReader - template - DigraphReader digraphReader(Digraph& digraph, - std::istream& is = std::cin) { - DigraphReader tmp(digraph, is); - return tmp; - } - - /// \brief Return a \ref DigraphReader class - /// - /// This function just returns a \ref DigraphReader class. - /// \relates DigraphReader - template - DigraphReader digraphReader(Digraph& digraph, - const std::string& fn) { - DigraphReader tmp(digraph, fn); - return tmp; - } - - /// \brief Return a \ref DigraphReader class - /// - /// This function just returns a \ref DigraphReader class. - /// \relates DigraphReader - template - DigraphReader digraphReader(Digraph& digraph, const char* fn) { - DigraphReader tmp(digraph, fn); - return tmp; - } + template + DigraphReader digraphReader(TDGR& digraph, std::istream& is = std::cin); + template + DigraphReader digraphReader(TDGR& digraph, const std::string& fn); + template + DigraphReader digraphReader(TDGR& digraph, const char *fn); /// \ingroup lemon_io /// @@ -443,7 +418,7 @@ /// rules. /// ///\code - /// DigraphReader(digraph, std::cin). + /// DigraphReader(digraph, std::cin). /// nodeMap("coordinates", coord_map). /// arcMap("capacity", cap_map). /// node("source", src). @@ -472,21 +447,21 @@ /// It is impossible to read this in /// a single pass, because the arcs are not constructed when the node /// maps are read. - template + template class DigraphReader { public: - typedef _Digraph Digraph; - TEMPLATE_DIGRAPH_TYPEDEFS(Digraph); + typedef DGR Digraph; private: + TEMPLATE_DIGRAPH_TYPEDEFS(DGR); std::istream* _is; bool local_is; std::string _filename; - Digraph& _digraph; + DGR& _digraph; std::string _nodes_caption; std::string _arcs_caption; @@ -524,7 +499,7 @@ /// /// Construct a directed graph reader, which reads from the given /// input stream. - DigraphReader(Digraph& digraph, std::istream& is = std::cin) + DigraphReader(DGR& digraph, std::istream& is = std::cin) : _is(&is), local_is(false), _digraph(digraph), _use_nodes(false), _use_arcs(false), _skip_nodes(false), _skip_arcs(false) {} @@ -533,7 +508,7 @@ /// /// Construct a directed graph reader, which reads from the given /// file. - DigraphReader(Digraph& digraph, const std::string& fn) + DigraphReader(DGR& digraph, const std::string& fn) : _is(new std::ifstream(fn.c_str())), local_is(true), _filename(fn), _digraph(digraph), _use_nodes(false), _use_arcs(false), @@ -548,7 +523,7 @@ /// /// Construct a directed graph reader, which reads from the given /// file. - DigraphReader(Digraph& digraph, const char* fn) + DigraphReader(DGR& digraph, const char* fn) : _is(new std::ifstream(fn)), local_is(true), _filename(fn), _digraph(digraph), _use_nodes(false), _use_arcs(false), @@ -584,12 +559,13 @@ private: - friend DigraphReader digraphReader<>(Digraph& digraph, - std::istream& is); - friend DigraphReader digraphReader<>(Digraph& digraph, - const std::string& fn); - friend DigraphReader digraphReader<>(Digraph& digraph, - const char *fn); + template + friend DigraphReader digraphReader(TDGR& digraph, std::istream& is); + template + friend DigraphReader digraphReader(TDGR& digraph, + const std::string& fn); + template + friend DigraphReader digraphReader(TDGR& digraph, const char *fn); DigraphReader(DigraphReader& other) : _is(other._is), local_is(other.local_is), _digraph(other._digraph), @@ -616,7 +592,7 @@ public: - /// \name Reading rules + /// \name Reading Rules /// @{ /// \brief Node map reading rule @@ -721,7 +697,7 @@ /// @} - /// \name Select section by name + /// \name Select Section by Name /// @{ /// \brief Set \c \@nodes section to be read @@ -750,7 +726,7 @@ /// @} - /// \name Using previously constructed node or arc set + /// \name Using Previously Constructed Node or Arc Set /// @{ /// \brief Use previously constructed node set @@ -1139,7 +1115,7 @@ public: - /// \name Execution of the reader + /// \name Execution of the Reader /// @{ /// \brief Start the batch processing @@ -1211,40 +1187,76 @@ /// @} }; - - template - class GraphReader; - - /// \brief Return a \ref GraphReader class + + /// \ingroup lemon_io /// - /// This function just returns a \ref GraphReader class. - /// \relates GraphReader - template - GraphReader graphReader(Graph& graph, std::istream& is = std::cin) { - GraphReader tmp(graph, is); + /// \brief Return a \ref DigraphReader class + /// + /// This function just returns a \ref DigraphReader class. + /// + /// With this function a digraph can be read from an + /// \ref lgf-format "LGF" file or input stream with several maps and + /// attributes. For example, there is network flow problem on a + /// digraph, i.e. a digraph with a \e capacity map on the arcs and + /// \e source and \e target nodes. This digraph can be read with the + /// following code: + /// + ///\code + ///ListDigraph digraph; + ///ListDigraph::ArcMap cm(digraph); + ///ListDigraph::Node src, trg; + ///digraphReader(digraph, std::cin). + /// arcMap("capacity", cap). + /// node("source", src). + /// node("target", trg). + /// run(); + ///\endcode + /// + /// For a complete documentation, please see the \ref DigraphReader + /// class documentation. + /// \warning Don't forget to put the \ref DigraphReader::run() "run()" + /// to the end of the parameter list. + /// \relates DigraphReader + /// \sa digraphReader(TDGR& digraph, const std::string& fn) + /// \sa digraphReader(TDGR& digraph, const char* fn) + template + DigraphReader digraphReader(TDGR& digraph, std::istream& is) { + DigraphReader tmp(digraph, is); return tmp; } - /// \brief Return a \ref GraphReader class + /// \brief Return a \ref DigraphReader class /// - /// This function just returns a \ref GraphReader class. - /// \relates GraphReader - template - GraphReader graphReader(Graph& graph, const std::string& fn) { - GraphReader tmp(graph, fn); + /// This function just returns a \ref DigraphReader class. + /// \relates DigraphReader + /// \sa digraphReader(TDGR& digraph, std::istream& is) + template + DigraphReader digraphReader(TDGR& digraph, const std::string& fn) { + DigraphReader tmp(digraph, fn); return tmp; } - /// \brief Return a \ref GraphReader class + /// \brief Return a \ref DigraphReader class /// - /// This function just returns a \ref GraphReader class. - /// \relates GraphReader - template - GraphReader graphReader(Graph& graph, const char* fn) { - GraphReader tmp(graph, fn); + /// This function just returns a \ref DigraphReader class. + /// \relates DigraphReader + /// \sa digraphReader(TDGR& digraph, std::istream& is) + template + DigraphReader digraphReader(TDGR& digraph, const char* fn) { + DigraphReader tmp(digraph, fn); return tmp; } + template + class GraphReader; + + template + GraphReader graphReader(TGR& graph, std::istream& is = std::cin); + template + GraphReader graphReader(TGR& graph, const std::string& fn); + template + GraphReader graphReader(TGR& graph, const char *fn); + /// \ingroup lemon_io /// /// \brief \ref lgf-format "LGF" reader for undirected graphs @@ -1260,20 +1272,21 @@ /// prefixed with \c '+' and \c '-', then these can be read into an /// arc map. Similarly, an attribute can be read into an arc, if /// it's value is an edge label prefixed with \c '+' or \c '-'. - template + template class GraphReader { public: - typedef _Graph Graph; - TEMPLATE_GRAPH_TYPEDEFS(Graph); + typedef GR Graph; private: + TEMPLATE_GRAPH_TYPEDEFS(GR); + std::istream* _is; bool local_is; std::string _filename; - Graph& _graph; + GR& _graph; std::string _nodes_caption; std::string _edges_caption; @@ -1311,7 +1324,7 @@ /// /// Construct an undirected graph reader, which reads from the given /// input stream. - GraphReader(Graph& graph, std::istream& is = std::cin) + GraphReader(GR& graph, std::istream& is = std::cin) : _is(&is), local_is(false), _graph(graph), _use_nodes(false), _use_edges(false), _skip_nodes(false), _skip_edges(false) {} @@ -1320,7 +1333,7 @@ /// /// Construct an undirected graph reader, which reads from the given /// file. - GraphReader(Graph& graph, const std::string& fn) + GraphReader(GR& graph, const std::string& fn) : _is(new std::ifstream(fn.c_str())), local_is(true), _filename(fn), _graph(graph), _use_nodes(false), _use_edges(false), @@ -1335,7 +1348,7 @@ /// /// Construct an undirected graph reader, which reads from the given /// file. - GraphReader(Graph& graph, const char* fn) + GraphReader(GR& graph, const char* fn) : _is(new std::ifstream(fn)), local_is(true), _filename(fn), _graph(graph), _use_nodes(false), _use_edges(false), @@ -1370,10 +1383,12 @@ } private: - friend GraphReader graphReader<>(Graph& graph, std::istream& is); - friend GraphReader graphReader<>(Graph& graph, - const std::string& fn); - friend GraphReader graphReader<>(Graph& graph, const char *fn); + template + friend GraphReader graphReader(TGR& graph, std::istream& is); + template + friend GraphReader graphReader(TGR& graph, const std::string& fn); + template + friend GraphReader graphReader(TGR& graph, const char *fn); GraphReader(GraphReader& other) : _is(other._is), local_is(other.local_is), _graph(other._graph), @@ -1400,7 +1415,7 @@ public: - /// \name Reading rules + /// \name Reading Rules /// @{ /// \brief Node map reading rule @@ -1465,7 +1480,7 @@ new _reader_bits::GraphArcMapStorage(_graph, map); _edge_maps.push_back(std::make_pair('+' + caption, forward_storage)); _reader_bits::MapStorageBase* backward_storage = - new _reader_bits::GraphArcMapStorage(_graph, map); + new _reader_bits::GraphArcMapStorage(_graph, map); _edge_maps.push_back(std::make_pair('-' + caption, backward_storage)); return *this; } @@ -1479,11 +1494,11 @@ const Converter& converter = Converter()) { checkConcept, Map>(); _reader_bits::MapStorageBase* forward_storage = - new _reader_bits::GraphArcMapStorage + new _reader_bits::GraphArcMapStorage (_graph, map, converter); _edge_maps.push_back(std::make_pair('+' + caption, forward_storage)); _reader_bits::MapStorageBase* backward_storage = - new _reader_bits::GraphArcMapStorage + new _reader_bits::GraphArcMapStorage (_graph, map, converter); _edge_maps.push_back(std::make_pair('-' + caption, backward_storage)); return *this; @@ -1541,7 +1556,7 @@ /// /// Add an arc reading rule to reader. GraphReader& arc(const std::string& caption, Arc& arc) { - typedef _reader_bits::GraphArcLookUpConverter Converter; + typedef _reader_bits::GraphArcLookUpConverter Converter; Converter converter(_graph, _edge_index); _reader_bits::ValueStorageBase* storage = new _reader_bits::ValueStorage(arc, converter); @@ -1551,7 +1566,7 @@ /// @} - /// \name Select section by name + /// \name Select Section by Name /// @{ /// \brief Set \c \@nodes section to be read @@ -1580,7 +1595,7 @@ /// @} - /// \name Using previously constructed node or edge set + /// \name Using Previously Constructed Node or Edge Set /// @{ /// \brief Use previously constructed node set @@ -1970,7 +1985,7 @@ public: - /// \name Execution of the reader + /// \name Execution of the Reader /// @{ /// \brief Start the batch processing @@ -2044,6 +2059,61 @@ }; + /// \ingroup lemon_io + /// + /// \brief Return a \ref GraphReader class + /// + /// This function just returns a \ref GraphReader class. + /// + /// With this function a graph can be read from an + /// \ref lgf-format "LGF" file or input stream with several maps and + /// attributes. For example, there is weighted matching problem on a + /// graph, i.e. a graph with a \e weight map on the edges. This + /// graph can be read with the following code: + /// + ///\code + ///ListGraph graph; + ///ListGraph::EdgeMap weight(graph); + ///graphReader(graph, std::cin). + /// edgeMap("weight", weight). + /// run(); + ///\endcode + /// + /// For a complete documentation, please see the \ref GraphReader + /// class documentation. + /// \warning Don't forget to put the \ref GraphReader::run() "run()" + /// to the end of the parameter list. + /// \relates GraphReader + /// \sa graphReader(TGR& graph, const std::string& fn) + /// \sa graphReader(TGR& graph, const char* fn) + template + GraphReader graphReader(TGR& graph, std::istream& is) { + GraphReader tmp(graph, is); + return tmp; + } + + /// \brief Return a \ref GraphReader class + /// + /// This function just returns a \ref GraphReader class. + /// \relates GraphReader + /// \sa graphReader(TGR& graph, std::istream& is) + template + GraphReader graphReader(TGR& graph, const std::string& fn) { + GraphReader tmp(graph, fn); + return tmp; + } + + /// \brief Return a \ref GraphReader class + /// + /// This function just returns a \ref GraphReader class. + /// \relates GraphReader + /// \sa graphReader(TGR& graph, std::istream& is) + template + GraphReader graphReader(TGR& graph, const char* fn) { + GraphReader tmp(graph, fn); + return tmp; + } + class SectionReader; SectionReader sectionReader(std::istream& is); @@ -2139,7 +2209,7 @@ public: - /// \name Section readers + /// \name Section Readers /// @{ /// \brief Add a section processor with line oriented reading @@ -2238,7 +2308,7 @@ public: - /// \name Execution of the reader + /// \name Execution of the Reader /// @{ /// \brief Start the batch processing @@ -2297,12 +2367,30 @@ }; + /// \ingroup lemon_io + /// + /// \brief Return a \ref SectionReader class + /// + /// This function just returns a \ref SectionReader class. + /// + /// Please see SectionReader documentation about the custom section + /// input. + /// + /// \relates SectionReader + /// \sa sectionReader(const std::string& fn) + /// \sa sectionReader(const char *fn) + inline SectionReader sectionReader(std::istream& is) { + SectionReader tmp(is); + return tmp; + } + /// \brief Return a \ref SectionReader class /// /// This function just returns a \ref SectionReader class. /// \relates SectionReader - inline SectionReader sectionReader(std::istream& is) { - SectionReader tmp(is); + /// \sa sectionReader(std::istream& is) + inline SectionReader sectionReader(const std::string& fn) { + SectionReader tmp(fn); return tmp; } @@ -2310,15 +2398,7 @@ /// /// This function just returns a \ref SectionReader class. /// \relates SectionReader - inline SectionReader sectionReader(const std::string& fn) { - SectionReader tmp(fn); - return tmp; - } - - /// \brief Return a \ref SectionReader class - /// - /// This function just returns a \ref SectionReader class. - /// \relates SectionReader + /// \sa sectionReader(std::istream& is) inline SectionReader sectionReader(const char* fn) { SectionReader tmp(fn); return tmp; @@ -2420,7 +2500,7 @@ public: - /// \name Node sections + /// \name Node Sections /// @{ /// \brief Gives back the number of node sections in the file. @@ -2446,7 +2526,7 @@ /// @} - /// \name Arc/Edge sections + /// \name Arc/Edge Sections /// @{ /// \brief Gives back the number of arc/edge sections in the file. @@ -2504,7 +2584,7 @@ /// @} - /// \name Attribute sections + /// \name Attribute Sections /// @{ /// \brief Gives back the number of attribute sections in the file. @@ -2530,7 +2610,7 @@ /// @} - /// \name Extra sections + /// \name Extra Sections /// @{ /// \brief Gives back the number of extra sections in the file. @@ -2606,7 +2686,7 @@ public: - /// \name Execution of the contents reader + /// \name Execution of the Contents Reader /// @{ /// \brief Starts the reading diff -r c35afa9e89e7 -r ef88c0a30f85 lemon/lgf_writer.h --- a/lemon/lgf_writer.h Mon Jan 12 23:11:39 2009 +0100 +++ b/lemon/lgf_writer.h Thu Nov 05 15:48:01 2009 +0100 @@ -347,41 +347,18 @@ } - template + template class DigraphWriter; - /// \brief Return a \ref DigraphWriter class - /// - /// This function just returns a \ref DigraphWriter class. - /// \relates DigraphWriter - template - DigraphWriter digraphWriter(const Digraph& digraph, - std::ostream& os = std::cout) { - DigraphWriter tmp(digraph, os); - return tmp; - } + template + DigraphWriter digraphWriter(const TDGR& digraph, + std::ostream& os = std::cout); + template + DigraphWriter digraphWriter(const TDGR& digraph, const std::string& fn); - /// \brief Return a \ref DigraphWriter class - /// - /// This function just returns a \ref DigraphWriter class. - /// \relates DigraphWriter - template - DigraphWriter digraphWriter(const Digraph& digraph, - const std::string& fn) { - DigraphWriter tmp(digraph, fn); - return tmp; - } + template + DigraphWriter digraphWriter(const TDGR& digraph, const char* fn); - /// \brief Return a \ref DigraphWriter class - /// - /// This function just returns a \ref DigraphWriter class. - /// \relates DigraphWriter - template - DigraphWriter digraphWriter(const Digraph& digraph, - const char* fn) { - DigraphWriter tmp(digraph, fn); - return tmp; - } /// \ingroup lemon_io /// @@ -402,7 +379,7 @@ /// arc() functions are used to add attribute writing rules. /// ///\code - /// DigraphWriter(digraph, std::cout). + /// DigraphWriter(digraph, std::cout). /// nodeMap("coordinates", coord_map). /// nodeMap("size", size). /// nodeMap("title", title). @@ -427,12 +404,12 @@ /// section to the stream. The output stream can be retrieved with /// the \c ostream() function, hence the second pass can append its /// output to the output of the first pass. - template + template class DigraphWriter { public: - typedef _Digraph Digraph; - TEMPLATE_DIGRAPH_TYPEDEFS(Digraph); + typedef DGR Digraph; + TEMPLATE_DIGRAPH_TYPEDEFS(DGR); private: @@ -440,7 +417,7 @@ std::ostream* _os; bool local_os; - const Digraph& _digraph; + const DGR& _digraph; std::string _nodes_caption; std::string _arcs_caption; @@ -472,7 +449,7 @@ /// /// Construct a directed graph writer, which writes to the given /// output stream. - DigraphWriter(const Digraph& digraph, std::ostream& os = std::cout) + DigraphWriter(const DGR& digraph, std::ostream& os = std::cout) : _os(&os), local_os(false), _digraph(digraph), _skip_nodes(false), _skip_arcs(false) {} @@ -480,7 +457,7 @@ /// /// Construct a directed graph writer, which writes to the given /// output file. - DigraphWriter(const Digraph& digraph, const std::string& fn) + DigraphWriter(const DGR& digraph, const std::string& fn) : _os(new std::ofstream(fn.c_str())), local_os(true), _digraph(digraph), _skip_nodes(false), _skip_arcs(false) { if (!(*_os)) { @@ -493,7 +470,7 @@ /// /// Construct a directed graph writer, which writes to the given /// output file. - DigraphWriter(const Digraph& digraph, const char* fn) + DigraphWriter(const DGR& digraph, const char* fn) : _os(new std::ofstream(fn)), local_os(true), _digraph(digraph), _skip_nodes(false), _skip_arcs(false) { if (!(*_os)) { @@ -526,12 +503,15 @@ private: - friend DigraphWriter digraphWriter<>(const Digraph& digraph, - std::ostream& os); - friend DigraphWriter digraphWriter<>(const Digraph& digraph, - const std::string& fn); - friend DigraphWriter digraphWriter<>(const Digraph& digraph, - const char *fn); + template + friend DigraphWriter digraphWriter(const TDGR& digraph, + std::ostream& os); + template + friend DigraphWriter digraphWriter(const TDGR& digraph, + const std::string& fn); + template + friend DigraphWriter digraphWriter(const TDGR& digraph, + const char *fn); DigraphWriter(DigraphWriter& other) : _os(other._os), local_os(other.local_os), _digraph(other._digraph), @@ -556,7 +536,7 @@ public: - /// \name Writing rules + /// \name Writing Rules /// @{ /// \brief Node map writing rule @@ -659,7 +639,7 @@ return *this; } - /// \name Section captions + /// \name Section Captions /// @{ /// \brief Add an additional caption to the \c \@nodes section @@ -686,7 +666,7 @@ return *this; } - /// \name Skipping section + /// \name Skipping Section /// @{ /// \brief Skip writing the node set @@ -742,8 +722,8 @@ } if (label == 0) { - IdMap id_map(_digraph); - _writer_bits::MapLess > id_less(id_map); + IdMap id_map(_digraph); + _writer_bits::MapLess > id_less(id_map); std::sort(nodes.begin(), nodes.end(), id_less); } else { label->sort(nodes); @@ -827,8 +807,8 @@ } if (label == 0) { - IdMap id_map(_digraph); - _writer_bits::MapLess > id_less(id_map); + IdMap id_map(_digraph); + _writer_bits::MapLess > id_less(id_map); std::sort(arcs.begin(), arcs.end(), id_less); } else { label->sort(arcs); @@ -903,7 +883,7 @@ public: - /// \name Execution of the writer + /// \name Execution of the Writer /// @{ /// \brief Start the batch processing @@ -933,40 +913,77 @@ /// @} }; - template - class GraphWriter; - - /// \brief Return a \ref GraphWriter class + /// \ingroup lemon_io /// - /// This function just returns a \ref GraphWriter class. - /// \relates GraphWriter - template - GraphWriter graphWriter(const Graph& graph, - std::ostream& os = std::cout) { - GraphWriter tmp(graph, os); + /// \brief Return a \ref DigraphWriter class + /// + /// This function just returns a \ref DigraphWriter class. + /// + /// With this function a digraph can be write to a file or output + /// stream in \ref lgf-format "LGF" format with several maps and + /// attributes. For example, with the following code a network flow + /// problem can be written to the standard output, i.e. a digraph + /// with a \e capacity map on the arcs and \e source and \e target + /// nodes: + /// + ///\code + ///ListDigraph digraph; + ///ListDigraph::ArcMap cap(digraph); + ///ListDigraph::Node src, trg; + /// // Setting the capacity map and source and target nodes + ///digraphWriter(digraph, std::cout). + /// arcMap("capacity", cap). + /// node("source", src). + /// node("target", trg). + /// run(); + ///\endcode + /// + /// For a complete documentation, please see the \ref DigraphWriter + /// class documentation. + /// \warning Don't forget to put the \ref DigraphWriter::run() "run()" + /// to the end of the parameter list. + /// \relates DigraphWriter + /// \sa digraphWriter(const TDGR& digraph, const std::string& fn) + /// \sa digraphWriter(const TDGR& digraph, const char* fn) + template + DigraphWriter digraphWriter(const TDGR& digraph, std::ostream& os) { + DigraphWriter tmp(digraph, os); return tmp; } - /// \brief Return a \ref GraphWriter class + /// \brief Return a \ref DigraphWriter class /// - /// This function just returns a \ref GraphWriter class. - /// \relates GraphWriter - template - GraphWriter graphWriter(const Graph& graph, const std::string& fn) { - GraphWriter tmp(graph, fn); + /// This function just returns a \ref DigraphWriter class. + /// \relates DigraphWriter + /// \sa digraphWriter(const TDGR& digraph, std::ostream& os) + template + DigraphWriter digraphWriter(const TDGR& digraph, + const std::string& fn) { + DigraphWriter tmp(digraph, fn); return tmp; } - /// \brief Return a \ref GraphWriter class + /// \brief Return a \ref DigraphWriter class /// - /// This function just returns a \ref GraphWriter class. - /// \relates GraphWriter - template - GraphWriter graphWriter(const Graph& graph, const char* fn) { - GraphWriter tmp(graph, fn); + /// This function just returns a \ref DigraphWriter class. + /// \relates DigraphWriter + /// \sa digraphWriter(const TDGR& digraph, std::ostream& os) + template + DigraphWriter digraphWriter(const TDGR& digraph, const char* fn) { + DigraphWriter tmp(digraph, fn); return tmp; } + template + class GraphWriter; + + template + GraphWriter graphWriter(const TGR& graph, std::ostream& os = std::cout); + template + GraphWriter graphWriter(const TGR& graph, const std::string& fn); + template + GraphWriter graphWriter(const TGR& graph, const char* fn); + /// \ingroup lemon_io /// /// \brief \ref lgf-format "LGF" writer for directed graphs @@ -982,12 +999,12 @@ /// '+' and \c '-'. The arcs are written into the \c \@attributes /// section as a \c '+' or a \c '-' prefix (depends on the direction /// of the arc) and the label of corresponding edge. - template + template class GraphWriter { public: - typedef _Graph Graph; - TEMPLATE_GRAPH_TYPEDEFS(Graph); + typedef GR Graph; + TEMPLATE_GRAPH_TYPEDEFS(GR); private: @@ -995,7 +1012,7 @@ std::ostream* _os; bool local_os; - const Graph& _graph; + const GR& _graph; std::string _nodes_caption; std::string _edges_caption; @@ -1027,7 +1044,7 @@ /// /// Construct a directed graph writer, which writes to the given /// output stream. - GraphWriter(const Graph& graph, std::ostream& os = std::cout) + GraphWriter(const GR& graph, std::ostream& os = std::cout) : _os(&os), local_os(false), _graph(graph), _skip_nodes(false), _skip_edges(false) {} @@ -1035,7 +1052,7 @@ /// /// Construct a directed graph writer, which writes to the given /// output file. - GraphWriter(const Graph& graph, const std::string& fn) + GraphWriter(const GR& graph, const std::string& fn) : _os(new std::ofstream(fn.c_str())), local_os(true), _graph(graph), _skip_nodes(false), _skip_edges(false) { if (!(*_os)) { @@ -1048,7 +1065,7 @@ /// /// Construct a directed graph writer, which writes to the given /// output file. - GraphWriter(const Graph& graph, const char* fn) + GraphWriter(const GR& graph, const char* fn) : _os(new std::ofstream(fn)), local_os(true), _graph(graph), _skip_nodes(false), _skip_edges(false) { if (!(*_os)) { @@ -1081,13 +1098,14 @@ private: - friend GraphWriter graphWriter<>(const Graph& graph, - std::ostream& os); - friend GraphWriter graphWriter<>(const Graph& graph, - const std::string& fn); - friend GraphWriter graphWriter<>(const Graph& graph, - const char *fn); - + template + friend GraphWriter graphWriter(const TGR& graph, std::ostream& os); + template + 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), _skip_nodes(other._skip_nodes), _skip_edges(other._skip_edges) { @@ -1111,7 +1129,7 @@ public: - /// \name Writing rules + /// \name Writing Rules /// @{ /// \brief Node map writing rule @@ -1173,10 +1191,10 @@ GraphWriter& arcMap(const std::string& caption, const Map& map) { checkConcept, Map>(); _writer_bits::MapStorageBase* forward_storage = - new _writer_bits::GraphArcMapStorage(_graph, map); + new _writer_bits::GraphArcMapStorage(_graph, map); _edge_maps.push_back(std::make_pair('+' + caption, forward_storage)); _writer_bits::MapStorageBase* backward_storage = - new _writer_bits::GraphArcMapStorage(_graph, map); + new _writer_bits::GraphArcMapStorage(_graph, map); _edge_maps.push_back(std::make_pair('-' + caption, backward_storage)); return *this; } @@ -1190,11 +1208,11 @@ const Converter& converter = Converter()) { checkConcept, Map>(); _writer_bits::MapStorageBase* forward_storage = - new _writer_bits::GraphArcMapStorage + new _writer_bits::GraphArcMapStorage (_graph, map, converter); _edge_maps.push_back(std::make_pair('+' + caption, forward_storage)); _writer_bits::MapStorageBase* backward_storage = - new _writer_bits::GraphArcMapStorage + new _writer_bits::GraphArcMapStorage (_graph, map, converter); _edge_maps.push_back(std::make_pair('-' + caption, backward_storage)); return *this; @@ -1252,7 +1270,7 @@ /// /// Add an arc writing rule to writer. GraphWriter& arc(const std::string& caption, const Arc& arc) { - typedef _writer_bits::GraphArcLookUpConverter Converter; + typedef _writer_bits::GraphArcLookUpConverter Converter; Converter converter(_graph, _edge_index); _writer_bits::ValueStorageBase* storage = new _writer_bits::ValueStorage(arc, converter); @@ -1260,7 +1278,7 @@ return *this; } - /// \name Section captions + /// \name Section Captions /// @{ /// \brief Add an additional caption to the \c \@nodes section @@ -1287,7 +1305,7 @@ return *this; } - /// \name Skipping section + /// \name Skipping Section /// @{ /// \brief Skip writing the node set @@ -1343,8 +1361,8 @@ } if (label == 0) { - IdMap id_map(_graph); - _writer_bits::MapLess > id_less(id_map); + IdMap id_map(_graph); + _writer_bits::MapLess > id_less(id_map); std::sort(nodes.begin(), nodes.end(), id_less); } else { label->sort(nodes); @@ -1428,8 +1446,8 @@ } if (label == 0) { - IdMap id_map(_graph); - _writer_bits::MapLess > id_less(id_map); + IdMap id_map(_graph); + _writer_bits::MapLess > id_less(id_map); std::sort(edges.begin(), edges.end(), id_less); } else { label->sort(edges); @@ -1504,7 +1522,7 @@ public: - /// \name Execution of the writer + /// \name Execution of the Writer /// @{ /// \brief Start the batch processing @@ -1534,6 +1552,62 @@ /// @} }; + /// \ingroup lemon_io + /// + /// \brief Return a \ref GraphWriter class + /// + /// This function just returns a \ref GraphWriter class. + /// + /// With this function a graph can be write to a file or output + /// stream in \ref lgf-format "LGF" format with several maps and + /// attributes. For example, with the following code a weighted + /// matching problem can be written to the standard output, i.e. a + /// graph with a \e weight map on the edges: + /// + ///\code + ///ListGraph graph; + ///ListGraph::EdgeMap weight(graph); + /// // Setting the weight map + ///graphWriter(graph, std::cout). + /// edgeMap("weight", weight). + /// run(); + ///\endcode + /// + /// For a complete documentation, please see the \ref GraphWriter + /// class documentation. + /// \warning Don't forget to put the \ref GraphWriter::run() "run()" + /// to the end of the parameter list. + /// \relates GraphWriter + /// \sa graphWriter(const TGR& graph, const std::string& fn) + /// \sa graphWriter(const TGR& graph, const char* fn) + template + GraphWriter graphWriter(const TGR& graph, std::ostream& os) { + GraphWriter tmp(graph, os); + return tmp; + } + + /// \brief Return a \ref GraphWriter class + /// + /// This function just returns a \ref GraphWriter class. + /// \relates GraphWriter + /// \sa graphWriter(const TGR& graph, std::ostream& os) + template + GraphWriter graphWriter(const TGR& graph, const std::string& fn) { + GraphWriter tmp(graph, fn); + return tmp; + } + + /// \brief Return a \ref GraphWriter class + /// + /// This function just returns a \ref GraphWriter class. + /// \relates GraphWriter + /// \sa graphWriter(const TGR& graph, std::ostream& os) + template + GraphWriter graphWriter(const TGR& graph, const char* fn) { + GraphWriter tmp(graph, fn); + return tmp; + } + class SectionWriter; SectionWriter sectionWriter(std::istream& is); @@ -1625,7 +1699,7 @@ public: - /// \name Section writers + /// \name Section Writers /// @{ /// \brief Add a section writer with line oriented writing @@ -1692,7 +1766,7 @@ public: - /// \name Execution of the writer + /// \name Execution of the Writer /// @{ /// \brief Start the batch processing @@ -1720,10 +1794,18 @@ }; + /// \ingroup lemon_io + /// /// \brief Return a \ref SectionWriter class /// /// This function just returns a \ref SectionWriter class. + /// + /// Please see SectionWriter documentation about the custom section + /// output. + /// /// \relates SectionWriter + /// \sa sectionWriter(const std::string& fn) + /// \sa sectionWriter(const char *fn) inline SectionWriter sectionWriter(std::ostream& os) { SectionWriter tmp(os); return tmp; @@ -1733,6 +1815,7 @@ /// /// This function just returns a \ref SectionWriter class. /// \relates SectionWriter + /// \sa sectionWriter(std::ostream& os) inline SectionWriter sectionWriter(const std::string& fn) { SectionWriter tmp(fn); return tmp; @@ -1742,6 +1825,7 @@ /// /// This function just returns a \ref SectionWriter class. /// \relates SectionWriter + /// \sa sectionWriter(std::ostream& os) inline SectionWriter sectionWriter(const char* fn) { SectionWriter tmp(fn); return tmp; diff -r c35afa9e89e7 -r ef88c0a30f85 lemon/list_graph.h --- a/lemon/list_graph.h Mon Jan 12 23:11:39 2009 +0100 +++ b/lemon/list_graph.h Thu Nov 05 15:48:01 2009 +0100 @@ -21,7 +21,7 @@ ///\ingroup graphs ///\file -///\brief ListDigraph, ListGraph classes. +///\brief ListDigraph and ListGraph classes. #include #include @@ -32,6 +32,8 @@ namespace lemon { + class ListDigraph; + class ListDigraphBase { protected: @@ -62,6 +64,7 @@ class Node { friend class ListDigraphBase; + friend class ListDigraph; protected: int id; @@ -77,6 +80,7 @@ class Arc { friend class ListDigraphBase; + friend class ListDigraph; protected: int id; @@ -116,20 +120,20 @@ void first(Arc& arc) const { int n; for(n = first_node; - n!=-1 && nodes[n].first_in == -1; + n != -1 && nodes[n].first_out == -1; n = nodes[n].next) {} - arc.id = (n == -1) ? -1 : nodes[n].first_in; + arc.id = (n == -1) ? -1 : nodes[n].first_out; } void next(Arc& arc) const { - if (arcs[arc.id].next_in != -1) { - arc.id = arcs[arc.id].next_in; + if (arcs[arc.id].next_out != -1) { + arc.id = arcs[arc.id].next_out; } else { int n; - for(n = nodes[arcs[arc.id].target].next; - n!=-1 && nodes[n].first_in == -1; + for(n = nodes[arcs[arc.id].source].next; + n != -1 && nodes[n].first_out == -1; n = nodes[n].next) {} - arc.id = (n == -1) ? -1 : nodes[n].first_in; + arc.id = (n == -1) ? -1 : nodes[n].first_out; } } @@ -311,37 +315,28 @@ ///A general directed graph structure. - ///\ref ListDigraph is a simple and fast directed graph - ///implementation based on static linked lists that are stored in + ///\ref ListDigraph is a versatile and fast directed graph + ///implementation based on linked lists that are stored in ///\c std::vector structures. /// - ///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 + ///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 ///only in the concept class. /// - ///An important extra feature of this digraph implementation is that - ///its maps are real \ref concepts::ReferenceMap "reference map"s. - /// ///\sa concepts::Digraph + ///\sa ListGraph + class ListDigraph : public ExtendedListDigraphBase { + typedef ExtendedListDigraphBase Parent; - class ListDigraph : public ExtendedListDigraphBase { private: - ///ListDigraph is \e not copy constructible. Use copyDigraph() instead. - - ///ListDigraph is \e not copy constructible. Use copyDigraph() instead. - /// + /// Digraphs are \e not copy constructible. Use DigraphCopy instead. ListDigraph(const ListDigraph &) :ExtendedListDigraphBase() {}; - ///\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. + /// \brief Assignment of a digraph to another one is \e not allowed. + /// Use DigraphCopy instead. void operator=(const ListDigraph &) {} public: - typedef ExtendedListDigraphBase Parent; - /// Constructor /// Constructor. @@ -350,71 +345,65 @@ ///Add a new node to the digraph. - ///Add a new node to the digraph. - ///\return the new node. + ///This function adds a new node to the digraph. + ///\return The new node. Node addNode() { return Parent::addNode(); } ///Add a new arc to the digraph. - ///Add a new arc to the digraph with source node \c s + ///This function adds a new arc to the digraph with source node \c s ///and target node \c t. - ///\return the new arc. - Arc addArc(const Node& s, const Node& t) { + ///\return The new arc. + Arc addArc(Node s, Node t) { return Parent::addArc(s, t); } ///\brief Erase a node from the digraph. /// - ///Erase a node from the digraph. - /// - void erase(const Node& n) { Parent::erase(n); } + ///This function erases the given node from the digraph. + void erase(Node n) { Parent::erase(n); } ///\brief Erase an arc from the digraph. /// - ///Erase an arc from the digraph. - /// - void erase(const Arc& a) { Parent::erase(a); } + ///This function erases the given arc from the digraph. + void erase(Arc a) { Parent::erase(a); } /// Node validity check - /// This function gives back true if the given node is valid, - /// ie. it is a real node of the graph. + /// This function gives back \c true if the given node is valid, + /// i.e. it is a real node of the digraph. /// - /// \warning A Node pointing to a removed item - /// could become valid again later if new nodes are - /// added to the graph. + /// \warning A removed node could become valid again if new nodes are + /// added to the digraph. 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. + /// This function gives back \c true if the given arc is valid, + /// i.e. it is a real arc of the digraph. /// - /// \warning An Arc pointing to a removed item - /// could become valid again later if new nodes are - /// added to the graph. + /// \warning A removed arc could become valid again if new arcs are + /// added to the digraph. bool valid(Arc a) const { return Parent::valid(a); } - /// Change the target of \c a to \c n + /// Change the target node of an arc - /// Change the target of \c a to \c n + /// This function changes the target node of the given arc \c a to \c n. /// - ///\note The ArcIts and OutArcIts referencing - ///the changed arc remain valid. However InArcIts are - ///invalidated. + ///\note \c ArcIt and \c OutArcIt iterators referencing the changed + ///arc remain valid, however \c InArcIt iterators are invalidated. /// ///\warning This functionality cannot be used together with the Snapshot ///feature. void changeTarget(Arc a, Node n) { Parent::changeTarget(a,n); } - /// Change the source of \c a to \c n + /// Change the source node of an arc - /// Change the source of \c a to \c n + /// This function changes the source node of the given arc \c a to \c n. /// - ///\note The InArcIts referencing the changed arc remain - ///valid. However the ArcIts and OutArcIts are - ///invalidated. + ///\note \c InArcIt iterators referencing the changed arc remain + ///valid, however \c ArcIt and \c OutArcIt iterators are invalidated. /// ///\warning This functionality cannot be used together with the Snapshot ///feature. @@ -422,94 +411,76 @@ Parent::changeSource(a,n); } - /// Invert the direction of an arc. + /// Reverse the direction of an arc. - ///\note The ArcIts referencing the changed arc remain - ///valid. However OutArcIts and InArcIts are - ///invalidated. + /// This function reverses the direction of the given arc. + ///\note \c ArcIt, \c OutArcIt and \c InArcIt iterators referencing + ///the changed arc are invalidated. /// ///\warning This functionality cannot be used together with the Snapshot ///feature. - void reverseArc(Arc e) { - Node t=target(e); - changeTarget(e,source(e)); - changeSource(e,t); + void reverseArc(Arc a) { + Node t=target(a); + changeTarget(a,source(a)); + changeSource(a,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 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. + ///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 ArcIts referencing a moved arc remain - ///valid. However InArcIts and OutArcIts - ///may be invalidated. + ///\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. /// ///\warning This functionality cannot be used together with the Snapshot ///feature. - void contract(Node a, Node b, bool r = true) + void contract(Node u, Node v, bool r = true) { - for(OutArcIt e(*this,b);e!=INVALID;) { + for(OutArcIt e(*this,v);e!=INVALID;) { OutArcIt f=e; ++f; - if(r && target(e)==a) erase(e); - else changeSource(e,a); + if(r && target(e)==u) erase(e); + else changeSource(e,u); e=f; } - for(InArcIt e(*this,b);e!=INVALID;) { + for(InArcIt e(*this,v);e!=INVALID;) { InArcIt f=e; ++f; - if(r && source(e)==a) erase(e); - else changeTarget(e,a); + if(r && source(e)==u) erase(e); + else changeTarget(e,u); e=f; } - erase(b); + erase(v); } ///Split a node. - ///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. + ///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. ///\return The newly created node. /// - ///\note The ArcIts referencing a moved arc remain - ///valid. However InArcIts and OutArcIts may - ///be invalidated. + ///\note All iterators remain valid. /// - ///\warning This functionality cannot be used in conjunction with the + ///\warning This functionality cannot be used together with the ///Snapshot feature. Node split(Node n, bool connect = true) { Node b = addNode(); - for(OutArcIt e(*this,n);e!=INVALID;) { - OutArcIt f=e; - ++f; - changeSource(e,b); - e=f; + 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; } if (connect) addArc(n,b); return b; @@ -517,21 +488,52 @@ ///Split an arc. - ///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. + ///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. + ///\return The newly created node. /// - ///\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 e) { - Node b = addNode(); - addArc(b,target(e)); - changeTarget(e,b); - return b; + 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. + /// + 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); }; + /// \brief Class to make a snapshot of the digraph and restore /// it later. /// @@ -540,9 +542,15 @@ /// The newly added nodes and arcs can be removed using the /// restore() function. /// - /// \warning Arc and node deletions and other modifications (e.g. - /// contracting, splitting, reversing arcs or nodes) cannot be + /// \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 /// 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: @@ -712,39 +720,40 @@ /// \brief Default constructor. /// /// Default constructor. - /// To actually make a snapshot you must call save(). + /// You have to call save() to actually make a snapshot. Snapshot() : digraph(0), node_observer_proxy(*this), arc_observer_proxy(*this) {} /// \brief Constructor that immediately makes a snapshot. /// - /// This constructor immediately makes a snapshot of the digraph. - /// \param _digraph The digraph we make a snapshot of. - Snapshot(ListDigraph &_digraph) + /// This constructor immediately makes a snapshot of the given digraph. + Snapshot(ListDigraph &gr) : node_observer_proxy(*this), arc_observer_proxy(*this) { - attach(_digraph); + attach(gr); } /// \brief Make a snapshot. /// - /// Make a snapshot of the digraph. - /// - /// This function can be called more than once. In case of a repeated + /// This function makes a snapshot of the given digraph. + /// It can be called more than once. In case of a repeated /// call, the previous snapshot gets lost. - /// \param _digraph The digraph we make the snapshot of. - void save(ListDigraph &_digraph) { + void save(ListDigraph &gr) { if (attached()) { detach(); clear(); } - attach(_digraph); + attach(gr); } /// \brief Undo the changes until the last snapshot. - // - /// Undo the changes until the last snapshot created by save(). + /// + /// 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. void restore() { detach(); for(std::list::iterator it = added_arcs.begin(); @@ -758,9 +767,9 @@ clear(); } - /// \brief Gives back true when the snapshot is valid. + /// \brief Returns \c true if the snapshot is valid. /// - /// Gives back true when the snapshot is valid. + /// This function returns \c true if the snapshot is valid. bool valid() const { return attached(); } @@ -796,11 +805,7 @@ public: - typedef ListGraphBase Digraph; - - class Node; - class Arc; - class Edge; + typedef ListGraphBase Graph; class Node { friend class ListGraphBase; @@ -851,8 +856,6 @@ bool operator<(const Arc& arc) const {return id < arc.id;} }; - - ListGraphBase() : nodes(), first_node(-1), first_free_node(-1), arcs(), first_free_arc(-1) {} @@ -1167,32 +1170,25 @@ ///A general undirected graph structure. - ///\ref ListGraph is a simple and fast undirected graph - ///implementation based on static linked lists that are stored in + ///\ref ListGraph is a versatile and fast undirected graph + ///implementation based on linked lists that are stored in ///\c std::vector structures. /// - ///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 + ///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 ///only in the concept class. /// - ///An important extra feature of this graph implementation is that - ///its maps are real \ref concepts::ReferenceMap "reference map"s. - /// ///\sa concepts::Graph + ///\sa ListDigraph + class ListGraph : public ExtendedListGraphBase { + typedef ExtendedListGraphBase Parent; - class ListGraph : public ExtendedListGraphBase { private: - ///ListGraph is \e not copy constructible. Use copyGraph() instead. - - ///ListGraph is \e not copy constructible. Use copyGraph() instead. - /// + /// Graphs are \e not copy constructible. Use GraphCopy instead. ListGraph(const ListGraph &) :ExtendedListGraphBase() {}; - ///\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. + /// \brief Assignment of a graph to another one is \e not allowed. + /// Use GraphCopy instead. void operator=(const ListGraph &) {} public: /// Constructor @@ -1201,100 +1197,99 @@ /// ListGraph() {} - typedef ExtendedListGraphBase Parent; - typedef Parent::OutArcIt IncEdgeIt; /// \brief Add a new node to the graph. /// - /// Add a new node to the graph. - /// \return the new node. + /// This function adds a new node to the graph. + /// \return The new node. Node addNode() { return Parent::addNode(); } /// \brief Add a new edge to the graph. /// - /// Add a new edge to the graph with source node \c s - /// and target node \c t. - /// \return the new edge. - Edge addEdge(const Node& s, const Node& t) { - return Parent::addEdge(s, t); + /// This function adds a new edge to the graph between nodes + /// \c u and \c v with inherent orientation from node \c u to + /// node \c v. + /// \return The new edge. + Edge addEdge(Node u, Node v) { + return Parent::addEdge(u, v); } - /// \brief Erase a node from the graph. + ///\brief Erase a node from the graph. /// - /// Erase a node from the graph. + /// This function erases the given node from the graph. + void erase(Node n) { Parent::erase(n); } + + ///\brief Erase an edge 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); } + /// This function erases the given edge from the graph. + void erase(Edge e) { Parent::erase(e); } /// Node validity check - /// This function gives back true if the given node is valid, - /// ie. it is a real node of the graph. + /// This function gives back \c true if the given node is valid, + /// i.e. 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 + /// \warning A removed node could become valid again if new nodes are /// added to the graph. bool valid(Node n) const { return Parent::valid(n); } + /// Edge validity check + + /// This function gives back \c true if the given edge is valid, + /// i.e. it is a real edge of the graph. + /// + /// \warning A removed edge could become valid again if new edges are + /// added to the graph. + bool valid(Edge e) const { return Parent::valid(e); } /// Arc validity check - /// This function gives back true if the given arc is valid, - /// ie. it is a real arc of the graph. + /// This function gives back \c true if the given arc is valid, + /// i.e. 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 + /// \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); } - /// Edge validity check - /// This function gives back true if the given edge is valid, - /// ie. it is a real arc of the graph. + /// \brief Change the first node of an edge. /// - /// \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); } - /// \brief Change the end \c u of \c e to \c n + /// This function changes the first node of the given edge \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. + ///\note \c EdgeIt and \c ArcIt iterators referencing the + ///changed edge are invalidated and all other iterators whose + ///base node is the changed node are also invalidated. /// ///\warning This functionality cannot be used together with the ///Snapshot feature. void changeU(Edge e, Node n) { Parent::changeU(e,n); } - /// \brief Change the end \c v of \c e to \c n + /// \brief Change the second node of an edge. /// - /// This function changes the end \c v of \c e to \c n. + /// This function changes the second node of the given edge \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. + ///\note \c EdgeIt iterators referencing the changed edge remain + ///valid, however \c ArcIt iterators referencing the changed edge and + ///all other iterators whose base node is the changed node are also + ///invalidated. /// ///\warning This functionality cannot be used together with the ///Snapshot feature. void changeV(Edge e, Node n) { Parent::changeV(e,n); } + /// \brief Contract two nodes. /// - /// 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. + /// 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 ArcIts referencing a moved arc remain - /// valid. + /// \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. /// ///\warning This functionality cannot be used together with the ///Snapshot feature. @@ -1313,6 +1308,33 @@ erase(b); } + ///Clear the graph. + + ///This function erases all nodes and arcs from the graph. + /// + void clear() { + Parent::clear(); + } + + /// Reserve memory for nodes. + + /// Using this function, it is possible to avoid superfluous memory + /// allocation: if you know that the graph you want to build will + /// be large (e.g. it will contain millions of nodes and/or edges), + /// then it is worth reserving space for this amount before starting + /// to build the graph. + /// \sa reserveEdge() + void reserveNode(int n) { nodes.reserve(n); }; + + /// Reserve memory for edges. + + /// Using this function, it is possible to avoid superfluous memory + /// allocation: if you know that the graph you want to build will + /// be large (e.g. it will contain millions of nodes and/or edges), + /// then it is worth reserving space for this amount before starting + /// to build the graph. + /// \sa reserveNode() + void reserveEdge(int m) { arcs.reserve(2 * m); }; /// \brief Class to make a snapshot of the graph and restore /// it later. @@ -1322,9 +1344,15 @@ /// The newly added nodes and edges can be removed /// using the restore() function. /// - /// \warning Edge and node deletions and other modifications - /// (e.g. changing nodes of edges, contracting nodes) cannot be - /// restored. These events invalidate the snapshot. + /// \note After a state is restored, you cannot restore a later state, + /// i.e. you cannot add the removed nodes and edges again using + /// another Snapshot instance. + /// + /// \warning Node and edge deletions and other modifications + /// (e.g. changing the end-nodes of edges or contracting nodes) + /// cannot be restored. These events invalidate the snapshot. + /// However the edges and nodes that were added to the graph after + /// making the current snapshot can be removed without invalidating it. class Snapshot { protected: @@ -1494,39 +1522,40 @@ /// \brief Default constructor. /// /// Default constructor. - /// To actually make a snapshot you must call save(). + /// You have to call save() to actually make a snapshot. Snapshot() : graph(0), node_observer_proxy(*this), edge_observer_proxy(*this) {} /// \brief Constructor that immediately makes a snapshot. /// - /// This constructor immediately makes a snapshot of the graph. - /// \param _graph The graph we make a snapshot of. - Snapshot(ListGraph &_graph) + /// This constructor immediately makes a snapshot of the given graph. + Snapshot(ListGraph &gr) : node_observer_proxy(*this), edge_observer_proxy(*this) { - attach(_graph); + attach(gr); } /// \brief Make a snapshot. /// - /// Make a snapshot of the graph. - /// - /// This function can be called more than once. In case of a repeated + /// This function makes a snapshot of the given graph. + /// It can be called more than once. In case of a repeated /// call, the previous snapshot gets lost. - /// \param _graph The graph we make the snapshot of. - void save(ListGraph &_graph) { + void save(ListGraph &gr) { if (attached()) { detach(); clear(); } - attach(_graph); + attach(gr); } /// \brief Undo the changes until the last snapshot. - // - /// Undo the changes until the last snapshot created by save(). + /// + /// 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. void restore() { detach(); for(std::list::iterator it = added_edges.begin(); @@ -1540,9 +1569,9 @@ clear(); } - /// \brief Gives back true when the snapshot is valid. + /// \brief Returns \c true if the snapshot is valid. /// - /// Gives back true when the snapshot is valid. + /// This function returns \c true if the snapshot is valid. bool valid() const { return attached(); } diff -r c35afa9e89e7 -r ef88c0a30f85 lemon/lp.h --- a/lemon/lp.h Mon Jan 12 23:11:39 2009 +0100 +++ b/lemon/lp.h Thu Nov 05 15:48:01 2009 +0100 @@ -22,13 +22,13 @@ #include -#ifdef HAVE_GLPK +#ifdef LEMON_HAVE_GLPK #include -#elif HAVE_CPLEX +#elif LEMON_HAVE_CPLEX #include -#elif HAVE_SOPLEX +#elif LEMON_HAVE_SOPLEX #include -#elif HAVE_CLP +#elif LEMON_HAVE_CLP #include #endif @@ -69,20 +69,20 @@ ///Currently, it is either \c GlpkMip or \c CplexMip typedef GlpkMip Mip; #else -#ifdef HAVE_GLPK +#ifdef LEMON_HAVE_GLPK # define LEMON_DEFAULT_LP GLPK typedef GlpkLp Lp; # define LEMON_DEFAULT_MIP GLPK typedef GlpkMip Mip; -#elif HAVE_CPLEX +#elif LEMON_HAVE_CPLEX # define LEMON_DEFAULT_LP CPLEX typedef CplexLp Lp; # define LEMON_DEFAULT_MIP CPLEX typedef CplexMip Mip; -#elif HAVE_SOPLEX +#elif LEMON_HAVE_SOPLEX # define DEFAULT_LP SOPLEX typedef SoplexLp Lp; -#elif HAVE_CLP +#elif LEMON_HAVE_CLP # define DEFAULT_LP CLP typedef ClpLp Lp; #endif diff -r c35afa9e89e7 -r ef88c0a30f85 lemon/lp_base.cc --- a/lemon/lp_base.cc Mon Jan 12 23:11:39 2009 +0100 +++ b/lemon/lp_base.cc Thu Nov 05 15:48:01 2009 +0100 @@ -22,7 +22,9 @@ #include namespace lemon { - const LpBase::Value LpBase::INF = std::numeric_limits::infinity(); - const LpBase::Value LpBase::NaN = std::numeric_limits::quiet_NaN(); + const LpBase::Value LpBase::INF = + std::numeric_limits::infinity(); + const LpBase::Value LpBase::NaN = + std::numeric_limits::quiet_NaN(); } //namespace lemon diff -r c35afa9e89e7 -r ef88c0a30f85 lemon/lp_base.h --- a/lemon/lp_base.h Mon Jan 12 23:11:39 2009 +0100 +++ b/lemon/lp_base.h Thu Nov 05 15:48:01 2009 +0100 @@ -52,12 +52,12 @@ ///Possible outcomes of an LP solving procedure enum SolveExitStatus { - ///This means that the problem has been successfully solved: either + /// = 0. It means that the problem has been successfully solved: either ///an optimal solution has been found or infeasibility/unboundedness ///has been proved. SOLVED = 0, - ///Any other case (including the case when some user specified - ///limit has been exceeded) + /// = 1. Any other case (including the case when some user specified + ///limit has been exceeded). UNSOLVED = 1 }; @@ -69,6 +69,21 @@ MAX }; + ///Enum for \c messageLevel() parameter + enum MessageLevel { + /// No output (default value). + MESSAGE_NOTHING, + /// Error messages only. + MESSAGE_ERROR, + /// Warnings. + MESSAGE_WARNING, + /// Normal output. + MESSAGE_NORMAL, + /// Verbose output. + MESSAGE_VERBOSE + }; + + ///The floating point type used by the solver typedef double Value; ///The infinity constant @@ -597,11 +612,11 @@ const Value &upperBound() const { return _ub; } ///Is the constraint lower bounded? bool lowerBounded() const { - return _lb != -INF && !std::isnan(_lb); + return _lb != -INF && !isNaN(_lb); } ///Is the constraint upper bounded? bool upperBounded() const { - return _ub != INF && !std::isnan(_ub); + return _ub != INF && !isNaN(_ub); } }; @@ -918,8 +933,6 @@ protected: //Abstract virtual functions - virtual LpBase* _newSolver() const = 0; - virtual LpBase* _cloneSolver() const = 0; virtual int _addColId(int col) { return cols.addIndex(col); } virtual int _addRowId(int row) { return rows.addIndex(row); } @@ -930,6 +943,14 @@ virtual int _addCol() = 0; virtual int _addRow() = 0; + virtual int _addRow(Value l, ExprIterator b, ExprIterator e, Value u) { + int row = _addRow(); + _setRowCoeffs(row, b, e); + _setRowLowerBound(row, l); + _setRowUpperBound(row, u); + return row; + } + virtual void _eraseCol(int col) = 0; virtual void _eraseRow(int row) = 0; @@ -975,6 +996,8 @@ virtual const char* _solverName() const = 0; + virtual void _messageLevel(MessageLevel level) = 0; + //Own protected stuff //Constant component of the objective function @@ -987,15 +1010,10 @@ /// Virtual destructor virtual ~LpBase() {} - ///Creates a new LP problem - LpBase* newSolver() {return _newSolver();} - ///Makes a copy of the LP problem - LpBase* cloneSolver() {return _cloneSolver();} - ///Gives back the name of the solver. const char* solverName() const {return _solverName();} - ///\name Build up and modify the LP + ///\name Build Up and Modify the LP ///@{ @@ -1067,8 +1085,8 @@ ///a better one. void col(Col c, const DualExpr &e) { e.simplify(); - _setColCoeffs(cols(id(c)), ExprIterator(e.comps.begin(), cols), - ExprIterator(e.comps.end(), cols)); + _setColCoeffs(cols(id(c)), ExprIterator(e.comps.begin(), rows), + ExprIterator(e.comps.end(), rows)); } ///Get a column (i.e a dual constraint) of the LP @@ -1197,8 +1215,10 @@ ///\param u is the upper bound (\ref INF means no bound) ///\return The created row. Row addRow(Value l,const Expr &e, Value u) { - Row r=addRow(); - row(r,l,e,u); + Row r; + e.simplify(); + r._id = _addRowId(_addRow(l - *e, ExprIterator(e.comps.begin(), cols), + ExprIterator(e.comps.end(), cols), u - *e)); return r; } @@ -1207,8 +1227,12 @@ ///\param c is a linear expression (see \ref Constr) ///\return The created row. Row addRow(const Constr &c) { - Row r=addRow(); - row(r,c); + Row r; + c.expr().simplify(); + r._id = _addRowId(_addRow(c.lowerBounded()?c.lowerBound():-INF, + ExprIterator(c.expr().comps.begin(), cols), + ExprIterator(c.expr().comps.end(), cols), + c.upperBounded()?c.upperBound():INF)); return r; } ///Erase a column (i.e a variable) from the LP @@ -1383,26 +1407,26 @@ template void colUpperBound(T &t, Value value) { return 0;} #else - template - typename enable_if::type - colUpperBound(T &t, Value value,dummy<0> = 0) { - for(typename T::iterator i=t.begin();i!=t.end();++i) { + template + typename enable_if::type + colUpperBound(T1 &t, Value value,dummy<0> = 0) { + for(typename T1::iterator i=t.begin();i!=t.end();++i) { colUpperBound(*i, value); } } - template - typename enable_if + typename enable_if::type - colUpperBound(T &t, Value value,dummy<1> = 1) { - for(typename T::iterator i=t.begin();i!=t.end();++i) { + colUpperBound(T1 &t, Value value,dummy<1> = 1) { + for(typename T1::iterator i=t.begin();i!=t.end();++i) { colUpperBound(i->second, value); } } - template - typename enable_if + typename enable_if::type - colUpperBound(T &t, Value value,dummy<2> = 2) { - for(typename T::MapIt i(t); i!=INVALID; ++i){ + colUpperBound(T1 &t, Value value,dummy<2> = 2) { + for(typename T1::MapIt i(t); i!=INVALID; ++i){ colUpperBound(*i, value); } } @@ -1432,24 +1456,24 @@ template void colBounds(T &t, Value lower, Value upper) { return 0;} #else - template - typename enable_if::type - colBounds(T &t, Value lower, Value upper,dummy<0> = 0) { - for(typename T::iterator i=t.begin();i!=t.end();++i) { + template + typename enable_if::type + colBounds(T2 &t, Value lower, Value upper,dummy<0> = 0) { + for(typename T2::iterator i=t.begin();i!=t.end();++i) { colBounds(*i, lower, upper); } } - template - typename enable_if::type - colBounds(T &t, Value lower, Value upper,dummy<1> = 1) { - for(typename T::iterator i=t.begin();i!=t.end();++i) { + template + typename enable_if::type + colBounds(T2 &t, Value lower, Value upper,dummy<1> = 1) { + for(typename T2::iterator i=t.begin();i!=t.end();++i) { colBounds(i->second, lower, upper); } } - template - typename enable_if::type - colBounds(T &t, Value lower, Value upper,dummy<2> = 2) { - for(typename T::MapIt i(t); i!=INVALID; ++i){ + template + typename enable_if::type + colBounds(T2 &t, Value lower, Value upper,dummy<2> = 2) { + for(typename T2::MapIt i(t); i!=INVALID; ++i){ colBounds(*i, lower, upper); } } @@ -1534,6 +1558,9 @@ ///Clears the problem void clear() { _clear(); } + /// Sets the message level of the solver + void messageLevel(MessageLevel level) { _messageLevel(level); } + ///@} }; @@ -1666,7 +1693,7 @@ inline LpBase::Constr operator<=(const LpBase::Value &n, const LpBase::Constr &c) { LpBase::Constr tmp(c); - LEMON_ASSERT(std::isnan(tmp.lowerBound()), "Wrong LP constraint"); + LEMON_ASSERT(isNaN(tmp.lowerBound()), "Wrong LP constraint"); tmp.lowerBound()=n; return tmp; } @@ -1678,7 +1705,7 @@ const LpBase::Value &n) { LpBase::Constr tmp(c); - LEMON_ASSERT(std::isnan(tmp.upperBound()), "Wrong LP constraint"); + LEMON_ASSERT(isNaN(tmp.upperBound()), "Wrong LP constraint"); tmp.upperBound()=n; return tmp; } @@ -1690,7 +1717,7 @@ inline LpBase::Constr operator>=(const LpBase::Value &n, const LpBase::Constr &c) { LpBase::Constr tmp(c); - LEMON_ASSERT(std::isnan(tmp.upperBound()), "Wrong LP constraint"); + LEMON_ASSERT(isNaN(tmp.upperBound()), "Wrong LP constraint"); tmp.upperBound()=n; return tmp; } @@ -1702,7 +1729,7 @@ const LpBase::Value &n) { LpBase::Constr tmp(c); - LEMON_ASSERT(std::isnan(tmp.lowerBound()), "Wrong LP constraint"); + LEMON_ASSERT(isNaN(tmp.lowerBound()), "Wrong LP constraint"); tmp.lowerBound()=n; return tmp; } @@ -1775,15 +1802,15 @@ /// The problem types for primal and dual problems enum ProblemType { - ///Feasible solution hasn't been found (but may exist). + /// = 0. Feasible solution hasn't been found (but may exist). UNDEFINED = 0, - ///The problem has no feasible solution + /// = 1. The problem has no feasible solution. INFEASIBLE = 1, - ///Feasible solution found + /// = 2. Feasible solution found. FEASIBLE = 2, - ///Optimal solution exists and found + /// = 3. Optimal solution exists and found. OPTIMAL = 3, - ///The cost function is unbounded + /// = 4. The cost function is unbounded. UNBOUNDED = 4 }; @@ -1821,6 +1848,11 @@ public: + ///Allocate a new LP problem instance + virtual LpSolver* newSolver() const = 0; + ///Make a copy of the LP problem + virtual LpSolver* cloneSolver() const = 0; + ///\name Solve the LP ///@{ @@ -1834,7 +1866,7 @@ ///@} - ///\name Obtain the solution + ///\name Obtain the Solution ///@{ @@ -1935,13 +1967,8 @@ Value primal() const { return _getPrimalValue()+obj_const_comp;} ///@} - LpSolver* newSolver() {return _newSolver();} - LpSolver* cloneSolver() {return _cloneSolver();} - protected: - virtual LpSolver* _newSolver() const = 0; - virtual LpSolver* _cloneSolver() const = 0; }; @@ -1961,20 +1988,24 @@ /// The problem types for MIP problems enum ProblemType { - ///Feasible solution hasn't been found (but may exist). + /// = 0. Feasible solution hasn't been found (but may exist). UNDEFINED = 0, - ///The problem has no feasible solution + /// = 1. The problem has no feasible solution. INFEASIBLE = 1, - ///Feasible solution found + /// = 2. Feasible solution found. FEASIBLE = 2, - ///Optimal solution exists and found + /// = 3. Optimal solution exists and found. OPTIMAL = 3, - ///The cost function is unbounded - /// - ///The Mip or at least the relaxed problem is unbounded + /// = 4. The cost function is unbounded. + ///The Mip or at least the relaxed problem is unbounded. UNBOUNDED = 4 }; + ///Allocate a new MIP problem instance + virtual MipSolver* newSolver() const = 0; + ///Make a copy of the MIP problem + virtual MipSolver* cloneSolver() const = 0; + ///\name Solve the MIP ///@{ @@ -1988,14 +2019,14 @@ ///@} - ///\name Setting column type + ///\name Set Column Type ///@{ ///Possible variable (column) types (e.g. real, integer, binary etc.) enum ColTypes { - ///Continuous variable (default) + /// = 0. Continuous variable (default). REAL = 0, - ///Integer variable + /// = 1. Integer variable. INTEGER = 1 }; @@ -2016,7 +2047,7 @@ } ///@} - ///\name Obtain the solution + ///\name Obtain the Solution ///@{ @@ -2062,15 +2093,6 @@ virtual Value _getSol(int i) const = 0; virtual Value _getSolValue() const = 0; - public: - - MipSolver* newSolver() {return _newSolver();} - MipSolver* cloneSolver() {return _cloneSolver();} - - protected: - - virtual MipSolver* _newSolver() const = 0; - virtual MipSolver* _cloneSolver() const = 0; }; diff -r c35afa9e89e7 -r ef88c0a30f85 lemon/lp_skeleton.cc --- a/lemon/lp_skeleton.cc Mon Jan 12 23:11:39 2009 +0100 +++ b/lemon/lp_skeleton.cc Thu Nov 05 15:48:01 2009 +0100 @@ -32,6 +32,11 @@ return ++row_num; } + int SkeletonSolverBase::_addRow(Value, ExprIterator, ExprIterator, Value) + { + return ++row_num; + } + void SkeletonSolverBase::_eraseCol(int) {} void SkeletonSolverBase::_eraseRow(int) {} @@ -84,6 +89,8 @@ row_num = col_num = 0; } + void SkeletonSolverBase::_messageLevel(MessageLevel) {} + LpSkeleton::SolveExitStatus LpSkeleton::_solve() { return SOLVED; } LpSkeleton::Value LpSkeleton::_getPrimal(int) const { return 0; } @@ -105,10 +112,10 @@ LpSkeleton::VarStatus LpSkeleton::_getRowStatus(int) const { return BASIC; } - LpSkeleton* LpSkeleton::_newSolver() const + LpSkeleton* LpSkeleton::newSolver() const { return static_cast(0); } - LpSkeleton* LpSkeleton::_cloneSolver() const + LpSkeleton* LpSkeleton::cloneSolver() const { return static_cast(0); } const char* LpSkeleton::_solverName() const { return "LpSkeleton"; } @@ -122,10 +129,10 @@ MipSkeleton::ProblemType MipSkeleton::_getType() const { return UNDEFINED; } - MipSkeleton* MipSkeleton::_newSolver() const + MipSkeleton* MipSkeleton::newSolver() const { return static_cast(0); } - MipSkeleton* MipSkeleton::_cloneSolver() const + MipSkeleton* MipSkeleton::cloneSolver() const { return static_cast(0); } const char* MipSkeleton::_solverName() const { return "MipSkeleton"; } diff -r c35afa9e89e7 -r ef88c0a30f85 lemon/lp_skeleton.h --- a/lemon/lp_skeleton.h Mon Jan 12 23:11:39 2009 +0100 +++ b/lemon/lp_skeleton.h Thu Nov 05 15:48:01 2009 +0100 @@ -16,16 +16,22 @@ * */ -#ifndef LEMON_LP_SKELETON -#define LEMON_LP_SKELETON +#ifndef LEMON_LP_SKELETON_H +#define LEMON_LP_SKELETON_H #include ///\file -///\brief A skeleton file to implement LP solver interfaces +///\brief Skeleton file to implement LP/MIP solver interfaces +/// +///The classes in this file do nothing, but they can serve as skeletons when +///implementing an interface to new solvers. namespace lemon { - ///A skeleton class to implement LP solver interfaces + ///A skeleton class to implement LP/MIP solver base interface + + ///This class does nothing, but it can serve as a skeleton when + ///implementing an interface to new solvers. class SkeletonSolverBase : public virtual LpBase { int col_num,row_num; @@ -39,6 +45,8 @@ /// \e virtual int _addRow(); /// \e + virtual int _addRow(Value l, ExprIterator b, ExprIterator e, Value u); + /// \e virtual void _eraseCol(int i); /// \e virtual void _eraseRow(int i); @@ -134,16 +142,24 @@ ///\e virtual void _clear(); + ///\e + virtual void _messageLevel(MessageLevel); }; - /// \brief Interface for a skeleton LP solver + /// \brief Skeleton class for an LP solver interface /// - /// This class implements an interface for a skeleton LP solver. + ///This class does nothing, but it can serve as a skeleton when + ///implementing an interface to new solvers. + ///\ingroup lp_group - class LpSkeleton : public SkeletonSolverBase, public LpSolver { + class LpSkeleton : public LpSolver, public SkeletonSolverBase { public: - LpSkeleton() : SkeletonSolverBase(), LpSolver() {} - + ///\e + LpSkeleton() : LpSolver(), SkeletonSolverBase() {} + ///\e + virtual LpSkeleton* newSolver() const; + ///\e + virtual LpSkeleton* cloneSolver() const; protected: ///\e @@ -173,57 +189,41 @@ virtual VarStatus _getRowStatus(int i) const; ///\e - virtual LpSkeleton* _newSolver() const; - ///\e - virtual LpSkeleton* _cloneSolver() const; - ///\e virtual const char* _solverName() const; }; - /// \brief Interface for a skeleton MIP solver + /// \brief Skeleton class for a MIP solver interface /// - /// This class implements an interface for a skeleton MIP solver. + ///This class does nothing, but it can serve as a skeleton when + ///implementing an interface to new solvers. ///\ingroup lp_group - class MipSkeleton : public SkeletonSolverBase, public MipSolver { + class MipSkeleton : public MipSolver, public SkeletonSolverBase { public: - MipSkeleton() : SkeletonSolverBase(), MipSolver() {} + ///\e + MipSkeleton() : MipSolver(), SkeletonSolverBase() {} + ///\e + virtual MipSkeleton* newSolver() const; + ///\e + virtual MipSkeleton* cloneSolver() const; protected: ///\e - - ///\bug Wrong interface - /// virtual SolveExitStatus _solve(); ///\e - - ///\bug Wrong interface - /// virtual Value _getSol(int i) const; ///\e - - ///\bug Wrong interface - /// virtual Value _getSolValue() const; ///\e - - ///\bug Wrong interface - /// virtual ProblemType _getType() const; ///\e - virtual MipSkeleton* _newSolver() const; - - ///\e - virtual MipSkeleton* _cloneSolver() const; - ///\e virtual const char* _solverName() const; - }; } //namespace lemon -#endif // LEMON_LP_SKELETON +#endif diff -r c35afa9e89e7 -r ef88c0a30f85 lemon/maps.h --- a/lemon/maps.h Mon Jan 12 23:11:39 2009 +0100 +++ b/lemon/maps.h Thu Nov 05 15:48:01 2009 +0100 @@ -22,6 +22,7 @@ #include #include #include +#include #include @@ -29,8 +30,6 @@ ///\ingroup maps ///\brief Miscellaneous property maps -#include - namespace lemon { /// \addtogroup maps @@ -57,15 +56,16 @@ /// its type definitions, or if you have to provide a writable map, /// but data written to it is not required (i.e. it will be sent to /// /dev/null). - /// It conforms the \ref concepts::ReadWriteMap "ReadWriteMap" concept. + /// It conforms to the \ref concepts::ReadWriteMap "ReadWriteMap" concept. /// /// \sa ConstMap template class NullMap : public MapBase { public: - typedef MapBase Parent; - typedef typename Parent::Key Key; - typedef typename Parent::Value Value; + ///\e + typedef K Key; + ///\e + typedef V Value; /// Gives back a default constructed element. Value operator[](const Key&) const { return Value(); } @@ -89,7 +89,7 @@ /// value to each key. /// /// In other aspects it is equivalent to \c NullMap. - /// So it conforms the \ref concepts::ReadWriteMap "ReadWriteMap" + /// So it conforms to the \ref concepts::ReadWriteMap "ReadWriteMap" /// concept, but it absorbs the data written to it. /// /// The simplest way of using this map is through the constMap() @@ -102,9 +102,10 @@ private: V _value; public: - typedef MapBase Parent; - typedef typename Parent::Key Key; - typedef typename Parent::Value Value; + ///\e + typedef K Key; + ///\e + typedef V Value; /// Default constructor @@ -157,7 +158,7 @@ /// value to each key. /// /// In other aspects it is equivalent to \c NullMap. - /// So it conforms the \ref concepts::ReadWriteMap "ReadWriteMap" + /// So it conforms to the \ref concepts::ReadWriteMap "ReadWriteMap" /// concept, but it absorbs the data written to it. /// /// The simplest way of using this map is through the constMap() @@ -168,9 +169,10 @@ template class ConstMap > : public MapBase { public: - typedef MapBase Parent; - typedef typename Parent::Key Key; - typedef typename Parent::Value Value; + ///\e + typedef K Key; + ///\e + typedef V Value; /// Constructor. ConstMap() {} @@ -202,9 +204,10 @@ template class IdentityMap : public MapBase { public: - typedef MapBase Parent; - typedef typename Parent::Key Key; - typedef typename Parent::Value Value; + ///\e + typedef T Key; + ///\e + typedef T Value; /// Gives back the given value without any modification. Value operator[](const Key &k) const { @@ -229,7 +232,7 @@ /// values to integer keys from the range [0..size-1]. /// 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 + /// integers. This map conforms to the \ref concepts::ReferenceMap /// "ReferenceMap" concept. /// /// The simplest way of using this map is through the rangeMap() @@ -245,11 +248,10 @@ public: - typedef MapBase Parent; /// Key type - typedef typename Parent::Key Key; + typedef int Key; /// Value type - typedef typename Parent::Value Value; + typedef V Value; /// Reference type typedef typename Vector::reference Reference; /// Const reference type @@ -338,7 +340,7 @@ /// that you can specify a default value for the keys that are not /// stored actually. This value can be different from the default /// contructed value (i.e. \c %Value()). - /// This type conforms the \ref concepts::ReferenceMap "ReferenceMap" + /// This type conforms to the \ref concepts::ReferenceMap "ReferenceMap" /// concept. /// /// This map is useful if a default value should be assigned to most of @@ -353,17 +355,16 @@ /// /// The simplest way of using this map is through the sparseMap() /// function. - template > + template > class SparseMap : public MapBase { template friend class SparseMap; public: - typedef MapBase Parent; /// Key type - typedef typename Parent::Key Key; + typedef K Key; /// Value type - typedef typename Parent::Value Value; + typedef V Value; /// Reference type typedef Value& Reference; /// Const reference type @@ -373,7 +374,7 @@ private: - typedef std::map Map; + typedef std::map Map; Map _map; Value _value; @@ -489,14 +490,15 @@ const M1 &_m1; const M2 &_m2; public: - typedef MapBase Parent; - typedef typename Parent::Key Key; - typedef typename Parent::Value Value; + ///\e + typedef typename M2::Key Key; + ///\e + typedef typename M1::Value Value; /// Constructor ComposeMap(const M1 &m1, const M2 &m2) : _m1(m1), _m2(m2) {} - /// \e + ///\e typename MapTraits::ConstReturnValue operator[](const Key &k) const { return _m1[_m2[k]]; } }; @@ -545,14 +547,15 @@ const M2 &_m2; F _f; public: - typedef MapBase Parent; - typedef typename Parent::Key Key; - typedef typename Parent::Value Value; + ///\e + typedef typename M1::Key Key; + ///\e + typedef V Value; /// Constructor CombineMap(const M1 &m1, const M2 &m2, const F &f = F()) : _m1(m1), _m2(m2), _f(f) {} - /// \e + ///\e Value operator[](const Key &k) const { return _f(_m1[k],_m2[k]); } }; @@ -615,13 +618,14 @@ class FunctorToMap : public MapBase { F _f; public: - typedef MapBase Parent; - typedef typename Parent::Key Key; - typedef typename Parent::Value Value; + ///\e + typedef K Key; + ///\e + typedef V Value; /// Constructor FunctorToMap(const F &f = F()) : _f(f) {} - /// \e + ///\e Value operator[](const Key &k) const { return _f(k); } }; @@ -669,18 +673,19 @@ class MapToFunctor : public MapBase { const M &_m; public: - typedef MapBase Parent; - typedef typename Parent::Key Key; - typedef typename Parent::Value Value; - - typedef typename Parent::Key argument_type; - typedef typename Parent::Value result_type; + ///\e + typedef typename M::Key Key; + ///\e + typedef typename M::Value Value; + + typedef typename M::Key argument_type; + typedef typename M::Value result_type; /// Constructor MapToFunctor(const M &m) : _m(m) {} - /// \e + ///\e Value operator()(const Key &k) const { return _m[k]; } - /// \e + ///\e Value operator[](const Key &k) const { return _m[k]; } }; @@ -701,7 +706,7 @@ /// "readable map" to another type using the default conversion. /// The \c Key type of it is inherited from \c M and the \c Value /// type is \c V. - /// This type conforms the \ref concepts::ReadMap "ReadMap" concept. + /// This type conforms to the \ref concepts::ReadMap "ReadMap" concept. /// /// The simplest way of using this map is through the convertMap() /// function. @@ -709,9 +714,10 @@ class ConvertMap : public MapBase { const M &_m; public: - typedef MapBase Parent; - typedef typename Parent::Key Key; - typedef typename Parent::Value Value; + ///\e + typedef typename M::Key Key; + ///\e + typedef V Value; /// Constructor @@ -719,7 +725,7 @@ /// \param m The underlying map. ConvertMap(const M &m) : _m(m) {} - /// \e + ///\e Value operator[](const Key &k) const { return _m[k]; } }; @@ -751,9 +757,10 @@ M1 &_m1; M2 &_m2; public: - typedef MapBase Parent; - typedef typename Parent::Key Key; - typedef typename Parent::Value Value; + ///\e + typedef typename M1::Key Key; + ///\e + typedef typename M1::Value Value; /// Constructor ForkMap(M1 &m1, M2 &m2) : _m1(m1), _m2(m2) {} @@ -797,13 +804,14 @@ const M1 &_m1; const M2 &_m2; public: - typedef MapBase Parent; - typedef typename Parent::Key Key; - typedef typename Parent::Value Value; + ///\e + typedef typename M1::Key Key; + ///\e + typedef typename M1::Value Value; /// Constructor AddMap(const M1 &m1, const M2 &m2) : _m1(m1), _m2(m2) {} - /// \e + ///\e Value operator[](const Key &k) const { return _m1[k]+_m2[k]; } }; @@ -845,13 +853,14 @@ const M1 &_m1; const M2 &_m2; public: - typedef MapBase Parent; - typedef typename Parent::Key Key; - typedef typename Parent::Value Value; + ///\e + typedef typename M1::Key Key; + ///\e + typedef typename M1::Value Value; /// Constructor SubMap(const M1 &m1, const M2 &m2) : _m1(m1), _m2(m2) {} - /// \e + ///\e Value operator[](const Key &k) const { return _m1[k]-_m2[k]; } }; @@ -894,13 +903,14 @@ const M1 &_m1; const M2 &_m2; public: - typedef MapBase Parent; - typedef typename Parent::Key Key; - typedef typename Parent::Value Value; + ///\e + typedef typename M1::Key Key; + ///\e + typedef typename M1::Value Value; /// Constructor MulMap(const M1 &m1,const M2 &m2) : _m1(m1), _m2(m2) {} - /// \e + ///\e Value operator[](const Key &k) const { return _m1[k]*_m2[k]; } }; @@ -942,13 +952,14 @@ const M1 &_m1; const M2 &_m2; public: - typedef MapBase Parent; - typedef typename Parent::Key Key; - typedef typename Parent::Value Value; + ///\e + typedef typename M1::Key Key; + ///\e + typedef typename M1::Value Value; /// Constructor DivMap(const M1 &m1,const M2 &m2) : _m1(m1), _m2(m2) {} - /// \e + ///\e Value operator[](const Key &k) const { return _m1[k]/_m2[k]; } }; @@ -992,9 +1003,10 @@ const M &_m; C _v; public: - typedef MapBase Parent; - typedef typename Parent::Key Key; - typedef typename Parent::Value Value; + ///\e + typedef typename M::Key Key; + ///\e + typedef typename M::Value Value; /// Constructor @@ -1002,7 +1014,7 @@ /// \param m The undelying map. /// \param v The constant value. ShiftMap(const M &m, const C &v) : _m(m), _v(v) {} - /// \e + ///\e Value operator[](const Key &k) const { return _m[k]+_v; } }; @@ -1022,9 +1034,10 @@ M &_m; C _v; public: - typedef MapBase Parent; - typedef typename Parent::Key Key; - typedef typename Parent::Value Value; + ///\e + typedef typename M::Key Key; + ///\e + typedef typename M::Value Value; /// Constructor @@ -1032,9 +1045,9 @@ /// \param m The undelying map. /// \param v The constant value. ShiftWriteMap(M &m, const C &v) : _m(m), _v(v) {} - /// \e + ///\e Value operator[](const Key &k) const { return _m[k]+_v; } - /// \e + ///\e void set(const Key &k, const Value &v) { _m.set(k, v-_v); } }; @@ -1093,9 +1106,10 @@ const M &_m; C _v; public: - typedef MapBase Parent; - typedef typename Parent::Key Key; - typedef typename Parent::Value Value; + ///\e + typedef typename M::Key Key; + ///\e + typedef typename M::Value Value; /// Constructor @@ -1103,7 +1117,7 @@ /// \param m The undelying map. /// \param v The constant value. ScaleMap(const M &m, const C &v) : _m(m), _v(v) {} - /// \e + ///\e Value operator[](const Key &k) const { return _v*_m[k]; } }; @@ -1124,9 +1138,10 @@ M &_m; C _v; public: - typedef MapBase Parent; - typedef typename Parent::Key Key; - typedef typename Parent::Value Value; + ///\e + typedef typename M::Key Key; + ///\e + typedef typename M::Value Value; /// Constructor @@ -1134,9 +1149,9 @@ /// \param m The undelying map. /// \param v The constant value. ScaleWriteMap(M &m, const C &v) : _m(m), _v(v) {} - /// \e + ///\e Value operator[](const Key &k) const { return _v*_m[k]; } - /// \e + ///\e void set(const Key &k, const Value &v) { _m.set(k, v/_v); } }; @@ -1193,13 +1208,14 @@ class NegMap : public MapBase { const M& _m; public: - typedef MapBase Parent; - typedef typename Parent::Key Key; - typedef typename Parent::Value Value; + ///\e + typedef typename M::Key Key; + ///\e + typedef typename M::Value Value; /// Constructor NegMap(const M &m) : _m(m) {} - /// \e + ///\e Value operator[](const Key &k) const { return -_m[k]; } }; @@ -1228,15 +1244,16 @@ class NegWriteMap : public MapBase { M &_m; public: - typedef MapBase Parent; - typedef typename Parent::Key Key; - typedef typename Parent::Value Value; + ///\e + typedef typename M::Key Key; + ///\e + typedef typename M::Value Value; /// Constructor NegWriteMap(M &m) : _m(m) {} - /// \e + ///\e Value operator[](const Key &k) const { return -_m[k]; } - /// \e + ///\e void set(const Key &k, const Value &v) { _m.set(k, -v); } }; @@ -1282,13 +1299,14 @@ class AbsMap : public MapBase { const M &_m; public: - typedef MapBase Parent; - typedef typename Parent::Key Key; - typedef typename Parent::Value Value; + ///\e + typedef typename M::Key Key; + ///\e + typedef typename M::Value Value; /// Constructor AbsMap(const M &m) : _m(m) {} - /// \e + ///\e Value operator[](const Key &k) const { Value tmp = _m[k]; return tmp >= 0 ? tmp : -tmp; @@ -1337,9 +1355,10 @@ template class TrueMap : public MapBase { public: - typedef MapBase Parent; - typedef typename Parent::Key Key; - typedef typename Parent::Value Value; + ///\e + typedef K Key; + ///\e + typedef bool Value; /// Gives back \c true. Value operator[](const Key&) const { return true; } @@ -1374,9 +1393,10 @@ template class FalseMap : public MapBase { public: - typedef MapBase Parent; - typedef typename Parent::Key Key; - typedef typename Parent::Value Value; + ///\e + typedef K Key; + ///\e + typedef bool Value; /// Gives back \c false. Value operator[](const Key&) const { return false; } @@ -1419,13 +1439,14 @@ const M1 &_m1; const M2 &_m2; public: - typedef MapBase Parent; - typedef typename Parent::Key Key; - typedef typename Parent::Value Value; + ///\e + typedef typename M1::Key Key; + ///\e + typedef bool Value; /// Constructor AndMap(const M1 &m1, const M2 &m2) : _m1(m1), _m2(m2) {} - /// \e + ///\e Value operator[](const Key &k) const { return _m1[k]&&_m2[k]; } }; @@ -1467,13 +1488,14 @@ const M1 &_m1; const M2 &_m2; public: - typedef MapBase Parent; - typedef typename Parent::Key Key; - typedef typename Parent::Value Value; + ///\e + typedef typename M1::Key Key; + ///\e + typedef bool Value; /// Constructor OrMap(const M1 &m1, const M2 &m2) : _m1(m1), _m2(m2) {} - /// \e + ///\e Value operator[](const Key &k) const { return _m1[k]||_m2[k]; } }; @@ -1506,13 +1528,14 @@ class NotMap : public MapBase { const M &_m; public: - typedef MapBase Parent; - typedef typename Parent::Key Key; - typedef typename Parent::Value Value; + ///\e + typedef typename M::Key Key; + ///\e + typedef bool Value; /// Constructor NotMap(const M &m) : _m(m) {} - /// \e + ///\e Value operator[](const Key &k) const { return !_m[k]; } }; @@ -1532,15 +1555,16 @@ class NotWriteMap : public MapBase { M &_m; public: - typedef MapBase Parent; - typedef typename Parent::Key Key; - typedef typename Parent::Value Value; + ///\e + typedef typename M::Key Key; + ///\e + typedef bool Value; /// Constructor NotWriteMap(M &m) : _m(m) {} - /// \e + ///\e Value operator[](const Key &k) const { return !_m[k]; } - /// \e + ///\e void set(const Key &k, bool v) { _m.set(k, !v); } }; @@ -1595,13 +1619,14 @@ const M1 &_m1; const M2 &_m2; public: - typedef MapBase Parent; - typedef typename Parent::Key Key; - typedef typename Parent::Value Value; + ///\e + typedef typename M1::Key Key; + ///\e + typedef bool Value; /// Constructor EqualMap(const M1 &m1, const M2 &m2) : _m1(m1), _m2(m2) {} - /// \e + ///\e Value operator[](const Key &k) const { return _m1[k]==_m2[k]; } }; @@ -1643,13 +1668,14 @@ const M1 &_m1; const M2 &_m2; public: - typedef MapBase Parent; - typedef typename Parent::Key Key; - typedef typename Parent::Value Value; + ///\e + typedef typename M1::Key Key; + ///\e + typedef bool Value; /// Constructor LessMap(const M1 &m1, const M2 &m2) : _m1(m1), _m2(m2) {} - /// \e + ///\e Value operator[](const Key &k) const { return _m1[k]<_m2[k]; } }; @@ -1705,24 +1731,27 @@ /// The simplest way of using this map is through the loggerBoolMap() /// function. /// - /// \tparam It The type of the iterator. - /// \tparam Ke The key type of the map. The default value set + /// \tparam IT The type of the iterator. + /// \tparam KEY The key type of the map. The default value set /// according to the iterator type should work in most cases. /// /// \note The container of the iterator must contain enough space /// for the elements or the iterator should be an inserter iterator. #ifdef DOXYGEN - template + template #else - template ::Value> + template ::Value> #endif - class LoggerBoolMap { + class LoggerBoolMap : public MapBase { public: - typedef It Iterator; - - typedef Ke Key; + + ///\e + typedef KEY Key; + ///\e typedef bool Value; + ///\e + typedef IT Iterator; /// Constructor LoggerBoolMap(Iterator it) @@ -1760,11 +1789,11 @@ /// order of Dfs algorithm, as the following examples show. /// \code /// std::vector v; - /// dfs(g,s).processedMap(loggerBoolMap(std::back_inserter(v))).run(); + /// dfs(g).processedMap(loggerBoolMap(std::back_inserter(v))).run(s); /// \endcode /// \code /// std::vector v(countNodes(g)); - /// dfs(g,s).processedMap(loggerBoolMap(v.begin())).run(); + /// dfs(g).processedMap(loggerBoolMap(v.begin())).run(s); /// \endcode /// /// \note The container of the iterator must contain enough space @@ -1785,23 +1814,36 @@ /// \addtogroup graph_maps /// @{ - /// Provides an immutable and unique id for each item in the graph. - - /// The IdMap class provides a unique and immutable id for each item of the - /// same type (e.g. node) in the graph. This id is
  • \b unique: - /// different items (nodes) get different ids
  • \b immutable: the id of an - /// item (node) does not change (even if you delete other nodes).
- /// Through this map you get access (i.e. can read) the inner id values of - /// the items stored in the graph. This map can be inverted with its member - /// class \c InverseMap or with the \c operator() member. + /// \brief Provides an immutable and unique id for each item in a graph. /// - template - class IdMap { + /// IdMap provides a unique and immutable id for each item of the + /// same type (\c Node, \c Arc or \c Edge) in a graph. This id is + /// - \b unique: different items get different ids, + /// - \b immutable: the id of an item does not change (even if you + /// delete other nodes). + /// + /// Using this map you get access (i.e. can read) the inner id values of + /// the items stored in the graph, which is returned by the \c id() + /// function of the graph. This map can be inverted with its member + /// class \c InverseMap or with the \c operator()() member. + /// + /// \tparam GR The graph type. + /// \tparam K The key type of the map (\c GR::Node, \c GR::Arc or + /// \c GR::Edge). + /// + /// \see RangeIdMap + template + class IdMap : public MapBase { public: - typedef _Graph Graph; + /// The graph type of IdMap. + typedef GR Graph; + typedef GR Digraph; + /// The key type of IdMap (\c Node, \c Arc or \c Edge). + typedef K Item; + /// The key type of IdMap (\c Node, \c Arc or \c Edge). + typedef K Key; + /// The value type of IdMap. typedef int Value; - typedef _Item Item; - typedef _Item Key; /// \brief Constructor. /// @@ -1813,9 +1855,9 @@ /// Gives back the immutable and unique \e id of the item. int operator[](const Item& item) const { return _graph->id(item);} - /// \brief Gives back the item by its id. + /// \brief Gives back the \e item by its id. /// - /// Gives back the item by its id. + /// Gives back the \e item by its id. Item operator()(int id) { return _graph->fromId(id, Item()); } private: @@ -1823,9 +1865,11 @@ public: - /// \brief The class represents the inverse of its owner (IdMap). + /// \brief The inverse map type of IdMap. /// - /// The class represents the inverse of its owner (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. /// \see inverse() class InverseMap { public: @@ -1840,10 +1884,9 @@ /// Constructor for creating an id-to-item map. explicit InverseMap(const IdMap& map) : _graph(map._graph) {} - /// \brief Gives back the given item from its id. + /// \brief Gives back an item by its id. /// - /// Gives back the given item from its id. - /// + /// Gives back an item by its id. Item operator[](int id) const { return _graph->fromId(id, Item());} private: @@ -1854,165 +1897,220 @@ /// /// Gives back the inverse of the IdMap. InverseMap inverse() const { return InverseMap(*_graph);} - }; - - /// \brief General invertable graph-map type. - - /// This type provides simple invertable graph-maps. - /// The InvertableMap wraps an arbitrary ReadWriteMap - /// and if a key is set to a new value then store it - /// in the inverse map. + /// \brief Returns an \c IdMap class. /// - /// The values of the map can be accessed - /// with stl compatible forward iterator. + /// 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. + + /// This class provides simple invertable graph maps. + /// It wraps a standard graph map (\c NodeMap, \c ArcMap or \c EdgeMap) + /// and if a key is set to a new value, then stores it in the inverse map. + /// The graph items can be accessed by their values either using + /// \c InverseMap or \c operator()(), and the values of the map can be + /// accessed with an STL compatible forward iterator (\c ValueIt). + /// + /// This map is intended to be used when all associated values are + /// different (the map is actually invertable) or there are only a few + /// items with the same value. + /// Otherwise consider to use \c IterableValueMap, which is more + /// suitable and more efficient for such cases. It provides iterators + /// to traverse the items with the same associated value, however + /// it does not have \c InverseMap. /// - /// \tparam _Graph The graph type. - /// \tparam _Item The item type of the graph. - /// \tparam _Value The value type of the map. + /// 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. /// /// \see IterableValueMap - template - class InvertableMap - : protected ItemSetTraits<_Graph, _Item>::template Map<_Value>::Type { + template + class CrossRefMap + : protected ItemSetTraits::template Map::Type { private: - typedef typename ItemSetTraits<_Graph, _Item>:: - template Map<_Value>::Type Map; - typedef _Graph Graph; - - typedef std::map<_Value, _Item> Container; + typedef typename ItemSetTraits:: + template Map::Type Map; + + typedef std::multimap Container; Container _inv_map; public: - /// The key type of InvertableMap (Node, Arc, Edge). - typedef typename Map::Key Key; - /// The value type of the InvertableMap. - typedef typename Map::Value Value; + /// The graph type of CrossRefMap. + typedef GR Graph; + typedef GR Digraph; + /// The key type of CrossRefMap (\c Node, \c Arc or \c Edge). + typedef K Item; + /// The key type of CrossRefMap (\c Node, \c Arc or \c Edge). + typedef K Key; + /// The value type of CrossRefMap. + typedef V Value; /// \brief Constructor. /// - /// Construct a new InvertableMap for the graph. - /// - explicit InvertableMap(const Graph& graph) : Map(graph) {} + /// Construct a new CrossRefMap for the given graph. + explicit CrossRefMap(const Graph& graph) : Map(graph) {} /// \brief Forward iterator for values. /// - /// This iterator is an stl compatible forward + /// This iterator is an STL compatible forward /// iterator on the values of the map. The values can - /// be accessed in the [beginValue, endValue) range. - /// - class ValueIterator + /// 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 : public std::iterator { - friend class InvertableMap; + friend class CrossRefMap; private: - ValueIterator(typename Container::const_iterator _it) + ValueIt(typename Container::const_iterator _it) : it(_it) {} public: - ValueIterator() {} - - ValueIterator& operator++() { ++it; return *this; } - ValueIterator operator++(int) { - ValueIterator tmp(*this); + /// 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); } - bool operator==(ValueIterator jt) const { return it == jt.it; } - bool operator!=(ValueIterator jt) const { return it != jt.it; } + /// \e + bool operator==(ValueIt jt) const { return it == jt.it; } + /// \e + bool operator!=(ValueIt jt) const { return it != jt.it; } private: typename Container::const_iterator it; }; + + /// 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) + /// map can be accessed in the [beginValue, endValue) /// range. - ValueIterator beginValue() const { - return ValueIterator(_inv_map.begin()); + ValueIt beginValue() const { + return ValueIt(_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) + /// map can be accessed in the [beginValue, endValue) /// range. - ValueIterator endValue() const { - return ValueIterator(_inv_map.end()); + ValueIt endValue() const { + return ValueIt(_inv_map.end()); } - /// \brief The setter function of the map. + /// \brief Sets the value associated with the given key. /// - /// Sets the mapped value. + /// Sets the value associated with the given key. void set(const Key& key, const Value& val) { Value oldval = Map::operator[](key); - typename Container::iterator it = _inv_map.find(oldval); - if (it != _inv_map.end() && it->second == key) { - _inv_map.erase(it); + typename Container::iterator it; + for (it = _inv_map.equal_range(oldval).first; + it != _inv_map.equal_range(oldval).second; ++it) { + if (it->second == key) { + _inv_map.erase(it); + break; + } } - _inv_map.insert(make_pair(val, key)); + _inv_map.insert(std::make_pair(val, key)); Map::set(key, val); } - /// \brief The getter function of the map. + /// \brief Returns the value associated with the given key. /// - /// It gives back the value associated with the key. + /// Returns the value associated with the given key. typename MapTraits::ConstReturnValue operator[](const Key& key) const { return Map::operator[](key); } - /// \brief Gives back the item by its value. + /// \brief Gives back an item by its value. /// - /// Gives back the item by its value. - Key operator()(const Value& key) const { - typename Container::const_iterator it = _inv_map.find(key); + /// This function gives back an item that is assigned to + /// the given value or \c INVALID if no such item exists. + /// If there are more items with the same associated value, + /// only one of them is returned. + Key operator()(const Value& val) const { + typename Container::const_iterator it = _inv_map.find(val); return it != _inv_map.end() ? it->second : INVALID; } + + /// \brief Returns the number of items with the given value. + /// + /// This function returns the number of items with the given value + /// associated with it. + int count(const Value &val) const { + return _inv_map.count(val); + } protected: - /// \brief Erase the key from the map. + /// \brief Erase the key from the map and the inverse map. /// - /// Erase the key to the map. It is called by the + /// Erase the key from the map and the inverse map. It is called by the /// \c AlterationNotifier. virtual void erase(const Key& key) { Value val = Map::operator[](key); - typename Container::iterator it = _inv_map.find(val); - if (it != _inv_map.end() && it->second == key) { - _inv_map.erase(it); + typename Container::iterator it; + for (it = _inv_map.equal_range(val).first; + it != _inv_map.equal_range(val).second; ++it) { + if (it->second == key) { + _inv_map.erase(it); + break; + } } Map::erase(key); } - /// \brief Erase more keys from the map. + /// \brief Erase more keys from the map and the inverse map. /// - /// Erase more keys from the map. It is called by the + /// Erase more keys from the map and the inverse map. It is called by the /// \c AlterationNotifier. virtual void erase(const std::vector& keys) { for (int i = 0; i < int(keys.size()); ++i) { Value val = Map::operator[](keys[i]); - typename Container::iterator it = _inv_map.find(val); - if (it != _inv_map.end() && it->second == keys[i]) { - _inv_map.erase(it); + typename Container::iterator it; + for (it = _inv_map.equal_range(val).first; + it != _inv_map.equal_range(val).second; ++it) { + if (it->second == keys[i]) { + _inv_map.erase(it); + break; + } } } Map::erase(keys); } - /// \brief Clear the keys from the map and inverse map. + /// \brief Clear the keys from the map and the inverse map. /// - /// Clear the keys from the map and inverse map. It is called by the + /// Clear the keys from the map and the inverse map. It is called by the /// \c AlterationNotifier. virtual void clear() { _inv_map.clear(); @@ -2021,79 +2119,90 @@ public: - /// \brief The inverse map type. + /// \brief The inverse map type of CrossRefMap. /// - /// The inverse of this map. The subscript operator of the map - /// gives back always the item what was last assigned to the value. + /// 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() class InverseMap { public: - /// \brief Constructor of the InverseMap. + /// \brief Constructor /// /// Constructor of the InverseMap. - explicit InverseMap(const InvertableMap& inverted) + explicit InverseMap(const CrossRefMap& inverted) : _inverted(inverted) {} /// The value type of the InverseMap. - typedef typename InvertableMap::Key Value; + typedef typename CrossRefMap::Key Value; /// The key type of the InverseMap. - typedef typename InvertableMap::Value Key; + typedef typename CrossRefMap::Value Key; /// \brief Subscript operator. /// - /// Subscript operator. It gives back always the item - /// what was last assigned to the value. + /// Subscript operator. It gives back an item + /// that is assigned to the given value or \c INVALID + /// if no such item exists. Value operator[](const Key& key) const { return _inverted(key); } private: - const InvertableMap& _inverted; + const CrossRefMap& _inverted; }; - /// \brief It gives back the just readable inverse map. + /// \brief Gives back the inverse of the map. /// - /// It gives back the just readable inverse map. + /// Gives back the inverse of the CrossRefMap. InverseMap inverse() const { return InverseMap(*this); } }; - /// \brief Provides a mutable, continuous and unique descriptor for each - /// item in the graph. + /// \brief Provides continuous and unique id for the + /// items of a graph. /// - /// The DescriptorMap class provides a unique and continuous (but mutable) - /// descriptor (id) for each item of the same type (e.g. node) in the - /// graph. This id is
  • \b unique: different items (nodes) get - /// different ids
  • \b continuous: the range of the ids is the set of - /// integers between 0 and \c n-1, where \c n is the number of the items of - /// this type (e.g. nodes) (so the id of a node can change if you delete an - /// other node, i.e. this id is mutable).
This map can be inverted - /// with its member class \c InverseMap, or with the \c operator() member. + /// RangeIdMap provides a unique and continuous + /// id for each item of a given type (\c Node, \c Arc or + /// \c Edge) in a graph. This id is + /// - \b unique: different items get different ids, + /// - \b continuous: the range of the ids is the set of integers + /// between 0 and \c n-1, where \c n is the number of the items of + /// this type (\c Node, \c Arc or \c Edge). + /// - So, the ids can change when deleting an item of the same type. /// - /// \tparam _Graph The graph class the \c DescriptorMap belongs to. - /// \tparam _Item The Item is the Key of the Map. It may be Node, Arc or - /// Edge. - template - class DescriptorMap - : protected ItemSetTraits<_Graph, _Item>::template Map::Type { - - typedef _Item Item; - typedef typename ItemSetTraits<_Graph, _Item>::template Map::Type Map; + /// Thus this id is not (necessarily) the same as what can get using + /// the \c id() function of the graph or \ref IdMap. + /// This map can be inverted with its member class \c InverseMap, + /// or with the \c operator()() member. + /// + /// \tparam GR The graph type. + /// \tparam K The key type of the map (\c GR::Node, \c GR::Arc or + /// \c GR::Edge). + /// + /// \see IdMap + template + class RangeIdMap + : protected ItemSetTraits::template Map::Type { + + typedef typename ItemSetTraits::template Map::Type Map; public: - /// The graph class of DescriptorMap. - typedef _Graph Graph; - - /// The key type of DescriptorMap (Node, Arc, Edge). - typedef typename Map::Key Key; - /// The value type of DescriptorMap. - typedef typename Map::Value Value; + /// The graph type of RangeIdMap. + typedef GR Graph; + typedef GR Digraph; + /// The key type of RangeIdMap (\c Node, \c Arc or \c Edge). + typedef K Item; + /// The key type of RangeIdMap (\c Node, \c Arc or \c Edge). + typedef K Key; + /// The value type of RangeIdMap. + typedef int Value; /// \brief Constructor. /// - /// Constructor for descriptor map. - explicit DescriptorMap(const Graph& _graph) : Map(_graph) { + /// Constructor. + explicit RangeIdMap(const Graph& gr) : Map(gr) { Item it; const typename Map::Notifier* nf = Map::notifier(); for (nf->first(it); it != INVALID; nf->next(it)) { @@ -2104,7 +2213,7 @@ protected: - /// \brief Add a new key to the map. + /// \brief Adds a new key to the map. /// /// Add a new key to the map. It is called by the /// \c AlterationNotifier. @@ -2194,16 +2303,16 @@ _inv_map[pi] = q; } - /// \brief Gives back the \e descriptor of the item. + /// \brief Gives back the \e range \e id of the item /// - /// Gives back the mutable and unique \e descriptor of the map. + /// Gives back the \e range \e id of the item. int operator[](const Item& item) const { return Map::operator[](item); } - /// \brief Gives back the item by its descriptor. + /// \brief Gives back the item belonging to a \e range \e id /// - /// Gives back th item by its descriptor. + /// Gives back the item belonging to the given \e range \e id. Item operator()(int id) const { return _inv_map[id]; } @@ -2214,27 +2323,30 @@ Container _inv_map; public: - /// \brief The inverse map type of DescriptorMap. + + /// \brief The inverse map type of RangeIdMap. /// - /// The inverse map type of DescriptorMap. + /// 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. class InverseMap { public: - /// \brief Constructor of the InverseMap. + /// \brief Constructor /// /// Constructor of the InverseMap. - explicit InverseMap(const DescriptorMap& inverted) + explicit InverseMap(const RangeIdMap& inverted) : _inverted(inverted) {} /// The value type of the InverseMap. - typedef typename DescriptorMap::Key Value; + typedef typename RangeIdMap::Key Value; /// The key type of the InverseMap. - typedef typename DescriptorMap::Value Key; + typedef typename RangeIdMap::Value Key; /// \brief Subscript operator. /// /// Subscript operator. It gives back the item - /// that the descriptor belongs to currently. + /// that the given \e range \e id currently belongs to. Value operator[](const Key& key) const { return _inverted(key); } @@ -2247,241 +2359,1134 @@ } private: - const DescriptorMap& _inverted; + const RangeIdMap& _inverted; }; /// \brief Gives back the inverse of the map. /// - /// Gives back the inverse of the map. + /// Gives back the inverse of the RangeIdMap. const InverseMap inverse() const { return InverseMap(*this); } }; - /// \brief Returns the source of the given arc. + /// \brief Returns a \c RangeIdMap class. /// - /// The SourceMap gives back the source Node of the given arc. + /// 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); + unlace(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; + }; + + /// \brief Map of the source nodes of arcs in a digraph. + /// + /// SourceMap provides access for the source node of each arc in a digraph, + /// which is returned by the \c source() function of the digraph. + /// \tparam GR The digraph type. /// \see TargetMap - template + template class SourceMap { public: - typedef typename Digraph::Node Value; - typedef typename Digraph::Arc Key; + /// The key type (the \c Arc type of the digraph). + typedef typename GR::Arc Key; + /// The value type (the \c Node type of the digraph). + typedef typename GR::Node Value; /// \brief Constructor /// - /// Constructor + /// Constructor. /// \param digraph The digraph that the map belongs to. - explicit SourceMap(const Digraph& digraph) : _digraph(digraph) {} - - /// \brief The subscript operator. + explicit SourceMap(const GR& digraph) : _graph(digraph) {} + + /// \brief Returns the source node of the given arc. /// - /// The subscript operator. - /// \param arc The arc - /// \return The source of the arc + /// Returns the source node of the given arc. Value operator[](const Key& arc) const { - return _digraph.source(arc); + return _graph.source(arc); } private: - const Digraph& _digraph; + const GR& _graph; }; /// \brief Returns a \c SourceMap class. /// /// This function just returns an \c SourceMap class. /// \relates SourceMap - template - inline SourceMap sourceMap(const Digraph& digraph) { - return SourceMap(digraph); + template + inline SourceMap sourceMap(const GR& graph) { + return SourceMap(graph); } - /// \brief Returns the target of the given arc. + /// \brief Map of the target nodes of arcs in a digraph. /// - /// The TargetMap gives back the target Node of the given arc. + /// TargetMap provides access for the target node of each arc in a digraph, + /// which is returned by the \c target() function of the digraph. + /// \tparam GR The digraph type. /// \see SourceMap - template + template class TargetMap { public: - typedef typename Digraph::Node Value; - typedef typename Digraph::Arc Key; + /// The key type (the \c Arc type of the digraph). + typedef typename GR::Arc Key; + /// The value type (the \c Node type of the digraph). + typedef typename GR::Node Value; /// \brief Constructor /// - /// Constructor + /// Constructor. /// \param digraph The digraph that the map belongs to. - explicit TargetMap(const Digraph& digraph) : _digraph(digraph) {} - - /// \brief The subscript operator. + explicit TargetMap(const GR& digraph) : _graph(digraph) {} + + /// \brief Returns the target node of the given arc. /// - /// The subscript operator. - /// \param e The arc - /// \return The target of the arc + /// Returns the target node of the given arc. Value operator[](const Key& e) const { - return _digraph.target(e); + return _graph.target(e); } private: - const Digraph& _digraph; + const GR& _graph; }; /// \brief Returns a \c TargetMap class. /// /// This function just returns a \c TargetMap class. /// \relates TargetMap - template - inline TargetMap targetMap(const Digraph& digraph) { - return TargetMap(digraph); + template + inline TargetMap targetMap(const GR& graph) { + return TargetMap(graph); } - /// \brief Returns the "forward" directed arc view of an edge. + /// \brief Map of the "forward" directed arc view of edges in a graph. /// - /// Returns the "forward" directed arc view of an edge. + /// ForwardMap provides access for the "forward" directed arc view of + /// each edge in a graph, which is returned by the \c direct() function + /// of the graph with \c true parameter. + /// \tparam GR The graph type. /// \see BackwardMap - template + template class ForwardMap { public: - typedef typename Graph::Arc Value; - typedef typename Graph::Edge Key; + /// The key type (the \c Edge type of the digraph). + typedef typename GR::Edge Key; + /// The value type (the \c Arc type of the digraph). + typedef typename GR::Arc Value; /// \brief Constructor /// - /// Constructor + /// Constructor. /// \param graph The graph that the map belongs to. - explicit ForwardMap(const Graph& graph) : _graph(graph) {} - - /// \brief The subscript operator. + explicit ForwardMap(const GR& graph) : _graph(graph) {} + + /// \brief Returns the "forward" directed arc view of the given edge. /// - /// The subscript operator. - /// \param key An edge - /// \return The "forward" directed arc view of edge + /// Returns the "forward" directed arc view of the given edge. Value operator[](const Key& key) const { return _graph.direct(key, true); } private: - const Graph& _graph; + const GR& _graph; }; /// \brief Returns a \c ForwardMap class. /// /// This function just returns an \c ForwardMap class. /// \relates ForwardMap - template - inline ForwardMap forwardMap(const Graph& graph) { - return ForwardMap(graph); + template + inline ForwardMap forwardMap(const GR& graph) { + return ForwardMap(graph); } - /// \brief Returns the "backward" directed arc view of an edge. + /// \brief Map of the "backward" directed arc view of edges in a graph. /// - /// Returns the "backward" directed arc view of an edge. + /// BackwardMap provides access for the "backward" directed arc view of + /// each edge in a graph, which is returned by the \c direct() function + /// of the graph with \c false parameter. + /// \tparam GR The graph type. /// \see ForwardMap - template + template class BackwardMap { public: - typedef typename Graph::Arc Value; - typedef typename Graph::Edge Key; + /// The key type (the \c Edge type of the digraph). + typedef typename GR::Edge Key; + /// The value type (the \c Arc type of the digraph). + typedef typename GR::Arc Value; /// \brief Constructor /// - /// Constructor + /// Constructor. /// \param graph The graph that the map belongs to. - explicit BackwardMap(const Graph& graph) : _graph(graph) {} - - /// \brief The subscript operator. + explicit BackwardMap(const GR& graph) : _graph(graph) {} + + /// \brief Returns the "backward" directed arc view of the given edge. /// - /// The subscript operator. - /// \param key An edge - /// \return The "backward" directed arc view of edge + /// Returns the "backward" directed arc view of the given edge. Value operator[](const Key& key) const { return _graph.direct(key, false); } private: - const Graph& _graph; + const GR& _graph; }; /// \brief Returns a \c BackwardMap class /// This function just returns a \c BackwardMap class. /// \relates BackwardMap - template - inline BackwardMap backwardMap(const Graph& graph) { - return BackwardMap(graph); + template + inline BackwardMap backwardMap(const GR& graph) { + return BackwardMap(graph); } - /// \brief Potential difference map - /// - /// If there is an potential map on the nodes then we - /// can get an arc map as we get the substraction of the - /// values of the target and source. - template - class PotentialDifferenceMap { - public: - typedef typename Digraph::Arc Key; - typedef typename NodeMap::Value Value; - - /// \brief Constructor - /// - /// Contructor of the map - explicit PotentialDifferenceMap(const Digraph& digraph, - const NodeMap& potential) - : _digraph(digraph), _potential(potential) {} - - /// \brief Const subscription operator - /// - /// Const subscription operator - Value operator[](const Key& arc) const { - return _potential[_digraph.target(arc)] - - _potential[_digraph.source(arc)]; - } - - private: - const Digraph& _digraph; - const NodeMap& _potential; - }; - - /// \brief Returns a PotentialDifferenceMap. - /// - /// This function just returns a PotentialDifferenceMap. - /// \relates PotentialDifferenceMap - template - PotentialDifferenceMap - potentialDifferenceMap(const Digraph& digraph, const NodeMap& potential) { - return PotentialDifferenceMap(digraph, potential); - } - - /// \brief Map of the node in-degrees. + /// \brief Map of the in-degrees of nodes in a digraph. /// /// This map returns the in-degree of a node. Once it is constructed, - /// the degrees are stored in a standard NodeMap, so each query is done + /// the degrees are stored in a standard \c NodeMap, so each query is done /// in constant time. On the other hand, the values are updated automatically /// whenever the digraph changes. /// - /// \warning Besides addNode() and addArc(), a digraph structure may provide - /// alternative ways to modify the digraph. The correct behavior of InDegMap - /// is not guarantied if these additional features are used. For example - /// the functions \ref ListDigraph::changeSource() "changeSource()", + /// \warning Besides \c addNode() and \c addArc(), a digraph structure + /// may provide alternative ways to modify the digraph. + /// The correct behavior of InDegMap is not guarantied if these additional + /// features are used. For example the functions + /// \ref ListDigraph::changeSource() "changeSource()", /// \ref ListDigraph::changeTarget() "changeTarget()" and /// \ref ListDigraph::reverseArc() "reverseArc()" /// of \ref ListDigraph will \e not update the degree values correctly. /// /// \sa OutDegMap - - template + template class InDegMap - : protected ItemSetTraits<_Digraph, typename _Digraph::Arc> + : protected ItemSetTraits ::ItemNotifier::ObserverBase { public: - typedef _Digraph Digraph; + /// The graph type of InDegMap + typedef GR Graph; + typedef GR Digraph; + /// The key type + typedef typename Digraph::Node Key; + /// The value type typedef int Value; - typedef typename Digraph::Node Key; typedef typename ItemSetTraits ::ItemNotifier::ObserverBase Parent; @@ -2523,9 +3528,9 @@ /// \brief Constructor. /// - /// Constructor for creating in-degree map. - explicit InDegMap(const Digraph& digraph) - : _digraph(digraph), _deg(digraph) { + /// Constructor for creating an in-degree map. + explicit InDegMap(const Digraph& graph) + : _digraph(graph), _deg(graph) { Parent::attach(_digraph.notifier(typename Digraph::Arc())); for(typename Digraph::NodeIt it(_digraph); it != INVALID; ++it) { @@ -2533,6 +3538,8 @@ } } + /// \brief Gives back the in-degree of a Node. + /// /// Gives back the in-degree of a Node. int operator[](const Key& key) const { return _deg[key]; @@ -2579,33 +3586,37 @@ AutoNodeMap _deg; }; - /// \brief Map of the node out-degrees. + /// \brief Map of the out-degrees of nodes in a digraph. /// /// This map returns the out-degree of a node. Once it is constructed, - /// the degrees are stored in a standard NodeMap, so each query is done + /// the degrees are stored in a standard \c NodeMap, so each query is done /// in constant time. On the other hand, the values are updated automatically /// whenever the digraph changes. /// - /// \warning Besides addNode() and addArc(), a digraph structure may provide - /// alternative ways to modify the digraph. The correct behavior of OutDegMap - /// is not guarantied if these additional features are used. For example - /// the functions \ref ListDigraph::changeSource() "changeSource()", + /// \warning Besides \c addNode() and \c addArc(), a digraph structure + /// may provide alternative ways to modify the digraph. + /// The correct behavior of OutDegMap is not guarantied if these additional + /// features are used. For example the functions + /// \ref ListDigraph::changeSource() "changeSource()", /// \ref ListDigraph::changeTarget() "changeTarget()" and /// \ref ListDigraph::reverseArc() "reverseArc()" /// of \ref ListDigraph will \e not update the degree values correctly. /// /// \sa InDegMap - - template + template class OutDegMap - : protected ItemSetTraits<_Digraph, typename _Digraph::Arc> + : protected ItemSetTraits ::ItemNotifier::ObserverBase { public: - typedef _Digraph Digraph; + /// The graph type of OutDegMap + typedef GR Graph; + typedef GR Digraph; + /// The key type + typedef typename Digraph::Node Key; + /// The value type typedef int Value; - typedef typename Digraph::Node Key; typedef typename ItemSetTraits ::ItemNotifier::ObserverBase Parent; @@ -2645,9 +3656,9 @@ /// \brief Constructor. /// - /// Constructor for creating out-degree map. - explicit OutDegMap(const Digraph& digraph) - : _digraph(digraph), _deg(digraph) { + /// Constructor for creating an out-degree map. + explicit OutDegMap(const Digraph& graph) + : _digraph(graph), _deg(graph) { Parent::attach(_digraph.notifier(typename Digraph::Arc())); for(typename Digraph::NodeIt it(_digraph); it != INVALID; ++it) { @@ -2655,6 +3666,8 @@ } } + /// \brief Gives back the out-degree of a Node. + /// /// Gives back the out-degree of a Node. int operator[](const Key& key) const { return _deg[key]; @@ -2701,6 +3714,56 @@ AutoNodeMap _deg; }; + /// \brief Potential difference map + /// + /// PotentialDifferenceMap returns the difference between the potentials of + /// the source and target nodes of each arc in a digraph, i.e. it returns + /// \code + /// potential[gr.target(arc)] - potential[gr.source(arc)]. + /// \endcode + /// \tparam GR The digraph type. + /// \tparam POT A node map storing the potentials. + template + class PotentialDifferenceMap { + public: + /// Key type + typedef typename GR::Arc Key; + /// Value type + typedef typename POT::Value Value; + + /// \brief Constructor + /// + /// Contructor of the map. + explicit PotentialDifferenceMap(const GR& gr, + const POT& potential) + : _digraph(gr), _potential(potential) {} + + /// \brief Returns the potential difference for the given arc. + /// + /// Returns the potential difference for the given arc, i.e. + /// \code + /// potential[gr.target(arc)] - potential[gr.source(arc)]. + /// \endcode + Value operator[](const Key& arc) const { + return _potential[_digraph.target(arc)] - + _potential[_digraph.source(arc)]; + } + + private: + const GR& _digraph; + const POT& _potential; + }; + + /// \brief Returns a PotentialDifferenceMap. + /// + /// This function just returns a PotentialDifferenceMap. + /// \relates PotentialDifferenceMap + template + PotentialDifferenceMap + potentialDifferenceMap(const GR& gr, const POT& potential) { + return PotentialDifferenceMap(gr, potential); + } + /// @} } diff -r c35afa9e89e7 -r ef88c0a30f85 lemon/matching.h --- /dev/null Thu Jan 01 00:00:00 1970 +0000 +++ b/lemon/matching.h Thu Nov 05 15:48:01 2009 +0100 @@ -0,0 +1,3244 @@ +/* -*- 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_MAX_MATCHING_H +#define LEMON_MAX_MATCHING_H + +#include +#include +#include +#include + +#include +#include +#include +#include + +///\ingroup matching +///\file +///\brief Maximum matching algorithms in general graphs. + +namespace lemon { + + /// \ingroup matching + /// + /// \brief Maximum cardinality matching in general graphs + /// + /// This class implements Edmonds' alternating forest matching algorithm + /// for finding a maximum cardinality matching in a general undirected graph. + /// It can be started from an arbitrary initial matching + /// (the default is the empty one). + /// + /// The dual solution of the problem is a map of the nodes to + /// \ref MaxMatching::Status "Status", having values \c EVEN (or \c D), + /// \c ODD (or \c A) and \c MATCHED (or \c C) defining the Gallai-Edmonds + /// decomposition of the graph. The nodes in \c EVEN/D induce a subgraph + /// with factor-critical components, the nodes in \c ODD/A form the + /// canonical barrier, and the nodes in \c MATCHED/C induce a graph having + /// a perfect matching. The number of the factor-critical components + /// minus the number of barrier nodes is a lower bound on the + /// unmatched nodes, and the matching is optimal if and only if this bound is + /// tight. This decomposition can be obtained using \ref status() or + /// \ref statusMap() after running the algorithm. + /// + /// \tparam GR The undirected graph type the algorithm runs on. + template + class MaxMatching { + public: + + /// The graph type of the algorithm + typedef GR Graph; + /// The type of the matching map + typedef typename Graph::template NodeMap + MatchingMap; + + ///\brief Status constants for Gallai-Edmonds decomposition. + /// + ///These constants are used for indicating the Gallai-Edmonds + ///decomposition of a graph. The nodes with status \c EVEN (or \c D) + ///induce a subgraph with factor-critical components, the nodes with + ///status \c ODD (or \c A) form the canonical barrier, and the nodes + ///with status \c MATCHED (or \c C) induce a subgraph having a + ///perfect matching. + enum Status { + EVEN = 1, ///< = 1. (\c D is an alias for \c EVEN.) + D = 1, + MATCHED = 0, ///< = 0. (\c C is an alias for \c MATCHED.) + C = 0, + ODD = -1, ///< = -1. (\c A is an alias for \c ODD.) + A = -1, + UNMATCHED = -2 ///< = -2. + }; + + /// The type of the status map + typedef typename Graph::template NodeMap StatusMap; + + private: + + TEMPLATE_GRAPH_TYPEDEFS(Graph); + + typedef UnionFindEnum BlossomSet; + typedef ExtendFindEnum TreeSet; + typedef RangeMap NodeIntMap; + typedef MatchingMap EarMap; + typedef std::vector NodeQueue; + + const Graph& _graph; + MatchingMap* _matching; + StatusMap* _status; + + EarMap* _ear; + + IntNodeMap* _blossom_set_index; + BlossomSet* _blossom_set; + NodeIntMap* _blossom_rep; + + IntNodeMap* _tree_set_index; + TreeSet* _tree_set; + + NodeQueue _node_queue; + int _process, _postpone, _last; + + int _node_num; + + private: + + void createStructures() { + _node_num = countNodes(_graph); + if (!_matching) { + _matching = new MatchingMap(_graph); + } + if (!_status) { + _status = new StatusMap(_graph); + } + if (!_ear) { + _ear = new EarMap(_graph); + } + if (!_blossom_set) { + _blossom_set_index = new IntNodeMap(_graph); + _blossom_set = new BlossomSet(*_blossom_set_index); + } + if (!_blossom_rep) { + _blossom_rep = new NodeIntMap(_node_num); + } + if (!_tree_set) { + _tree_set_index = new IntNodeMap(_graph); + _tree_set = new TreeSet(*_tree_set_index); + } + _node_queue.resize(_node_num); + } + + void destroyStructures() { + if (_matching) { + delete _matching; + } + if (_status) { + delete _status; + } + if (_ear) { + delete _ear; + } + if (_blossom_set) { + delete _blossom_set; + delete _blossom_set_index; + } + if (_blossom_rep) { + delete _blossom_rep; + } + if (_tree_set) { + delete _tree_set_index; + delete _tree_set; + } + } + + void processDense(const Node& n) { + _process = _postpone = _last = 0; + _node_queue[_last++] = n; + + while (_process != _last) { + Node u = _node_queue[_process++]; + for (OutArcIt a(_graph, u); a != INVALID; ++a) { + Node v = _graph.target(a); + if ((*_status)[v] == MATCHED) { + extendOnArc(a); + } else if ((*_status)[v] == UNMATCHED) { + augmentOnArc(a); + return; + } + } + } + + while (_postpone != _last) { + Node u = _node_queue[_postpone++]; + + for (OutArcIt a(_graph, u); a != INVALID ; ++a) { + Node v = _graph.target(a); + + if ((*_status)[v] == EVEN) { + if (_blossom_set->find(u) != _blossom_set->find(v)) { + shrinkOnEdge(a); + } + } + + while (_process != _last) { + Node w = _node_queue[_process++]; + for (OutArcIt b(_graph, w); b != INVALID; ++b) { + Node x = _graph.target(b); + if ((*_status)[x] == MATCHED) { + extendOnArc(b); + } else if ((*_status)[x] == UNMATCHED) { + augmentOnArc(b); + return; + } + } + } + } + } + } + + void processSparse(const Node& n) { + _process = _last = 0; + _node_queue[_last++] = n; + while (_process != _last) { + Node u = _node_queue[_process++]; + for (OutArcIt a(_graph, u); a != INVALID; ++a) { + Node v = _graph.target(a); + + if ((*_status)[v] == EVEN) { + if (_blossom_set->find(u) != _blossom_set->find(v)) { + shrinkOnEdge(a); + } + } else if ((*_status)[v] == MATCHED) { + extendOnArc(a); + } else if ((*_status)[v] == UNMATCHED) { + augmentOnArc(a); + return; + } + } + } + } + + void shrinkOnEdge(const Edge& e) { + Node nca = INVALID; + + { + std::set left_set, right_set; + + Node left = (*_blossom_rep)[_blossom_set->find(_graph.u(e))]; + left_set.insert(left); + + Node right = (*_blossom_rep)[_blossom_set->find(_graph.v(e))]; + right_set.insert(right); + + while (true) { + if ((*_matching)[left] == INVALID) break; + left = _graph.target((*_matching)[left]); + left = (*_blossom_rep)[_blossom_set-> + find(_graph.target((*_ear)[left]))]; + if (right_set.find(left) != right_set.end()) { + nca = left; + break; + } + left_set.insert(left); + + if ((*_matching)[right] == INVALID) break; + right = _graph.target((*_matching)[right]); + right = (*_blossom_rep)[_blossom_set-> + find(_graph.target((*_ear)[right]))]; + if (left_set.find(right) != left_set.end()) { + nca = right; + break; + } + right_set.insert(right); + } + + if (nca == INVALID) { + if ((*_matching)[left] == INVALID) { + nca = right; + while (left_set.find(nca) == left_set.end()) { + nca = _graph.target((*_matching)[nca]); + nca =(*_blossom_rep)[_blossom_set-> + find(_graph.target((*_ear)[nca]))]; + } + } else { + nca = left; + while (right_set.find(nca) == right_set.end()) { + nca = _graph.target((*_matching)[nca]); + nca = (*_blossom_rep)[_blossom_set-> + find(_graph.target((*_ear)[nca]))]; + } + } + } + } + + { + + Node node = _graph.u(e); + Arc arc = _graph.direct(e, true); + Node base = (*_blossom_rep)[_blossom_set->find(node)]; + + while (base != nca) { + (*_ear)[node] = arc; + + Node n = node; + while (n != base) { + n = _graph.target((*_matching)[n]); + Arc a = (*_ear)[n]; + n = _graph.target(a); + (*_ear)[n] = _graph.oppositeArc(a); + } + node = _graph.target((*_matching)[base]); + _tree_set->erase(base); + _tree_set->erase(node); + _blossom_set->insert(node, _blossom_set->find(base)); + (*_status)[node] = EVEN; + _node_queue[_last++] = node; + arc = _graph.oppositeArc((*_ear)[node]); + node = _graph.target((*_ear)[node]); + base = (*_blossom_rep)[_blossom_set->find(node)]; + _blossom_set->join(_graph.target(arc), base); + } + } + + (*_blossom_rep)[_blossom_set->find(nca)] = nca; + + { + + Node node = _graph.v(e); + Arc arc = _graph.direct(e, false); + Node base = (*_blossom_rep)[_blossom_set->find(node)]; + + while (base != nca) { + (*_ear)[node] = arc; + + Node n = node; + while (n != base) { + n = _graph.target((*_matching)[n]); + Arc a = (*_ear)[n]; + n = _graph.target(a); + (*_ear)[n] = _graph.oppositeArc(a); + } + node = _graph.target((*_matching)[base]); + _tree_set->erase(base); + _tree_set->erase(node); + _blossom_set->insert(node, _blossom_set->find(base)); + (*_status)[node] = EVEN; + _node_queue[_last++] = node; + arc = _graph.oppositeArc((*_ear)[node]); + node = _graph.target((*_ear)[node]); + base = (*_blossom_rep)[_blossom_set->find(node)]; + _blossom_set->join(_graph.target(arc), base); + } + } + + (*_blossom_rep)[_blossom_set->find(nca)] = nca; + } + + void extendOnArc(const Arc& a) { + Node base = _graph.source(a); + Node odd = _graph.target(a); + + (*_ear)[odd] = _graph.oppositeArc(a); + Node even = _graph.target((*_matching)[odd]); + (*_blossom_rep)[_blossom_set->insert(even)] = even; + (*_status)[odd] = ODD; + (*_status)[even] = EVEN; + int tree = _tree_set->find((*_blossom_rep)[_blossom_set->find(base)]); + _tree_set->insert(odd, tree); + _tree_set->insert(even, tree); + _node_queue[_last++] = even; + + } + + void augmentOnArc(const Arc& a) { + Node even = _graph.source(a); + Node odd = _graph.target(a); + + int tree = _tree_set->find((*_blossom_rep)[_blossom_set->find(even)]); + + (*_matching)[odd] = _graph.oppositeArc(a); + (*_status)[odd] = MATCHED; + + Arc arc = (*_matching)[even]; + (*_matching)[even] = a; + + while (arc != INVALID) { + odd = _graph.target(arc); + arc = (*_ear)[odd]; + even = _graph.target(arc); + (*_matching)[odd] = arc; + arc = (*_matching)[even]; + (*_matching)[even] = _graph.oppositeArc((*_matching)[odd]); + } + + for (typename TreeSet::ItemIt it(*_tree_set, tree); + it != INVALID; ++it) { + if ((*_status)[it] == ODD) { + (*_status)[it] = MATCHED; + } else { + int blossom = _blossom_set->find(it); + for (typename BlossomSet::ItemIt jt(*_blossom_set, blossom); + jt != INVALID; ++jt) { + (*_status)[jt] = MATCHED; + } + _blossom_set->eraseClass(blossom); + } + } + _tree_set->eraseClass(tree); + + } + + public: + + /// \brief Constructor + /// + /// Constructor. + MaxMatching(const Graph& graph) + : _graph(graph), _matching(0), _status(0), _ear(0), + _blossom_set_index(0), _blossom_set(0), _blossom_rep(0), + _tree_set_index(0), _tree_set(0) {} + + ~MaxMatching() { + destroyStructures(); + } + + /// \name Execution Control + /// The simplest way to execute the algorithm is to use the + /// \c run() member function.\n + /// If you need better control on the execution, you have to call + /// one of the functions \ref init(), \ref greedyInit() or + /// \ref matchingInit() first, then you can start the algorithm with + /// \ref startSparse() or \ref startDense(). + + ///@{ + + /// \brief Set the initial matching to the empty matching. + /// + /// This function sets the initial matching to the empty matching. + void init() { + createStructures(); + for(NodeIt n(_graph); n != INVALID; ++n) { + (*_matching)[n] = INVALID; + (*_status)[n] = UNMATCHED; + } + } + + /// \brief Find an initial matching in a greedy way. + /// + /// This function finds an initial matching in a greedy way. + void greedyInit() { + createStructures(); + for (NodeIt n(_graph); n != INVALID; ++n) { + (*_matching)[n] = INVALID; + (*_status)[n] = UNMATCHED; + } + for (NodeIt n(_graph); n != INVALID; ++n) { + if ((*_matching)[n] == INVALID) { + for (OutArcIt a(_graph, n); a != INVALID ; ++a) { + Node v = _graph.target(a); + if ((*_matching)[v] == INVALID && v != n) { + (*_matching)[n] = a; + (*_status)[n] = MATCHED; + (*_matching)[v] = _graph.oppositeArc(a); + (*_status)[v] = MATCHED; + break; + } + } + } + } + } + + + /// \brief Initialize the matching from a map. + /// + /// This function initializes the matching from a \c bool valued edge + /// map. This map should have the property that there are no two incident + /// edges with \c true value, i.e. it really contains a matching. + /// \return \c true if the map contains a matching. + template + bool matchingInit(const MatchingMap& matching) { + createStructures(); + + for (NodeIt n(_graph); n != INVALID; ++n) { + (*_matching)[n] = INVALID; + (*_status)[n] = UNMATCHED; + } + for(EdgeIt e(_graph); e!=INVALID; ++e) { + if (matching[e]) { + + Node u = _graph.u(e); + if ((*_matching)[u] != INVALID) return false; + (*_matching)[u] = _graph.direct(e, true); + (*_status)[u] = MATCHED; + + Node v = _graph.v(e); + if ((*_matching)[v] != INVALID) return false; + (*_matching)[v] = _graph.direct(e, false); + (*_status)[v] = MATCHED; + } + } + return true; + } + + /// \brief Start Edmonds' algorithm + /// + /// This function runs the original Edmonds' algorithm. + /// + /// \pre \ref init(), \ref greedyInit() or \ref matchingInit() must be + /// called before using this function. + void startSparse() { + for(NodeIt n(_graph); n != INVALID; ++n) { + if ((*_status)[n] == UNMATCHED) { + (*_blossom_rep)[_blossom_set->insert(n)] = n; + _tree_set->insert(n); + (*_status)[n] = EVEN; + processSparse(n); + } + } + } + + /// \brief Start Edmonds' algorithm with a heuristic improvement + /// for dense graphs + /// + /// This function runs Edmonds' algorithm with a heuristic of postponing + /// shrinks, therefore resulting in a faster algorithm for dense graphs. + /// + /// \pre \ref init(), \ref greedyInit() or \ref matchingInit() must be + /// called before using this function. + void startDense() { + for(NodeIt n(_graph); n != INVALID; ++n) { + if ((*_status)[n] == UNMATCHED) { + (*_blossom_rep)[_blossom_set->insert(n)] = n; + _tree_set->insert(n); + (*_status)[n] = EVEN; + processDense(n); + } + } + } + + + /// \brief Run Edmonds' algorithm + /// + /// This function runs Edmonds' algorithm. An additional heuristic of + /// postponing shrinks is used for relatively dense graphs + /// (for which m>=2*n holds). + void run() { + if (countEdges(_graph) < 2 * countNodes(_graph)) { + greedyInit(); + startSparse(); + } else { + init(); + startDense(); + } + } + + /// @} + + /// \name Primal Solution + /// Functions to get the primal solution, i.e. the maximum matching. + + /// @{ + + /// \brief Return the size (cardinality) of the matching. + /// + /// This function returns the size (cardinality) of the current matching. + /// After run() it returns the size of the maximum matching in the graph. + int matchingSize() const { + int size = 0; + for (NodeIt n(_graph); n != INVALID; ++n) { + if ((*_matching)[n] != INVALID) { + ++size; + } + } + return size / 2; + } + + /// \brief Return \c true if the given edge is in the matching. + /// + /// This function returns \c true if the given edge is in the current + /// matching. + bool matching(const Edge& edge) const { + return edge == (*_matching)[_graph.u(edge)]; + } + + /// \brief Return the matching arc (or edge) incident to the given node. + /// + /// This function returns the matching arc (or edge) incident to the + /// given node in the current matching or \c INVALID if the node is + /// not covered by the matching. + Arc matching(const Node& n) const { + return (*_matching)[n]; + } + + /// \brief Return a const reference to the matching map. + /// + /// This function returns a const reference to a node map that stores + /// the matching arc (or edge) incident to each node. + const MatchingMap& matchingMap() const { + return *_matching; + } + + /// \brief Return the mate of the given node. + /// + /// This function returns the mate of the given node in the current + /// matching or \c INVALID if the node is not covered by the matching. + Node mate(const Node& n) const { + return (*_matching)[n] != INVALID ? + _graph.target((*_matching)[n]) : INVALID; + } + + /// @} + + /// \name Dual Solution + /// Functions to get the dual solution, i.e. the Gallai-Edmonds + /// decomposition. + + /// @{ + + /// \brief Return the status of the given node in the Edmonds-Gallai + /// decomposition. + /// + /// This function returns the \ref Status "status" of the given node + /// in the Edmonds-Gallai decomposition. + Status status(const Node& n) const { + return (*_status)[n]; + } + + /// \brief Return a const reference to the status map, which stores + /// the Edmonds-Gallai decomposition. + /// + /// This function returns a const reference to a node map that stores the + /// \ref Status "status" of each node in the Edmonds-Gallai decomposition. + const StatusMap& statusMap() const { + return *_status; + } + + /// \brief Return \c true if the given node is in the barrier. + /// + /// This function returns \c true if the given node is in the barrier. + bool barrier(const Node& n) const { + return (*_status)[n] == ODD; + } + + /// @} + + }; + + /// \ingroup matching + /// + /// \brief Weighted matching in general graphs + /// + /// This class provides an efficient implementation of Edmond's + /// maximum weighted matching algorithm. The implementation is based + /// on extensive use of priority queues and provides + /// \f$O(nm\log n)\f$ time complexity. + /// + /// The maximum weighted matching problem is to find a subset of the + /// edges in an undirected graph with maximum overall weight for which + /// each node has at most one incident edge. + /// It can be formulated with the following linear program. + /// \f[ \sum_{e \in \delta(u)}x_e \le 1 \quad \forall u\in V\f] + /** \f[ \sum_{e \in \gamma(B)}x_e \le \frac{\vert B \vert - 1}{2} + \quad \forall B\in\mathcal{O}\f] */ + /// \f[x_e \ge 0\quad \forall e\in E\f] + /// \f[\max \sum_{e\in E}x_ew_e\f] + /// where \f$\delta(X)\f$ is the set of edges incident to a node in + /// \f$X\f$, \f$\gamma(X)\f$ is the set of edges with both ends in + /// \f$X\f$ and \f$\mathcal{O}\f$ is the set of odd cardinality + /// subsets of the nodes. + /// + /// The algorithm calculates an optimal matching and a proof of the + /// optimality. The solution of the dual problem can be used to check + /// the result of the algorithm. The dual linear problem is the + /// following. + /** \f[ y_u + y_v + \sum_{B \in \mathcal{O}, uv \in \gamma(B)} + z_B \ge w_{uv} \quad \forall uv\in E\f] */ + /// \f[y_u \ge 0 \quad \forall u \in V\f] + /// \f[z_B \ge 0 \quad \forall B \in \mathcal{O}\f] + /** \f[\min \sum_{u \in V}y_u + \sum_{B \in \mathcal{O}} + \frac{\vert B \vert - 1}{2}z_B\f] */ + /// + /// The algorithm can be executed with the run() function. + /// After it the matching (the primal solution) and the dual solution + /// can be obtained using the query functions and the + /// \ref MaxWeightedMatching::BlossomIt "BlossomIt" nested class, + /// which is able to iterate on the nodes of a blossom. + /// If the value type is integer, then the dual solution is multiplied + /// by \ref MaxWeightedMatching::dualScale "4". + /// + /// \tparam GR The undirected graph type the algorithm runs on. + /// \tparam WM The type edge weight map. The default type is + /// \ref concepts::Graph::EdgeMap "GR::EdgeMap". +#ifdef DOXYGEN + template +#else + template > +#endif + class MaxWeightedMatching { + public: + + /// The graph type of the algorithm + typedef GR Graph; + /// The type of the edge weight map + typedef WM WeightMap; + /// The value type of the edge weights + typedef typename WeightMap::Value Value; + + /// The type of the matching map + typedef typename Graph::template NodeMap + MatchingMap; + + /// \brief Scaling factor for dual solution + /// + /// Scaling factor for dual solution. It is equal to 4 or 1 + /// according to the value type. + static const int dualScale = + std::numeric_limits::is_integer ? 4 : 1; + + private: + + TEMPLATE_GRAPH_TYPEDEFS(Graph); + + typedef typename Graph::template NodeMap NodePotential; + typedef std::vector BlossomNodeList; + + struct BlossomVariable { + int begin, end; + Value value; + + BlossomVariable(int _begin, int _end, Value _value) + : begin(_begin), end(_end), value(_value) {} + + }; + + typedef std::vector BlossomPotential; + + const Graph& _graph; + const WeightMap& _weight; + + MatchingMap* _matching; + + NodePotential* _node_potential; + + BlossomPotential _blossom_potential; + BlossomNodeList _blossom_node_list; + + int _node_num; + int _blossom_num; + + typedef RangeMap IntIntMap; + + enum Status { + EVEN = -1, MATCHED = 0, ODD = 1, UNMATCHED = -2 + }; + + typedef HeapUnionFind BlossomSet; + struct BlossomData { + int tree; + Status status; + Arc pred, next; + Value pot, offset; + Node base; + }; + + IntNodeMap *_blossom_index; + BlossomSet *_blossom_set; + RangeMap* _blossom_data; + + IntNodeMap *_node_index; + IntArcMap *_node_heap_index; + + struct NodeData { + + NodeData(IntArcMap& node_heap_index) + : heap(node_heap_index) {} + + int blossom; + Value pot; + BinHeap heap; + std::map heap_index; + + int tree; + }; + + RangeMap* _node_data; + + typedef ExtendFindEnum TreeSet; + + IntIntMap *_tree_set_index; + TreeSet *_tree_set; + + IntNodeMap *_delta1_index; + BinHeap *_delta1; + + IntIntMap *_delta2_index; + BinHeap *_delta2; + + IntEdgeMap *_delta3_index; + BinHeap *_delta3; + + IntIntMap *_delta4_index; + BinHeap *_delta4; + + Value _delta_sum; + + void createStructures() { + _node_num = countNodes(_graph); + _blossom_num = _node_num * 3 / 2; + + if (!_matching) { + _matching = new MatchingMap(_graph); + } + if (!_node_potential) { + _node_potential = new NodePotential(_graph); + } + if (!_blossom_set) { + _blossom_index = new IntNodeMap(_graph); + _blossom_set = new BlossomSet(*_blossom_index); + _blossom_data = new RangeMap(_blossom_num); + } + + if (!_node_index) { + _node_index = new IntNodeMap(_graph); + _node_heap_index = new IntArcMap(_graph); + _node_data = new RangeMap(_node_num, + NodeData(*_node_heap_index)); + } + + if (!_tree_set) { + _tree_set_index = new IntIntMap(_blossom_num); + _tree_set = new TreeSet(*_tree_set_index); + } + if (!_delta1) { + _delta1_index = new IntNodeMap(_graph); + _delta1 = new BinHeap(*_delta1_index); + } + if (!_delta2) { + _delta2_index = new IntIntMap(_blossom_num); + _delta2 = new BinHeap(*_delta2_index); + } + if (!_delta3) { + _delta3_index = new IntEdgeMap(_graph); + _delta3 = new BinHeap(*_delta3_index); + } + if (!_delta4) { + _delta4_index = new IntIntMap(_blossom_num); + _delta4 = new BinHeap(*_delta4_index); + } + } + + void destroyStructures() { + _node_num = countNodes(_graph); + _blossom_num = _node_num * 3 / 2; + + if (_matching) { + delete _matching; + } + if (_node_potential) { + delete _node_potential; + } + if (_blossom_set) { + delete _blossom_index; + delete _blossom_set; + delete _blossom_data; + } + + if (_node_index) { + delete _node_index; + delete _node_heap_index; + delete _node_data; + } + + if (_tree_set) { + delete _tree_set_index; + delete _tree_set; + } + if (_delta1) { + delete _delta1_index; + delete _delta1; + } + if (_delta2) { + delete _delta2_index; + delete _delta2; + } + if (_delta3) { + delete _delta3_index; + delete _delta3; + } + if (_delta4) { + delete _delta4_index; + delete _delta4; + } + } + + void matchedToEven(int blossom, int tree) { + if (_delta2->state(blossom) == _delta2->IN_HEAP) { + _delta2->erase(blossom); + } + + if (!_blossom_set->trivial(blossom)) { + (*_blossom_data)[blossom].pot -= + 2 * (_delta_sum - (*_blossom_data)[blossom].offset); + } + + for (typename BlossomSet::ItemIt n(*_blossom_set, blossom); + n != INVALID; ++n) { + + _blossom_set->increase(n, std::numeric_limits::max()); + int ni = (*_node_index)[n]; + + (*_node_data)[ni].heap.clear(); + (*_node_data)[ni].heap_index.clear(); + + (*_node_data)[ni].pot += _delta_sum - (*_blossom_data)[blossom].offset; + + _delta1->push(n, (*_node_data)[ni].pot); + + for (InArcIt e(_graph, n); e != INVALID; ++e) { + Node v = _graph.source(e); + int vb = _blossom_set->find(v); + int vi = (*_node_index)[v]; + + Value rw = (*_node_data)[ni].pot + (*_node_data)[vi].pot - + dualScale * _weight[e]; + + if ((*_blossom_data)[vb].status == EVEN) { + if (_delta3->state(e) != _delta3->IN_HEAP && blossom != vb) { + _delta3->push(e, rw / 2); + } + } else 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); + + 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 matchedToUnmatched(int blossom) { + if (_delta2->state(blossom) == _delta2->IN_HEAP) { + _delta2->erase(blossom); + } + + for (typename BlossomSet::ItemIt n(*_blossom_set, blossom); + n != INVALID; ++n) { + int ni = (*_node_index)[n]; + + _blossom_set->increase(n, std::numeric_limits::max()); + + (*_node_data)[ni].heap.clear(); + (*_node_data)[ni].heap_index.clear(); + + for (OutArcIt e(_graph, n); e != INVALID; ++e) { + Node v = _graph.target(e); + int vb = _blossom_set->find(v); + int vi = (*_node_index)[v]; + + Value rw = (*_node_data)[ni].pot + (*_node_data)[vi].pot - + dualScale * _weight[e]; + + if ((*_blossom_data)[vb].status == EVEN) { + if (_delta3->state(e) != _delta3->IN_HEAP) { + _delta3->push(e, rw); + } + } + } + } + } + + void unmatchedToMatched(int blossom) { + for (typename BlossomSet::ItemIt n(*_blossom_set, blossom); + n != INVALID; ++n) { + int ni = (*_node_index)[n]; + + for (InArcIt e(_graph, n); e != INVALID; ++e) { + Node v = _graph.source(e); + int vb = _blossom_set->find(v); + int vi = (*_node_index)[v]; + + Value rw = (*_node_data)[ni].pot + (*_node_data)[vi].pot - + dualScale * _weight[e]; + + if (vb == blossom) { + if (_delta3->state(e) == _delta3->IN_HEAP) { + _delta3->erase(e); + } + } else if ((*_blossom_data)[vb].status == EVEN) { + + if (_delta3->state(e) == _delta3->IN_HEAP) { + _delta3->erase(e); + } + + int vt = _tree_set->find(vb); + + Arc r = _graph.oppositeArc(e); + + typename std::map::iterator it = + (*_node_data)[ni].heap_index.find(vt); + + if (it != (*_node_data)[ni].heap_index.end()) { + if ((*_node_data)[ni].heap[it->second] > rw) { + (*_node_data)[ni].heap.replace(it->second, r); + (*_node_data)[ni].heap.decrease(r, rw); + it->second = r; + } + } else { + (*_node_data)[ni].heap.push(r, rw); + (*_node_data)[ni].heap_index.insert(std::make_pair(vt, r)); + } + + if ((*_blossom_set)[n] > (*_node_data)[ni].heap.prio()) { + _blossom_set->decrease(n, (*_node_data)[ni].heap.prio()); + + if (_delta2->state(blossom) != _delta2->IN_HEAP) { + _delta2->push(blossom, _blossom_set->classPrio(blossom) - + (*_blossom_data)[blossom].offset); + } else if ((*_delta2)[blossom] > _blossom_set->classPrio(blossom)- + (*_blossom_data)[blossom].offset){ + _delta2->decrease(blossom, _blossom_set->classPrio(blossom) - + (*_blossom_data)[blossom].offset); + } + } + + } else if ((*_blossom_data)[vb].status == UNMATCHED) { + if (_delta3->state(e) == _delta3->IN_HEAP) { + _delta3->erase(e); + } + } + } + } + } + + void alternatePath(int even, int tree) { + int odd; + + evenToMatched(even, tree); + (*_blossom_data)[even].status = MATCHED; + + while ((*_blossom_data)[even].pred != INVALID) { + odd = _blossom_set->find(_graph.target((*_blossom_data)[even].pred)); + (*_blossom_data)[odd].status = MATCHED; + oddToMatched(odd); + (*_blossom_data)[odd].next = (*_blossom_data)[odd].pred; + + even = _blossom_set->find(_graph.target((*_blossom_data)[odd].pred)); + (*_blossom_data)[even].status = MATCHED; + evenToMatched(even, tree); + (*_blossom_data)[even].next = + _graph.oppositeArc((*_blossom_data)[odd].pred); + } + + } + + void destroyTree(int tree) { + for (TreeSet::ItemIt b(*_tree_set, tree); b != INVALID; ++b) { + if ((*_blossom_data)[b].status == EVEN) { + (*_blossom_data)[b].status = MATCHED; + evenToMatched(b, tree); + } else if ((*_blossom_data)[b].status == ODD) { + (*_blossom_data)[b].status = MATCHED; + oddToMatched(b); + } + } + _tree_set->eraseClass(tree); + } + + + void unmatchNode(const Node& node) { + int blossom = _blossom_set->find(node); + int tree = _tree_set->find(blossom); + + alternatePath(blossom, tree); + destroyTree(tree); + + (*_blossom_data)[blossom].status = UNMATCHED; + (*_blossom_data)[blossom].base = node; + matchedToUnmatched(blossom); + } + + + void augmentOnEdge(const Edge& edge) { + + int left = _blossom_set->find(_graph.u(edge)); + int right = _blossom_set->find(_graph.v(edge)); + + if ((*_blossom_data)[left].status == EVEN) { + int left_tree = _tree_set->find(left); + alternatePath(left, left_tree); + destroyTree(left_tree); + } else { + (*_blossom_data)[left].status = MATCHED; + unmatchedToMatched(left); + } + + if ((*_blossom_data)[right].status == EVEN) { + int right_tree = _tree_set->find(right); + alternatePath(right, right_tree); + destroyTree(right_tree); + } else { + (*_blossom_data)[right].status = MATCHED; + unmatchedToMatched(right); + } + + (*_blossom_data)[left].next = _graph.direct(edge, true); + (*_blossom_data)[right].next = _graph.direct(edge, false); + } + + void extendOnArc(const Arc& arc) { + int base = _blossom_set->find(_graph.target(arc)); + int tree = _tree_set->find(base); + + int odd = _blossom_set->find(_graph.source(arc)); + _tree_set->insert(odd, tree); + (*_blossom_data)[odd].status = ODD; + matchedToOdd(odd); + (*_blossom_data)[odd].pred = arc; + + int even = _blossom_set->find(_graph.target((*_blossom_data)[odd].next)); + (*_blossom_data)[even].pred = (*_blossom_data)[even].next; + _tree_set->insert(even, tree); + (*_blossom_data)[even].status = EVEN; + matchedToEven(even, tree); + } + + void shrinkOnEdge(const Edge& edge, int tree) { + int nca = -1; + std::vector left_path, right_path; + + { + std::set left_set, right_set; + int left = _blossom_set->find(_graph.u(edge)); + left_path.push_back(left); + left_set.insert(left); + + int right = _blossom_set->find(_graph.v(edge)); + right_path.push_back(right); + right_set.insert(right); + + while (true) { + + if ((*_blossom_data)[left].pred == INVALID) break; + + left = + _blossom_set->find(_graph.target((*_blossom_data)[left].pred)); + left_path.push_back(left); + left = + _blossom_set->find(_graph.target((*_blossom_data)[left].pred)); + left_path.push_back(left); + + left_set.insert(left); + + if (right_set.find(left) != right_set.end()) { + nca = left; + break; + } + + if ((*_blossom_data)[right].pred == INVALID) break; + + right = + _blossom_set->find(_graph.target((*_blossom_data)[right].pred)); + right_path.push_back(right); + right = + _blossom_set->find(_graph.target((*_blossom_data)[right].pred)); + right_path.push_back(right); + + right_set.insert(right); + + if (left_set.find(right) != left_set.end()) { + nca = right; + break; + } + + } + + if (nca == -1) { + if ((*_blossom_data)[left].pred == INVALID) { + nca = right; + while (left_set.find(nca) == left_set.end()) { + nca = + _blossom_set->find(_graph.target((*_blossom_data)[nca].pred)); + right_path.push_back(nca); + nca = + _blossom_set->find(_graph.target((*_blossom_data)[nca].pred)); + right_path.push_back(nca); + } + } else { + nca = left; + while (right_set.find(nca) == right_set.end()) { + nca = + _blossom_set->find(_graph.target((*_blossom_data)[nca].pred)); + left_path.push_back(nca); + nca = + _blossom_set->find(_graph.target((*_blossom_data)[nca].pred)); + left_path.push_back(nca); + } + } + } + } + + std::vector subblossoms; + Arc prev; + + prev = _graph.direct(edge, true); + for (int i = 0; left_path[i] != nca; i += 2) { + subblossoms.push_back(left_path[i]); + (*_blossom_data)[left_path[i]].next = prev; + _tree_set->erase(left_path[i]); + + subblossoms.push_back(left_path[i + 1]); + (*_blossom_data)[left_path[i + 1]].status = EVEN; + oddToEven(left_path[i + 1], tree); + _tree_set->erase(left_path[i + 1]); + prev = _graph.oppositeArc((*_blossom_data)[left_path[i + 1]].pred); + } + + int k = 0; + while (right_path[k] != nca) ++k; + + subblossoms.push_back(nca); + (*_blossom_data)[nca].next = prev; + + for (int i = k - 2; i >= 0; i -= 2) { + subblossoms.push_back(right_path[i + 1]); + (*_blossom_data)[right_path[i + 1]].status = EVEN; + oddToEven(right_path[i + 1], tree); + _tree_set->erase(right_path[i + 1]); + + (*_blossom_data)[right_path[i + 1]].next = + (*_blossom_data)[right_path[i + 1]].pred; + + subblossoms.push_back(right_path[i]); + _tree_set->erase(right_path[i]); + } + + int surface = + _blossom_set->join(subblossoms.begin(), subblossoms.end()); + + for (int i = 0; i < int(subblossoms.size()); ++i) { + if (!_blossom_set->trivial(subblossoms[i])) { + (*_blossom_data)[subblossoms[i]].pot += 2 * _delta_sum; + } + (*_blossom_data)[subblossoms[i]].status = MATCHED; + } + + (*_blossom_data)[surface].pot = -2 * _delta_sum; + (*_blossom_data)[surface].offset = 0; + (*_blossom_data)[surface].status = EVEN; + (*_blossom_data)[surface].pred = (*_blossom_data)[nca].pred; + (*_blossom_data)[surface].next = (*_blossom_data)[nca].pred; + + _tree_set->insert(surface, tree); + _tree_set->erase(nca); + } + + void splitBlossom(int blossom) { + Arc next = (*_blossom_data)[blossom].next; + Arc pred = (*_blossom_data)[blossom].pred; + + int tree = _tree_set->find(blossom); + + (*_blossom_data)[blossom].status = MATCHED; + oddToMatched(blossom); + if (_delta2->state(blossom) == _delta2->IN_HEAP) { + _delta2->erase(blossom); + } + + std::vector subblossoms; + _blossom_set->split(blossom, std::back_inserter(subblossoms)); + + Value offset = (*_blossom_data)[blossom].offset; + int b = _blossom_set->find(_graph.source(pred)); + int d = _blossom_set->find(_graph.source(next)); + + int ib = -1, id = -1; + for (int i = 0; i < int(subblossoms.size()); ++i) { + if (subblossoms[i] == b) ib = i; + if (subblossoms[i] == d) id = i; + + (*_blossom_data)[subblossoms[i]].offset = offset; + if (!_blossom_set->trivial(subblossoms[i])) { + (*_blossom_data)[subblossoms[i]].pot -= 2 * offset; + } + if (_blossom_set->classPrio(subblossoms[i]) != + std::numeric_limits::max()) { + _delta2->push(subblossoms[i], + _blossom_set->classPrio(subblossoms[i]) - + (*_blossom_data)[subblossoms[i]].offset); + } + } + + if (id > ib ? ((id - ib) % 2 == 0) : ((ib - id) % 2 == 1)) { + for (int i = (id + 1) % subblossoms.size(); + i != ib; i = (i + 2) % subblossoms.size()) { + int sb = subblossoms[i]; + int tb = subblossoms[(i + 1) % subblossoms.size()]; + (*_blossom_data)[sb].next = + _graph.oppositeArc((*_blossom_data)[tb].next); + } + + for (int i = ib; i != id; i = (i + 2) % subblossoms.size()) { + int sb = subblossoms[i]; + int tb = subblossoms[(i + 1) % subblossoms.size()]; + int ub = subblossoms[(i + 2) % subblossoms.size()]; + + (*_blossom_data)[sb].status = ODD; + matchedToOdd(sb); + _tree_set->insert(sb, tree); + (*_blossom_data)[sb].pred = pred; + (*_blossom_data)[sb].next = + _graph.oppositeArc((*_blossom_data)[tb].next); + + pred = (*_blossom_data)[ub].next; + + (*_blossom_data)[tb].status = EVEN; + matchedToEven(tb, tree); + _tree_set->insert(tb, tree); + (*_blossom_data)[tb].pred = (*_blossom_data)[tb].next; + } + + (*_blossom_data)[subblossoms[id]].status = ODD; + matchedToOdd(subblossoms[id]); + _tree_set->insert(subblossoms[id], tree); + (*_blossom_data)[subblossoms[id]].next = next; + (*_blossom_data)[subblossoms[id]].pred = pred; + + } else { + + for (int i = (ib + 1) % subblossoms.size(); + i != id; i = (i + 2) % subblossoms.size()) { + int sb = subblossoms[i]; + int tb = subblossoms[(i + 1) % subblossoms.size()]; + (*_blossom_data)[sb].next = + _graph.oppositeArc((*_blossom_data)[tb].next); + } + + for (int i = id; i != ib; i = (i + 2) % subblossoms.size()) { + int sb = subblossoms[i]; + int tb = subblossoms[(i + 1) % subblossoms.size()]; + int ub = subblossoms[(i + 2) % subblossoms.size()]; + + (*_blossom_data)[sb].status = ODD; + matchedToOdd(sb); + _tree_set->insert(sb, tree); + (*_blossom_data)[sb].next = next; + (*_blossom_data)[sb].pred = + _graph.oppositeArc((*_blossom_data)[tb].next); + + (*_blossom_data)[tb].status = EVEN; + matchedToEven(tb, tree); + _tree_set->insert(tb, tree); + (*_blossom_data)[tb].pred = + (*_blossom_data)[tb].next = + _graph.oppositeArc((*_blossom_data)[ub].next); + next = (*_blossom_data)[ub].next; + } + + (*_blossom_data)[subblossoms[ib]].status = ODD; + matchedToOdd(subblossoms[ib]); + _tree_set->insert(subblossoms[ib], tree); + (*_blossom_data)[subblossoms[ib]].next = next; + (*_blossom_data)[subblossoms[ib]].pred = pred; + } + _tree_set->erase(blossom); + } + + void extractBlossom(int blossom, const Node& base, const Arc& matching) { + if (_blossom_set->trivial(blossom)) { + int bi = (*_node_index)[base]; + Value pot = (*_node_data)[bi].pot; + + (*_matching)[base] = matching; + _blossom_node_list.push_back(base); + (*_node_potential)[base] = pot; + } else { + + Value pot = (*_blossom_data)[blossom].pot; + int bn = _blossom_node_list.size(); + + std::vector subblossoms; + _blossom_set->split(blossom, std::back_inserter(subblossoms)); + int b = _blossom_set->find(base); + int ib = -1; + for (int i = 0; i < int(subblossoms.size()); ++i) { + if (subblossoms[i] == b) { ib = i; break; } + } + + for (int i = 1; i < int(subblossoms.size()); i += 2) { + int sb = subblossoms[(ib + i) % subblossoms.size()]; + int tb = subblossoms[(ib + i + 1) % subblossoms.size()]; + + Arc m = (*_blossom_data)[tb].next; + extractBlossom(sb, _graph.target(m), _graph.oppositeArc(m)); + extractBlossom(tb, _graph.source(m), m); + } + extractBlossom(subblossoms[ib], base, matching); + + int en = _blossom_node_list.size(); + + _blossom_potential.push_back(BlossomVariable(bn, en, pot)); + } + } + + void extractMatching() { + std::vector blossoms; + for (typename BlossomSet::ClassIt c(*_blossom_set); c != INVALID; ++c) { + blossoms.push_back(c); + } + + for (int i = 0; i < int(blossoms.size()); ++i) { + if ((*_blossom_data)[blossoms[i]].status == MATCHED) { + + Value offset = (*_blossom_data)[blossoms[i]].offset; + (*_blossom_data)[blossoms[i]].pot += 2 * offset; + for (typename BlossomSet::ItemIt n(*_blossom_set, blossoms[i]); + n != INVALID; ++n) { + (*_node_data)[(*_node_index)[n]].pot -= offset; + } + + Arc matching = (*_blossom_data)[blossoms[i]].next; + Node base = _graph.source(matching); + extractBlossom(blossoms[i], base, matching); + } else { + Node base = (*_blossom_data)[blossoms[i]].base; + extractBlossom(blossoms[i], base, INVALID); + } + } + } + + public: + + /// \brief Constructor + /// + /// Constructor. + MaxWeightedMatching(const Graph& graph, const WeightMap& weight) + : _graph(graph), _weight(weight), _matching(0), + _node_potential(0), _blossom_potential(), _blossom_node_list(), + _node_num(0), _blossom_num(0), + + _blossom_index(0), _blossom_set(0), _blossom_data(0), + _node_index(0), _node_heap_index(0), _node_data(0), + _tree_set_index(0), _tree_set(0), + + _delta1_index(0), _delta1(0), + _delta2_index(0), _delta2(0), + _delta3_index(0), _delta3(0), + _delta4_index(0), _delta4(0), + + _delta_sum() {} + + ~MaxWeightedMatching() { + 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 (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; + } + + int index = 0; + for (NodeIt n(_graph); n != INVALID; ++n) { + Value max = 0; + for (OutArcIt e(_graph, n); e != INVALID; ++e) { + if (_graph.target(e) == n) continue; + if ((dualScale * _weight[e]) / 2 > max) { + max = (dualScale * _weight[e]) / 2; + } + } + (*_node_index)[n] = index; + (*_node_data)[index].pot = max; + _delta1->push(n, max); + int blossom = + _blossom_set->insert(n, std::numeric_limits::max()); + + _tree_set->insert(blossom); + + (*_blossom_data)[blossom].status = EVEN; + (*_blossom_data)[blossom].pred = INVALID; + (*_blossom_data)[blossom].next = INVALID; + (*_blossom_data)[blossom].pot = 0; + (*_blossom_data)[blossom].offset = 0; + ++index; + } + for (EdgeIt e(_graph); e != INVALID; ++e) { + int si = (*_node_index)[_graph.u(e)]; + int ti = (*_node_index)[_graph.v(e)]; + if (_graph.u(e) != _graph.v(e)) { + _delta3->push(e, ((*_node_data)[si].pot + (*_node_data)[ti].pot - + dualScale * _weight[e]) / 2); + } + } + } + + /// \brief 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, D4 + }; + + 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(); + + Value d4 = !_delta4->empty() ? + _delta4->prio() : std::numeric_limits::max(); + + _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) { + case D1: + { + Node n = _delta1->top(); + unmatchNode(n); + --unmatched; + } + break; + case D2: + { + int blossom = _delta2->top(); + Node n = _blossom_set->classTop(blossom); + Arc e = (*_node_data)[(*_node_index)[n]].heap.top(); + extendOnArc(e); + } + break; + case D3: + { + Edge e = _delta3->top(); + + int left_blossom = _blossom_set->find(_graph.u(e)); + int right_blossom = _blossom_set->find(_graph.v(e)); + + if (left_blossom == right_blossom) { + _delta3->pop(); + } else { + int left_tree; + 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) { + shrinkOnEdge(e, left_tree); + } else { + augmentOnEdge(e); + unmatched -= 2; + } + } + } break; + case D4: + splitBlossom(_delta4->top()); + break; + } + } + extractMatching(); + } + + /// \brief Run the algorithm. + /// + /// This method runs the \c %MaxWeightedMatching algorithm. + /// + /// \note mwm.run() is just a shortcut of the following code. + /// \code + /// mwm.init(); + /// mwm.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. + /// + /// \pre Either run() or start() must be called before using this function. + Value matchingWeight() const { + Value sum = 0; + for (NodeIt n(_graph); n != INVALID; ++n) { + if ((*_matching)[n] != INVALID) { + sum += _weight[(*_matching)[n]]; + } + } + return sum /= 2; + } + + /// \brief Return the size (cardinality) of the matching. + /// + /// This function returns the size (cardinality) of the found matching. + /// + /// \pre Either run() or start() must be called before using this function. + int matchingSize() const { + int num = 0; + for (NodeIt n(_graph); n != INVALID; ++n) { + if ((*_matching)[n] != INVALID) { + ++num; + } + } + return num /= 2; + } + + /// \brief Return \c true if the given edge is in the matching. + /// + /// This function returns \c true if the given edge is in the found + /// matching. + /// + /// \pre Either run() or start() must be called before using this function. + bool matching(const Edge& edge) const { + return edge == (*_matching)[_graph.u(edge)]; + } + + /// \brief Return the matching arc (or edge) incident to the given node. + /// + /// This function returns the matching arc (or edge) incident to the + /// given node in the found matching or \c INVALID if the node is + /// not covered by the matching. + /// + /// \pre Either run() or start() must be called before using this function. + Arc matching(const Node& node) const { + return (*_matching)[node]; + } + + /// \brief Return a const reference to the matching map. + /// + /// This function returns a const reference to a node map that stores + /// the matching arc (or edge) incident to each node. + const MatchingMap& matchingMap() const { + return *_matching; + } + + /// \brief Return the mate of the given node. + /// + /// This function returns the mate of the given node in the found + /// matching or \c INVALID if the node is not covered by the matching. + /// + /// \pre Either run() or start() must be called before using this function. + Node mate(const Node& node) const { + return (*_matching)[node] != INVALID ? + _graph.target((*_matching)[node]) : INVALID; + } + + /// @} + + /// \name Dual Solution + /// Functions to get the dual solution.\n + /// Either \ref run() or \ref start() function should be called before + /// using them. + + /// @{ + + /// \brief Return the value of the dual solution. + /// + /// This function returns the value of the dual solution. + /// It should be equal to the primal value scaled by \ref dualScale + /// "dual scale". + /// + /// \pre Either run() or start() must be called before using this function. + Value dualValue() const { + Value sum = 0; + for (NodeIt n(_graph); n != INVALID; ++n) { + sum += nodeValue(n); + } + for (int i = 0; i < blossomNum(); ++i) { + sum += blossomValue(i) * (blossomSize(i) / 2); + } + return sum; + } + + /// \brief Return the dual value (potential) of the given node. + /// + /// This function returns the dual value (potential) of the given node. + /// + /// \pre Either run() or start() must be called before using this function. + Value nodeValue(const Node& n) const { + return (*_node_potential)[n]; + } + + /// \brief Return the number of the blossoms in the basis. + /// + /// This function returns the number of the blossoms in the basis. + /// + /// \pre Either run() or start() must be called before using this function. + /// \see BlossomIt + int blossomNum() const { + return _blossom_potential.size(); + } + + /// \brief Return the number of the nodes in the given blossom. + /// + /// This function returns the number of the nodes in the given blossom. + /// + /// \pre Either run() or start() must be called before using this function. + /// \see BlossomIt + int blossomSize(int k) const { + return _blossom_potential[k].end - _blossom_potential[k].begin; + } + + /// \brief Return the dual value (ptential) of the given blossom. + /// + /// This function returns the dual value (ptential) of the given blossom. + /// + /// \pre Either run() or start() must be called before using this function. + Value blossomValue(int k) const { + return _blossom_potential[k].value; + } + + /// \brief Iterator for obtaining the nodes of a blossom. + /// + /// This class provides an iterator for obtaining the nodes of the + /// given blossom. It lists a subset of the nodes. + /// Before using this iterator, you must allocate a + /// MaxWeightedMatching class and execute it. + class BlossomIt { + public: + + /// \brief Constructor. + /// + /// Constructor to get the nodes of the given variable. + /// + /// \pre Either \ref MaxWeightedMatching::run() "algorithm.run()" or + /// \ref MaxWeightedMatching::start() "algorithm.start()" must be + /// called before initializing this iterator. + BlossomIt(const MaxWeightedMatching& algorithm, int variable) + : _algorithm(&algorithm) + { + _index = _algorithm->_blossom_potential[variable].begin; + _last = _algorithm->_blossom_potential[variable].end; + } + + /// \brief Conversion to \c Node. + /// + /// Conversion to \c Node. + operator Node() const { + return _algorithm->_blossom_node_list[_index]; + } + + /// \brief Increment operator. + /// + /// Increment operator. + BlossomIt& operator++() { + ++_index; + return *this; + } + + /// \brief Validity checking + /// + /// Checks whether the iterator is invalid. + bool operator==(Invalid) const { return _index == _last; } + + /// \brief Validity checking + /// + /// Checks whether the iterator is valid. + bool operator!=(Invalid) const { return _index != _last; } + + private: + const MaxWeightedMatching* _algorithm; + int _last; + int _index; + }; + + /// @} + + }; + + /// \ingroup matching + /// + /// \brief Weighted perfect matching in general graphs + /// + /// This class provides an efficient implementation of Edmond's + /// maximum weighted perfect matching algorithm. The implementation + /// is based on extensive use of priority queues and provides + /// \f$O(nm\log n)\f$ time complexity. + /// + /// The maximum weighted perfect matching problem is to find a subset of + /// the edges in an undirected graph with maximum overall weight for which + /// each node has exactly one incident edge. + /// It can be formulated with the following linear program. + /// \f[ \sum_{e \in \delta(u)}x_e = 1 \quad \forall u\in V\f] + /** \f[ \sum_{e \in \gamma(B)}x_e \le \frac{\vert B \vert - 1}{2} + \quad \forall B\in\mathcal{O}\f] */ + /// \f[x_e \ge 0\quad \forall e\in E\f] + /// \f[\max \sum_{e\in E}x_ew_e\f] + /// where \f$\delta(X)\f$ is the set of edges incident to a node in + /// \f$X\f$, \f$\gamma(X)\f$ is the set of edges with both ends in + /// \f$X\f$ and \f$\mathcal{O}\f$ is the set of odd cardinality + /// subsets of the nodes. + /// + /// The algorithm calculates an optimal matching and a proof of the + /// optimality. The solution of the dual problem can be used to check + /// the result of the algorithm. The dual linear problem is the + /// following. + /** \f[ y_u + y_v + \sum_{B \in \mathcal{O}, uv \in \gamma(B)}z_B \ge + w_{uv} \quad \forall uv\in E\f] */ + /// \f[z_B \ge 0 \quad \forall B \in \mathcal{O}\f] + /** \f[\min \sum_{u \in V}y_u + \sum_{B \in \mathcal{O}} + \frac{\vert B \vert - 1}{2}z_B\f] */ + /// + /// The algorithm can be executed with the run() function. + /// After it the matching (the primal solution) and the dual solution + /// can be obtained using the query functions and the + /// \ref MaxWeightedPerfectMatching::BlossomIt "BlossomIt" nested class, + /// which is able to iterate on the nodes of a blossom. + /// If the value type is integer, then the dual solution is multiplied + /// by \ref MaxWeightedMatching::dualScale "4". + /// + /// \tparam GR The undirected graph type the algorithm runs on. + /// \tparam WM The type edge weight map. The default type is + /// \ref concepts::Graph::EdgeMap "GR::EdgeMap". +#ifdef DOXYGEN + template +#else + template > +#endif + class MaxWeightedPerfectMatching { + public: + + /// The graph type of the algorithm + typedef GR Graph; + /// The type of the edge weight map + typedef WM WeightMap; + /// The value type of the edge weights + typedef typename WeightMap::Value Value; + + /// \brief Scaling factor for dual solution + /// + /// Scaling factor for dual solution, it is equal to 4 or 1 + /// according to the value type. + static const int dualScale = + std::numeric_limits::is_integer ? 4 : 1; + + /// The type of the matching map + typedef typename Graph::template NodeMap + MatchingMap; + + private: + + TEMPLATE_GRAPH_TYPEDEFS(Graph); + + typedef typename Graph::template NodeMap NodePotential; + typedef std::vector BlossomNodeList; + + struct BlossomVariable { + int begin, end; + Value value; + + BlossomVariable(int _begin, int _end, Value _value) + : begin(_begin), end(_end), value(_value) {} + + }; + + typedef std::vector BlossomPotential; + + const Graph& _graph; + const WeightMap& _weight; + + MatchingMap* _matching; + + NodePotential* _node_potential; + + BlossomPotential _blossom_potential; + BlossomNodeList _blossom_node_list; + + int _node_num; + int _blossom_num; + + typedef RangeMap IntIntMap; + + enum Status { + EVEN = -1, MATCHED = 0, ODD = 1 + }; + + typedef HeapUnionFind BlossomSet; + struct BlossomData { + int tree; + Status status; + Arc pred, next; + Value pot, offset; + }; + + IntNodeMap *_blossom_index; + BlossomSet *_blossom_set; + RangeMap* _blossom_data; + + IntNodeMap *_node_index; + IntArcMap *_node_heap_index; + + struct NodeData { + + NodeData(IntArcMap& node_heap_index) + : heap(node_heap_index) {} + + int blossom; + Value pot; + BinHeap heap; + std::map heap_index; + + int tree; + }; + + RangeMap* _node_data; + + typedef ExtendFindEnum TreeSet; + + IntIntMap *_tree_set_index; + TreeSet *_tree_set; + + IntIntMap *_delta2_index; + BinHeap *_delta2; + + IntEdgeMap *_delta3_index; + BinHeap *_delta3; + + IntIntMap *_delta4_index; + BinHeap *_delta4; + + Value _delta_sum; + + void createStructures() { + _node_num = countNodes(_graph); + _blossom_num = _node_num * 3 / 2; + + if (!_matching) { + _matching = new MatchingMap(_graph); + } + if (!_node_potential) { + _node_potential = new NodePotential(_graph); + } + if (!_blossom_set) { + _blossom_index = new IntNodeMap(_graph); + _blossom_set = new BlossomSet(*_blossom_index); + _blossom_data = new RangeMap(_blossom_num); + } + + if (!_node_index) { + _node_index = new IntNodeMap(_graph); + _node_heap_index = new IntArcMap(_graph); + _node_data = new RangeMap(_node_num, + NodeData(*_node_heap_index)); + } + + if (!_tree_set) { + _tree_set_index = new IntIntMap(_blossom_num); + _tree_set = new TreeSet(*_tree_set_index); + } + if (!_delta2) { + _delta2_index = new IntIntMap(_blossom_num); + _delta2 = new BinHeap(*_delta2_index); + } + if (!_delta3) { + _delta3_index = new IntEdgeMap(_graph); + _delta3 = new BinHeap(*_delta3_index); + } + if (!_delta4) { + _delta4_index = new IntIntMap(_blossom_num); + _delta4 = new BinHeap(*_delta4_index); + } + } + + void destroyStructures() { + _node_num = countNodes(_graph); + _blossom_num = _node_num * 3 / 2; + + if (_matching) { + delete _matching; + } + if (_node_potential) { + delete _node_potential; + } + if (_blossom_set) { + delete _blossom_index; + delete _blossom_set; + delete _blossom_data; + } + + if (_node_index) { + delete _node_index; + delete _node_heap_index; + delete _node_data; + } + + if (_tree_set) { + delete _tree_set_index; + delete _tree_set; + } + if (_delta2) { + delete _delta2_index; + delete _delta2; + } + if (_delta3) { + delete _delta3_index; + delete _delta3; + } + if (_delta4) { + delete _delta4_index; + delete _delta4; + } + } + + void matchedToEven(int blossom, int tree) { + if (_delta2->state(blossom) == _delta2->IN_HEAP) { + _delta2->erase(blossom); + } + + if (!_blossom_set->trivial(blossom)) { + (*_blossom_data)[blossom].pot -= + 2 * (_delta_sum - (*_blossom_data)[blossom].offset); + } + + for (typename BlossomSet::ItemIt n(*_blossom_set, blossom); + n != INVALID; ++n) { + + _blossom_set->increase(n, std::numeric_limits::max()); + int ni = (*_node_index)[n]; + + (*_node_data)[ni].heap.clear(); + (*_node_data)[ni].heap_index.clear(); + + (*_node_data)[ni].pot += _delta_sum - (*_blossom_data)[blossom].offset; + + for (InArcIt e(_graph, n); e != INVALID; ++e) { + Node v = _graph.source(e); + int vb = _blossom_set->find(v); + int vi = (*_node_index)[v]; + + Value rw = (*_node_data)[ni].pot + (*_node_data)[vi].pot - + dualScale * _weight[e]; + + if ((*_blossom_data)[vb].status == EVEN) { + if (_delta3->state(e) != _delta3->IN_HEAP && blossom != vb) { + _delta3->push(e, rw / 2); + } + } else { + typename std::map::iterator it = + (*_node_data)[vi].heap_index.find(tree); + + if (it != (*_node_data)[vi].heap_index.end()) { + if ((*_node_data)[vi].heap[it->second] > rw) { + (*_node_data)[vi].heap.replace(it->second, e); + (*_node_data)[vi].heap.decrease(e, rw); + it->second = e; + } + } else { + (*_node_data)[vi].heap.push(e, rw); + (*_node_data)[vi].heap_index.insert(std::make_pair(tree, e)); + } + + if ((*_blossom_set)[v] > (*_node_data)[vi].heap.prio()) { + _blossom_set->decrease(v, (*_node_data)[vi].heap.prio()); + + if ((*_blossom_data)[vb].status == MATCHED) { + if (_delta2->state(vb) != _delta2->IN_HEAP) { + _delta2->push(vb, _blossom_set->classPrio(vb) - + (*_blossom_data)[vb].offset); + } else if ((*_delta2)[vb] > _blossom_set->classPrio(vb) - + (*_blossom_data)[vb].offset){ + _delta2->decrease(vb, _blossom_set->classPrio(vb) - + (*_blossom_data)[vb].offset); + } + } + } + } + } + } + (*_blossom_data)[blossom].offset = 0; + } + + void matchedToOdd(int blossom) { + if (_delta2->state(blossom) == _delta2->IN_HEAP) { + _delta2->erase(blossom); + } + (*_blossom_data)[blossom].offset += _delta_sum; + if (!_blossom_set->trivial(blossom)) { + _delta4->push(blossom, (*_blossom_data)[blossom].pot / 2 + + (*_blossom_data)[blossom].offset); + } + } + + void evenToMatched(int blossom, int tree) { + if (!_blossom_set->trivial(blossom)) { + (*_blossom_data)[blossom].pot += 2 * _delta_sum; + } + + for (typename BlossomSet::ItemIt n(*_blossom_set, blossom); + n != INVALID; ++n) { + int ni = (*_node_index)[n]; + (*_node_data)[ni].pot -= _delta_sum; + + for (InArcIt e(_graph, n); e != INVALID; ++e) { + Node v = _graph.source(e); + int vb = _blossom_set->find(v); + int vi = (*_node_index)[v]; + + Value rw = (*_node_data)[ni].pot + (*_node_data)[vi].pot - + dualScale * _weight[e]; + + if (vb == blossom) { + if (_delta3->state(e) == _delta3->IN_HEAP) { + _delta3->erase(e); + } + } else if ((*_blossom_data)[vb].status == EVEN) { + + if (_delta3->state(e) == _delta3->IN_HEAP) { + _delta3->erase(e); + } + + int vt = _tree_set->find(vb); + + if (vt != tree) { + + Arc r = _graph.oppositeArc(e); + + typename std::map::iterator it = + (*_node_data)[ni].heap_index.find(vt); + + if (it != (*_node_data)[ni].heap_index.end()) { + if ((*_node_data)[ni].heap[it->second] > rw) { + (*_node_data)[ni].heap.replace(it->second, r); + (*_node_data)[ni].heap.decrease(r, rw); + it->second = r; + } + } else { + (*_node_data)[ni].heap.push(r, rw); + (*_node_data)[ni].heap_index.insert(std::make_pair(vt, r)); + } + + if ((*_blossom_set)[n] > (*_node_data)[ni].heap.prio()) { + _blossom_set->decrease(n, (*_node_data)[ni].heap.prio()); + + if (_delta2->state(blossom) != _delta2->IN_HEAP) { + _delta2->push(blossom, _blossom_set->classPrio(blossom) - + (*_blossom_data)[blossom].offset); + } else if ((*_delta2)[blossom] > + _blossom_set->classPrio(blossom) - + (*_blossom_data)[blossom].offset){ + _delta2->decrease(blossom, _blossom_set->classPrio(blossom) - + (*_blossom_data)[blossom].offset); + } + } + } + } else { + + typename std::map::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; + + 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; + } + } else { + (*_node_data)[vi].heap.push(e, rw); + (*_node_data)[vi].heap_index.insert(std::make_pair(tree, e)); + } + + if ((*_blossom_set)[v] > (*_node_data)[vi].heap.prio()) { + _blossom_set->decrease(v, (*_node_data)[vi].heap.prio()); + + if ((*_blossom_data)[vb].status == MATCHED) { + if (_delta2->state(vb) != _delta2->IN_HEAP) { + _delta2->push(vb, _blossom_set->classPrio(vb) - + (*_blossom_data)[vb].offset); + } else if ((*_delta2)[vb] > _blossom_set->classPrio(vb) - + (*_blossom_data)[vb].offset) { + _delta2->decrease(vb, _blossom_set->classPrio(vb) - + (*_blossom_data)[vb].offset); + } + } + } + } + } + } + (*_blossom_data)[blossom].offset = 0; + } + + void alternatePath(int even, int tree) { + int odd; + + evenToMatched(even, tree); + (*_blossom_data)[even].status = MATCHED; + + while ((*_blossom_data)[even].pred != INVALID) { + odd = _blossom_set->find(_graph.target((*_blossom_data)[even].pred)); + (*_blossom_data)[odd].status = MATCHED; + oddToMatched(odd); + (*_blossom_data)[odd].next = (*_blossom_data)[odd].pred; + + even = _blossom_set->find(_graph.target((*_blossom_data)[odd].pred)); + (*_blossom_data)[even].status = MATCHED; + evenToMatched(even, tree); + (*_blossom_data)[even].next = + _graph.oppositeArc((*_blossom_data)[odd].pred); + } + + } + + void destroyTree(int tree) { + for (TreeSet::ItemIt b(*_tree_set, tree); b != INVALID; ++b) { + if ((*_blossom_data)[b].status == EVEN) { + (*_blossom_data)[b].status = MATCHED; + evenToMatched(b, tree); + } else if ((*_blossom_data)[b].status == ODD) { + (*_blossom_data)[b].status = MATCHED; + oddToMatched(b); + } + } + _tree_set->eraseClass(tree); + } + + void augmentOnEdge(const Edge& edge) { + + int left = _blossom_set->find(_graph.u(edge)); + int right = _blossom_set->find(_graph.v(edge)); + + int left_tree = _tree_set->find(left); + alternatePath(left, left_tree); + destroyTree(left_tree); + + int right_tree = _tree_set->find(right); + alternatePath(right, right_tree); + destroyTree(right_tree); + + (*_blossom_data)[left].next = _graph.direct(edge, true); + (*_blossom_data)[right].next = _graph.direct(edge, false); + } + + void extendOnArc(const Arc& arc) { + int base = _blossom_set->find(_graph.target(arc)); + int tree = _tree_set->find(base); + + int odd = _blossom_set->find(_graph.source(arc)); + _tree_set->insert(odd, tree); + (*_blossom_data)[odd].status = ODD; + matchedToOdd(odd); + (*_blossom_data)[odd].pred = arc; + + int even = _blossom_set->find(_graph.target((*_blossom_data)[odd].next)); + (*_blossom_data)[even].pred = (*_blossom_data)[even].next; + _tree_set->insert(even, tree); + (*_blossom_data)[even].status = EVEN; + matchedToEven(even, tree); + } + + void shrinkOnEdge(const Edge& edge, int tree) { + int nca = -1; + std::vector left_path, right_path; + + { + std::set left_set, right_set; + int left = _blossom_set->find(_graph.u(edge)); + left_path.push_back(left); + left_set.insert(left); + + int right = _blossom_set->find(_graph.v(edge)); + right_path.push_back(right); + right_set.insert(right); + + while (true) { + + if ((*_blossom_data)[left].pred == INVALID) break; + + left = + _blossom_set->find(_graph.target((*_blossom_data)[left].pred)); + left_path.push_back(left); + left = + _blossom_set->find(_graph.target((*_blossom_data)[left].pred)); + left_path.push_back(left); + + left_set.insert(left); + + if (right_set.find(left) != right_set.end()) { + nca = left; + break; + } + + if ((*_blossom_data)[right].pred == INVALID) break; + + right = + _blossom_set->find(_graph.target((*_blossom_data)[right].pred)); + right_path.push_back(right); + right = + _blossom_set->find(_graph.target((*_blossom_data)[right].pred)); + right_path.push_back(right); + + right_set.insert(right); + + if (left_set.find(right) != left_set.end()) { + nca = right; + break; + } + + } + + if (nca == -1) { + if ((*_blossom_data)[left].pred == INVALID) { + nca = right; + while (left_set.find(nca) == left_set.end()) { + nca = + _blossom_set->find(_graph.target((*_blossom_data)[nca].pred)); + right_path.push_back(nca); + nca = + _blossom_set->find(_graph.target((*_blossom_data)[nca].pred)); + right_path.push_back(nca); + } + } else { + nca = left; + while (right_set.find(nca) == right_set.end()) { + nca = + _blossom_set->find(_graph.target((*_blossom_data)[nca].pred)); + left_path.push_back(nca); + nca = + _blossom_set->find(_graph.target((*_blossom_data)[nca].pred)); + left_path.push_back(nca); + } + } + } + } + + std::vector subblossoms; + Arc prev; + + prev = _graph.direct(edge, true); + for (int i = 0; left_path[i] != nca; i += 2) { + subblossoms.push_back(left_path[i]); + (*_blossom_data)[left_path[i]].next = prev; + _tree_set->erase(left_path[i]); + + subblossoms.push_back(left_path[i + 1]); + (*_blossom_data)[left_path[i + 1]].status = EVEN; + oddToEven(left_path[i + 1], tree); + _tree_set->erase(left_path[i + 1]); + prev = _graph.oppositeArc((*_blossom_data)[left_path[i + 1]].pred); + } + + int k = 0; + while (right_path[k] != nca) ++k; + + subblossoms.push_back(nca); + (*_blossom_data)[nca].next = prev; + + for (int i = k - 2; i >= 0; i -= 2) { + subblossoms.push_back(right_path[i + 1]); + (*_blossom_data)[right_path[i + 1]].status = EVEN; + oddToEven(right_path[i + 1], tree); + _tree_set->erase(right_path[i + 1]); + + (*_blossom_data)[right_path[i + 1]].next = + (*_blossom_data)[right_path[i + 1]].pred; + + subblossoms.push_back(right_path[i]); + _tree_set->erase(right_path[i]); + } + + int surface = + _blossom_set->join(subblossoms.begin(), subblossoms.end()); + + for (int i = 0; i < int(subblossoms.size()); ++i) { + if (!_blossom_set->trivial(subblossoms[i])) { + (*_blossom_data)[subblossoms[i]].pot += 2 * _delta_sum; + } + (*_blossom_data)[subblossoms[i]].status = MATCHED; + } + + (*_blossom_data)[surface].pot = -2 * _delta_sum; + (*_blossom_data)[surface].offset = 0; + (*_blossom_data)[surface].status = EVEN; + (*_blossom_data)[surface].pred = (*_blossom_data)[nca].pred; + (*_blossom_data)[surface].next = (*_blossom_data)[nca].pred; + + _tree_set->insert(surface, tree); + _tree_set->erase(nca); + } + + void splitBlossom(int blossom) { + Arc next = (*_blossom_data)[blossom].next; + Arc pred = (*_blossom_data)[blossom].pred; + + int tree = _tree_set->find(blossom); + + (*_blossom_data)[blossom].status = MATCHED; + oddToMatched(blossom); + if (_delta2->state(blossom) == _delta2->IN_HEAP) { + _delta2->erase(blossom); + } + + std::vector subblossoms; + _blossom_set->split(blossom, std::back_inserter(subblossoms)); + + Value offset = (*_blossom_data)[blossom].offset; + int b = _blossom_set->find(_graph.source(pred)); + int d = _blossom_set->find(_graph.source(next)); + + int ib = -1, id = -1; + for (int i = 0; i < int(subblossoms.size()); ++i) { + if (subblossoms[i] == b) ib = i; + if (subblossoms[i] == d) id = i; + + (*_blossom_data)[subblossoms[i]].offset = offset; + if (!_blossom_set->trivial(subblossoms[i])) { + (*_blossom_data)[subblossoms[i]].pot -= 2 * offset; + } + if (_blossom_set->classPrio(subblossoms[i]) != + std::numeric_limits::max()) { + _delta2->push(subblossoms[i], + _blossom_set->classPrio(subblossoms[i]) - + (*_blossom_data)[subblossoms[i]].offset); + } + } + + if (id > ib ? ((id - ib) % 2 == 0) : ((ib - id) % 2 == 1)) { + for (int i = (id + 1) % subblossoms.size(); + i != ib; i = (i + 2) % subblossoms.size()) { + int sb = subblossoms[i]; + int tb = subblossoms[(i + 1) % subblossoms.size()]; + (*_blossom_data)[sb].next = + _graph.oppositeArc((*_blossom_data)[tb].next); + } + + for (int i = ib; i != id; i = (i + 2) % subblossoms.size()) { + int sb = subblossoms[i]; + int tb = subblossoms[(i + 1) % subblossoms.size()]; + int ub = subblossoms[(i + 2) % subblossoms.size()]; + + (*_blossom_data)[sb].status = ODD; + matchedToOdd(sb); + _tree_set->insert(sb, tree); + (*_blossom_data)[sb].pred = pred; + (*_blossom_data)[sb].next = + _graph.oppositeArc((*_blossom_data)[tb].next); + + pred = (*_blossom_data)[ub].next; + + (*_blossom_data)[tb].status = EVEN; + matchedToEven(tb, tree); + _tree_set->insert(tb, tree); + (*_blossom_data)[tb].pred = (*_blossom_data)[tb].next; + } + + (*_blossom_data)[subblossoms[id]].status = ODD; + matchedToOdd(subblossoms[id]); + _tree_set->insert(subblossoms[id], tree); + (*_blossom_data)[subblossoms[id]].next = next; + (*_blossom_data)[subblossoms[id]].pred = pred; + + } else { + + for (int i = (ib + 1) % subblossoms.size(); + i != id; i = (i + 2) % subblossoms.size()) { + int sb = subblossoms[i]; + int tb = subblossoms[(i + 1) % subblossoms.size()]; + (*_blossom_data)[sb].next = + _graph.oppositeArc((*_blossom_data)[tb].next); + } + + for (int i = id; i != ib; i = (i + 2) % subblossoms.size()) { + int sb = subblossoms[i]; + int tb = subblossoms[(i + 1) % subblossoms.size()]; + int ub = subblossoms[(i + 2) % subblossoms.size()]; + + (*_blossom_data)[sb].status = ODD; + matchedToOdd(sb); + _tree_set->insert(sb, tree); + (*_blossom_data)[sb].next = next; + (*_blossom_data)[sb].pred = + _graph.oppositeArc((*_blossom_data)[tb].next); + + (*_blossom_data)[tb].status = EVEN; + matchedToEven(tb, tree); + _tree_set->insert(tb, tree); + (*_blossom_data)[tb].pred = + (*_blossom_data)[tb].next = + _graph.oppositeArc((*_blossom_data)[ub].next); + next = (*_blossom_data)[ub].next; + } + + (*_blossom_data)[subblossoms[ib]].status = ODD; + matchedToOdd(subblossoms[ib]); + _tree_set->insert(subblossoms[ib], tree); + (*_blossom_data)[subblossoms[ib]].next = next; + (*_blossom_data)[subblossoms[ib]].pred = pred; + } + _tree_set->erase(blossom); + } + + void extractBlossom(int blossom, const Node& base, const Arc& matching) { + if (_blossom_set->trivial(blossom)) { + int bi = (*_node_index)[base]; + Value pot = (*_node_data)[bi].pot; + + (*_matching)[base] = matching; + _blossom_node_list.push_back(base); + (*_node_potential)[base] = pot; + } else { + + Value pot = (*_blossom_data)[blossom].pot; + int bn = _blossom_node_list.size(); + + std::vector subblossoms; + _blossom_set->split(blossom, std::back_inserter(subblossoms)); + int b = _blossom_set->find(base); + int ib = -1; + for (int i = 0; i < int(subblossoms.size()); ++i) { + if (subblossoms[i] == b) { ib = i; break; } + } + + for (int i = 1; i < int(subblossoms.size()); i += 2) { + int sb = subblossoms[(ib + i) % subblossoms.size()]; + int tb = subblossoms[(ib + i + 1) % subblossoms.size()]; + + Arc m = (*_blossom_data)[tb].next; + extractBlossom(sb, _graph.target(m), _graph.oppositeArc(m)); + extractBlossom(tb, _graph.source(m), m); + } + extractBlossom(subblossoms[ib], base, matching); + + int en = _blossom_node_list.size(); + + _blossom_potential.push_back(BlossomVariable(bn, en, pot)); + } + } + + void extractMatching() { + std::vector blossoms; + for (typename BlossomSet::ClassIt c(*_blossom_set); c != INVALID; ++c) { + blossoms.push_back(c); + } + + for (int i = 0; i < int(blossoms.size()); ++i) { + + Value offset = (*_blossom_data)[blossoms[i]].offset; + (*_blossom_data)[blossoms[i]].pot += 2 * offset; + for (typename BlossomSet::ItemIt n(*_blossom_set, blossoms[i]); + n != INVALID; ++n) { + (*_node_data)[(*_node_index)[n]].pot -= offset; + } + + Arc matching = (*_blossom_data)[blossoms[i]].next; + Node base = _graph.source(matching); + extractBlossom(blossoms[i], base, matching); + } + } + + public: + + /// \brief Constructor + /// + /// Constructor. + MaxWeightedPerfectMatching(const Graph& graph, const WeightMap& weight) + : _graph(graph), _weight(weight), _matching(0), + _node_potential(0), _blossom_potential(), _blossom_node_list(), + _node_num(0), _blossom_num(0), + + _blossom_index(0), _blossom_set(0), _blossom_data(0), + _node_index(0), _node_heap_index(0), _node_data(0), + _tree_set_index(0), _tree_set(0), + + _delta2_index(0), _delta2(0), + _delta3_index(0), _delta3(0), + _delta4_index(0), _delta4(0), + + _delta_sum() {} + + ~MaxWeightedPerfectMatching() { + 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 (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; + } + + int index = 0; + 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) continue; + if ((dualScale * _weight[e]) / 2 > max) { + max = (dualScale * _weight[e]) / 2; + } + } + (*_node_index)[n] = index; + (*_node_data)[index].pot = max; + int blossom = + _blossom_set->insert(n, std::numeric_limits::max()); + + _tree_set->insert(blossom); + + (*_blossom_data)[blossom].status = EVEN; + (*_blossom_data)[blossom].pred = INVALID; + (*_blossom_data)[blossom].next = INVALID; + (*_blossom_data)[blossom].pot = 0; + (*_blossom_data)[blossom].offset = 0; + ++index; + } + for (EdgeIt e(_graph); e != INVALID; ++e) { + int si = (*_node_index)[_graph.u(e)]; + int ti = (*_node_index)[_graph.v(e)]; + if (_graph.u(e) != _graph.v(e)) { + _delta3->push(e, ((*_node_data)[si].pot + (*_node_data)[ti].pot - + dualScale * _weight[e]) / 2); + } + } + } + + /// \brief Start the algorithm + /// + /// This function starts the algorithm. + /// + /// \pre \ref init() must be called before using this function. + bool start() { + enum OpType { + D2, D3, D4 + }; + + 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(); + + Value d4 = !_delta4->empty() ? + _delta4->prio() : std::numeric_limits::max(); + + _delta_sum = d2; OpType ot = D2; + if (d3 < _delta_sum) { _delta_sum = d3; ot = D3; } + if (d4 < _delta_sum) { _delta_sum = d4; ot = D4; } + + if (_delta_sum == std::numeric_limits::max()) { + return false; + } + + switch (ot) { + case D2: + { + int blossom = _delta2->top(); + Node n = _blossom_set->classTop(blossom); + Arc e = (*_node_data)[(*_node_index)[n]].heap.top(); + extendOnArc(e); + } + break; + case D3: + { + Edge e = _delta3->top(); + + int left_blossom = _blossom_set->find(_graph.u(e)); + int right_blossom = _blossom_set->find(_graph.v(e)); + + if (left_blossom == right_blossom) { + _delta3->pop(); + } else { + int left_tree = _tree_set->find(left_blossom); + int right_tree = _tree_set->find(right_blossom); + + if (left_tree == right_tree) { + shrinkOnEdge(e, left_tree); + } else { + augmentOnEdge(e); + unmatched -= 2; + } + } + } break; + case D4: + splitBlossom(_delta4->top()); + break; + } + } + extractMatching(); + return true; + } + + /// \brief Run the algorithm. + /// + /// This method runs the \c %MaxWeightedPerfectMatching algorithm. + /// + /// \note mwpm.run() is just a shortcut of the following code. + /// \code + /// mwpm.init(); + /// mwpm.start(); + /// \endcode + bool run() { + init(); + return start(); + } + + /// @} + + /// \name Primal Solution + /// Functions to get the primal solution, i.e. the maximum weighted + /// perfect matching.\n + /// Either \ref run() or \ref start() function should be called before + /// using them. + + /// @{ + + /// \brief Return the weight of the matching. + /// + /// This function returns the weight of the found matching. + /// + /// \pre Either run() or start() must be called before using this function. + Value matchingWeight() const { + Value sum = 0; + for (NodeIt n(_graph); n != INVALID; ++n) { + if ((*_matching)[n] != INVALID) { + sum += _weight[(*_matching)[n]]; + } + } + return sum /= 2; + } + + /// \brief Return \c true if the given edge is in the matching. + /// + /// This function returns \c true if the given edge is in the found + /// matching. + /// + /// \pre Either run() or start() must be called before using this function. + bool matching(const Edge& edge) const { + return static_cast((*_matching)[_graph.u(edge)]) == edge; + } + + /// \brief Return the matching arc (or edge) incident to the given node. + /// + /// This function returns the matching arc (or edge) incident to the + /// given node in the found matching or \c INVALID if the node is + /// not covered by the matching. + /// + /// \pre Either run() or start() must be called before using this function. + Arc matching(const Node& node) const { + return (*_matching)[node]; + } + + /// \brief Return a const reference to the matching map. + /// + /// This function returns a const reference to a node map that stores + /// the matching arc (or edge) incident to each node. + const MatchingMap& matchingMap() const { + return *_matching; + } + + /// \brief Return the mate of the given node. + /// + /// This function returns the mate of the given node in the found + /// matching or \c INVALID if the node is not covered by the matching. + /// + /// \pre Either run() or start() must be called before using this function. + Node mate(const Node& node) const { + return _graph.target((*_matching)[node]); + } + + /// @} + + /// \name Dual Solution + /// Functions to get the dual solution.\n + /// Either \ref run() or \ref start() function should be called before + /// using them. + + /// @{ + + /// \brief Return the value of the dual solution. + /// + /// This function returns the value of the dual solution. + /// It should be equal to the primal value scaled by \ref dualScale + /// "dual scale". + /// + /// \pre Either run() or start() must be called before using this function. + Value dualValue() const { + Value sum = 0; + for (NodeIt n(_graph); n != INVALID; ++n) { + sum += nodeValue(n); + } + for (int i = 0; i < blossomNum(); ++i) { + sum += blossomValue(i) * (blossomSize(i) / 2); + } + return sum; + } + + /// \brief Return the dual value (potential) of the given node. + /// + /// This function returns the dual value (potential) of the given node. + /// + /// \pre Either run() or start() must be called before using this function. + Value nodeValue(const Node& n) const { + return (*_node_potential)[n]; + } + + /// \brief Return the number of the blossoms in the basis. + /// + /// This function returns the number of the blossoms in the basis. + /// + /// \pre Either run() or start() must be called before using this function. + /// \see BlossomIt + int blossomNum() const { + return _blossom_potential.size(); + } + + /// \brief Return the number of the nodes in the given blossom. + /// + /// This function returns the number of the nodes in the given blossom. + /// + /// \pre Either run() or start() must be called before using this function. + /// \see BlossomIt + int blossomSize(int k) const { + return _blossom_potential[k].end - _blossom_potential[k].begin; + } + + /// \brief Return the dual value (ptential) of the given blossom. + /// + /// This function returns the dual value (ptential) of the given blossom. + /// + /// \pre Either run() or start() must be called before using this function. + Value blossomValue(int k) const { + return _blossom_potential[k].value; + } + + /// \brief Iterator for obtaining the nodes of a blossom. + /// + /// This class provides an iterator for obtaining the nodes of the + /// given blossom. It lists a subset of the nodes. + /// Before using this iterator, you must allocate a + /// MaxWeightedPerfectMatching class and execute it. + class BlossomIt { + public: + + /// \brief Constructor. + /// + /// Constructor to get the nodes of the given variable. + /// + /// \pre Either \ref MaxWeightedPerfectMatching::run() "algorithm.run()" + /// or \ref MaxWeightedPerfectMatching::start() "algorithm.start()" + /// must be called before initializing this iterator. + BlossomIt(const MaxWeightedPerfectMatching& algorithm, int variable) + : _algorithm(&algorithm) + { + _index = _algorithm->_blossom_potential[variable].begin; + _last = _algorithm->_blossom_potential[variable].end; + } + + /// \brief Conversion to \c Node. + /// + /// Conversion to \c Node. + operator Node() const { + return _algorithm->_blossom_node_list[_index]; + } + + /// \brief Increment operator. + /// + /// Increment operator. + BlossomIt& operator++() { + ++_index; + return *this; + } + + /// \brief Validity checking + /// + /// This function checks whether the iterator is invalid. + bool operator==(Invalid) const { return _index == _last; } + + /// \brief Validity checking + /// + /// This function checks whether the iterator is valid. + bool operator!=(Invalid) const { return _index != _last; } + + private: + const MaxWeightedPerfectMatching* _algorithm; + int _last; + int _index; + }; + + /// @} + + }; + +} //END OF NAMESPACE LEMON + +#endif //LEMON_MAX_MATCHING_H diff -r c35afa9e89e7 -r ef88c0a30f85 lemon/math.h --- a/lemon/math.h Mon Jan 12 23:11:39 2009 +0100 +++ b/lemon/math.h Thu Nov 05 15:48:01 2009 +0100 @@ -55,6 +55,15 @@ /// 1/sqrt(2) const long double SQRT1_2 = 0.7071067811865475244008443621048490L; + ///Check whether the parameter is NaN or not + + ///This function checks whether the parameter is NaN or not. + ///Is should be equivalent with std::isnan(), but it is not + ///provided by all compilers. + inline bool isNaN(double v) + { + return v!=v; + } /// @} diff -r c35afa9e89e7 -r ef88c0a30f85 lemon/max_matching.h --- a/lemon/max_matching.h Mon Jan 12 23:11:39 2009 +0100 +++ /dev/null Thu Jan 01 00:00:00 1970 +0000 @@ -1,3104 +0,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_MAX_MATCHING_H -#define LEMON_MAX_MATCHING_H - -#include -#include -#include -#include - -#include -#include -#include -#include - -///\ingroup matching -///\file -///\brief Maximum matching algorithms in general graphs. - -namespace lemon { - - /// \ingroup matching - /// - /// \brief Edmonds' alternating forest maximum matching algorithm. - /// - /// This class implements Edmonds' alternating forest matching - /// algorithm. The algorithm can be started from an arbitrary initial - /// matching (the default is the empty one) - /// - /// The dual solution of the problem is a map of the nodes to - /// MaxMatching::Status, having values \c EVEN/D, \c ODD/A and \c - /// MATCHED/C showing the Gallai-Edmonds decomposition of the - /// graph. The nodes in \c EVEN/D induce a graph with - /// factor-critical components, the nodes in \c ODD/A form the - /// barrier, and the nodes in \c MATCHED/C induce a graph having a - /// perfect matching. The number of the factor-critical components - /// minus the number of barrier nodes is a lower bound on the - /// unmatched nodes, and the matching is optimal if and only if this bound is - /// tight. This decomposition can be attained by calling \c - /// decomposition() after running the algorithm. - /// - /// \param _Graph The graph type the algorithm runs on. - template - class MaxMatching { - public: - - typedef _Graph Graph; - typedef typename Graph::template NodeMap - MatchingMap; - - ///\brief Indicates the Gallai-Edmonds decomposition of the graph. - /// - ///Indicates the Gallai-Edmonds decomposition of the graph. The - ///nodes with Status \c EVEN/D induce a graph with factor-critical - ///components, the nodes in \c ODD/A form the canonical barrier, - ///and the nodes in \c MATCHED/C induce a graph having a perfect - ///matching. - enum Status { - EVEN = 1, D = 1, MATCHED = 0, C = 0, ODD = -1, A = -1, UNMATCHED = -2 - }; - - typedef typename Graph::template NodeMap StatusMap; - - private: - - TEMPLATE_GRAPH_TYPEDEFS(Graph); - - typedef UnionFindEnum BlossomSet; - typedef ExtendFindEnum TreeSet; - typedef RangeMap NodeIntMap; - typedef MatchingMap EarMap; - typedef std::vector NodeQueue; - - const Graph& _graph; - MatchingMap* _matching; - StatusMap* _status; - - EarMap* _ear; - - IntNodeMap* _blossom_set_index; - BlossomSet* _blossom_set; - NodeIntMap* _blossom_rep; - - IntNodeMap* _tree_set_index; - TreeSet* _tree_set; - - NodeQueue _node_queue; - int _process, _postpone, _last; - - int _node_num; - - private: - - void createStructures() { - _node_num = countNodes(_graph); - if (!_matching) { - _matching = new MatchingMap(_graph); - } - if (!_status) { - _status = new StatusMap(_graph); - } - if (!_ear) { - _ear = new EarMap(_graph); - } - if (!_blossom_set) { - _blossom_set_index = new IntNodeMap(_graph); - _blossom_set = new BlossomSet(*_blossom_set_index); - } - if (!_blossom_rep) { - _blossom_rep = new NodeIntMap(_node_num); - } - if (!_tree_set) { - _tree_set_index = new IntNodeMap(_graph); - _tree_set = new TreeSet(*_tree_set_index); - } - _node_queue.resize(_node_num); - } - - void destroyStructures() { - if (_matching) { - delete _matching; - } - if (_status) { - delete _status; - } - if (_ear) { - delete _ear; - } - if (_blossom_set) { - delete _blossom_set; - delete _blossom_set_index; - } - if (_blossom_rep) { - delete _blossom_rep; - } - if (_tree_set) { - delete _tree_set_index; - delete _tree_set; - } - } - - void processDense(const Node& n) { - _process = _postpone = _last = 0; - _node_queue[_last++] = n; - - while (_process != _last) { - Node u = _node_queue[_process++]; - for (OutArcIt a(_graph, u); a != INVALID; ++a) { - Node v = _graph.target(a); - if ((*_status)[v] == MATCHED) { - extendOnArc(a); - } else if ((*_status)[v] == UNMATCHED) { - augmentOnArc(a); - return; - } - } - } - - while (_postpone != _last) { - Node u = _node_queue[_postpone++]; - - for (OutArcIt a(_graph, u); a != INVALID ; ++a) { - Node v = _graph.target(a); - - if ((*_status)[v] == EVEN) { - if (_blossom_set->find(u) != _blossom_set->find(v)) { - shrinkOnEdge(a); - } - } - - while (_process != _last) { - Node w = _node_queue[_process++]; - for (OutArcIt b(_graph, w); b != INVALID; ++b) { - Node x = _graph.target(b); - if ((*_status)[x] == MATCHED) { - extendOnArc(b); - } else if ((*_status)[x] == UNMATCHED) { - augmentOnArc(b); - return; - } - } - } - } - } - } - - void processSparse(const Node& n) { - _process = _last = 0; - _node_queue[_last++] = n; - while (_process != _last) { - Node u = _node_queue[_process++]; - for (OutArcIt a(_graph, u); a != INVALID; ++a) { - Node v = _graph.target(a); - - if ((*_status)[v] == EVEN) { - if (_blossom_set->find(u) != _blossom_set->find(v)) { - shrinkOnEdge(a); - } - } else if ((*_status)[v] == MATCHED) { - extendOnArc(a); - } else if ((*_status)[v] == UNMATCHED) { - augmentOnArc(a); - return; - } - } - } - } - - void shrinkOnEdge(const Edge& e) { - Node nca = INVALID; - - { - std::set left_set, right_set; - - Node left = (*_blossom_rep)[_blossom_set->find(_graph.u(e))]; - left_set.insert(left); - - Node right = (*_blossom_rep)[_blossom_set->find(_graph.v(e))]; - right_set.insert(right); - - while (true) { - if ((*_matching)[left] == INVALID) break; - left = _graph.target((*_matching)[left]); - left = (*_blossom_rep)[_blossom_set-> - find(_graph.target((*_ear)[left]))]; - if (right_set.find(left) != right_set.end()) { - nca = left; - break; - } - left_set.insert(left); - - if ((*_matching)[right] == INVALID) break; - right = _graph.target((*_matching)[right]); - right = (*_blossom_rep)[_blossom_set-> - find(_graph.target((*_ear)[right]))]; - if (left_set.find(right) != left_set.end()) { - nca = right; - break; - } - right_set.insert(right); - } - - if (nca == INVALID) { - if ((*_matching)[left] == INVALID) { - nca = right; - while (left_set.find(nca) == left_set.end()) { - nca = _graph.target((*_matching)[nca]); - nca =(*_blossom_rep)[_blossom_set-> - find(_graph.target((*_ear)[nca]))]; - } - } else { - nca = left; - while (right_set.find(nca) == right_set.end()) { - nca = _graph.target((*_matching)[nca]); - nca = (*_blossom_rep)[_blossom_set-> - find(_graph.target((*_ear)[nca]))]; - } - } - } - } - - { - - Node node = _graph.u(e); - Arc arc = _graph.direct(e, true); - Node base = (*_blossom_rep)[_blossom_set->find(node)]; - - while (base != nca) { - _ear->set(node, arc); - - Node n = node; - while (n != base) { - n = _graph.target((*_matching)[n]); - Arc a = (*_ear)[n]; - n = _graph.target(a); - _ear->set(n, _graph.oppositeArc(a)); - } - node = _graph.target((*_matching)[base]); - _tree_set->erase(base); - _tree_set->erase(node); - _blossom_set->insert(node, _blossom_set->find(base)); - _status->set(node, EVEN); - _node_queue[_last++] = node; - arc = _graph.oppositeArc((*_ear)[node]); - node = _graph.target((*_ear)[node]); - base = (*_blossom_rep)[_blossom_set->find(node)]; - _blossom_set->join(_graph.target(arc), base); - } - } - - _blossom_rep->set(_blossom_set->find(nca), nca); - - { - - Node node = _graph.v(e); - Arc arc = _graph.direct(e, false); - Node base = (*_blossom_rep)[_blossom_set->find(node)]; - - while (base != nca) { - _ear->set(node, arc); - - Node n = node; - while (n != base) { - n = _graph.target((*_matching)[n]); - Arc a = (*_ear)[n]; - n = _graph.target(a); - _ear->set(n, _graph.oppositeArc(a)); - } - node = _graph.target((*_matching)[base]); - _tree_set->erase(base); - _tree_set->erase(node); - _blossom_set->insert(node, _blossom_set->find(base)); - _status->set(node, EVEN); - _node_queue[_last++] = node; - arc = _graph.oppositeArc((*_ear)[node]); - node = _graph.target((*_ear)[node]); - base = (*_blossom_rep)[_blossom_set->find(node)]; - _blossom_set->join(_graph.target(arc), base); - } - } - - _blossom_rep->set(_blossom_set->find(nca), nca); - } - - - - void extendOnArc(const Arc& a) { - Node base = _graph.source(a); - Node odd = _graph.target(a); - - _ear->set(odd, _graph.oppositeArc(a)); - Node even = _graph.target((*_matching)[odd]); - _blossom_rep->set(_blossom_set->insert(even), even); - _status->set(odd, ODD); - _status->set(even, EVEN); - int tree = _tree_set->find((*_blossom_rep)[_blossom_set->find(base)]); - _tree_set->insert(odd, tree); - _tree_set->insert(even, tree); - _node_queue[_last++] = even; - - } - - void augmentOnArc(const Arc& a) { - Node even = _graph.source(a); - Node odd = _graph.target(a); - - int tree = _tree_set->find((*_blossom_rep)[_blossom_set->find(even)]); - - _matching->set(odd, _graph.oppositeArc(a)); - _status->set(odd, MATCHED); - - Arc arc = (*_matching)[even]; - _matching->set(even, a); - - while (arc != INVALID) { - odd = _graph.target(arc); - arc = (*_ear)[odd]; - even = _graph.target(arc); - _matching->set(odd, arc); - arc = (*_matching)[even]; - _matching->set(even, _graph.oppositeArc((*_matching)[odd])); - } - - for (typename TreeSet::ItemIt it(*_tree_set, tree); - it != INVALID; ++it) { - if ((*_status)[it] == ODD) { - _status->set(it, MATCHED); - } else { - int blossom = _blossom_set->find(it); - for (typename BlossomSet::ItemIt jt(*_blossom_set, blossom); - jt != INVALID; ++jt) { - _status->set(jt, MATCHED); - } - _blossom_set->eraseClass(blossom); - } - } - _tree_set->eraseClass(tree); - - } - - public: - - /// \brief Constructor - /// - /// Constructor. - MaxMatching(const Graph& graph) - : _graph(graph), _matching(0), _status(0), _ear(0), - _blossom_set_index(0), _blossom_set(0), _blossom_rep(0), - _tree_set_index(0), _tree_set(0) {} - - ~MaxMatching() { - destroyStructures(); - } - - /// \name Execution control - /// The simplest way to execute the algorithm is to use the - /// \c run() member function. - /// \n - - /// If you need better control on the execution, you must call - /// \ref init(), \ref greedyInit() or \ref matchingInit() - /// functions first, then you can start the algorithm with the \ref - /// startSparse() or startDense() functions. - - ///@{ - - /// \brief Sets the actual matching to the empty matching. - /// - /// Sets the actual matching to the empty matching. - /// - void init() { - createStructures(); - for(NodeIt n(_graph); n != INVALID; ++n) { - _matching->set(n, INVALID); - _status->set(n, UNMATCHED); - } - } - - ///\brief Finds an initial matching in a greedy way - /// - ///It finds an initial matching in a greedy way. - void greedyInit() { - createStructures(); - for (NodeIt n(_graph); n != INVALID; ++n) { - _matching->set(n, INVALID); - _status->set(n, UNMATCHED); - } - for (NodeIt n(_graph); n != INVALID; ++n) { - if ((*_matching)[n] == INVALID) { - for (OutArcIt a(_graph, n); a != INVALID ; ++a) { - Node v = _graph.target(a); - if ((*_matching)[v] == INVALID && v != n) { - _matching->set(n, a); - _status->set(n, MATCHED); - _matching->set(v, _graph.oppositeArc(a)); - _status->set(v, MATCHED); - break; - } - } - } - } - } - - - /// \brief Initialize the matching from a map containing. - /// - /// Initialize the matching from a \c bool valued \c Edge map. This - /// map must have the property that there are no two incident edges - /// with true value, ie. it contains a matching. - /// \return %True if the map contains a matching. - template - bool matchingInit(const MatchingMap& matching) { - createStructures(); - - for (NodeIt n(_graph); n != INVALID; ++n) { - _matching->set(n, INVALID); - _status->set(n, UNMATCHED); - } - for(EdgeIt e(_graph); e!=INVALID; ++e) { - if (matching[e]) { - - Node u = _graph.u(e); - if ((*_matching)[u] != INVALID) return false; - _matching->set(u, _graph.direct(e, true)); - _status->set(u, MATCHED); - - Node v = _graph.v(e); - if ((*_matching)[v] != INVALID) return false; - _matching->set(v, _graph.direct(e, false)); - _status->set(v, MATCHED); - } - } - return true; - } - - /// \brief Starts Edmonds' algorithm - /// - /// If runs the original Edmonds' algorithm. - void startSparse() { - for(NodeIt n(_graph); n != INVALID; ++n) { - if ((*_status)[n] == UNMATCHED) { - (*_blossom_rep)[_blossom_set->insert(n)] = n; - _tree_set->insert(n); - _status->set(n, EVEN); - processSparse(n); - } - } - } - - /// \brief Starts Edmonds' algorithm. - /// - /// It runs Edmonds' algorithm with a heuristic of postponing - /// shrinks, therefore resulting in a faster algorithm for dense graphs. - void startDense() { - for(NodeIt n(_graph); n != INVALID; ++n) { - if ((*_status)[n] == UNMATCHED) { - (*_blossom_rep)[_blossom_set->insert(n)] = n; - _tree_set->insert(n); - _status->set(n, EVEN); - processDense(n); - } - } - } - - - /// \brief Runs Edmonds' algorithm - /// - /// Runs Edmonds' algorithm for sparse graphs (m<2*n) - /// or Edmonds' algorithm with a heuristic of - /// postponing shrinks for dense graphs. - void run() { - if (countEdges(_graph) < 2 * countNodes(_graph)) { - greedyInit(); - startSparse(); - } else { - init(); - startDense(); - } - } - - /// @} - - /// \name Primal solution - /// Functions to get the primal solution, ie. the matching. - - /// @{ - - ///\brief Returns the size of the current matching. - /// - ///Returns the size of the current matching. After \ref - ///run() it returns the size of the maximum matching in the graph. - int matchingSize() const { - int size = 0; - for (NodeIt n(_graph); n != INVALID; ++n) { - if ((*_matching)[n] != INVALID) { - ++size; - } - } - return size / 2; - } - - /// \brief Returns true when the edge is in the matching. - /// - /// Returns true when the edge is in the matching. - bool matching(const Edge& edge) const { - return edge == (*_matching)[_graph.u(edge)]; - } - - /// \brief Returns the matching edge incident to the given node. - /// - /// Returns the matching edge of a \c node in the actual matching or - /// INVALID if the \c node is not covered by the actual matching. - Arc matching(const Node& n) const { - return (*_matching)[n]; - } - - ///\brief Returns the mate of a node in the actual matching. - /// - ///Returns the mate of a \c node in the actual matching or - ///INVALID if the \c node is not covered by the actual matching. - Node mate(const Node& n) const { - return (*_matching)[n] != INVALID ? - _graph.target((*_matching)[n]) : INVALID; - } - - /// @} - - /// \name Dual solution - /// Functions to get the dual solution, ie. the decomposition. - - /// @{ - - /// \brief Returns the class of the node in the Edmonds-Gallai - /// decomposition. - /// - /// Returns the class of the node in the Edmonds-Gallai - /// decomposition. - Status decomposition(const Node& n) const { - return (*_status)[n]; - } - - /// \brief Returns true when the node is in the barrier. - /// - /// Returns true when the node is in the barrier. - bool barrier(const Node& n) const { - return (*_status)[n] == ODD; - } - - /// @} - - }; - - /// \ingroup matching - /// - /// \brief Weighted matching in general graphs - /// - /// This class provides an efficient implementation of Edmond's - /// maximum weighted matching algorithm. The implementation is based - /// on extensive use of priority queues and provides - /// \f$O(nm\log(n))\f$ time complexity. - /// - /// The maximum weighted matching problem is to find undirected - /// edges in the graph with maximum overall weight and no two of - /// them shares their ends. The problem can be formulated with the - /// following linear program. - /// \f[ \sum_{e \in \delta(u)}x_e \le 1 \quad \forall u\in V\f] - /** \f[ \sum_{e \in \gamma(B)}x_e \le \frac{\vert B \vert - 1}{2} - \quad \forall B\in\mathcal{O}\f] */ - /// \f[x_e \ge 0\quad \forall e\in E\f] - /// \f[\max \sum_{e\in E}x_ew_e\f] - /// where \f$\delta(X)\f$ is the set of edges incident to a node in - /// \f$X\f$, \f$\gamma(X)\f$ is the set of edges with both ends in - /// \f$X\f$ and \f$\mathcal{O}\f$ is the set of odd cardinality - /// subsets of the nodes. - /// - /// The algorithm calculates an optimal matching and a proof of the - /// optimality. The solution of the dual problem can be used to check - /// the result of the algorithm. The dual linear problem is the - /** \f[ y_u + y_v + \sum_{B \in \mathcal{O}, uv \in \gamma(B)} - z_B \ge w_{uv} \quad \forall uv\in E\f] */ - /// \f[y_u \ge 0 \quad \forall u \in V\f] - /// \f[z_B \ge 0 \quad \forall B \in \mathcal{O}\f] - /** \f[\min \sum_{u \in V}y_u + \sum_{B \in \mathcal{O}} - \frac{\vert B \vert - 1}{2}z_B\f] */ - /// - /// The algorithm can be executed with \c run() or the \c init() and - /// then the \c start() member functions. After it the matching can - /// be asked with \c matching() or mate() functions. The dual - /// solution can be get with \c nodeValue(), \c blossomNum() and \c - /// blossomValue() members and \ref MaxWeightedMatching::BlossomIt - /// "BlossomIt" nested class, which is able to iterate on the nodes - /// of a blossom. If the value type is integral then the dual - /// solution is multiplied by \ref MaxWeightedMatching::dualScale "4". - template > - class MaxWeightedMatching { - public: - - typedef _Graph Graph; - typedef _WeightMap WeightMap; - typedef typename WeightMap::Value Value; - - /// \brief Scaling factor for dual solution - /// - /// Scaling factor for dual solution, it is equal to 4 or 1 - /// according to the value type. - static const int dualScale = - std::numeric_limits::is_integer ? 4 : 1; - - typedef typename Graph::template NodeMap - MatchingMap; - - private: - - TEMPLATE_GRAPH_TYPEDEFS(Graph); - - typedef typename Graph::template NodeMap NodePotential; - typedef std::vector BlossomNodeList; - - struct BlossomVariable { - int begin, end; - Value value; - - BlossomVariable(int _begin, int _end, Value _value) - : begin(_begin), end(_end), value(_value) {} - - }; - - typedef std::vector BlossomPotential; - - const Graph& _graph; - const WeightMap& _weight; - - MatchingMap* _matching; - - NodePotential* _node_potential; - - BlossomPotential _blossom_potential; - BlossomNodeList _blossom_node_list; - - int _node_num; - int _blossom_num; - - typedef RangeMap IntIntMap; - - enum Status { - EVEN = -1, MATCHED = 0, ODD = 1, UNMATCHED = -2 - }; - - typedef HeapUnionFind BlossomSet; - struct BlossomData { - int tree; - Status status; - Arc pred, next; - Value pot, offset; - Node base; - }; - - IntNodeMap *_blossom_index; - BlossomSet *_blossom_set; - RangeMap* _blossom_data; - - IntNodeMap *_node_index; - IntArcMap *_node_heap_index; - - struct NodeData { - - NodeData(IntArcMap& node_heap_index) - : heap(node_heap_index) {} - - int blossom; - Value pot; - BinHeap heap; - std::map heap_index; - - int tree; - }; - - RangeMap* _node_data; - - typedef ExtendFindEnum TreeSet; - - IntIntMap *_tree_set_index; - TreeSet *_tree_set; - - IntNodeMap *_delta1_index; - BinHeap *_delta1; - - IntIntMap *_delta2_index; - BinHeap *_delta2; - - IntEdgeMap *_delta3_index; - BinHeap *_delta3; - - IntIntMap *_delta4_index; - BinHeap *_delta4; - - Value _delta_sum; - - void createStructures() { - _node_num = countNodes(_graph); - _blossom_num = _node_num * 3 / 2; - - if (!_matching) { - _matching = new MatchingMap(_graph); - } - if (!_node_potential) { - _node_potential = new NodePotential(_graph); - } - if (!_blossom_set) { - _blossom_index = new IntNodeMap(_graph); - _blossom_set = new BlossomSet(*_blossom_index); - _blossom_data = new RangeMap(_blossom_num); - } - - if (!_node_index) { - _node_index = new IntNodeMap(_graph); - _node_heap_index = new IntArcMap(_graph); - _node_data = new RangeMap(_node_num, - NodeData(*_node_heap_index)); - } - - if (!_tree_set) { - _tree_set_index = new IntIntMap(_blossom_num); - _tree_set = new TreeSet(*_tree_set_index); - } - if (!_delta1) { - _delta1_index = new IntNodeMap(_graph); - _delta1 = new BinHeap(*_delta1_index); - } - if (!_delta2) { - _delta2_index = new IntIntMap(_blossom_num); - _delta2 = new BinHeap(*_delta2_index); - } - if (!_delta3) { - _delta3_index = new IntEdgeMap(_graph); - _delta3 = new BinHeap(*_delta3_index); - } - if (!_delta4) { - _delta4_index = new IntIntMap(_blossom_num); - _delta4 = new BinHeap(*_delta4_index); - } - } - - void destroyStructures() { - _node_num = countNodes(_graph); - _blossom_num = _node_num * 3 / 2; - - if (_matching) { - delete _matching; - } - if (_node_potential) { - delete _node_potential; - } - if (_blossom_set) { - delete _blossom_index; - delete _blossom_set; - delete _blossom_data; - } - - if (_node_index) { - delete _node_index; - delete _node_heap_index; - delete _node_data; - } - - if (_tree_set) { - delete _tree_set_index; - delete _tree_set; - } - if (_delta1) { - delete _delta1_index; - delete _delta1; - } - if (_delta2) { - delete _delta2_index; - delete _delta2; - } - if (_delta3) { - delete _delta3_index; - delete _delta3; - } - if (_delta4) { - delete _delta4_index; - delete _delta4; - } - } - - void matchedToEven(int blossom, int tree) { - if (_delta2->state(blossom) == _delta2->IN_HEAP) { - _delta2->erase(blossom); - } - - if (!_blossom_set->trivial(blossom)) { - (*_blossom_data)[blossom].pot -= - 2 * (_delta_sum - (*_blossom_data)[blossom].offset); - } - - for (typename BlossomSet::ItemIt n(*_blossom_set, blossom); - n != INVALID; ++n) { - - _blossom_set->increase(n, std::numeric_limits::max()); - int ni = (*_node_index)[n]; - - (*_node_data)[ni].heap.clear(); - (*_node_data)[ni].heap_index.clear(); - - (*_node_data)[ni].pot += _delta_sum - (*_blossom_data)[blossom].offset; - - _delta1->push(n, (*_node_data)[ni].pot); - - for (InArcIt e(_graph, n); e != INVALID; ++e) { - Node v = _graph.source(e); - int vb = _blossom_set->find(v); - int vi = (*_node_index)[v]; - - Value rw = (*_node_data)[ni].pot + (*_node_data)[vi].pot - - dualScale * _weight[e]; - - if ((*_blossom_data)[vb].status == EVEN) { - if (_delta3->state(e) != _delta3->IN_HEAP && blossom != vb) { - _delta3->push(e, rw / 2); - } - } else 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); - - 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 matchedToUnmatched(int blossom) { - if (_delta2->state(blossom) == _delta2->IN_HEAP) { - _delta2->erase(blossom); - } - - for (typename BlossomSet::ItemIt n(*_blossom_set, blossom); - n != INVALID; ++n) { - int ni = (*_node_index)[n]; - - _blossom_set->increase(n, std::numeric_limits::max()); - - (*_node_data)[ni].heap.clear(); - (*_node_data)[ni].heap_index.clear(); - - for (OutArcIt e(_graph, n); e != INVALID; ++e) { - Node v = _graph.target(e); - int vb = _blossom_set->find(v); - int vi = (*_node_index)[v]; - - Value rw = (*_node_data)[ni].pot + (*_node_data)[vi].pot - - dualScale * _weight[e]; - - if ((*_blossom_data)[vb].status == EVEN) { - if (_delta3->state(e) != _delta3->IN_HEAP) { - _delta3->push(e, rw); - } - } - } - } - } - - void unmatchedToMatched(int blossom) { - for (typename BlossomSet::ItemIt n(*_blossom_set, blossom); - n != INVALID; ++n) { - int ni = (*_node_index)[n]; - - for (InArcIt e(_graph, n); e != INVALID; ++e) { - Node v = _graph.source(e); - int vb = _blossom_set->find(v); - int vi = (*_node_index)[v]; - - Value rw = (*_node_data)[ni].pot + (*_node_data)[vi].pot - - dualScale * _weight[e]; - - if (vb == blossom) { - if (_delta3->state(e) == _delta3->IN_HEAP) { - _delta3->erase(e); - } - } else if ((*_blossom_data)[vb].status == EVEN) { - - if (_delta3->state(e) == _delta3->IN_HEAP) { - _delta3->erase(e); - } - - int vt = _tree_set->find(vb); - - Arc r = _graph.oppositeArc(e); - - typename std::map::iterator it = - (*_node_data)[ni].heap_index.find(vt); - - if (it != (*_node_data)[ni].heap_index.end()) { - if ((*_node_data)[ni].heap[it->second] > rw) { - (*_node_data)[ni].heap.replace(it->second, r); - (*_node_data)[ni].heap.decrease(r, rw); - it->second = r; - } - } else { - (*_node_data)[ni].heap.push(r, rw); - (*_node_data)[ni].heap_index.insert(std::make_pair(vt, r)); - } - - if ((*_blossom_set)[n] > (*_node_data)[ni].heap.prio()) { - _blossom_set->decrease(n, (*_node_data)[ni].heap.prio()); - - if (_delta2->state(blossom) != _delta2->IN_HEAP) { - _delta2->push(blossom, _blossom_set->classPrio(blossom) - - (*_blossom_data)[blossom].offset); - } else if ((*_delta2)[blossom] > _blossom_set->classPrio(blossom)- - (*_blossom_data)[blossom].offset){ - _delta2->decrease(blossom, _blossom_set->classPrio(blossom) - - (*_blossom_data)[blossom].offset); - } - } - - } else if ((*_blossom_data)[vb].status == UNMATCHED) { - if (_delta3->state(e) == _delta3->IN_HEAP) { - _delta3->erase(e); - } - } - } - } - } - - void alternatePath(int even, int tree) { - int odd; - - evenToMatched(even, tree); - (*_blossom_data)[even].status = MATCHED; - - while ((*_blossom_data)[even].pred != INVALID) { - odd = _blossom_set->find(_graph.target((*_blossom_data)[even].pred)); - (*_blossom_data)[odd].status = MATCHED; - oddToMatched(odd); - (*_blossom_data)[odd].next = (*_blossom_data)[odd].pred; - - even = _blossom_set->find(_graph.target((*_blossom_data)[odd].pred)); - (*_blossom_data)[even].status = MATCHED; - evenToMatched(even, tree); - (*_blossom_data)[even].next = - _graph.oppositeArc((*_blossom_data)[odd].pred); - } - - } - - void destroyTree(int tree) { - for (TreeSet::ItemIt b(*_tree_set, tree); b != INVALID; ++b) { - if ((*_blossom_data)[b].status == EVEN) { - (*_blossom_data)[b].status = MATCHED; - evenToMatched(b, tree); - } else if ((*_blossom_data)[b].status == ODD) { - (*_blossom_data)[b].status = MATCHED; - oddToMatched(b); - } - } - _tree_set->eraseClass(tree); - } - - - void unmatchNode(const Node& node) { - int blossom = _blossom_set->find(node); - int tree = _tree_set->find(blossom); - - alternatePath(blossom, tree); - destroyTree(tree); - - (*_blossom_data)[blossom].status = UNMATCHED; - (*_blossom_data)[blossom].base = node; - matchedToUnmatched(blossom); - } - - - void augmentOnEdge(const Edge& edge) { - - int left = _blossom_set->find(_graph.u(edge)); - int right = _blossom_set->find(_graph.v(edge)); - - if ((*_blossom_data)[left].status == EVEN) { - int left_tree = _tree_set->find(left); - alternatePath(left, left_tree); - destroyTree(left_tree); - } else { - (*_blossom_data)[left].status = MATCHED; - unmatchedToMatched(left); - } - - if ((*_blossom_data)[right].status == EVEN) { - int right_tree = _tree_set->find(right); - alternatePath(right, right_tree); - destroyTree(right_tree); - } else { - (*_blossom_data)[right].status = MATCHED; - unmatchedToMatched(right); - } - - (*_blossom_data)[left].next = _graph.direct(edge, true); - (*_blossom_data)[right].next = _graph.direct(edge, false); - } - - void extendOnArc(const Arc& arc) { - int base = _blossom_set->find(_graph.target(arc)); - int tree = _tree_set->find(base); - - int odd = _blossom_set->find(_graph.source(arc)); - _tree_set->insert(odd, tree); - (*_blossom_data)[odd].status = ODD; - matchedToOdd(odd); - (*_blossom_data)[odd].pred = arc; - - int even = _blossom_set->find(_graph.target((*_blossom_data)[odd].next)); - (*_blossom_data)[even].pred = (*_blossom_data)[even].next; - _tree_set->insert(even, tree); - (*_blossom_data)[even].status = EVEN; - matchedToEven(even, tree); - } - - void shrinkOnEdge(const Edge& edge, int tree) { - int nca = -1; - std::vector left_path, right_path; - - { - std::set left_set, right_set; - int left = _blossom_set->find(_graph.u(edge)); - left_path.push_back(left); - left_set.insert(left); - - int right = _blossom_set->find(_graph.v(edge)); - right_path.push_back(right); - right_set.insert(right); - - while (true) { - - if ((*_blossom_data)[left].pred == INVALID) break; - - left = - _blossom_set->find(_graph.target((*_blossom_data)[left].pred)); - left_path.push_back(left); - left = - _blossom_set->find(_graph.target((*_blossom_data)[left].pred)); - left_path.push_back(left); - - left_set.insert(left); - - if (right_set.find(left) != right_set.end()) { - nca = left; - break; - } - - if ((*_blossom_data)[right].pred == INVALID) break; - - right = - _blossom_set->find(_graph.target((*_blossom_data)[right].pred)); - right_path.push_back(right); - right = - _blossom_set->find(_graph.target((*_blossom_data)[right].pred)); - right_path.push_back(right); - - right_set.insert(right); - - if (left_set.find(right) != left_set.end()) { - nca = right; - break; - } - - } - - if (nca == -1) { - if ((*_blossom_data)[left].pred == INVALID) { - nca = right; - while (left_set.find(nca) == left_set.end()) { - nca = - _blossom_set->find(_graph.target((*_blossom_data)[nca].pred)); - right_path.push_back(nca); - nca = - _blossom_set->find(_graph.target((*_blossom_data)[nca].pred)); - right_path.push_back(nca); - } - } else { - nca = left; - while (right_set.find(nca) == right_set.end()) { - nca = - _blossom_set->find(_graph.target((*_blossom_data)[nca].pred)); - left_path.push_back(nca); - nca = - _blossom_set->find(_graph.target((*_blossom_data)[nca].pred)); - left_path.push_back(nca); - } - } - } - } - - std::vector subblossoms; - Arc prev; - - prev = _graph.direct(edge, true); - for (int i = 0; left_path[i] != nca; i += 2) { - subblossoms.push_back(left_path[i]); - (*_blossom_data)[left_path[i]].next = prev; - _tree_set->erase(left_path[i]); - - subblossoms.push_back(left_path[i + 1]); - (*_blossom_data)[left_path[i + 1]].status = EVEN; - oddToEven(left_path[i + 1], tree); - _tree_set->erase(left_path[i + 1]); - prev = _graph.oppositeArc((*_blossom_data)[left_path[i + 1]].pred); - } - - int k = 0; - while (right_path[k] != nca) ++k; - - subblossoms.push_back(nca); - (*_blossom_data)[nca].next = prev; - - for (int i = k - 2; i >= 0; i -= 2) { - subblossoms.push_back(right_path[i + 1]); - (*_blossom_data)[right_path[i + 1]].status = EVEN; - oddToEven(right_path[i + 1], tree); - _tree_set->erase(right_path[i + 1]); - - (*_blossom_data)[right_path[i + 1]].next = - (*_blossom_data)[right_path[i + 1]].pred; - - subblossoms.push_back(right_path[i]); - _tree_set->erase(right_path[i]); - } - - int surface = - _blossom_set->join(subblossoms.begin(), subblossoms.end()); - - for (int i = 0; i < int(subblossoms.size()); ++i) { - if (!_blossom_set->trivial(subblossoms[i])) { - (*_blossom_data)[subblossoms[i]].pot += 2 * _delta_sum; - } - (*_blossom_data)[subblossoms[i]].status = MATCHED; - } - - (*_blossom_data)[surface].pot = -2 * _delta_sum; - (*_blossom_data)[surface].offset = 0; - (*_blossom_data)[surface].status = EVEN; - (*_blossom_data)[surface].pred = (*_blossom_data)[nca].pred; - (*_blossom_data)[surface].next = (*_blossom_data)[nca].pred; - - _tree_set->insert(surface, tree); - _tree_set->erase(nca); - } - - void splitBlossom(int blossom) { - Arc next = (*_blossom_data)[blossom].next; - Arc pred = (*_blossom_data)[blossom].pred; - - int tree = _tree_set->find(blossom); - - (*_blossom_data)[blossom].status = MATCHED; - oddToMatched(blossom); - if (_delta2->state(blossom) == _delta2->IN_HEAP) { - _delta2->erase(blossom); - } - - std::vector subblossoms; - _blossom_set->split(blossom, std::back_inserter(subblossoms)); - - Value offset = (*_blossom_data)[blossom].offset; - int b = _blossom_set->find(_graph.source(pred)); - int d = _blossom_set->find(_graph.source(next)); - - int ib = -1, id = -1; - for (int i = 0; i < int(subblossoms.size()); ++i) { - if (subblossoms[i] == b) ib = i; - if (subblossoms[i] == d) id = i; - - (*_blossom_data)[subblossoms[i]].offset = offset; - if (!_blossom_set->trivial(subblossoms[i])) { - (*_blossom_data)[subblossoms[i]].pot -= 2 * offset; - } - if (_blossom_set->classPrio(subblossoms[i]) != - std::numeric_limits::max()) { - _delta2->push(subblossoms[i], - _blossom_set->classPrio(subblossoms[i]) - - (*_blossom_data)[subblossoms[i]].offset); - } - } - - if (id > ib ? ((id - ib) % 2 == 0) : ((ib - id) % 2 == 1)) { - for (int i = (id + 1) % subblossoms.size(); - i != ib; i = (i + 2) % subblossoms.size()) { - int sb = subblossoms[i]; - int tb = subblossoms[(i + 1) % subblossoms.size()]; - (*_blossom_data)[sb].next = - _graph.oppositeArc((*_blossom_data)[tb].next); - } - - for (int i = ib; i != id; i = (i + 2) % subblossoms.size()) { - int sb = subblossoms[i]; - int tb = subblossoms[(i + 1) % subblossoms.size()]; - int ub = subblossoms[(i + 2) % subblossoms.size()]; - - (*_blossom_data)[sb].status = ODD; - matchedToOdd(sb); - _tree_set->insert(sb, tree); - (*_blossom_data)[sb].pred = pred; - (*_blossom_data)[sb].next = - _graph.oppositeArc((*_blossom_data)[tb].next); - - pred = (*_blossom_data)[ub].next; - - (*_blossom_data)[tb].status = EVEN; - matchedToEven(tb, tree); - _tree_set->insert(tb, tree); - (*_blossom_data)[tb].pred = (*_blossom_data)[tb].next; - } - - (*_blossom_data)[subblossoms[id]].status = ODD; - matchedToOdd(subblossoms[id]); - _tree_set->insert(subblossoms[id], tree); - (*_blossom_data)[subblossoms[id]].next = next; - (*_blossom_data)[subblossoms[id]].pred = pred; - - } else { - - for (int i = (ib + 1) % subblossoms.size(); - i != id; i = (i + 2) % subblossoms.size()) { - int sb = subblossoms[i]; - int tb = subblossoms[(i + 1) % subblossoms.size()]; - (*_blossom_data)[sb].next = - _graph.oppositeArc((*_blossom_data)[tb].next); - } - - for (int i = id; i != ib; i = (i + 2) % subblossoms.size()) { - int sb = subblossoms[i]; - int tb = subblossoms[(i + 1) % subblossoms.size()]; - int ub = subblossoms[(i + 2) % subblossoms.size()]; - - (*_blossom_data)[sb].status = ODD; - matchedToOdd(sb); - _tree_set->insert(sb, tree); - (*_blossom_data)[sb].next = next; - (*_blossom_data)[sb].pred = - _graph.oppositeArc((*_blossom_data)[tb].next); - - (*_blossom_data)[tb].status = EVEN; - matchedToEven(tb, tree); - _tree_set->insert(tb, tree); - (*_blossom_data)[tb].pred = - (*_blossom_data)[tb].next = - _graph.oppositeArc((*_blossom_data)[ub].next); - next = (*_blossom_data)[ub].next; - } - - (*_blossom_data)[subblossoms[ib]].status = ODD; - matchedToOdd(subblossoms[ib]); - _tree_set->insert(subblossoms[ib], tree); - (*_blossom_data)[subblossoms[ib]].next = next; - (*_blossom_data)[subblossoms[ib]].pred = pred; - } - _tree_set->erase(blossom); - } - - void extractBlossom(int blossom, const Node& base, const Arc& matching) { - if (_blossom_set->trivial(blossom)) { - int bi = (*_node_index)[base]; - Value pot = (*_node_data)[bi].pot; - - _matching->set(base, matching); - _blossom_node_list.push_back(base); - _node_potential->set(base, pot); - } else { - - Value pot = (*_blossom_data)[blossom].pot; - int bn = _blossom_node_list.size(); - - std::vector subblossoms; - _blossom_set->split(blossom, std::back_inserter(subblossoms)); - int b = _blossom_set->find(base); - int ib = -1; - for (int i = 0; i < int(subblossoms.size()); ++i) { - if (subblossoms[i] == b) { ib = i; break; } - } - - for (int i = 1; i < int(subblossoms.size()); i += 2) { - int sb = subblossoms[(ib + i) % subblossoms.size()]; - int tb = subblossoms[(ib + i + 1) % subblossoms.size()]; - - Arc m = (*_blossom_data)[tb].next; - extractBlossom(sb, _graph.target(m), _graph.oppositeArc(m)); - extractBlossom(tb, _graph.source(m), m); - } - extractBlossom(subblossoms[ib], base, matching); - - int en = _blossom_node_list.size(); - - _blossom_potential.push_back(BlossomVariable(bn, en, pot)); - } - } - - void extractMatching() { - std::vector blossoms; - for (typename BlossomSet::ClassIt c(*_blossom_set); c != INVALID; ++c) { - blossoms.push_back(c); - } - - for (int i = 0; i < int(blossoms.size()); ++i) { - if ((*_blossom_data)[blossoms[i]].status == MATCHED) { - - Value offset = (*_blossom_data)[blossoms[i]].offset; - (*_blossom_data)[blossoms[i]].pot += 2 * offset; - for (typename BlossomSet::ItemIt n(*_blossom_set, blossoms[i]); - n != INVALID; ++n) { - (*_node_data)[(*_node_index)[n]].pot -= offset; - } - - Arc matching = (*_blossom_data)[blossoms[i]].next; - Node base = _graph.source(matching); - extractBlossom(blossoms[i], base, matching); - } else { - Node base = (*_blossom_data)[blossoms[i]].base; - extractBlossom(blossoms[i], base, INVALID); - } - } - } - - public: - - /// \brief Constructor - /// - /// Constructor. - MaxWeightedMatching(const Graph& graph, const WeightMap& weight) - : _graph(graph), _weight(weight), _matching(0), - _node_potential(0), _blossom_potential(), _blossom_node_list(), - _node_num(0), _blossom_num(0), - - _blossom_index(0), _blossom_set(0), _blossom_data(0), - _node_index(0), _node_heap_index(0), _node_data(0), - _tree_set_index(0), _tree_set(0), - - _delta1_index(0), _delta1(0), - _delta2_index(0), _delta2(0), - _delta3_index(0), _delta3(0), - _delta4_index(0), _delta4(0), - - _delta_sum() {} - - ~MaxWeightedMatching() { - destroyStructures(); - } - - /// \name Execution control - /// The simplest way to execute the algorithm is to use the - /// \c run() member function. - - ///@{ - - /// \brief Initialize the algorithm - /// - /// Initialize the algorithm - void init() { - createStructures(); - - for (ArcIt e(_graph); e != INVALID; ++e) { - _node_heap_index->set(e, BinHeap::PRE_HEAP); - } - for (NodeIt n(_graph); n != INVALID; ++n) { - _delta1_index->set(n, _delta1->PRE_HEAP); - } - for (EdgeIt e(_graph); e != INVALID; ++e) { - _delta3_index->set(e, _delta3->PRE_HEAP); - } - for (int i = 0; i < _blossom_num; ++i) { - _delta2_index->set(i, _delta2->PRE_HEAP); - _delta4_index->set(i, _delta4->PRE_HEAP); - } - - int index = 0; - for (NodeIt n(_graph); n != INVALID; ++n) { - Value max = 0; - for (OutArcIt e(_graph, n); e != INVALID; ++e) { - if (_graph.target(e) == n) continue; - if ((dualScale * _weight[e]) / 2 > max) { - max = (dualScale * _weight[e]) / 2; - } - } - _node_index->set(n, index); - (*_node_data)[index].pot = max; - _delta1->push(n, max); - int blossom = - _blossom_set->insert(n, std::numeric_limits::max()); - - _tree_set->insert(blossom); - - (*_blossom_data)[blossom].status = EVEN; - (*_blossom_data)[blossom].pred = INVALID; - (*_blossom_data)[blossom].next = INVALID; - (*_blossom_data)[blossom].pot = 0; - (*_blossom_data)[blossom].offset = 0; - ++index; - } - for (EdgeIt e(_graph); e != INVALID; ++e) { - int si = (*_node_index)[_graph.u(e)]; - int ti = (*_node_index)[_graph.v(e)]; - if (_graph.u(e) != _graph.v(e)) { - _delta3->push(e, ((*_node_data)[si].pot + (*_node_data)[ti].pot - - dualScale * _weight[e]) / 2); - } - } - } - - /// \brief Starts the algorithm - /// - /// Starts the algorithm - void start() { - enum OpType { - D1, D2, D3, D4 - }; - - 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(); - - Value d4 = !_delta4->empty() ? - _delta4->prio() : std::numeric_limits::max(); - - _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) { - case D1: - { - Node n = _delta1->top(); - unmatchNode(n); - --unmatched; - } - break; - case D2: - { - int blossom = _delta2->top(); - Node n = _blossom_set->classTop(blossom); - Arc e = (*_node_data)[(*_node_index)[n]].heap.top(); - extendOnArc(e); - } - break; - case D3: - { - Edge e = _delta3->top(); - - int left_blossom = _blossom_set->find(_graph.u(e)); - int right_blossom = _blossom_set->find(_graph.v(e)); - - if (left_blossom == right_blossom) { - _delta3->pop(); - } else { - int left_tree; - 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) { - shrinkOnEdge(e, left_tree); - } else { - augmentOnEdge(e); - unmatched -= 2; - } - } - } break; - case D4: - splitBlossom(_delta4->top()); - break; - } - } - extractMatching(); - } - - /// \brief Runs %MaxWeightedMatching algorithm. - /// - /// This method runs the %MaxWeightedMatching algorithm. - /// - /// \note mwm.run() is just a shortcut of the following code. - /// \code - /// mwm.init(); - /// mwm.start(); - /// \endcode - void run() { - init(); - start(); - } - - /// @} - - /// \name Primal solution - /// Functions to get the primal solution, ie. the matching. - - /// @{ - - /// \brief Returns the weight of the matching. - /// - /// Returns the weight of the matching. - Value matchingValue() const { - Value sum = 0; - for (NodeIt n(_graph); n != INVALID; ++n) { - if ((*_matching)[n] != INVALID) { - sum += _weight[(*_matching)[n]]; - } - } - return sum /= 2; - } - - /// \brief Returns the cardinality of the matching. - /// - /// Returns the cardinality of the matching. - int matchingSize() const { - int num = 0; - for (NodeIt n(_graph); n != INVALID; ++n) { - if ((*_matching)[n] != INVALID) { - ++num; - } - } - return num /= 2; - } - - /// \brief Returns true when the edge is in the matching. - /// - /// Returns true when the edge is in the matching. - bool matching(const Edge& edge) const { - return edge == (*_matching)[_graph.u(edge)]; - } - - /// \brief Returns the incident matching arc. - /// - /// Returns the incident matching arc from given node. If the - /// node is not matched then it gives back \c INVALID. - Arc matching(const Node& node) const { - return (*_matching)[node]; - } - - /// \brief Returns the mate of the node. - /// - /// Returns the adjancent node in a mathcing arc. If the node is - /// not matched then it gives back \c INVALID. - Node mate(const Node& node) const { - return (*_matching)[node] != INVALID ? - _graph.target((*_matching)[node]) : INVALID; - } - - /// @} - - /// \name Dual solution - /// Functions to get the dual solution. - - /// @{ - - /// \brief Returns the value of the dual solution. - /// - /// Returns the value of the dual solution. It should be equal to - /// the primal value scaled by \ref dualScale "dual scale". - Value dualValue() const { - Value sum = 0; - for (NodeIt n(_graph); n != INVALID; ++n) { - sum += nodeValue(n); - } - for (int i = 0; i < blossomNum(); ++i) { - sum += blossomValue(i) * (blossomSize(i) / 2); - } - return sum; - } - - /// \brief Returns the value of the node. - /// - /// Returns the the value of the node. - Value nodeValue(const Node& n) const { - return (*_node_potential)[n]; - } - - /// \brief Returns the number of the blossoms in the basis. - /// - /// Returns the number of the blossoms in the basis. - /// \see BlossomIt - int blossomNum() const { - return _blossom_potential.size(); - } - - - /// \brief Returns the number of the nodes in the blossom. - /// - /// Returns the number of the nodes in the blossom. - int blossomSize(int k) const { - return _blossom_potential[k].end - _blossom_potential[k].begin; - } - - /// \brief Returns the value of the blossom. - /// - /// Returns the the value of the blossom. - /// \see BlossomIt - Value blossomValue(int k) const { - return _blossom_potential[k].value; - } - - /// \brief Iterator for obtaining the nodes of the blossom. - /// - /// Iterator for obtaining the nodes of the blossom. This class - /// provides a common lemon style iterator for listing a - /// subset of the nodes. - class BlossomIt { - public: - - /// \brief Constructor. - /// - /// Constructor to get the nodes of the variable. - BlossomIt(const MaxWeightedMatching& algorithm, int variable) - : _algorithm(&algorithm) - { - _index = _algorithm->_blossom_potential[variable].begin; - _last = _algorithm->_blossom_potential[variable].end; - } - - /// \brief Conversion to node. - /// - /// Conversion to node. - operator Node() const { - return _algorithm->_blossom_node_list[_index]; - } - - /// \brief Increment operator. - /// - /// Increment operator. - BlossomIt& operator++() { - ++_index; - return *this; - } - - /// \brief Validity checking - /// - /// Checks whether the iterator is invalid. - bool operator==(Invalid) const { return _index == _last; } - - /// \brief Validity checking - /// - /// Checks whether the iterator is valid. - bool operator!=(Invalid) const { return _index != _last; } - - private: - const MaxWeightedMatching* _algorithm; - int _last; - int _index; - }; - - /// @} - - }; - - /// \ingroup matching - /// - /// \brief Weighted perfect matching in general graphs - /// - /// This class provides an efficient implementation of Edmond's - /// maximum weighted perfect matching algorithm. The implementation - /// is based on extensive use of priority queues and provides - /// \f$O(nm\log(n))\f$ time complexity. - /// - /// The maximum weighted matching problem is to find undirected - /// edges in the graph with maximum overall weight and no two of - /// them shares their ends and covers all nodes. The problem can be - /// formulated with the following linear program. - /// \f[ \sum_{e \in \delta(u)}x_e = 1 \quad \forall u\in V\f] - /** \f[ \sum_{e \in \gamma(B)}x_e \le \frac{\vert B \vert - 1}{2} - \quad \forall B\in\mathcal{O}\f] */ - /// \f[x_e \ge 0\quad \forall e\in E\f] - /// \f[\max \sum_{e\in E}x_ew_e\f] - /// where \f$\delta(X)\f$ is the set of edges incident to a node in - /// \f$X\f$, \f$\gamma(X)\f$ is the set of edges with both ends in - /// \f$X\f$ and \f$\mathcal{O}\f$ is the set of odd cardinality - /// subsets of the nodes. - /// - /// The algorithm calculates an optimal matching and a proof of the - /// optimality. The solution of the dual problem can be used to check - /// the result of the algorithm. The dual linear problem is the - /** \f[ y_u + y_v + \sum_{B \in \mathcal{O}, uv \in \gamma(B)}z_B \ge - w_{uv} \quad \forall uv\in E\f] */ - /// \f[z_B \ge 0 \quad \forall B \in \mathcal{O}\f] - /** \f[\min \sum_{u \in V}y_u + \sum_{B \in \mathcal{O}} - \frac{\vert B \vert - 1}{2}z_B\f] */ - /// - /// The algorithm can be executed with \c run() or the \c init() and - /// then the \c start() member functions. After it the matching can - /// be asked with \c matching() or mate() functions. The dual - /// solution can be get with \c nodeValue(), \c blossomNum() and \c - /// blossomValue() members and \ref MaxWeightedMatching::BlossomIt - /// "BlossomIt" nested class which is able to iterate on the nodes - /// of a blossom. If the value type is integral then the dual - /// solution is multiplied by \ref MaxWeightedMatching::dualScale "4". - template > - class MaxWeightedPerfectMatching { - public: - - typedef _Graph Graph; - typedef _WeightMap WeightMap; - typedef typename WeightMap::Value Value; - - /// \brief Scaling factor for dual solution - /// - /// Scaling factor for dual solution, it is equal to 4 or 1 - /// according to the value type. - static const int dualScale = - std::numeric_limits::is_integer ? 4 : 1; - - typedef typename Graph::template NodeMap - MatchingMap; - - private: - - TEMPLATE_GRAPH_TYPEDEFS(Graph); - - typedef typename Graph::template NodeMap NodePotential; - typedef std::vector BlossomNodeList; - - struct BlossomVariable { - int begin, end; - Value value; - - BlossomVariable(int _begin, int _end, Value _value) - : begin(_begin), end(_end), value(_value) {} - - }; - - typedef std::vector BlossomPotential; - - const Graph& _graph; - const WeightMap& _weight; - - MatchingMap* _matching; - - NodePotential* _node_potential; - - BlossomPotential _blossom_potential; - BlossomNodeList _blossom_node_list; - - int _node_num; - int _blossom_num; - - typedef RangeMap IntIntMap; - - enum Status { - EVEN = -1, MATCHED = 0, ODD = 1 - }; - - typedef HeapUnionFind BlossomSet; - struct BlossomData { - int tree; - Status status; - Arc pred, next; - Value pot, offset; - }; - - IntNodeMap *_blossom_index; - BlossomSet *_blossom_set; - RangeMap* _blossom_data; - - IntNodeMap *_node_index; - IntArcMap *_node_heap_index; - - struct NodeData { - - NodeData(IntArcMap& node_heap_index) - : heap(node_heap_index) {} - - int blossom; - Value pot; - BinHeap heap; - std::map heap_index; - - int tree; - }; - - RangeMap* _node_data; - - typedef ExtendFindEnum TreeSet; - - IntIntMap *_tree_set_index; - TreeSet *_tree_set; - - IntIntMap *_delta2_index; - BinHeap *_delta2; - - IntEdgeMap *_delta3_index; - BinHeap *_delta3; - - IntIntMap *_delta4_index; - BinHeap *_delta4; - - Value _delta_sum; - - void createStructures() { - _node_num = countNodes(_graph); - _blossom_num = _node_num * 3 / 2; - - if (!_matching) { - _matching = new MatchingMap(_graph); - } - if (!_node_potential) { - _node_potential = new NodePotential(_graph); - } - if (!_blossom_set) { - _blossom_index = new IntNodeMap(_graph); - _blossom_set = new BlossomSet(*_blossom_index); - _blossom_data = new RangeMap(_blossom_num); - } - - if (!_node_index) { - _node_index = new IntNodeMap(_graph); - _node_heap_index = new IntArcMap(_graph); - _node_data = new RangeMap(_node_num, - NodeData(*_node_heap_index)); - } - - if (!_tree_set) { - _tree_set_index = new IntIntMap(_blossom_num); - _tree_set = new TreeSet(*_tree_set_index); - } - if (!_delta2) { - _delta2_index = new IntIntMap(_blossom_num); - _delta2 = new BinHeap(*_delta2_index); - } - if (!_delta3) { - _delta3_index = new IntEdgeMap(_graph); - _delta3 = new BinHeap(*_delta3_index); - } - if (!_delta4) { - _delta4_index = new IntIntMap(_blossom_num); - _delta4 = new BinHeap(*_delta4_index); - } - } - - void destroyStructures() { - _node_num = countNodes(_graph); - _blossom_num = _node_num * 3 / 2; - - if (_matching) { - delete _matching; - } - if (_node_potential) { - delete _node_potential; - } - if (_blossom_set) { - delete _blossom_index; - delete _blossom_set; - delete _blossom_data; - } - - if (_node_index) { - delete _node_index; - delete _node_heap_index; - delete _node_data; - } - - if (_tree_set) { - delete _tree_set_index; - delete _tree_set; - } - if (_delta2) { - delete _delta2_index; - delete _delta2; - } - if (_delta3) { - delete _delta3_index; - delete _delta3; - } - if (_delta4) { - delete _delta4_index; - delete _delta4; - } - } - - void matchedToEven(int blossom, int tree) { - if (_delta2->state(blossom) == _delta2->IN_HEAP) { - _delta2->erase(blossom); - } - - if (!_blossom_set->trivial(blossom)) { - (*_blossom_data)[blossom].pot -= - 2 * (_delta_sum - (*_blossom_data)[blossom].offset); - } - - for (typename BlossomSet::ItemIt n(*_blossom_set, blossom); - n != INVALID; ++n) { - - _blossom_set->increase(n, std::numeric_limits::max()); - int ni = (*_node_index)[n]; - - (*_node_data)[ni].heap.clear(); - (*_node_data)[ni].heap_index.clear(); - - (*_node_data)[ni].pot += _delta_sum - (*_blossom_data)[blossom].offset; - - for (InArcIt e(_graph, n); e != INVALID; ++e) { - Node v = _graph.source(e); - int vb = _blossom_set->find(v); - int vi = (*_node_index)[v]; - - Value rw = (*_node_data)[ni].pot + (*_node_data)[vi].pot - - dualScale * _weight[e]; - - if ((*_blossom_data)[vb].status == EVEN) { - if (_delta3->state(e) != _delta3->IN_HEAP && blossom != vb) { - _delta3->push(e, rw / 2); - } - } else { - typename std::map::iterator it = - (*_node_data)[vi].heap_index.find(tree); - - if (it != (*_node_data)[vi].heap_index.end()) { - if ((*_node_data)[vi].heap[it->second] > rw) { - (*_node_data)[vi].heap.replace(it->second, e); - (*_node_data)[vi].heap.decrease(e, rw); - it->second = e; - } - } else { - (*_node_data)[vi].heap.push(e, rw); - (*_node_data)[vi].heap_index.insert(std::make_pair(tree, e)); - } - - if ((*_blossom_set)[v] > (*_node_data)[vi].heap.prio()) { - _blossom_set->decrease(v, (*_node_data)[vi].heap.prio()); - - if ((*_blossom_data)[vb].status == MATCHED) { - if (_delta2->state(vb) != _delta2->IN_HEAP) { - _delta2->push(vb, _blossom_set->classPrio(vb) - - (*_blossom_data)[vb].offset); - } else if ((*_delta2)[vb] > _blossom_set->classPrio(vb) - - (*_blossom_data)[vb].offset){ - _delta2->decrease(vb, _blossom_set->classPrio(vb) - - (*_blossom_data)[vb].offset); - } - } - } - } - } - } - (*_blossom_data)[blossom].offset = 0; - } - - void matchedToOdd(int blossom) { - if (_delta2->state(blossom) == _delta2->IN_HEAP) { - _delta2->erase(blossom); - } - (*_blossom_data)[blossom].offset += _delta_sum; - if (!_blossom_set->trivial(blossom)) { - _delta4->push(blossom, (*_blossom_data)[blossom].pot / 2 + - (*_blossom_data)[blossom].offset); - } - } - - void evenToMatched(int blossom, int tree) { - if (!_blossom_set->trivial(blossom)) { - (*_blossom_data)[blossom].pot += 2 * _delta_sum; - } - - for (typename BlossomSet::ItemIt n(*_blossom_set, blossom); - n != INVALID; ++n) { - int ni = (*_node_index)[n]; - (*_node_data)[ni].pot -= _delta_sum; - - for (InArcIt e(_graph, n); e != INVALID; ++e) { - Node v = _graph.source(e); - int vb = _blossom_set->find(v); - int vi = (*_node_index)[v]; - - Value rw = (*_node_data)[ni].pot + (*_node_data)[vi].pot - - dualScale * _weight[e]; - - if (vb == blossom) { - if (_delta3->state(e) == _delta3->IN_HEAP) { - _delta3->erase(e); - } - } else if ((*_blossom_data)[vb].status == EVEN) { - - if (_delta3->state(e) == _delta3->IN_HEAP) { - _delta3->erase(e); - } - - int vt = _tree_set->find(vb); - - if (vt != tree) { - - Arc r = _graph.oppositeArc(e); - - typename std::map::iterator it = - (*_node_data)[ni].heap_index.find(vt); - - if (it != (*_node_data)[ni].heap_index.end()) { - if ((*_node_data)[ni].heap[it->second] > rw) { - (*_node_data)[ni].heap.replace(it->second, r); - (*_node_data)[ni].heap.decrease(r, rw); - it->second = r; - } - } else { - (*_node_data)[ni].heap.push(r, rw); - (*_node_data)[ni].heap_index.insert(std::make_pair(vt, r)); - } - - if ((*_blossom_set)[n] > (*_node_data)[ni].heap.prio()) { - _blossom_set->decrease(n, (*_node_data)[ni].heap.prio()); - - if (_delta2->state(blossom) != _delta2->IN_HEAP) { - _delta2->push(blossom, _blossom_set->classPrio(blossom) - - (*_blossom_data)[blossom].offset); - } else if ((*_delta2)[blossom] > - _blossom_set->classPrio(blossom) - - (*_blossom_data)[blossom].offset){ - _delta2->decrease(blossom, _blossom_set->classPrio(blossom) - - (*_blossom_data)[blossom].offset); - } - } - } - } else { - - typename std::map::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; - - 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; - } - } else { - (*_node_data)[vi].heap.push(e, rw); - (*_node_data)[vi].heap_index.insert(std::make_pair(tree, e)); - } - - if ((*_blossom_set)[v] > (*_node_data)[vi].heap.prio()) { - _blossom_set->decrease(v, (*_node_data)[vi].heap.prio()); - - if ((*_blossom_data)[vb].status == MATCHED) { - if (_delta2->state(vb) != _delta2->IN_HEAP) { - _delta2->push(vb, _blossom_set->classPrio(vb) - - (*_blossom_data)[vb].offset); - } else if ((*_delta2)[vb] > _blossom_set->classPrio(vb) - - (*_blossom_data)[vb].offset) { - _delta2->decrease(vb, _blossom_set->classPrio(vb) - - (*_blossom_data)[vb].offset); - } - } - } - } - } - } - (*_blossom_data)[blossom].offset = 0; - } - - void alternatePath(int even, int tree) { - int odd; - - evenToMatched(even, tree); - (*_blossom_data)[even].status = MATCHED; - - while ((*_blossom_data)[even].pred != INVALID) { - odd = _blossom_set->find(_graph.target((*_blossom_data)[even].pred)); - (*_blossom_data)[odd].status = MATCHED; - oddToMatched(odd); - (*_blossom_data)[odd].next = (*_blossom_data)[odd].pred; - - even = _blossom_set->find(_graph.target((*_blossom_data)[odd].pred)); - (*_blossom_data)[even].status = MATCHED; - evenToMatched(even, tree); - (*_blossom_data)[even].next = - _graph.oppositeArc((*_blossom_data)[odd].pred); - } - - } - - void destroyTree(int tree) { - for (TreeSet::ItemIt b(*_tree_set, tree); b != INVALID; ++b) { - if ((*_blossom_data)[b].status == EVEN) { - (*_blossom_data)[b].status = MATCHED; - evenToMatched(b, tree); - } else if ((*_blossom_data)[b].status == ODD) { - (*_blossom_data)[b].status = MATCHED; - oddToMatched(b); - } - } - _tree_set->eraseClass(tree); - } - - void augmentOnEdge(const Edge& edge) { - - int left = _blossom_set->find(_graph.u(edge)); - int right = _blossom_set->find(_graph.v(edge)); - - int left_tree = _tree_set->find(left); - alternatePath(left, left_tree); - destroyTree(left_tree); - - int right_tree = _tree_set->find(right); - alternatePath(right, right_tree); - destroyTree(right_tree); - - (*_blossom_data)[left].next = _graph.direct(edge, true); - (*_blossom_data)[right].next = _graph.direct(edge, false); - } - - void extendOnArc(const Arc& arc) { - int base = _blossom_set->find(_graph.target(arc)); - int tree = _tree_set->find(base); - - int odd = _blossom_set->find(_graph.source(arc)); - _tree_set->insert(odd, tree); - (*_blossom_data)[odd].status = ODD; - matchedToOdd(odd); - (*_blossom_data)[odd].pred = arc; - - int even = _blossom_set->find(_graph.target((*_blossom_data)[odd].next)); - (*_blossom_data)[even].pred = (*_blossom_data)[even].next; - _tree_set->insert(even, tree); - (*_blossom_data)[even].status = EVEN; - matchedToEven(even, tree); - } - - void shrinkOnEdge(const Edge& edge, int tree) { - int nca = -1; - std::vector left_path, right_path; - - { - std::set left_set, right_set; - int left = _blossom_set->find(_graph.u(edge)); - left_path.push_back(left); - left_set.insert(left); - - int right = _blossom_set->find(_graph.v(edge)); - right_path.push_back(right); - right_set.insert(right); - - while (true) { - - if ((*_blossom_data)[left].pred == INVALID) break; - - left = - _blossom_set->find(_graph.target((*_blossom_data)[left].pred)); - left_path.push_back(left); - left = - _blossom_set->find(_graph.target((*_blossom_data)[left].pred)); - left_path.push_back(left); - - left_set.insert(left); - - if (right_set.find(left) != right_set.end()) { - nca = left; - break; - } - - if ((*_blossom_data)[right].pred == INVALID) break; - - right = - _blossom_set->find(_graph.target((*_blossom_data)[right].pred)); - right_path.push_back(right); - right = - _blossom_set->find(_graph.target((*_blossom_data)[right].pred)); - right_path.push_back(right); - - right_set.insert(right); - - if (left_set.find(right) != left_set.end()) { - nca = right; - break; - } - - } - - if (nca == -1) { - if ((*_blossom_data)[left].pred == INVALID) { - nca = right; - while (left_set.find(nca) == left_set.end()) { - nca = - _blossom_set->find(_graph.target((*_blossom_data)[nca].pred)); - right_path.push_back(nca); - nca = - _blossom_set->find(_graph.target((*_blossom_data)[nca].pred)); - right_path.push_back(nca); - } - } else { - nca = left; - while (right_set.find(nca) == right_set.end()) { - nca = - _blossom_set->find(_graph.target((*_blossom_data)[nca].pred)); - left_path.push_back(nca); - nca = - _blossom_set->find(_graph.target((*_blossom_data)[nca].pred)); - left_path.push_back(nca); - } - } - } - } - - std::vector subblossoms; - Arc prev; - - prev = _graph.direct(edge, true); - for (int i = 0; left_path[i] != nca; i += 2) { - subblossoms.push_back(left_path[i]); - (*_blossom_data)[left_path[i]].next = prev; - _tree_set->erase(left_path[i]); - - subblossoms.push_back(left_path[i + 1]); - (*_blossom_data)[left_path[i + 1]].status = EVEN; - oddToEven(left_path[i + 1], tree); - _tree_set->erase(left_path[i + 1]); - prev = _graph.oppositeArc((*_blossom_data)[left_path[i + 1]].pred); - } - - int k = 0; - while (right_path[k] != nca) ++k; - - subblossoms.push_back(nca); - (*_blossom_data)[nca].next = prev; - - for (int i = k - 2; i >= 0; i -= 2) { - subblossoms.push_back(right_path[i + 1]); - (*_blossom_data)[right_path[i + 1]].status = EVEN; - oddToEven(right_path[i + 1], tree); - _tree_set->erase(right_path[i + 1]); - - (*_blossom_data)[right_path[i + 1]].next = - (*_blossom_data)[right_path[i + 1]].pred; - - subblossoms.push_back(right_path[i]); - _tree_set->erase(right_path[i]); - } - - int surface = - _blossom_set->join(subblossoms.begin(), subblossoms.end()); - - for (int i = 0; i < int(subblossoms.size()); ++i) { - if (!_blossom_set->trivial(subblossoms[i])) { - (*_blossom_data)[subblossoms[i]].pot += 2 * _delta_sum; - } - (*_blossom_data)[subblossoms[i]].status = MATCHED; - } - - (*_blossom_data)[surface].pot = -2 * _delta_sum; - (*_blossom_data)[surface].offset = 0; - (*_blossom_data)[surface].status = EVEN; - (*_blossom_data)[surface].pred = (*_blossom_data)[nca].pred; - (*_blossom_data)[surface].next = (*_blossom_data)[nca].pred; - - _tree_set->insert(surface, tree); - _tree_set->erase(nca); - } - - void splitBlossom(int blossom) { - Arc next = (*_blossom_data)[blossom].next; - Arc pred = (*_blossom_data)[blossom].pred; - - int tree = _tree_set->find(blossom); - - (*_blossom_data)[blossom].status = MATCHED; - oddToMatched(blossom); - if (_delta2->state(blossom) == _delta2->IN_HEAP) { - _delta2->erase(blossom); - } - - std::vector subblossoms; - _blossom_set->split(blossom, std::back_inserter(subblossoms)); - - Value offset = (*_blossom_data)[blossom].offset; - int b = _blossom_set->find(_graph.source(pred)); - int d = _blossom_set->find(_graph.source(next)); - - int ib = -1, id = -1; - for (int i = 0; i < int(subblossoms.size()); ++i) { - if (subblossoms[i] == b) ib = i; - if (subblossoms[i] == d) id = i; - - (*_blossom_data)[subblossoms[i]].offset = offset; - if (!_blossom_set->trivial(subblossoms[i])) { - (*_blossom_data)[subblossoms[i]].pot -= 2 * offset; - } - if (_blossom_set->classPrio(subblossoms[i]) != - std::numeric_limits::max()) { - _delta2->push(subblossoms[i], - _blossom_set->classPrio(subblossoms[i]) - - (*_blossom_data)[subblossoms[i]].offset); - } - } - - if (id > ib ? ((id - ib) % 2 == 0) : ((ib - id) % 2 == 1)) { - for (int i = (id + 1) % subblossoms.size(); - i != ib; i = (i + 2) % subblossoms.size()) { - int sb = subblossoms[i]; - int tb = subblossoms[(i + 1) % subblossoms.size()]; - (*_blossom_data)[sb].next = - _graph.oppositeArc((*_blossom_data)[tb].next); - } - - for (int i = ib; i != id; i = (i + 2) % subblossoms.size()) { - int sb = subblossoms[i]; - int tb = subblossoms[(i + 1) % subblossoms.size()]; - int ub = subblossoms[(i + 2) % subblossoms.size()]; - - (*_blossom_data)[sb].status = ODD; - matchedToOdd(sb); - _tree_set->insert(sb, tree); - (*_blossom_data)[sb].pred = pred; - (*_blossom_data)[sb].next = - _graph.oppositeArc((*_blossom_data)[tb].next); - - pred = (*_blossom_data)[ub].next; - - (*_blossom_data)[tb].status = EVEN; - matchedToEven(tb, tree); - _tree_set->insert(tb, tree); - (*_blossom_data)[tb].pred = (*_blossom_data)[tb].next; - } - - (*_blossom_data)[subblossoms[id]].status = ODD; - matchedToOdd(subblossoms[id]); - _tree_set->insert(subblossoms[id], tree); - (*_blossom_data)[subblossoms[id]].next = next; - (*_blossom_data)[subblossoms[id]].pred = pred; - - } else { - - for (int i = (ib + 1) % subblossoms.size(); - i != id; i = (i + 2) % subblossoms.size()) { - int sb = subblossoms[i]; - int tb = subblossoms[(i + 1) % subblossoms.size()]; - (*_blossom_data)[sb].next = - _graph.oppositeArc((*_blossom_data)[tb].next); - } - - for (int i = id; i != ib; i = (i + 2) % subblossoms.size()) { - int sb = subblossoms[i]; - int tb = subblossoms[(i + 1) % subblossoms.size()]; - int ub = subblossoms[(i + 2) % subblossoms.size()]; - - (*_blossom_data)[sb].status = ODD; - matchedToOdd(sb); - _tree_set->insert(sb, tree); - (*_blossom_data)[sb].next = next; - (*_blossom_data)[sb].pred = - _graph.oppositeArc((*_blossom_data)[tb].next); - - (*_blossom_data)[tb].status = EVEN; - matchedToEven(tb, tree); - _tree_set->insert(tb, tree); - (*_blossom_data)[tb].pred = - (*_blossom_data)[tb].next = - _graph.oppositeArc((*_blossom_data)[ub].next); - next = (*_blossom_data)[ub].next; - } - - (*_blossom_data)[subblossoms[ib]].status = ODD; - matchedToOdd(subblossoms[ib]); - _tree_set->insert(subblossoms[ib], tree); - (*_blossom_data)[subblossoms[ib]].next = next; - (*_blossom_data)[subblossoms[ib]].pred = pred; - } - _tree_set->erase(blossom); - } - - void extractBlossom(int blossom, const Node& base, const Arc& matching) { - if (_blossom_set->trivial(blossom)) { - int bi = (*_node_index)[base]; - Value pot = (*_node_data)[bi].pot; - - _matching->set(base, matching); - _blossom_node_list.push_back(base); - _node_potential->set(base, pot); - } else { - - Value pot = (*_blossom_data)[blossom].pot; - int bn = _blossom_node_list.size(); - - std::vector subblossoms; - _blossom_set->split(blossom, std::back_inserter(subblossoms)); - int b = _blossom_set->find(base); - int ib = -1; - for (int i = 0; i < int(subblossoms.size()); ++i) { - if (subblossoms[i] == b) { ib = i; break; } - } - - for (int i = 1; i < int(subblossoms.size()); i += 2) { - int sb = subblossoms[(ib + i) % subblossoms.size()]; - int tb = subblossoms[(ib + i + 1) % subblossoms.size()]; - - Arc m = (*_blossom_data)[tb].next; - extractBlossom(sb, _graph.target(m), _graph.oppositeArc(m)); - extractBlossom(tb, _graph.source(m), m); - } - extractBlossom(subblossoms[ib], base, matching); - - int en = _blossom_node_list.size(); - - _blossom_potential.push_back(BlossomVariable(bn, en, pot)); - } - } - - void extractMatching() { - std::vector blossoms; - for (typename BlossomSet::ClassIt c(*_blossom_set); c != INVALID; ++c) { - blossoms.push_back(c); - } - - for (int i = 0; i < int(blossoms.size()); ++i) { - - Value offset = (*_blossom_data)[blossoms[i]].offset; - (*_blossom_data)[blossoms[i]].pot += 2 * offset; - for (typename BlossomSet::ItemIt n(*_blossom_set, blossoms[i]); - n != INVALID; ++n) { - (*_node_data)[(*_node_index)[n]].pot -= offset; - } - - Arc matching = (*_blossom_data)[blossoms[i]].next; - Node base = _graph.source(matching); - extractBlossom(blossoms[i], base, matching); - } - } - - public: - - /// \brief Constructor - /// - /// Constructor. - MaxWeightedPerfectMatching(const Graph& graph, const WeightMap& weight) - : _graph(graph), _weight(weight), _matching(0), - _node_potential(0), _blossom_potential(), _blossom_node_list(), - _node_num(0), _blossom_num(0), - - _blossom_index(0), _blossom_set(0), _blossom_data(0), - _node_index(0), _node_heap_index(0), _node_data(0), - _tree_set_index(0), _tree_set(0), - - _delta2_index(0), _delta2(0), - _delta3_index(0), _delta3(0), - _delta4_index(0), _delta4(0), - - _delta_sum() {} - - ~MaxWeightedPerfectMatching() { - destroyStructures(); - } - - /// \name Execution control - /// The simplest way to execute the algorithm is to use the - /// \c run() member function. - - ///@{ - - /// \brief Initialize the algorithm - /// - /// Initialize the algorithm - void init() { - createStructures(); - - for (ArcIt e(_graph); e != INVALID; ++e) { - _node_heap_index->set(e, BinHeap::PRE_HEAP); - } - for (EdgeIt e(_graph); e != INVALID; ++e) { - _delta3_index->set(e, _delta3->PRE_HEAP); - } - for (int i = 0; i < _blossom_num; ++i) { - _delta2_index->set(i, _delta2->PRE_HEAP); - _delta4_index->set(i, _delta4->PRE_HEAP); - } - - int index = 0; - 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) continue; - if ((dualScale * _weight[e]) / 2 > max) { - max = (dualScale * _weight[e]) / 2; - } - } - _node_index->set(n, index); - (*_node_data)[index].pot = max; - int blossom = - _blossom_set->insert(n, std::numeric_limits::max()); - - _tree_set->insert(blossom); - - (*_blossom_data)[blossom].status = EVEN; - (*_blossom_data)[blossom].pred = INVALID; - (*_blossom_data)[blossom].next = INVALID; - (*_blossom_data)[blossom].pot = 0; - (*_blossom_data)[blossom].offset = 0; - ++index; - } - for (EdgeIt e(_graph); e != INVALID; ++e) { - int si = (*_node_index)[_graph.u(e)]; - int ti = (*_node_index)[_graph.v(e)]; - if (_graph.u(e) != _graph.v(e)) { - _delta3->push(e, ((*_node_data)[si].pot + (*_node_data)[ti].pot - - dualScale * _weight[e]) / 2); - } - } - } - - /// \brief Starts the algorithm - /// - /// Starts the algorithm - bool start() { - enum OpType { - D2, D3, D4 - }; - - 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(); - - Value d4 = !_delta4->empty() ? - _delta4->prio() : std::numeric_limits::max(); - - _delta_sum = d2; OpType ot = D2; - if (d3 < _delta_sum) { _delta_sum = d3; ot = D3; } - if (d4 < _delta_sum) { _delta_sum = d4; ot = D4; } - - if (_delta_sum == std::numeric_limits::max()) { - return false; - } - - switch (ot) { - case D2: - { - int blossom = _delta2->top(); - Node n = _blossom_set->classTop(blossom); - Arc e = (*_node_data)[(*_node_index)[n]].heap.top(); - extendOnArc(e); - } - break; - case D3: - { - Edge e = _delta3->top(); - - int left_blossom = _blossom_set->find(_graph.u(e)); - int right_blossom = _blossom_set->find(_graph.v(e)); - - if (left_blossom == right_blossom) { - _delta3->pop(); - } else { - int left_tree = _tree_set->find(left_blossom); - int right_tree = _tree_set->find(right_blossom); - - if (left_tree == right_tree) { - shrinkOnEdge(e, left_tree); - } else { - augmentOnEdge(e); - unmatched -= 2; - } - } - } break; - case D4: - splitBlossom(_delta4->top()); - break; - } - } - extractMatching(); - return true; - } - - /// \brief Runs %MaxWeightedPerfectMatching algorithm. - /// - /// This method runs the %MaxWeightedPerfectMatching algorithm. - /// - /// \note mwm.run() is just a shortcut of the following code. - /// \code - /// mwm.init(); - /// mwm.start(); - /// \endcode - bool run() { - init(); - return start(); - } - - /// @} - - /// \name Primal solution - /// Functions to get the primal solution, ie. the matching. - - /// @{ - - /// \brief Returns the matching value. - /// - /// Returns the matching value. - Value matchingValue() const { - Value sum = 0; - for (NodeIt n(_graph); n != INVALID; ++n) { - if ((*_matching)[n] != INVALID) { - sum += _weight[(*_matching)[n]]; - } - } - return sum /= 2; - } - - /// \brief Returns true when the edge is in the matching. - /// - /// Returns true when the edge is in the matching. - bool matching(const Edge& edge) const { - return static_cast((*_matching)[_graph.u(edge)]) == edge; - } - - /// \brief Returns the incident matching edge. - /// - /// Returns the incident matching arc from given edge. - Arc matching(const Node& node) const { - return (*_matching)[node]; - } - - /// \brief Returns the mate of the node. - /// - /// Returns the adjancent node in a mathcing arc. - Node mate(const Node& node) const { - return _graph.target((*_matching)[node]); - } - - /// @} - - /// \name Dual solution - /// Functions to get the dual solution. - - /// @{ - - /// \brief Returns the value of the dual solution. - /// - /// Returns the value of the dual solution. It should be equal to - /// the primal value scaled by \ref dualScale "dual scale". - Value dualValue() const { - Value sum = 0; - for (NodeIt n(_graph); n != INVALID; ++n) { - sum += nodeValue(n); - } - for (int i = 0; i < blossomNum(); ++i) { - sum += blossomValue(i) * (blossomSize(i) / 2); - } - return sum; - } - - /// \brief Returns the value of the node. - /// - /// Returns the the value of the node. - Value nodeValue(const Node& n) const { - return (*_node_potential)[n]; - } - - /// \brief Returns the number of the blossoms in the basis. - /// - /// Returns the number of the blossoms in the basis. - /// \see BlossomIt - int blossomNum() const { - return _blossom_potential.size(); - } - - - /// \brief Returns the number of the nodes in the blossom. - /// - /// Returns the number of the nodes in the blossom. - int blossomSize(int k) const { - return _blossom_potential[k].end - _blossom_potential[k].begin; - } - - /// \brief Returns the value of the blossom. - /// - /// Returns the the value of the blossom. - /// \see BlossomIt - Value blossomValue(int k) const { - return _blossom_potential[k].value; - } - - /// \brief Iterator for obtaining the nodes of the blossom. - /// - /// Iterator for obtaining the nodes of the blossom. This class - /// provides a common lemon style iterator for listing a - /// subset of the nodes. - class BlossomIt { - public: - - /// \brief Constructor. - /// - /// Constructor to get the nodes of the variable. - BlossomIt(const MaxWeightedPerfectMatching& algorithm, int variable) - : _algorithm(&algorithm) - { - _index = _algorithm->_blossom_potential[variable].begin; - _last = _algorithm->_blossom_potential[variable].end; - } - - /// \brief Conversion to node. - /// - /// Conversion to node. - operator Node() const { - return _algorithm->_blossom_node_list[_index]; - } - - /// \brief Increment operator. - /// - /// Increment operator. - BlossomIt& operator++() { - ++_index; - return *this; - } - - /// \brief Validity checking - /// - /// Checks whether the iterator is invalid. - bool operator==(Invalid) const { return _index == _last; } - - /// \brief Validity checking - /// - /// Checks whether the iterator is valid. - bool operator!=(Invalid) const { return _index != _last; } - - private: - const MaxWeightedPerfectMatching* _algorithm; - int _last; - int _index; - }; - - /// @} - - }; - - -} //END OF NAMESPACE LEMON - -#endif //LEMON_MAX_MATCHING_H diff -r c35afa9e89e7 -r ef88c0a30f85 lemon/min_cost_arborescence.h --- /dev/null Thu Jan 01 00:00:00 1970 +0000 +++ b/lemon/min_cost_arborescence.h Thu Nov 05 15:48:01 2009 +0100 @@ -0,0 +1,807 @@ +/* -*- mode: C++; indent-tabs-mode: nil; -*- + * + * This file is a part of LEMON, a generic C++ optimization library. + * + * Copyright (C) 2003-2008 + * Egervary Jeno Kombinatorikus Optimalizalasi Kutatocsoport + * (Egervary Research Group on Combinatorial Optimization, EGRES). + * + * Permission to use, modify and distribute this software is granted + * provided that this copyright notice appears in all copies. For + * precise terms see the accompanying LICENSE file. + * + * This software is provided "AS IS" with no warranty of any kind, + * express or implied, and with no claim as to its suitability for any + * purpose. + * + */ + +#ifndef LEMON_MIN_COST_ARBORESCENCE_H +#define LEMON_MIN_COST_ARBORESCENCE_H + +///\ingroup spantree +///\file +///\brief Minimum Cost Arborescence algorithm. + +#include + +#include +#include +#include + +namespace lemon { + + + /// \brief Default traits class for MinCostArborescence class. + /// + /// Default traits class for MinCostArborescence class. + /// \param GR Digraph type. + /// \param CM Type of the cost map. + template + struct MinCostArborescenceDefaultTraits{ + + /// \brief The digraph type the algorithm runs on. + typedef GR Digraph; + + /// \brief The type of the map that stores the arc costs. + /// + /// The type of the map that stores the arc costs. + /// It must conform to the \ref concepts::ReadMap "ReadMap" concept. + typedef CM CostMap; + + /// \brief The value type of the costs. + /// + /// The value type of the costs. + typedef typename CostMap::Value Value; + + /// \brief The type of the map that stores which arcs are in the + /// arborescence. + /// + /// The type of the map that stores which arcs are in the + /// arborescence. It must conform to the \ref concepts::WriteMap + /// "WriteMap" concept, and its value type must be \c bool + /// (or convertible). Initially it will be set to \c false on each + /// arc, then it will be set on each arborescence arc once. + typedef typename Digraph::template ArcMap ArborescenceMap; + + /// \brief Instantiates a \c ArborescenceMap. + /// + /// This function instantiates a \c ArborescenceMap. + /// \param digraph The digraph to which we would like to calculate + /// the \c ArborescenceMap. + static ArborescenceMap *createArborescenceMap(const Digraph &digraph){ + return new ArborescenceMap(digraph); + } + + /// \brief The type of the \c PredMap + /// + /// The type of the \c PredMap. It must confrom to the + /// \ref concepts::WriteMap "WriteMap" concept, and its value type + /// must be the \c Arc type of the digraph. + typedef typename Digraph::template NodeMap PredMap; + + /// \brief Instantiates a \c PredMap. + /// + /// This function instantiates a \c PredMap. + /// \param digraph The digraph to which we would like to define the + /// \c PredMap. + static PredMap *createPredMap(const Digraph &digraph){ + return new PredMap(digraph); + } + + }; + + /// \ingroup spantree + /// + /// \brief Minimum Cost Arborescence algorithm class. + /// + /// This class provides an efficient implementation of the + /// Minimum Cost Arborescence algorithm. The arborescence is a tree + /// which is directed from a given source node of the digraph. One or + /// more sources should be given to the algorithm and it will calculate + /// the minimum cost subgraph that is the union of arborescences with the + /// given sources and spans all the nodes which are reachable from the + /// sources. The time complexity of the algorithm is O(n2+e). + /// + /// The algorithm also provides an optimal dual solution, therefore + /// the optimality of the solution can be checked. + /// + /// \param GR The digraph type the algorithm runs on. + /// \param CM A read-only arc map storing the costs of the + /// arcs. It is read once for each arc, so the map may involve in + /// relatively time consuming process to compute the arc costs if + /// it is necessary. The default map type is \ref + /// concepts::Digraph::ArcMap "Digraph::ArcMap". + /// \param TR Traits class to set various data types used + /// by the algorithm. The default traits class is + /// \ref MinCostArborescenceDefaultTraits + /// "MinCostArborescenceDefaultTraits". +#ifndef DOXYGEN + template , + typename TR = + MinCostArborescenceDefaultTraits > +#else + template +#endif + class MinCostArborescence { + public: + + /// \brief The \ref MinCostArborescenceDefaultTraits "traits class" + /// of the algorithm. + typedef TR Traits; + /// The type of the underlying digraph. + typedef typename Traits::Digraph Digraph; + /// The type of the map that stores the arc costs. + typedef typename Traits::CostMap CostMap; + ///The type of the costs of the arcs. + typedef typename Traits::Value Value; + ///The type of the predecessor map. + typedef typename Traits::PredMap PredMap; + ///The type of the map that stores which arcs are in the arborescence. + typedef typename Traits::ArborescenceMap ArborescenceMap; + + typedef MinCostArborescence Create; + + private: + + TEMPLATE_DIGRAPH_TYPEDEFS(Digraph); + + struct CostArc { + + Arc arc; + Value value; + + CostArc() {} + CostArc(Arc _arc, Value _value) : arc(_arc), value(_value) {} + + }; + + const Digraph *_digraph; + const CostMap *_cost; + + PredMap *_pred; + bool local_pred; + + ArborescenceMap *_arborescence; + bool local_arborescence; + + typedef typename Digraph::template ArcMap ArcOrder; + ArcOrder *_arc_order; + + typedef typename Digraph::template NodeMap NodeOrder; + NodeOrder *_node_order; + + typedef typename Digraph::template NodeMap CostArcMap; + CostArcMap *_cost_arcs; + + struct StackLevel { + + std::vector arcs; + int node_level; + + }; + + std::vector level_stack; + std::vector queue; + + typedef std::vector DualNodeList; + + DualNodeList _dual_node_list; + + struct DualVariable { + int begin, end; + Value value; + + DualVariable(int _begin, int _end, Value _value) + : begin(_begin), end(_end), value(_value) {} + + }; + + typedef std::vector DualVariables; + + DualVariables _dual_variables; + + typedef typename Digraph::template NodeMap HeapCrossRef; + + HeapCrossRef *_heap_cross_ref; + + typedef BinHeap Heap; + + Heap *_heap; + + protected: + + MinCostArborescence() {} + + private: + + void createStructures() { + if (!_pred) { + local_pred = true; + _pred = Traits::createPredMap(*_digraph); + } + if (!_arborescence) { + local_arborescence = true; + _arborescence = Traits::createArborescenceMap(*_digraph); + } + if (!_arc_order) { + _arc_order = new ArcOrder(*_digraph); + } + if (!_node_order) { + _node_order = new NodeOrder(*_digraph); + } + if (!_cost_arcs) { + _cost_arcs = new CostArcMap(*_digraph); + } + if (!_heap_cross_ref) { + _heap_cross_ref = new HeapCrossRef(*_digraph, -1); + } + if (!_heap) { + _heap = new Heap(*_heap_cross_ref); + } + } + + void destroyStructures() { + if (local_arborescence) { + delete _arborescence; + } + if (local_pred) { + delete _pred; + } + if (_arc_order) { + delete _arc_order; + } + if (_node_order) { + delete _node_order; + } + if (_cost_arcs) { + delete _cost_arcs; + } + if (_heap) { + delete _heap; + } + if (_heap_cross_ref) { + delete _heap_cross_ref; + } + } + + Arc prepare(Node node) { + std::vector nodes; + (*_node_order)[node] = _dual_node_list.size(); + StackLevel level; + level.node_level = _dual_node_list.size(); + _dual_node_list.push_back(node); + for (InArcIt it(*_digraph, node); it != INVALID; ++it) { + Arc arc = it; + Node source = _digraph->source(arc); + Value value = (*_cost)[it]; + if (source == node || (*_node_order)[source] == -3) continue; + if ((*_cost_arcs)[source].arc == INVALID) { + (*_cost_arcs)[source].arc = arc; + (*_cost_arcs)[source].value = value; + nodes.push_back(source); + } else { + if ((*_cost_arcs)[source].value > value) { + (*_cost_arcs)[source].arc = arc; + (*_cost_arcs)[source].value = value; + } + } + } + CostArc minimum = (*_cost_arcs)[nodes[0]]; + for (int i = 1; i < int(nodes.size()); ++i) { + if ((*_cost_arcs)[nodes[i]].value < minimum.value) { + minimum = (*_cost_arcs)[nodes[i]]; + } + } + (*_arc_order)[minimum.arc] = _dual_variables.size(); + DualVariable var(_dual_node_list.size() - 1, + _dual_node_list.size(), minimum.value); + _dual_variables.push_back(var); + for (int i = 0; i < int(nodes.size()); ++i) { + (*_cost_arcs)[nodes[i]].value -= minimum.value; + level.arcs.push_back((*_cost_arcs)[nodes[i]]); + (*_cost_arcs)[nodes[i]].arc = INVALID; + } + level_stack.push_back(level); + return minimum.arc; + } + + Arc contract(Node node) { + int node_bottom = bottom(node); + std::vector nodes; + while (!level_stack.empty() && + level_stack.back().node_level >= node_bottom) { + for (int i = 0; i < int(level_stack.back().arcs.size()); ++i) { + Arc arc = level_stack.back().arcs[i].arc; + Node source = _digraph->source(arc); + Value value = level_stack.back().arcs[i].value; + if ((*_node_order)[source] >= node_bottom) continue; + if ((*_cost_arcs)[source].arc == INVALID) { + (*_cost_arcs)[source].arc = arc; + (*_cost_arcs)[source].value = value; + nodes.push_back(source); + } else { + if ((*_cost_arcs)[source].value > value) { + (*_cost_arcs)[source].arc = arc; + (*_cost_arcs)[source].value = value; + } + } + } + level_stack.pop_back(); + } + CostArc minimum = (*_cost_arcs)[nodes[0]]; + for (int i = 1; i < int(nodes.size()); ++i) { + if ((*_cost_arcs)[nodes[i]].value < minimum.value) { + minimum = (*_cost_arcs)[nodes[i]]; + } + } + (*_arc_order)[minimum.arc] = _dual_variables.size(); + DualVariable var(node_bottom, _dual_node_list.size(), minimum.value); + _dual_variables.push_back(var); + StackLevel level; + level.node_level = node_bottom; + for (int i = 0; i < int(nodes.size()); ++i) { + (*_cost_arcs)[nodes[i]].value -= minimum.value; + level.arcs.push_back((*_cost_arcs)[nodes[i]]); + (*_cost_arcs)[nodes[i]].arc = INVALID; + } + level_stack.push_back(level); + return minimum.arc; + } + + int bottom(Node node) { + int k = level_stack.size() - 1; + while (level_stack[k].node_level > (*_node_order)[node]) { + --k; + } + return level_stack[k].node_level; + } + + void finalize(Arc arc) { + Node node = _digraph->target(arc); + _heap->push(node, (*_arc_order)[arc]); + _pred->set(node, arc); + while (!_heap->empty()) { + Node source = _heap->top(); + _heap->pop(); + (*_node_order)[source] = -1; + for (OutArcIt it(*_digraph, source); it != INVALID; ++it) { + if ((*_arc_order)[it] < 0) continue; + Node target = _digraph->target(it); + switch(_heap->state(target)) { + case Heap::PRE_HEAP: + _heap->push(target, (*_arc_order)[it]); + _pred->set(target, it); + break; + case Heap::IN_HEAP: + if ((*_arc_order)[it] < (*_heap)[target]) { + _heap->decrease(target, (*_arc_order)[it]); + _pred->set(target, it); + } + break; + case Heap::POST_HEAP: + break; + } + } + _arborescence->set((*_pred)[source], true); + } + } + + + public: + + /// \name Named Template Parameters + + /// @{ + + template + struct SetArborescenceMapTraits : public Traits { + typedef T ArborescenceMap; + static ArborescenceMap *createArborescenceMap(const Digraph &) + { + LEMON_ASSERT(false, "ArborescenceMap is not initialized"); + return 0; // ignore warnings + } + }; + + /// \brief \ref named-templ-param "Named parameter" for + /// setting \c ArborescenceMap type + /// + /// \ref named-templ-param "Named parameter" for setting + /// \c ArborescenceMap type. + /// It must conform to the \ref concepts::WriteMap "WriteMap" concept, + /// and its value type must be \c bool (or convertible). + /// Initially it will be set to \c false on each arc, + /// then it will be set on each arborescence arc once. + template + struct SetArborescenceMap + : public MinCostArborescence > { + }; + + 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 meet the \ref concepts::WriteMap "WriteMap" concept, + /// and its value type must be the \c Arc type of the digraph. + template + struct SetPredMap + : public MinCostArborescence > { + }; + + /// @} + + /// \brief Constructor. + /// + /// \param digraph The digraph the algorithm will run on. + /// \param cost The cost map used by the algorithm. + MinCostArborescence(const Digraph& digraph, const CostMap& cost) + : _digraph(&digraph), _cost(&cost), _pred(0), local_pred(false), + _arborescence(0), local_arborescence(false), + _arc_order(0), _node_order(0), _cost_arcs(0), + _heap_cross_ref(0), _heap(0) {} + + /// \brief Destructor. + ~MinCostArborescence() { + destroyStructures(); + } + + /// \brief Sets the arborescence map. + /// + /// Sets the arborescence map. + /// \return (*this) + MinCostArborescence& arborescenceMap(ArborescenceMap& m) { + if (local_arborescence) { + delete _arborescence; + } + local_arborescence = false; + _arborescence = &m; + return *this; + } + + /// \brief Sets the predecessor map. + /// + /// Sets the predecessor map. + /// \return (*this) + MinCostArborescence& predMap(PredMap& m) { + if (local_pred) { + delete _pred; + } + local_pred = false; + _pred = &m; + return *this; + } + + /// \name Execution Control + /// The simplest way to execute the algorithm is to use + /// one of the member functions called \c run(...). \n + /// If you need better control on the execution, + /// you have to call \ref init() first, then you can add several + /// source nodes with \ref addSource(). + /// Finally \ref start() will perform the arborescence + /// computation. + + ///@{ + + /// \brief Initializes the internal data structures. + /// + /// Initializes the internal data structures. + /// + void init() { + createStructures(); + _heap->clear(); + for (NodeIt it(*_digraph); it != INVALID; ++it) { + (*_cost_arcs)[it].arc = INVALID; + (*_node_order)[it] = -3; + (*_heap_cross_ref)[it] = Heap::PRE_HEAP; + _pred->set(it, INVALID); + } + for (ArcIt it(*_digraph); it != INVALID; ++it) { + _arborescence->set(it, false); + (*_arc_order)[it] = -1; + } + _dual_node_list.clear(); + _dual_variables.clear(); + } + + /// \brief Adds a new source node. + /// + /// Adds a new source node to the algorithm. + void addSource(Node source) { + std::vector nodes; + nodes.push_back(source); + while (!nodes.empty()) { + Node node = nodes.back(); + nodes.pop_back(); + for (OutArcIt it(*_digraph, node); it != INVALID; ++it) { + Node target = _digraph->target(it); + if ((*_node_order)[target] == -3) { + (*_node_order)[target] = -2; + nodes.push_back(target); + queue.push_back(target); + } + } + } + (*_node_order)[source] = -1; + } + + /// \brief Processes the next node in the priority queue. + /// + /// Processes the next node in the priority queue. + /// + /// \return The processed node. + /// + /// \warning The queue must not be empty. + Node processNextNode() { + Node node = queue.back(); + queue.pop_back(); + if ((*_node_order)[node] == -2) { + Arc arc = prepare(node); + Node source = _digraph->source(arc); + while ((*_node_order)[source] != -1) { + if ((*_node_order)[source] >= 0) { + arc = contract(source); + } else { + arc = prepare(source); + } + source = _digraph->source(arc); + } + finalize(arc); + level_stack.clear(); + } + return node; + } + + /// \brief Returns the number of the nodes to be processed. + /// + /// Returns the number of the nodes to be processed in the priority + /// queue. + int queueSize() const { + return queue.size(); + } + + /// \brief Returns \c false if there are nodes to be processed. + /// + /// Returns \c false if there are nodes to be processed. + bool emptyQueue() const { + return queue.empty(); + } + + /// \brief Executes the algorithm. + /// + /// Executes the algorithm. + /// + /// \pre init() must be called and at least one node should be added + /// with addSource() before using this function. + /// + ///\note mca.start() is just a shortcut of the following code. + ///\code + ///while (!mca.emptyQueue()) { + /// mca.processNextNode(); + ///} + ///\endcode + void start() { + while (!emptyQueue()) { + processNextNode(); + } + } + + /// \brief Runs %MinCostArborescence algorithm from node \c s. + /// + /// This method runs the %MinCostArborescence algorithm from + /// a root node \c s. + /// + /// \note mca.run(s) is just a shortcut of the following code. + /// \code + /// mca.init(); + /// mca.addSource(s); + /// mca.start(); + /// \endcode + void run(Node s) { + init(); + addSource(s); + start(); + } + + ///@} + + /// \name Query Functions + /// The result of the %MinCostArborescence algorithm can be obtained + /// using these functions.\n + /// Either run() or start() must be called before using them. + + /// @{ + + /// \brief Returns the cost of the arborescence. + /// + /// Returns the cost of the arborescence. + Value arborescenceCost() const { + Value sum = 0; + for (ArcIt it(*_digraph); it != INVALID; ++it) { + if (arborescence(it)) { + sum += (*_cost)[it]; + } + } + return sum; + } + + /// \brief Returns \c true if the arc is in the arborescence. + /// + /// Returns \c true if the given arc is in the arborescence. + /// \param arc An arc of the digraph. + /// \pre \ref run() must be called before using this function. + bool arborescence(Arc arc) const { + return (*_pred)[_digraph->target(arc)] == arc; + } + + /// \brief Returns a const reference to the arborescence map. + /// + /// Returns a const reference to the arborescence map. + /// \pre \ref run() must be called before using this function. + const ArborescenceMap& arborescenceMap() const { + return *_arborescence; + } + + /// \brief Returns the predecessor arc of the given node. + /// + /// Returns the predecessor arc of the given node. + /// \pre \ref run() must be called before using this function. + Arc pred(Node node) const { + return (*_pred)[node]; + } + + /// \brief Returns a const reference to the pred map. + /// + /// Returns a const reference to the pred map. + /// \pre \ref run() must be called before using this function. + const PredMap& predMap() const { + return *_pred; + } + + /// \brief Indicates that a node is reachable from the sources. + /// + /// Indicates that a node is reachable from the sources. + bool reached(Node node) const { + return (*_node_order)[node] != -3; + } + + /// \brief Indicates that a node is processed. + /// + /// Indicates that a node is processed. The arborescence path exists + /// from the source to the given node. + bool processed(Node node) const { + return (*_node_order)[node] == -1; + } + + /// \brief Returns the number of the dual variables in basis. + /// + /// Returns the number of the dual variables in basis. + int dualNum() const { + return _dual_variables.size(); + } + + /// \brief Returns the value of the dual solution. + /// + /// Returns the value of the dual solution. It should be + /// equal to the arborescence value. + Value dualValue() const { + Value sum = 0; + for (int i = 0; i < int(_dual_variables.size()); ++i) { + sum += _dual_variables[i].value; + } + return sum; + } + + /// \brief Returns the number of the nodes in the dual variable. + /// + /// Returns the number of the nodes in the dual variable. + int dualSize(int k) const { + return _dual_variables[k].end - _dual_variables[k].begin; + } + + /// \brief Returns the value of the dual variable. + /// + /// Returns the the value of the dual variable. + Value dualValue(int k) const { + return _dual_variables[k].value; + } + + /// \brief LEMON iterator for getting a dual variable. + /// + /// This class provides a common style LEMON iterator for getting a + /// dual variable of \ref MinCostArborescence algorithm. + /// It iterates over a subset of the nodes. + class DualIt { + public: + + /// \brief Constructor. + /// + /// Constructor for getting the nodeset of the dual variable + /// of \ref MinCostArborescence algorithm. + DualIt(const MinCostArborescence& algorithm, int variable) + : _algorithm(&algorithm) + { + _index = _algorithm->_dual_variables[variable].begin; + _last = _algorithm->_dual_variables[variable].end; + } + + /// \brief Conversion to \c Node. + /// + /// Conversion to \c Node. + operator Node() const { + return _algorithm->_dual_node_list[_index]; + } + + /// \brief Increment operator. + /// + /// Increment operator. + DualIt& operator++() { + ++_index; + return *this; + } + + /// \brief Validity checking + /// + /// Checks whether the iterator is invalid. + bool operator==(Invalid) const { + return _index == _last; + } + + /// \brief Validity checking + /// + /// Checks whether the iterator is valid. + bool operator!=(Invalid) const { + return _index != _last; + } + + private: + const MinCostArborescence* _algorithm; + int _index, _last; + }; + + /// @} + + }; + + /// \ingroup spantree + /// + /// \brief Function type interface for MinCostArborescence algorithm. + /// + /// Function type interface for MinCostArborescence algorithm. + /// \param digraph The digraph the algorithm runs on. + /// \param cost An arc map storing the costs. + /// \param source The source node of the arborescence. + /// \retval arborescence An arc map with \c bool (or convertible) value + /// type that stores the arborescence. + /// \return The total cost of the arborescence. + /// + /// \sa MinCostArborescence + template + typename CostMap::Value minCostArborescence(const Digraph& digraph, + const CostMap& cost, + typename Digraph::Node source, + ArborescenceMap& arborescence) { + typename MinCostArborescence + ::template SetArborescenceMap + ::Create mca(digraph, cost); + mca.arborescenceMap(arborescence); + mca.run(source); + return mca.arborescenceCost(); + } + +} + +#endif diff -r c35afa9e89e7 -r ef88c0a30f85 lemon/network_simplex.h --- /dev/null Thu Jan 01 00:00:00 1970 +0000 +++ b/lemon/network_simplex.h Thu Nov 05 15:48:01 2009 +0100 @@ -0,0 +1,1485 @@ +/* -*- 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_NETWORK_SIMPLEX_H +#define LEMON_NETWORK_SIMPLEX_H + +/// \ingroup min_cost_flow_algs +/// +/// \file +/// \brief Network Simplex algorithm for finding a minimum cost flow. + +#include +#include +#include + +#include +#include + +namespace lemon { + + /// \addtogroup min_cost_flow_algs + /// @{ + + /// \brief Implementation of the primal Network Simplex algorithm + /// for finding a \ref min_cost_flow "minimum cost flow". + /// + /// \ref NetworkSimplex implements the primal Network Simplex algorithm + /// for finding a \ref min_cost_flow "minimum cost flow" + /// \ref amo93networkflows, \ref dantzig63linearprog, + /// \ref kellyoneill91netsimplex. + /// This algorithm is a 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 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) + /// 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 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 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. + template + class NetworkSimplex + { + public: + + /// The type of the flow amounts, capacity bounds and supply values + typedef V Value; + /// The type of the arc costs + typedef C Cost; + + public: + + /// \brief Problem type constants for the \c run() function. + /// + /// Enum type containing the problem type constants that can be + /// returned by the \ref run() function of the algorithm. + enum ProblemType { + /// The problem has no feasible solution (flow). + INFEASIBLE, + /// The problem has optimal solution (i.e. it is feasible and + /// bounded), and the algorithm has found optimal flow and node + /// potentials (primal and dual solutions). + OPTIMAL, + /// The objective function of the problem is unbounded, i.e. + /// there is a directed cycle having negative total cost and + /// infinite upper bound. + UNBOUNDED + }; + + /// \brief Constants for selecting the type of the supply constraints. + /// + /// Enum type containing constants for selecting the supply type, + /// i.e. the direction of the inequalities in the supply/demand + /// constraints of the \ref min_cost_flow "minimum cost flow problem". + /// + /// The default supply type is \c GEQ, the \c LEQ type can be + /// selected using \ref supplyType(). + /// The equality form is a special case of both supply types. + enum SupplyType { + /// This option means that there are "greater or equal" + /// supply/demand constraints in the definition of the problem. + GEQ, + /// This option means that there are "less or equal" + /// supply/demand constraints in the definition of the problem. + LEQ + }; + + /// \brief Constants for selecting the pivot rule. + /// + /// Enum type containing constants for selecting the pivot rule for + /// the \ref run() function. + /// + /// \ref NetworkSimplex provides five different pivot rule + /// implementations that significantly affect the running time + /// of the algorithm. + /// By default \ref BLOCK_SEARCH "Block Search" is used, which + /// proved to be the most efficient and the most robust on various + /// test inputs according to our benchmark tests. + /// However another pivot rule can be selected using the \ref run() + /// function with the proper parameter. + enum PivotRule { + + /// The First Eligible pivot rule. + /// The next eligible arc is selected in a wraparound fashion + /// in every iteration. + FIRST_ELIGIBLE, + + /// The Best Eligible pivot rule. + /// The best eligible arc is selected in every iteration. + BEST_ELIGIBLE, + + /// 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 + /// from this block. + BLOCK_SEARCH, + + /// 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 + /// the best eligible arc is selected from this list. + CANDIDATE_LIST, + + /// The Altering Candidate List pivot rule. + /// It is a modified version of the Candidate List method. + /// It keeps only the several best eligible arcs from the former + /// candidate list and extends this list in every iteration. + ALTERING_LIST + }; + + private: + + TEMPLATE_DIGRAPH_TYPEDEFS(GR); + + typedef std::vector IntVector; + typedef std::vector BoolVector; + typedef std::vector ValueVector; + typedef std::vector CostVector; + + // State constants for arcs + enum ArcStateEnum { + STATE_UPPER = -1, + STATE_TREE = 0, + STATE_LOWER = 1 + }; + + private: + + // Data related to the underlying digraph + const GR &_graph; + int _node_num; + int _arc_num; + int _all_arc_num; + int _search_arc_num; + + // Parameters of the problem + bool _have_lower; + SupplyType _stype; + Value _sum_supply; + + // Data structures for storing the digraph + IntNodeMap _node_id; + IntArcMap _arc_id; + IntVector _source; + IntVector _target; + + // Node and arc data + ValueVector _lower; + ValueVector _upper; + ValueVector _cap; + CostVector _cost; + ValueVector _supply; + ValueVector _flow; + CostVector _pi; + + // Data for storing the spanning tree structure + IntVector _parent; + IntVector _pred; + IntVector _thread; + IntVector _rev_thread; + IntVector _succ_num; + IntVector _last_succ; + IntVector _dirty_revs; + BoolVector _forward; + 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; + + 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: + + // Implementation of the First Eligible pivot rule + class FirstEligiblePivotRule + { + private: + + // References to the NetworkSimplex class + const IntVector &_source; + const IntVector &_target; + const CostVector &_cost; + const IntVector &_state; + const CostVector &_pi; + int &_in_arc; + int _search_arc_num; + + // Pivot rule data + int _next_arc; + + public: + + // Constructor + FirstEligiblePivotRule(NetworkSimplex &ns) : + _source(ns._source), _target(ns._target), + _cost(ns._cost), _state(ns._state), _pi(ns._pi), + _in_arc(ns.in_arc), _search_arc_num(ns._search_arc_num), + _next_arc(0) + {} + + // Find next entering arc + bool findEnteringArc() { + Cost c; + for (int e = _next_arc; e < _search_arc_num; ++e) { + c = _state[e] * (_cost[e] + _pi[_source[e]] - _pi[_target[e]]); + if (c < 0) { + _in_arc = e; + _next_arc = e + 1; + return true; + } + } + for (int e = 0; e < _next_arc; ++e) { + c = _state[e] * (_cost[e] + _pi[_source[e]] - _pi[_target[e]]); + if (c < 0) { + _in_arc = e; + _next_arc = e + 1; + return true; + } + } + return false; + } + + }; //class FirstEligiblePivotRule + + + // Implementation of the Best Eligible pivot rule + class BestEligiblePivotRule + { + private: + + // References to the NetworkSimplex class + const IntVector &_source; + const IntVector &_target; + const CostVector &_cost; + const IntVector &_state; + const CostVector &_pi; + int &_in_arc; + int _search_arc_num; + + public: + + // Constructor + BestEligiblePivotRule(NetworkSimplex &ns) : + _source(ns._source), _target(ns._target), + _cost(ns._cost), _state(ns._state), _pi(ns._pi), + _in_arc(ns.in_arc), _search_arc_num(ns._search_arc_num) + {} + + // Find next entering arc + bool findEnteringArc() { + Cost c, min = 0; + for (int e = 0; e < _search_arc_num; ++e) { + c = _state[e] * (_cost[e] + _pi[_source[e]] - _pi[_target[e]]); + if (c < min) { + min = c; + _in_arc = e; + } + } + return min < 0; + } + + }; //class BestEligiblePivotRule + + + // Implementation of the Block Search pivot rule + class BlockSearchPivotRule + { + private: + + // References to the NetworkSimplex class + const IntVector &_source; + const IntVector &_target; + const CostVector &_cost; + const IntVector &_state; + const CostVector &_pi; + int &_in_arc; + int _search_arc_num; + + // Pivot rule data + int _block_size; + int _next_arc; + + public: + + // Constructor + BlockSearchPivotRule(NetworkSimplex &ns) : + _source(ns._source), _target(ns._target), + _cost(ns._cost), _state(ns._state), _pi(ns._pi), + _in_arc(ns.in_arc), _search_arc_num(ns._search_arc_num), + _next_arc(0) + { + // The main parameters of the pivot rule + const double BLOCK_SIZE_FACTOR = 0.5; + const int MIN_BLOCK_SIZE = 10; + + _block_size = std::max( int(BLOCK_SIZE_FACTOR * + std::sqrt(double(_search_arc_num))), + MIN_BLOCK_SIZE ); + } + + // Find next entering arc + bool findEnteringArc() { + Cost c, min = 0; + int cnt = _block_size; + int e; + for (e = _next_arc; e < _search_arc_num; ++e) { + c = _state[e] * (_cost[e] + _pi[_source[e]] - _pi[_target[e]]); + if (c < min) { + min = c; + _in_arc = e; + } + if (--cnt == 0) { + if (min < 0) goto search_end; + cnt = _block_size; + } + } + for (e = 0; e < _next_arc; ++e) { + c = _state[e] * (_cost[e] + _pi[_source[e]] - _pi[_target[e]]); + if (c < min) { + min = c; + _in_arc = e; + } + if (--cnt == 0) { + if (min < 0) goto search_end; + cnt = _block_size; + } + } + if (min >= 0) return false; + + search_end: + _next_arc = e; + return true; + } + + }; //class BlockSearchPivotRule + + + // Implementation of the Candidate List pivot rule + class CandidateListPivotRule + { + private: + + // References to the NetworkSimplex class + const IntVector &_source; + const IntVector &_target; + const CostVector &_cost; + const IntVector &_state; + const CostVector &_pi; + int &_in_arc; + int _search_arc_num; + + // Pivot rule data + IntVector _candidates; + int _list_length, _minor_limit; + int _curr_length, _minor_count; + int _next_arc; + + public: + + /// Constructor + CandidateListPivotRule(NetworkSimplex &ns) : + _source(ns._source), _target(ns._target), + _cost(ns._cost), _state(ns._state), _pi(ns._pi), + _in_arc(ns.in_arc), _search_arc_num(ns._search_arc_num), + _next_arc(0) + { + // The main parameters of the pivot rule + const double LIST_LENGTH_FACTOR = 0.25; + const int MIN_LIST_LENGTH = 10; + const double MINOR_LIMIT_FACTOR = 0.1; + const int MIN_MINOR_LIMIT = 3; + + _list_length = std::max( int(LIST_LENGTH_FACTOR * + std::sqrt(double(_search_arc_num))), + MIN_LIST_LENGTH ); + _minor_limit = std::max( int(MINOR_LIMIT_FACTOR * _list_length), + MIN_MINOR_LIMIT ); + _curr_length = _minor_count = 0; + _candidates.resize(_list_length); + } + + /// Find next entering arc + bool findEnteringArc() { + Cost min, c; + int e; + if (_curr_length > 0 && _minor_count < _minor_limit) { + // Minor iteration: select the best eligible arc from the + // current candidate list + ++_minor_count; + min = 0; + for (int i = 0; i < _curr_length; ++i) { + e = _candidates[i]; + c = _state[e] * (_cost[e] + _pi[_source[e]] - _pi[_target[e]]); + if (c < min) { + min = c; + _in_arc = e; + } + else if (c >= 0) { + _candidates[i--] = _candidates[--_curr_length]; + } + } + if (min < 0) return true; + } + + // Major iteration: build a new candidate list + min = 0; + _curr_length = 0; + for (e = _next_arc; e < _search_arc_num; ++e) { + c = _state[e] * (_cost[e] + _pi[_source[e]] - _pi[_target[e]]); + if (c < 0) { + _candidates[_curr_length++] = e; + if (c < min) { + min = c; + _in_arc = e; + } + if (_curr_length == _list_length) goto search_end; + } + } + for (e = 0; e < _next_arc; ++e) { + c = _state[e] * (_cost[e] + _pi[_source[e]] - _pi[_target[e]]); + if (c < 0) { + _candidates[_curr_length++] = e; + if (c < min) { + min = c; + _in_arc = e; + } + if (_curr_length == _list_length) goto search_end; + } + } + if (_curr_length == 0) return false; + + search_end: + _minor_count = 1; + _next_arc = e; + return true; + } + + }; //class CandidateListPivotRule + + + // Implementation of the Altering Candidate List pivot rule + class AlteringListPivotRule + { + private: + + // References to the NetworkSimplex class + const IntVector &_source; + const IntVector &_target; + const CostVector &_cost; + const IntVector &_state; + const CostVector &_pi; + int &_in_arc; + int _search_arc_num; + + // Pivot rule data + int _block_size, _head_length, _curr_length; + int _next_arc; + IntVector _candidates; + CostVector _cand_cost; + + // Functor class to compare arcs during sort of the candidate list + class SortFunc + { + private: + const CostVector &_map; + public: + SortFunc(const CostVector &map) : _map(map) {} + bool operator()(int left, int right) { + return _map[left] > _map[right]; + } + }; + + SortFunc _sort_func; + + public: + + // Constructor + AlteringListPivotRule(NetworkSimplex &ns) : + _source(ns._source), _target(ns._target), + _cost(ns._cost), _state(ns._state), _pi(ns._pi), + _in_arc(ns.in_arc), _search_arc_num(ns._search_arc_num), + _next_arc(0), _cand_cost(ns._search_arc_num), _sort_func(_cand_cost) + { + // The main parameters of the pivot rule + const double BLOCK_SIZE_FACTOR = 1.0; + const int MIN_BLOCK_SIZE = 10; + const double HEAD_LENGTH_FACTOR = 0.1; + const int MIN_HEAD_LENGTH = 3; + + _block_size = std::max( int(BLOCK_SIZE_FACTOR * + std::sqrt(double(_search_arc_num))), + MIN_BLOCK_SIZE ); + _head_length = std::max( int(HEAD_LENGTH_FACTOR * _block_size), + MIN_HEAD_LENGTH ); + _candidates.resize(_head_length + _block_size); + _curr_length = 0; + } + + // Find next entering arc + bool findEnteringArc() { + // Check the current candidate list + int e; + for (int i = 0; i < _curr_length; ++i) { + e = _candidates[i]; + _cand_cost[e] = _state[e] * + (_cost[e] + _pi[_source[e]] - _pi[_target[e]]); + if (_cand_cost[e] >= 0) { + _candidates[i--] = _candidates[--_curr_length]; + } + } + + // Extend the list + int cnt = _block_size; + int limit = _head_length; + + for (e = _next_arc; e < _search_arc_num; ++e) { + _cand_cost[e] = _state[e] * + (_cost[e] + _pi[_source[e]] - _pi[_target[e]]); + if (_cand_cost[e] < 0) { + _candidates[_curr_length++] = e; + } + if (--cnt == 0) { + if (_curr_length > limit) goto search_end; + limit = 0; + cnt = _block_size; + } + } + for (e = 0; e < _next_arc; ++e) { + _cand_cost[e] = _state[e] * + (_cost[e] + _pi[_source[e]] - _pi[_target[e]]); + if (_cand_cost[e] < 0) { + _candidates[_curr_length++] = e; + } + if (--cnt == 0) { + if (_curr_length > limit) goto search_end; + limit = 0; + cnt = _block_size; + } + } + if (_curr_length == 0) return false; + + search_end: + + // Make heap of the candidate list (approximating a partial sort) + make_heap( _candidates.begin(), _candidates.begin() + _curr_length, + _sort_func ); + + // Pop the first element of the heap + _in_arc = _candidates[0]; + _next_arc = e; + pop_heap( _candidates.begin(), _candidates.begin() + _curr_length, + _sort_func ); + _curr_length = std::min(_head_length, _curr_length - 1); + return true; + } + + }; //class AlteringListPivotRule + + public: + + /// \brief Constructor. + /// + /// The constructor of the class. + /// + /// \param graph The digraph the algorithm runs on. + /// \param arc_mixing Indicate if the arcs have to be stored in a + /// mixed order in the internal data structure. + /// In special cases, it could lead to better overall performance, + /// but it is usually slower. Therefore it is disabled by default. + NetworkSimplex(const GR& graph, bool arc_mixing = false) : + _graph(graph), _node_id(graph), _arc_id(graph), + INF(std::numeric_limits::has_infinity ? + std::numeric_limits::infinity() : + std::numeric_limits::max()) + { + // 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"); + + // Resize vectors + _node_num = countNodes(_graph); + _arc_num = countArcs(_graph); + int all_node_num = _node_num + 1; + int max_arc_num = _arc_num + 2 * _node_num; + + _source.resize(max_arc_num); + _target.resize(max_arc_num); + + _lower.resize(_arc_num); + _upper.resize(_arc_num); + _cap.resize(max_arc_num); + _cost.resize(max_arc_num); + _supply.resize(all_node_num); + _flow.resize(max_arc_num); + _pi.resize(all_node_num); + + _parent.resize(all_node_num); + _pred.resize(all_node_num); + _forward.resize(all_node_num); + _thread.resize(all_node_num); + _rev_thread.resize(all_node_num); + _succ_num.resize(all_node_num); + _last_succ.resize(all_node_num); + _state.resize(max_arc_num); + + // Copy the graph + int i = 0; + for (NodeIt n(_graph); n != INVALID; ++n, ++i) { + _node_id[n] = i; + } + if (arc_mixing) { + // Store the arcs in a mixed order + int k = std::max(int(std::sqrt(double(_arc_num))), 10); + int i = 0, j = 0; + for (ArcIt a(_graph); a != INVALID; ++a) { + _arc_id[a] = i; + _source[i] = _node_id[_graph.source(a)]; + _target[i] = _node_id[_graph.target(a)]; + if ((i += k) >= _arc_num) i = ++j; + } + } else { + // Store the arcs in the original order + int i = 0; + for (ArcIt a(_graph); a != INVALID; ++a, ++i) { + _arc_id[a] = i; + _source[i] = _node_id[_graph.source(a)]; + _target[i] = _node_id[_graph.target(a)]; + } + } + + // Reset parameters + 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 + NetworkSimplex& lowerMap(const LowerMap& map) { + _have_lower = true; + for (ArcIt a(_graph); a != INVALID; ++a) { + _lower[_arc_id[a]] = map[a]; + } + return *this; + } + + /// \brief Set the upper bounds (capacities) on the arcs. + /// + /// This function sets the upper bounds (capacities) on the arcs. + /// If it is not used before calling \ref run(), the upper bounds + /// will be set to \ref INF on all arcs (i.e. the flow value will be + /// unbounded from above on each arc). + /// + /// \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 + NetworkSimplex& upperMap(const UpperMap& map) { + for (ArcIt a(_graph); a != INVALID; ++a) { + _upper[_arc_id[a]] = map[a]; + } + return *this; + } + + /// \brief Set the costs of the arcs. + /// + /// This function sets the costs of the arcs. + /// If it is not used before calling \ref run(), the costs + /// will be set to \c 1 on all arcs. + /// + /// \param map An arc map storing the costs. + /// Its \c Value type must be convertible to the \c Cost type + /// of the algorithm. + /// + /// \return (*this) + template + NetworkSimplex& costMap(const CostMap& map) { + for (ArcIt a(_graph); a != INVALID; ++a) { + _cost[_arc_id[a]] = map[a]; + } + return *this; + } + + /// \brief Set the supply values of the nodes. + /// + /// This function sets the supply values of the nodes. + /// If neither this function nor \ref stSupply() is used before + /// calling \ref run(), the supply of each node will be set to zero. + /// + /// \param map A node map storing the supply values. + /// Its \c Value type must be convertible to the \c Value type + /// of the algorithm. + /// + /// \return (*this) + template + NetworkSimplex& supplyMap(const SupplyMap& map) { + for (NodeIt n(_graph); n != INVALID; ++n) { + _supply[_node_id[n]] = map[n]; + } + return *this; + } + + /// \brief Set single source and target nodes and a supply value. + /// + /// This function sets a single source node and a single target node + /// and the required flow value. + /// If neither this function nor \ref supplyMap() is used before + /// calling \ref run(), the supply of each node will be set to zero. + /// + /// Using this function has the same effect as using \ref supplyMap() + /// with such a map in which \c k is assigned to \c s, \c -k is + /// assigned to \c t and all other nodes have zero supply value. + /// + /// \param s The source node. + /// \param t The target node. + /// \param k The required amount of flow from node \c s to node \c t + /// (i.e. the supply of \c s and the demand of \c t). + /// + /// \return (*this) + NetworkSimplex& stSupply(const Node& s, const Node& t, Value k) { + for (int i = 0; i != _node_num; ++i) { + _supply[i] = 0; + } + _supply[_node_id[s]] = k; + _supply[_node_id[t]] = -k; + return *this; + } + + /// \brief Set the type of the supply constraints. + /// + /// This function sets the type of the supply/demand constraints. + /// If it is not used before calling \ref run(), the \ref GEQ supply + /// type will be used. + /// + /// For more information see \ref SupplyType. + /// + /// \return (*this) + NetworkSimplex& supplyType(SupplyType supply_type) { + _stype = supply_type; + return *this; + } + + /// @} + + /// \name Execution Control + /// The algorithm can be executed using \ref run(). + + /// @{ + + /// \brief Run the algorithm. + /// + /// This function runs the algorithm. + /// The paramters can be specified using functions \ref lowerMap(), + /// \ref upperMap(), \ref costMap(), \ref supplyMap(), \ref stSupply(), + /// \ref supplyType(). + /// For example, + /// \code + /// NetworkSimplex ns(graph); + /// ns.lowerMap(lower).upperMap(upper).costMap(cost) + /// .supplyMap(sup).run(); + /// \endcode + /// + /// This function can be called more than once. All the parameters + /// that have been given are kept for the next call, unless + /// \ref reset() is called, thus only the modified parameters + /// have to be set again. See \ref reset() for examples. + /// However the underlying digraph must not be modified after this + /// class have been constructed, since it copies and extends the graph. + /// + /// \param pivot_rule The pivot rule that will be used during the + /// algorithm. For more information see \ref PivotRule. + /// + /// \return \c INFEASIBLE if no feasible flow exists, + /// \n \c OPTIMAL if the problem has optimal solution + /// (i.e. it is feasible and bounded), and the algorithm has found + /// optimal flow and node potentials (primal and dual solutions), + /// \n \c UNBOUNDED if the objective function of the problem is + /// unbounded, i.e. there is a directed cycle having negative total + /// cost and infinite upper bound. + /// + /// \see ProblemType, PivotRule + ProblemType run(PivotRule pivot_rule = BLOCK_SEARCH) { + if (!init()) return INFEASIBLE; + return start(pivot_rule); + } + + /// \brief Reset all the parameters that have been given before. + /// + /// This function resets all the paramaters that have been given + /// before using functions \ref lowerMap(), \ref upperMap(), + /// \ref costMap(), \ref supplyMap(), \ref stSupply(), \ref supplyType(). + /// + /// It is useful for multiple run() calls. If this function is not + /// used, all the parameters given before are kept for the next + /// \ref run() call. + /// However the underlying digraph must not be modified after this + /// class have been constructed, since it copies and extends the graph. + /// + /// For example, + /// \code + /// NetworkSimplex ns(graph); + /// + /// // First run + /// ns.lowerMap(lower).upperMap(upper).costMap(cost) + /// .supplyMap(sup).run(); + /// + /// // Run again with modified cost map (reset() is not called, + /// // so only the cost map have to be set again) + /// cost[e] += 100; + /// ns.costMap(cost).run(); + /// + /// // Run again from scratch using reset() + /// // (the lower bounds will be set to zero on all arcs) + /// ns.reset(); + /// ns.upperMap(capacity).costMap(cost) + /// .supplyMap(sup).run(); + /// \endcode + /// + /// \return (*this) + NetworkSimplex& reset() { + for (int i = 0; i != _node_num; ++i) { + _supply[i] = 0; + } + for (int i = 0; i != _arc_num; ++i) { + _lower[i] = 0; + _upper[i] = INF; + _cost[i] = 1; + } + _have_lower = false; + _stype = GEQ; + return *this; + } + + /// @} + + /// \name Query Functions + /// The results of the algorithm can be obtained using these + /// functions.\n + /// The \ref run() function must be called before using them. + + /// @{ + + /// \brief Return the total cost of the found flow. + /// + /// This function returns the total cost of the found flow. + /// Its complexity is O(e). + /// + /// \note The return type of the function can be specified as a + /// template parameter. For example, + /// \code + /// ns.totalCost(); + /// \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_id[a]; + c += Number(_flow[i]) * Number(_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 _flow[_arc_id[a]]; + } + + /// \brief Return the flow map (the primal solution). + /// + /// This function copies the flow value on each arc into the given + /// map. The \c Value type of the algorithm must be convertible to + /// the \c Value type of the map. + /// + /// \pre \ref run() must be called before using this function. + template + void flowMap(FlowMap &map) const { + for (ArcIt a(_graph); a != INVALID; ++a) { + map.set(a, _flow[_arc_id[a]]); + } + } + + /// \brief Return the potential (dual value) of the given node. + /// + /// This function returns the potential (dual value) of the + /// given node. + /// + /// \pre \ref run() must be called before using this function. + Cost potential(const Node& n) const { + return _pi[_node_id[n]]; + } + + /// \brief Return the potential map (the dual solution). + /// + /// This function copies the potential (dual value) of each node + /// into the given map. + /// The \c Cost type of the algorithm must be convertible to the + /// \c Value type of the map. + /// + /// \pre \ref run() must be called before using this function. + template + void potentialMap(PotentialMap &map) const { + for (NodeIt n(_graph); n != INVALID; ++n) { + map.set(n, _pi[_node_id[n]]); + } + } + + /// @} + + private: + + // Initialize internal data structures + bool init() { + if (_node_num == 0) return false; + + // Check the sum of supply values + _sum_supply = 0; + for (int i = 0; i != _node_num; ++i) { + _sum_supply += _supply[i]; + } + if ( !((_stype == GEQ && _sum_supply <= 0) || + (_stype == LEQ && _sum_supply >= 0)) ) return false; + + // Remove non-zero lower bounds + if (_have_lower) { + for (int i = 0; i != _arc_num; ++i) { + Value c = _lower[i]; + if (c >= 0) { + _cap[i] = _upper[i] < INF ? _upper[i] - c : INF; + } else { + _cap[i] = _upper[i] < INF + c ? _upper[i] - c : INF; + } + _supply[_source[i]] -= c; + _supply[_target[i]] += c; + } + } else { + for (int i = 0; i != _arc_num; ++i) { + _cap[i] = _upper[i]; + } + } + + // Initialize artifical cost + Cost ART_COST; + if (std::numeric_limits::is_exact) { + ART_COST = std::numeric_limits::max() / 2 + 1; + } else { + ART_COST = std::numeric_limits::min(); + for (int i = 0; i != _arc_num; ++i) { + if (_cost[i] > ART_COST) ART_COST = _cost[i]; + } + ART_COST = (ART_COST + 1) * _node_num; + } + + // Initialize arc maps + for (int i = 0; i != _arc_num; ++i) { + _flow[i] = 0; + _state[i] = STATE_LOWER; + } + + // Set data for the artificial root node + _root = _node_num; + _parent[_root] = -1; + _pred[_root] = -1; + _thread[_root] = 0; + _rev_thread[0] = _root; + _succ_num[_root] = _node_num + 1; + _last_succ[_root] = _root - 1; + _supply[_root] = -_sum_supply; + _pi[_root] = 0; + + // Add artificial arcs and initialize the spanning tree data structure + if (_sum_supply == 0) { + // EQ supply constraints + _search_arc_num = _arc_num; + _all_arc_num = _arc_num + _node_num; + for (int u = 0, e = _arc_num; u != _node_num; ++u, ++e) { + _parent[u] = _root; + _pred[u] = e; + _thread[u] = u + 1; + _rev_thread[u + 1] = u; + _succ_num[u] = 1; + _last_succ[u] = u; + _cap[e] = INF; + _state[e] = STATE_TREE; + if (_supply[u] >= 0) { + _forward[u] = true; + _pi[u] = 0; + _source[e] = u; + _target[e] = _root; + _flow[e] = _supply[u]; + _cost[e] = 0; + } else { + _forward[u] = false; + _pi[u] = ART_COST; + _source[e] = _root; + _target[e] = u; + _flow[e] = -_supply[u]; + _cost[e] = ART_COST; + } + } + } + else if (_sum_supply > 0) { + // LEQ supply constraints + _search_arc_num = _arc_num + _node_num; + int f = _arc_num + _node_num; + for (int u = 0, e = _arc_num; u != _node_num; ++u, ++e) { + _parent[u] = _root; + _thread[u] = u + 1; + _rev_thread[u + 1] = u; + _succ_num[u] = 1; + _last_succ[u] = u; + if (_supply[u] >= 0) { + _forward[u] = true; + _pi[u] = 0; + _pred[u] = e; + _source[e] = u; + _target[e] = _root; + _cap[e] = INF; + _flow[e] = _supply[u]; + _cost[e] = 0; + _state[e] = STATE_TREE; + } else { + _forward[u] = false; + _pi[u] = ART_COST; + _pred[u] = f; + _source[f] = _root; + _target[f] = u; + _cap[f] = INF; + _flow[f] = -_supply[u]; + _cost[f] = ART_COST; + _state[f] = STATE_TREE; + _source[e] = u; + _target[e] = _root; + _cap[e] = INF; + _flow[e] = 0; + _cost[e] = 0; + _state[e] = STATE_LOWER; + ++f; + } + } + _all_arc_num = f; + } + else { + // GEQ supply constraints + _search_arc_num = _arc_num + _node_num; + int f = _arc_num + _node_num; + for (int u = 0, e = _arc_num; u != _node_num; ++u, ++e) { + _parent[u] = _root; + _thread[u] = u + 1; + _rev_thread[u + 1] = u; + _succ_num[u] = 1; + _last_succ[u] = u; + if (_supply[u] <= 0) { + _forward[u] = false; + _pi[u] = 0; + _pred[u] = e; + _source[e] = _root; + _target[e] = u; + _cap[e] = INF; + _flow[e] = -_supply[u]; + _cost[e] = 0; + _state[e] = STATE_TREE; + } else { + _forward[u] = true; + _pi[u] = -ART_COST; + _pred[u] = f; + _source[f] = u; + _target[f] = _root; + _cap[f] = INF; + _flow[f] = _supply[u]; + _state[f] = STATE_TREE; + _cost[f] = ART_COST; + _source[e] = _root; + _target[e] = u; + _cap[e] = INF; + _flow[e] = 0; + _cost[e] = 0; + _state[e] = STATE_LOWER; + ++f; + } + } + _all_arc_num = f; + } + + return true; + } + + // Find the join node + void findJoinNode() { + int u = _source[in_arc]; + int v = _target[in_arc]; + while (u != v) { + if (_succ_num[u] < _succ_num[v]) { + u = _parent[u]; + } else { + v = _parent[v]; + } + } + join = u; + } + + // Find the leaving arc of the cycle and returns true if the + // leaving arc is not the same as the entering arc + bool findLeavingArc() { + // Initialize first and second nodes according to the direction + // of the cycle + if (_state[in_arc] == STATE_LOWER) { + first = _source[in_arc]; + second = _target[in_arc]; + } else { + first = _target[in_arc]; + second = _source[in_arc]; + } + delta = _cap[in_arc]; + int result = 0; + Value d; + int e; + + // Search the cycle along the path form the first node to the root + for (int u = first; u != join; u = _parent[u]) { + e = _pred[u]; + d = _forward[u] ? + _flow[e] : (_cap[e] == INF ? INF : _cap[e] - _flow[e]); + if (d < delta) { + delta = d; + u_out = u; + result = 1; + } + } + // Search the cycle along the path form the second node to the root + for (int u = second; u != join; u = _parent[u]) { + e = _pred[u]; + d = _forward[u] ? + (_cap[e] == INF ? INF : _cap[e] - _flow[e]) : _flow[e]; + if (d <= delta) { + delta = d; + u_out = u; + result = 2; + } + } + + if (result == 1) { + u_in = first; + v_in = second; + } else { + u_in = second; + v_in = first; + } + return result != 0; + } + + // Change _flow and _state vectors + void changeFlow(bool change) { + // Augment along the cycle + if (delta > 0) { + Value val = _state[in_arc] * delta; + _flow[in_arc] += val; + for (int u = _source[in_arc]; u != join; u = _parent[u]) { + _flow[_pred[u]] += _forward[u] ? -val : val; + } + for (int u = _target[in_arc]; u != join; u = _parent[u]) { + _flow[_pred[u]] += _forward[u] ? val : -val; + } + } + // Update the state of the entering and leaving arcs + if (change) { + _state[in_arc] = STATE_TREE; + _state[_pred[u_out]] = + (_flow[_pred[u_out]] == 0) ? STATE_LOWER : STATE_UPPER; + } else { + _state[in_arc] = -_state[in_arc]; + } + } + + // Update the tree structure + void updateTreeStructure() { + int u, w; + int old_rev_thread = _rev_thread[u_out]; + int old_succ_num = _succ_num[u_out]; + int old_last_succ = _last_succ[u_out]; + v_out = _parent[u_out]; + + u = _last_succ[u_in]; // the last successor of u_in + right = _thread[u]; // the node after it + + // Handle the case when old_rev_thread equals to v_in + // (it also means that join and v_out coincide) + if (old_rev_thread == v_in) { + last = _thread[_last_succ[u_out]]; + } else { + last = _thread[v_in]; + } + + // Update _thread and _parent along the stem nodes (i.e. the nodes + // between u_in and u_out, whose parent have to be changed) + _thread[v_in] = stem = u_in; + _dirty_revs.clear(); + _dirty_revs.push_back(v_in); + par_stem = v_in; + while (stem != u_out) { + // Insert the next stem node into the thread list + new_stem = _parent[stem]; + _thread[u] = new_stem; + _dirty_revs.push_back(u); + + // Remove the subtree of stem from the thread list + w = _rev_thread[stem]; + _thread[w] = right; + _rev_thread[right] = w; + + // Change the parent node and shift stem nodes + _parent[stem] = par_stem; + par_stem = stem; + stem = new_stem; + + // Update u and right + u = _last_succ[stem] == _last_succ[par_stem] ? + _rev_thread[par_stem] : _last_succ[stem]; + right = _thread[u]; + } + _parent[u_out] = par_stem; + _thread[u] = last; + _rev_thread[last] = u; + _last_succ[u_out] = u; + + // Remove the subtree of u_out from the thread list except for + // the case when old_rev_thread equals to v_in + // (it also means that join and v_out coincide) + if (old_rev_thread != v_in) { + _thread[old_rev_thread] = right; + _rev_thread[right] = old_rev_thread; + } + + // Update _rev_thread using the new _thread values + for (int i = 0; i < int(_dirty_revs.size()); ++i) { + u = _dirty_revs[i]; + _rev_thread[_thread[u]] = u; + } + + // Update _pred, _forward, _last_succ and _succ_num for the + // stem nodes from u_out to u_in + int tmp_sc = 0, tmp_ls = _last_succ[u_out]; + u = u_out; + while (u != u_in) { + w = _parent[u]; + _pred[u] = _pred[w]; + _forward[u] = !_forward[w]; + tmp_sc += _succ_num[u] - _succ_num[w]; + _succ_num[u] = tmp_sc; + _last_succ[w] = tmp_ls; + u = w; + } + _pred[u_in] = in_arc; + _forward[u_in] = (u_in == _source[in_arc]); + _succ_num[u_in] = old_succ_num; + + // Set limits for updating _last_succ form v_in and v_out + // towards the root + int up_limit_in = -1; + int up_limit_out = -1; + if (_last_succ[join] == v_in) { + up_limit_out = join; + } else { + up_limit_in = join; + } + + // Update _last_succ from v_in towards the root + for (u = v_in; u != up_limit_in && _last_succ[u] == v_in; + u = _parent[u]) { + _last_succ[u] = _last_succ[u_out]; + } + // Update _last_succ from v_out towards the root + if (join != old_rev_thread && v_in != old_rev_thread) { + for (u = v_out; u != up_limit_out && _last_succ[u] == old_last_succ; + u = _parent[u]) { + _last_succ[u] = old_rev_thread; + } + } else { + for (u = v_out; u != up_limit_out && _last_succ[u] == old_last_succ; + u = _parent[u]) { + _last_succ[u] = _last_succ[u_out]; + } + } + + // Update _succ_num from v_in to join + for (u = v_in; u != join; u = _parent[u]) { + _succ_num[u] += old_succ_num; + } + // Update _succ_num from v_out to join + for (u = v_out; u != join; u = _parent[u]) { + _succ_num[u] -= old_succ_num; + } + } + + // Update potentials + void updatePotential() { + Cost sigma = _forward[u_in] ? + _pi[v_in] - _pi[u_in] - _cost[_pred[u_in]] : + _pi[v_in] - _pi[u_in] + _cost[_pred[u_in]]; + // Update potentials in the subtree, which has been moved + int end = _thread[_last_succ[u_in]]; + for (int u = u_in; u != end; u = _thread[u]) { + _pi[u] += sigma; + } + } + + // Execute the algorithm + ProblemType start(PivotRule pivot_rule) { + // Select the pivot rule implementation + switch (pivot_rule) { + case FIRST_ELIGIBLE: + return start(); + case BEST_ELIGIBLE: + return start(); + case BLOCK_SEARCH: + return start(); + case CANDIDATE_LIST: + return start(); + case ALTERING_LIST: + return start(); + } + return INFEASIBLE; // avoid warning + } + + template + ProblemType start() { + PivotRuleImpl pivot(*this); + + // Execute the Network Simplex algorithm + while (pivot.findEnteringArc()) { + findJoinNode(); + bool change = findLeavingArc(); + if (delta >= INF) return UNBOUNDED; + changeFlow(change); + if (change) { + updateTreeStructure(); + updatePotential(); + } + } + + // Check feasibility + for (int e = _search_arc_num; e != _all_arc_num; ++e) { + if (_flow[e] != 0) return INFEASIBLE; + } + + // Transform the solution and the supply map to the original form + if (_have_lower) { + for (int i = 0; i != _arc_num; ++i) { + Value c = _lower[i]; + if (c != 0) { + _flow[i] += c; + _supply[_source[i]] += c; + _supply[_target[i]] -= c; + } + } + } + + // Shift potentials to meet the requirements of the GEQ/LEQ type + // optimality conditions + if (_sum_supply == 0) { + if (_stype == GEQ) { + Cost max_pot = std::numeric_limits::min(); + for (int i = 0; i != _node_num; ++i) { + if (_pi[i] > max_pot) max_pot = _pi[i]; + } + if (max_pot > 0) { + for (int i = 0; i != _node_num; ++i) + _pi[i] -= max_pot; + } + } else { + Cost min_pot = std::numeric_limits::max(); + for (int i = 0; i != _node_num; ++i) { + if (_pi[i] < min_pot) min_pot = _pi[i]; + } + if (min_pot < 0) { + for (int i = 0; i != _node_num; ++i) + _pi[i] -= min_pot; + } + } + } + + return OPTIMAL; + } + + }; //class NetworkSimplex + + ///@} + +} //namespace lemon + +#endif //LEMON_NETWORK_SIMPLEX_H diff -r c35afa9e89e7 -r ef88c0a30f85 lemon/pairing_heap.h --- /dev/null Thu Jan 01 00:00:00 1970 +0000 +++ b/lemon/pairing_heap.h Thu Nov 05 15:48:01 2009 +0100 @@ -0,0 +1,474 @@ +/* -*- 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 + diff -r c35afa9e89e7 -r ef88c0a30f85 lemon/path.h --- a/lemon/path.h Mon Jan 12 23:11:39 2009 +0100 +++ b/lemon/path.h Thu Nov 05 15:48:01 2009 +0100 @@ -40,7 +40,7 @@ /// \brief A structure for representing directed paths in a digraph. /// /// A structure for representing directed path in a digraph. - /// \tparam _Digraph The digraph type in which the path is. + /// \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 @@ -52,11 +52,11 @@ /// insertion and erase is done in O(1) (amortized) time. The /// implementation uses two vectors for storing the front and back /// insertions. - template + template class Path { public: - typedef _Digraph Digraph; + typedef GR Digraph; typedef typename Digraph::Arc Arc; /// \brief Default constructor @@ -137,7 +137,7 @@ /// \brief The nth arc. /// - /// \pre n is in the [0..length() - 1] range + /// \pre \c n is in the [0..length() - 1] range. const Arc& nth(int n) const { return n < int(head.size()) ? *(head.rbegin() + n) : *(tail.begin() + (n - head.size())); @@ -145,7 +145,7 @@ /// \brief Initialize arc iterator to point to the nth arc /// - /// \pre n is in the [0..length() - 1] range + /// \pre \c n is in the [0..length() - 1] range. ArcIt nthIt(int n) const { return ArcIt(*this, n); } @@ -228,7 +228,7 @@ /// \brief A structure for representing directed paths in a digraph. /// /// A structure for representing directed path in a digraph. - /// \tparam _Digraph The digraph type in which the path is. + /// \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 @@ -240,11 +240,11 @@ /// erasure is amortized O(1) time. This implementation is faster /// then the \c Path type because it use just one vector for the /// arcs. - template + template class SimplePath { public: - typedef _Digraph Digraph; + typedef GR Digraph; typedef typename Digraph::Arc Arc; /// \brief Default constructor @@ -329,7 +329,7 @@ /// \brief The nth arc. /// - /// \pre n is in the [0..length() - 1] range + /// \pre \c n is in the [0..length() - 1] range. const Arc& nth(int n) const { return data[n]; } @@ -392,7 +392,7 @@ /// \brief A structure for representing directed paths in a digraph. /// /// A structure for representing directed path in a digraph. - /// \tparam _Digraph The digraph type in which the path is. + /// \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 @@ -404,11 +404,11 @@ /// of the arc in the path. The length can be computed in O(n) /// time. The front and back insertion and erasure is O(1) time /// and it can be splited and spliced in O(1) time. - template + template class ListPath { public: - typedef _Digraph Digraph; + typedef GR Digraph; typedef typename Digraph::Arc Arc; protected: @@ -507,7 +507,7 @@ /// \brief The nth arc. /// /// This function looks for the nth arc in O(n) time. - /// \pre n is in the [0..length() - 1] range + /// \pre \c n is in the [0..length() - 1] range. const Arc& nth(int n) const { Node *node = first; for (int i = 0; i < n; ++i) { @@ -732,7 +732,7 @@ /// \brief A structure for representing directed paths in a digraph. /// /// A structure for representing directed path in a digraph. - /// \tparam _Digraph The digraph type in which the path is. + /// \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 @@ -746,11 +746,11 @@ /// Being the the most memory efficient path type in LEMON, /// it is intented to be /// used when you want to store a large number of paths. - template + template class StaticPath { public: - typedef _Digraph Digraph; + typedef GR Digraph; typedef typename Digraph::Arc Arc; /// \brief Default constructor @@ -833,7 +833,7 @@ /// \brief The nth arc. /// - /// \pre n is in the [0..length() - 1] range + /// \pre \c n is in the [0..length() - 1] range. const Arc& nth(int n) const { return arcs[n]; } @@ -929,9 +929,8 @@ }; template ::value, - bool revEnable = RevPathTagIndicator::value> - struct PathCopySelector { + bool buildEnable = BuildTagIndicator::value> + struct PathCopySelectorForward { static void copy(Target& target, const Source& source) { target.clear(); for (typename Source::ArcIt it(source); it != INVALID; ++it) { @@ -941,7 +940,16 @@ }; template - struct PathCopySelector { + struct PathCopySelectorForward { + static void copy(Target& target, const Source& source) { + target.clear(); + target.build(source); + } + }; + + template ::value> + struct PathCopySelectorBackward { static void copy(Target& target, const Source& source) { target.clear(); for (typename Source::RevArcIt it(source); it != INVALID; ++it) { @@ -951,21 +959,29 @@ }; template - struct PathCopySelector { - static void copy(Target& target, const Source& source) { - target.clear(); - target.build(source); - } - }; - - template - struct PathCopySelector { + struct PathCopySelectorBackward { static void copy(Target& target, const Source& source) { target.clear(); target.buildRev(source); } }; + + template ::value> + struct PathCopySelector { + static void copy(Target& target, const Source& source) { + PathCopySelectorForward::copy(target, source); + } + }; + + template + struct PathCopySelector { + static void copy(Target& target, const Source& source) { + PathCopySelectorBackward::copy(target, source); + } + }; + } @@ -999,18 +1015,20 @@ /// \brief The source of a path /// - /// This function returns the source of the given path. + /// This function returns the source node of the given path. + /// If the path is empty, then it returns \c INVALID. template typename Digraph::Node pathSource(const Digraph& digraph, const Path& path) { - return digraph.source(path.front()); + return path.empty() ? INVALID : digraph.source(path.front()); } /// \brief The target of a path /// - /// This function returns the target of the given path. + /// This function returns the target node of the given path. + /// If the path is empty, then it returns \c INVALID. template typename Digraph::Node pathTarget(const Digraph& digraph, const Path& path) { - return digraph.target(path.back()); + return path.empty() ? INVALID : digraph.target(path.back()); } /// \brief Class which helps to iterate through the nodes of a path diff -r c35afa9e89e7 -r ef88c0a30f85 lemon/preflow.h --- a/lemon/preflow.h Mon Jan 12 23:11:39 2009 +0100 +++ b/lemon/preflow.h Thu Nov 05 15:48:01 2009 +0100 @@ -31,19 +31,19 @@ /// \brief Default traits class of Preflow class. /// /// Default traits class of Preflow class. - /// \tparam _Digraph Digraph type. - /// \tparam _CapacityMap Capacity map type. - template + /// \tparam GR Digraph type. + /// \tparam CAP Capacity map type. + template struct PreflowDefaultTraits { /// \brief The type of the digraph the algorithm runs on. - typedef _Digraph Digraph; + typedef GR Digraph; /// \brief The type of the map that stores the arc capacities. /// /// The type of the map that stores the arc capacities. /// It must meet the \ref concepts::ReadMap "ReadMap" concept. - typedef _CapacityMap CapacityMap; + typedef CAP CapacityMap; /// \brief The type of the flow values. typedef typename CapacityMap::Value Value; @@ -52,12 +52,16 @@ /// /// 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. /// /// This function instantiates a \ref FlowMap. - /// \param digraph The digraph, to which we would like to define + /// \param digraph The digraph for which we would like to define /// the flow map. static FlowMap* createFlowMap(const Digraph& digraph) { return new FlowMap(digraph); @@ -67,14 +71,17 @@ /// /// The elevator type used by Preflow algorithm. /// - /// \sa Elevator - /// \sa LinkedElevator - typedef LinkedElevator Elevator; + /// \sa Elevator, LinkedElevator +#ifdef DOXYGEN + typedef lemon::Elevator Elevator; +#else + typedef lemon::Elevator Elevator; +#endif /// \brief Instantiates an Elevator. /// /// This function instantiates an \ref Elevator. - /// \param digraph The digraph, to which we would like to define + /// \param digraph The digraph for which we would like to define /// the elevator. /// \param max_level The maximum level of the elevator. static Elevator* createElevator(const Digraph& digraph, int max_level) { @@ -94,9 +101,11 @@ /// \brief %Preflow algorithm class. /// /// This class provides an implementation of Goldberg-Tarjan's \e preflow - /// \e push-relabel algorithm producing a flow of maximum value in a - /// digraph. The preflow algorithms are the fastest known maximum - /// flow algorithms. The current implementation use a mixture of the + /// \e push-relabel algorithm producing a \ref max_flow + /// "flow of maximum value" in a digraph \ref clrs01algorithms, + /// \ref amo93networkflows, \ref goldberg88newapproach. + /// The preflow algorithms are the fastest known maximum + /// flow algorithms. The current implementation uses a mixture of the /// \e "highest label" and the \e "bound decrease" heuristics. /// The worst case time complexity of the algorithm is \f$O(n^2\sqrt{e})\f$. /// @@ -104,21 +113,21 @@ /// the maximum flow value and the minimum cut is obtained. The /// second phase constructs a feasible maximum flow on each arc. /// - /// \tparam _Digraph The type of the digraph the algorithm runs on. - /// \tparam _CapacityMap The type of the capacity map. The default map - /// type is \ref concepts::Digraph::ArcMap "_Digraph::ArcMap". + /// \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". #ifdef DOXYGEN - template + template #else - template , - typename _Traits = PreflowDefaultTraits<_Digraph, _CapacityMap> > + template , + typename TR = PreflowDefaultTraits > #endif class Preflow { public: ///The \ref PreflowDefaultTraits "traits class" of the algorithm. - typedef _Traits Traits; + typedef TR Traits; ///The type of the digraph the algorithm runs on. typedef typename Traits::Digraph Digraph; ///The type of the capacity map. @@ -194,9 +203,9 @@ ///@{ - template + template struct SetFlowMapTraits : public Traits { - typedef _FlowMap FlowMap; + typedef T FlowMap; static FlowMap *createFlowMap(const Digraph&) { LEMON_ASSERT(false, "FlowMap is not initialized"); return 0; // ignore warnings @@ -208,16 +217,16 @@ /// /// \ref named-templ-param "Named parameter" for setting FlowMap /// type. - template + template struct SetFlowMap - : public Preflow > { + : public Preflow > { typedef Preflow > Create; + SetFlowMapTraits > Create; }; - template + template struct SetElevatorTraits : public Traits { - typedef _Elevator Elevator; + typedef T Elevator; static Elevator *createElevator(const Digraph&, int) { LEMON_ASSERT(false, "Elevator is not initialized"); return 0; // ignore warnings @@ -233,16 +242,16 @@ /// \ref elevator(Elevator&) "elevator()" function before calling /// \ref run() or \ref init(). /// \sa SetStandardElevator - template + template struct SetElevator - : public Preflow > { + : public Preflow > { typedef Preflow > Create; + SetElevatorTraits > Create; }; - template + template struct SetStandardElevatorTraits : public Traits { - typedef _Elevator Elevator; + typedef T Elevator; static Elevator *createElevator(const Digraph& digraph, int max_level) { return new Elevator(digraph, max_level); } @@ -260,12 +269,12 @@ /// algorithm with the \ref elevator(Elevator&) "elevator()" function /// before calling \ref run() or \ref init(). /// \sa SetElevator - template + template struct SetStandardElevator : public Preflow > { + SetStandardElevatorTraits > { typedef Preflow > Create; + SetStandardElevatorTraits > Create; }; /// @} @@ -370,26 +379,28 @@ return *_level; } - /// \brief Sets the tolerance used by algorithm. + /// \brief Sets the tolerance used by the algorithm. /// - /// Sets the tolerance used by algorithm. - Preflow& tolerance(const Tolerance& tolerance) const { + /// Sets the tolerance object used by the algorithm. + /// \return (*this) + Preflow& tolerance(const Tolerance& tolerance) { _tolerance = tolerance; return *this; } /// \brief Returns a const reference to the tolerance. /// - /// Returns a const reference to the tolerance. + /// Returns a const reference to the tolerance object used by + /// the algorithm. const Tolerance& tolerance() const { - return tolerance; + return _tolerance; } /// \name Execution Control /// The simplest way to execute the preflow algorithm is to use /// \ref run() or \ref runMinCut().\n - /// If you need more control on the initial solution or the execution, - /// first you have to call one of the \ref init() functions, then + /// If you need better control on the initial solution or the execution, + /// you have to call one of the \ref init() functions first, then /// \ref startFirstPhase() and if you need it \ref startSecondPhase(). ///@{ @@ -403,7 +414,7 @@ _phase = true; for (NodeIt n(_graph); n != INVALID; ++n) { - _excess->set(n, 0); + (*_excess)[n] = 0; } for (ArcIt e(_graph); e != INVALID; ++e) { @@ -416,10 +427,10 @@ _level->initAddItem(_target); std::vector queue; - reached.set(_source, true); + reached[_source] = true; queue.push_back(_target); - reached.set(_target, true); + reached[_target] = true; while (!queue.empty()) { _level->initNewLevel(); std::vector nqueue; @@ -428,7 +439,7 @@ for (InArcIt e(_graph, n); e != INVALID; ++e) { Node u = _graph.source(e); if (!reached[u] && _tolerance.positive((*_capacity)[e])) { - reached.set(u, true); + reached[u] = true; _level->initAddItem(u); nqueue.push_back(u); } @@ -443,7 +454,7 @@ Node u = _graph.target(e); if ((*_level)[u] == _level->maxLevel()) continue; _flow->set(e, (*_capacity)[e]); - _excess->set(u, (*_excess)[u] + (*_capacity)[e]); + (*_excess)[u] += (*_capacity)[e]; if (u != _target && !_level->active(u)) { _level->activate(u); } @@ -477,7 +488,7 @@ excess -= (*_flow)[e]; } if (excess < 0 && n != _source) return false; - _excess->set(n, excess); + (*_excess)[n] = excess; } typename Digraph::template NodeMap reached(_graph, false); @@ -486,10 +497,10 @@ _level->initAddItem(_target); std::vector queue; - reached.set(_source, true); + reached[_source] = true; queue.push_back(_target); - reached.set(_target, true); + reached[_target] = true; while (!queue.empty()) { _level->initNewLevel(); std::vector nqueue; @@ -499,7 +510,7 @@ Node u = _graph.source(e); if (!reached[u] && _tolerance.positive((*_capacity)[e] - (*_flow)[e])) { - reached.set(u, true); + reached[u] = true; _level->initAddItem(u); nqueue.push_back(u); } @@ -507,7 +518,7 @@ for (OutArcIt e(_graph, n); e != INVALID; ++e) { Node v = _graph.target(e); if (!reached[v] && _tolerance.positive((*_flow)[e])) { - reached.set(v, true); + reached[v] = true; _level->initAddItem(v); nqueue.push_back(v); } @@ -523,7 +534,7 @@ Node u = _graph.target(e); if ((*_level)[u] == _level->maxLevel()) continue; _flow->set(e, (*_capacity)[e]); - _excess->set(u, (*_excess)[u] + rem); + (*_excess)[u] += rem; if (u != _target && !_level->active(u)) { _level->activate(u); } @@ -535,7 +546,7 @@ Node v = _graph.source(e); if ((*_level)[v] == _level->maxLevel()) continue; _flow->set(e, 0); - _excess->set(v, (*_excess)[v] + rem); + (*_excess)[v] += rem; if (v != _target && !_level->active(v)) { _level->activate(v); } @@ -576,12 +587,12 @@ } if (!_tolerance.less(rem, excess)) { _flow->set(e, (*_flow)[e] + excess); - _excess->set(v, (*_excess)[v] + excess); + (*_excess)[v] += excess; excess = 0; goto no_more_push_1; } else { excess -= rem; - _excess->set(v, (*_excess)[v] + rem); + (*_excess)[v] += rem; _flow->set(e, (*_capacity)[e]); } } else if (new_level > (*_level)[v]) { @@ -599,12 +610,12 @@ } if (!_tolerance.less(rem, excess)) { _flow->set(e, (*_flow)[e] - excess); - _excess->set(v, (*_excess)[v] + excess); + (*_excess)[v] += excess; excess = 0; goto no_more_push_1; } else { excess -= rem; - _excess->set(v, (*_excess)[v] + rem); + (*_excess)[v] += rem; _flow->set(e, 0); } } else if (new_level > (*_level)[v]) { @@ -614,7 +625,7 @@ no_more_push_1: - _excess->set(n, excess); + (*_excess)[n] = excess; if (excess != 0) { if (new_level + 1 < _level->maxLevel()) { @@ -649,12 +660,12 @@ } if (!_tolerance.less(rem, excess)) { _flow->set(e, (*_flow)[e] + excess); - _excess->set(v, (*_excess)[v] + excess); + (*_excess)[v] += excess; excess = 0; goto no_more_push_2; } else { excess -= rem; - _excess->set(v, (*_excess)[v] + rem); + (*_excess)[v] += rem; _flow->set(e, (*_capacity)[e]); } } else if (new_level > (*_level)[v]) { @@ -672,12 +683,12 @@ } if (!_tolerance.less(rem, excess)) { _flow->set(e, (*_flow)[e] - excess); - _excess->set(v, (*_excess)[v] + excess); + (*_excess)[v] += excess; excess = 0; goto no_more_push_2; } else { excess -= rem; - _excess->set(v, (*_excess)[v] + rem); + (*_excess)[v] += rem; _flow->set(e, 0); } } else if (new_level > (*_level)[v]) { @@ -687,7 +698,7 @@ no_more_push_2: - _excess->set(n, excess); + (*_excess)[n] = excess; if (excess != 0) { if (new_level + 1 < _level->maxLevel()) { @@ -730,7 +741,7 @@ typename Digraph::template NodeMap reached(_graph); for (NodeIt n(_graph); n != INVALID; ++n) { - reached.set(n, (*_level)[n] < _level->maxLevel()); + reached[n] = (*_level)[n] < _level->maxLevel(); } _level->initStart(); @@ -738,7 +749,7 @@ std::vector queue; queue.push_back(_source); - reached.set(_source, true); + reached[_source] = true; while (!queue.empty()) { _level->initNewLevel(); @@ -748,7 +759,7 @@ for (OutArcIt e(_graph, n); e != INVALID; ++e) { Node v = _graph.target(e); if (!reached[v] && _tolerance.positive((*_flow)[e])) { - reached.set(v, true); + reached[v] = true; _level->initAddItem(v); nqueue.push_back(v); } @@ -757,7 +768,7 @@ Node u = _graph.source(e); if (!reached[u] && _tolerance.positive((*_capacity)[e] - (*_flow)[e])) { - reached.set(u, true); + reached[u] = true; _level->initAddItem(u); nqueue.push_back(u); } @@ -791,12 +802,12 @@ } if (!_tolerance.less(rem, excess)) { _flow->set(e, (*_flow)[e] + excess); - _excess->set(v, (*_excess)[v] + excess); + (*_excess)[v] += excess; excess = 0; goto no_more_push; } else { excess -= rem; - _excess->set(v, (*_excess)[v] + rem); + (*_excess)[v] += rem; _flow->set(e, (*_capacity)[e]); } } else if (new_level > (*_level)[v]) { @@ -814,12 +825,12 @@ } if (!_tolerance.less(rem, excess)) { _flow->set(e, (*_flow)[e] - excess); - _excess->set(v, (*_excess)[v] + excess); + (*_excess)[v] += excess; excess = 0; goto no_more_push; } else { excess -= rem; - _excess->set(v, (*_excess)[v] + rem); + (*_excess)[v] += rem; _flow->set(e, 0); } } else if (new_level > (*_level)[v]) { @@ -829,7 +840,7 @@ no_more_push: - _excess->set(n, excess); + (*_excess)[n] = excess; if (excess != 0) { if (new_level + 1 < _level->maxLevel()) { @@ -900,9 +911,9 @@ return (*_excess)[_target]; } - /// \brief Returns the flow on the given arc. + /// \brief Returns the flow value on the given arc. /// - /// Returns the flow on the given arc. This method can + /// Returns the flow value on the given arc. This method can /// be called after the second phase of the algorithm. /// /// \pre Either \ref run() or \ref init() must be called before @@ -946,7 +957,7 @@ /// could be slightly different if inexact computation is used. /// /// \note This function calls \ref minCut() for each node, so it runs in - /// \f$O(n)\f$ time. + /// O(n) time. /// /// \pre Either \ref run() or \ref init() must be called before /// using this function. diff -r c35afa9e89e7 -r ef88c0a30f85 lemon/radix_heap.h --- /dev/null Thu Jan 01 00:00:00 1970 +0000 +++ b/lemon/radix_heap.h Thu Nov 05 15:48:01 2009 +0100 @@ -0,0 +1,438 @@ +/* -*- mode: C++; indent-tabs-mode: nil; -*- + * + * This file is a part of LEMON, a generic C++ optimization library. + * + * Copyright (C) 2003-2009 + * Egervary Jeno Kombinatorikus Optimalizalasi Kutatocsoport + * (Egervary Research Group on Combinatorial Optimization, EGRES). + * + * Permission to use, modify and distribute this software is granted + * provided that this copyright notice appears in all copies. For + * precise terms see the accompanying LICENSE file. + * + * This software is provided "AS IS" with no warranty of any kind, + * express or implied, and with no claim as to its suitability for any + * purpose. + * + */ + +#ifndef LEMON_RADIX_HEAP_H +#define LEMON_RADIX_HEAP_H + +///\ingroup heaps +///\file +///\brief Radix heap implementation. + +#include +#include + +namespace lemon { + + + /// \ingroup heaps + /// + /// \brief Radix heap data structure. + /// + /// This class implements the \e radix \e heap data structure. + /// It practically conforms to the \ref concepts::Heap "heap concept", + /// but it has some limitations due its special implementation. + /// The type of the priorities must be \c int and the priority of an + /// item cannot be decreased under the priority of the last removed item. + /// + /// \tparam IM A read-writable item map with \c int values, used + /// internally to handle the cross references. + template + class RadixHeap { + + public: + + /// Type of the item-int map. + typedef IM ItemIntMap; + /// Type of the priorities. + typedef int Prio; + /// Type of the items stored in the heap. + typedef typename ItemIntMap::Key Item; + + /// \brief Exception thrown by RadixHeap. + /// + /// This exception is thrown when an item is inserted into a + /// RadixHeap with a priority smaller than the last erased one. + /// \see RadixHeap + class PriorityUnderflowError : public Exception { + public: + virtual const char* what() const throw() { + return "lemon::RadixHeap::PriorityUnderflowError"; + } + }; + + /// \brief Type to represent the states of the items. + /// + /// Each item has a state associated to it. It can be "in heap", + /// "pre-heap" or "post-heap". The latter two are indifferent from the + /// heap's point of view, but may be useful to the user. + /// + /// The item-int map must be initialized in such way that it assigns + /// \c PRE_HEAP (-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: + + struct RadixItem { + int prev, next, box; + Item item; + int prio; + RadixItem(Item _item, int _prio) : item(_item), prio(_prio) {} + }; + + struct RadixBox { + int first; + int min, size; + RadixBox(int _min, int _size) : first(-1), min(_min), size(_size) {} + }; + + std::vector _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)) { + extend(); + } + } + + /// \brief The number of items stored in the heap. + /// + /// This function returns the number of items stored in the heap. + int size() const { return _data.size(); } + + /// \brief Check if the heap is empty. + /// + /// This function returns \c true if the heap is empty. + bool empty() const { return _data.empty(); } + + /// \brief Make the heap empty. + /// + /// This functon makes the heap empty. + /// It does not change the cross reference map. If you want to reuse + /// a heap that is not surely empty, you should first clear it and + /// then you should set the cross reference map to \c PRE_HEAP + /// for each item. + /// \param minimum The minimum value of the heap. + /// \param capacity The capacity of the heap. + void clear(int minimum = 0, int capacity = 0) { + _data.clear(); _boxes.clear(); + _boxes.push_back(RadixBox(minimum, 1)); + _boxes.push_back(RadixBox(minimum + 1, 1)); + while (lower(_boxes.size() - 1, capacity + minimum - 1)) { + extend(); + } + } + + private: + + bool upper(int box, Prio pr) { + return pr < _boxes[box].min; + } + + bool lower(int box, Prio pr) { + return pr >= _boxes[box].min + _boxes[box].size; + } + + // Remove item from the box list + void remove(int index) { + if (_data[index].prev >= 0) { + _data[_data[index].prev].next = _data[index].next; + } else { + _boxes[_data[index].box].first = _data[index].next; + } + if (_data[index].next >= 0) { + _data[_data[index].next].prev = _data[index].prev; + } + } + + // Insert item into the box list + void insert(int box, int index) { + if (_boxes[box].first == -1) { + _boxes[box].first = index; + _data[index].next = _data[index].prev = -1; + } else { + _data[index].next = _boxes[box].first; + _data[_boxes[box].first].prev = index; + _data[index].prev = -1; + _boxes[box].first = index; + } + _data[index].box = box; + } + + // Add a new box to the box list + void extend() { + int min = _boxes.back().min + _boxes.back().size; + int bs = 2 * _boxes.back().size; + _boxes.push_back(RadixBox(min, bs)); + } + + // Move an item up into the proper box. + void bubbleUp(int index) { + if (!lower(_data[index].box, _data[index].prio)) return; + remove(index); + int box = findUp(_data[index].box, _data[index].prio); + insert(box, index); + } + + // Find up the proper box for the item with the given priority + int findUp(int start, int pr) { + while (lower(start, pr)) { + if (++start == int(_boxes.size())) { + extend(); + } + } + return start; + } + + // Move an item down into the proper box + void bubbleDown(int index) { + if (!upper(_data[index].box, _data[index].prio)) return; + remove(index); + int box = findDown(_data[index].box, _data[index].prio); + insert(box, index); + } + + // Find down the proper box for the item with the given priority + int findDown(int start, int pr) { + while (upper(start, pr)) { + if (--start < 0) throw PriorityUnderflowError(); + } + return start; + } + + // Find the first non-empty box + int findFirst() { + int first = 0; + while (_boxes[first].first == -1) ++first; + return first; + } + + // Gives back the minimum priority of the given box + int minValue(int box) { + int min = _data[_boxes[box].first].prio; + for (int k = _boxes[box].first; k != -1; k = _data[k].next) { + if (_data[k].prio < min) min = _data[k].prio; + } + return min; + } + + // Rearrange the items of the heap and make the first box non-empty + void moveDown() { + int box = findFirst(); + if (box == 0) return; + int min = minValue(box); + for (int i = 0; i <= box; ++i) { + _boxes[i].min = min; + min += _boxes[i].size; + } + int curr = _boxes[box].first, next; + while (curr != -1) { + next = _data[curr].next; + bubbleDown(curr); + curr = next; + } + } + + void relocateLast(int index) { + if (index != int(_data.size()) - 1) { + _data[index] = _data.back(); + if (_data[index].prev != -1) { + _data[_data[index].prev].next = index; + } else { + _boxes[_data[index].box].first = index; + } + if (_data[index].next != -1) { + _data[_data[index].next].prev = index; + } + _iim[_data[index].item] = index; + } + _data.pop_back(); + } + + public: + + /// \brief Insert an item into the heap with the given priority. + /// + /// This function inserts the given item into the heap with the + /// given priority. + /// \param i The item to insert. + /// \param p The priority of the item. + /// \pre \e i must not be stored in the heap. + /// \warning This method may throw an \c UnderFlowPriorityException. + void push(const Item &i, const Prio &p) { + int n = _data.size(); + _iim.set(i, n); + _data.push_back(RadixItem(i, p)); + while (lower(_boxes.size() - 1, p)) { + extend(); + } + int box = findDown(_boxes.size() - 1, p); + insert(box, n); + } + + /// \brief Return the item having minimum priority. + /// + /// This function returns the item having minimum priority. + /// \pre The heap must be non-empty. + Item top() const { + const_cast&>(*this).moveDown(); + return _data[_boxes[0].first].item; + } + + /// \brief The minimum priority. + /// + /// This function returns the minimum priority. + /// \pre The heap must be non-empty. + Prio prio() const { + const_cast&>(*this).moveDown(); + return _data[_boxes[0].first].prio; + } + + /// \brief Remove the item having minimum priority. + /// + /// This function removes the item having minimum priority. + /// \pre The heap must be non-empty. + void pop() { + moveDown(); + int index = _boxes[0].first; + _iim[_data[index].item] = POST_HEAP; + remove(index); + relocateLast(index); + } + + /// \brief Remove the given item from the heap. + /// + /// This function removes the given item from the heap if it is + /// already stored. + /// \param i The item to delete. + /// \pre \e i must be in the heap. + void erase(const Item &i) { + int index = _iim[i]; + _iim[i] = POST_HEAP; + remove(index); + relocateLast(index); + } + + /// \brief The priority of the given item. + /// + /// This function returns the priority of the given item. + /// \param i The item. + /// \pre \e i must be in the heap. + Prio operator[](const Item &i) const { + int idx = _iim[i]; + return _data[idx].prio; + } + + /// \brief Set the priority of an item or insert it, if it is + /// not stored in the heap. + /// + /// This method sets the priority of the given item if it is + /// already stored in the heap. Otherwise it inserts the given + /// item into the heap with the given priority. + /// \param i The item. + /// \param p The priority. + /// \pre \e i must be in the heap. + /// \warning This method may throw an \c UnderFlowPriorityException. + void set(const Item &i, const Prio &p) { + int idx = _iim[i]; + if( idx < 0 ) { + push(i, p); + } + else if( p >= _data[idx].prio ) { + _data[idx].prio = p; + bubbleUp(idx); + } else { + _data[idx].prio = p; + bubbleDown(idx); + } + } + + /// \brief Decrease the priority of an item to the given value. + /// + /// This function decreases the priority of an item to the given value. + /// \param i The item. + /// \param p The priority. + /// \pre \e i must be stored in the heap with priority at least \e p. + /// \warning This method may throw an \c UnderFlowPriorityException. + void decrease(const Item &i, const Prio &p) { + int idx = _iim[i]; + _data[idx].prio = p; + bubbleDown(idx); + } + + /// \brief Increase the priority of an item to the given value. + /// + /// This function increases the priority of an item to the given value. + /// \param i The item. + /// \param p The priority. + /// \pre \e i must be stored in the heap with priority at most \e p. + void increase(const Item &i, const Prio &p) { + int idx = _iim[i]; + _data[idx].prio = p; + bubbleUp(idx); + } + + /// \brief Return the state of an item. + /// + /// This method returns \c PRE_HEAP if the given item has never + /// been in the heap, \c IN_HEAP if it is in the heap at the moment, + /// and \c POST_HEAP otherwise. + /// In the latter case it is possible that the item will get back + /// to the heap again. + /// \param i The item. + State state(const Item &i) const { + int s = _iim[i]; + if( s >= 0 ) s = 0; + return State(s); + } + + /// \brief Set the state of an item in the heap. + /// + /// This function sets the state of the given item in the heap. + /// It can be used to manually clear the heap when it is important + /// to achive better time complexity. + /// \param i The item. + /// \param st The state. It should not be \c IN_HEAP. + void state(const Item& i, State st) { + switch (st) { + case POST_HEAP: + case PRE_HEAP: + if (state(i) == IN_HEAP) { + erase(i); + } + _iim[i] = st; + break; + case IN_HEAP: + break; + } + } + + }; // class RadixHeap + +} // namespace lemon + +#endif // LEMON_RADIX_HEAP_H diff -r c35afa9e89e7 -r ef88c0a30f85 lemon/radix_sort.h --- a/lemon/radix_sort.h Mon Jan 12 23:11:39 2009 +0100 +++ b/lemon/radix_sort.h Thu Nov 05 15:48:01 2009 +0100 @@ -205,11 +205,11 @@ /// the identity function instead. /// /// This is a special quick sort algorithm where the pivot - /// values to split the items are choosen to be \f$ 2^k \f$ for each \c k. - /// Therefore, the time complexity of the - /// algorithm is \f$ O(\log(c)n) \f$ and it uses \f$ O(\log(c)) \f$, - /// additional space, where \c c is the maximal value and \c n is the - /// number of the items in the container. + /// values to split the items are choosen to be 2k + /// for each \c k. + /// Therefore, the time complexity of the algorithm is O(log(c)*n) and + /// it uses O(log(c)) additional space, where \c c is the maximal value + /// and \c n is the number of the items in the container. /// /// \param first The begin of the given range. /// \param last The end of the given range. @@ -430,10 +430,10 @@ /// bytes of the integer number. The algorithm sorts the items /// byte-by-byte. First, it counts how many times a byte value occurs /// in the container, then it copies the corresponding items to - /// another container in asceding order in \c O(n) time. + /// another container in asceding order in O(n) time. /// - /// The time complexity of the algorithm is \f$ O(\log(c)n) \f$ and - /// it uses \f$ O(n) \f$, additional space, where \c c is the + /// The time complexity of the algorithm is O(log(c)*n) and + /// it uses O(n) additional space, where \c c is the /// maximal value and \c n is the number of the items in the /// container. /// diff -r c35afa9e89e7 -r ef88c0a30f85 lemon/random.h --- a/lemon/random.h Mon Jan 12 23:11:39 2009 +0100 +++ b/lemon/random.h Thu Nov 05 15:48:01 2009 +0100 @@ -77,7 +77,7 @@ #include #include #else -#include +#include #endif ///\ingroup misc @@ -344,56 +344,46 @@ } }; - template = 0)> + template struct ShiftMultiplier { static const Result multiplier() { Result res = ShiftMultiplier::multiplier(); res *= res; - if ((exp & 1) == 1) res *= static_cast(2.0); - return res; - } - }; - - template - struct ShiftMultiplier { - static const Result multiplier() { - Result res = ShiftMultiplier::multiplier(); - res *= res; if ((exp & 1) == 1) res *= static_cast(0.5); return res; } }; template - struct ShiftMultiplier { + struct ShiftMultiplier { static const Result multiplier() { return static_cast(1.0); } }; template - struct ShiftMultiplier { + struct ShiftMultiplier { static const Result multiplier() { return static_cast(1.0/1048576.0); } }; template - struct ShiftMultiplier { + struct ShiftMultiplier { static const Result multiplier() { - return static_cast(1.0/424967296.0); + return static_cast(1.0/4294967296.0); } }; template - struct ShiftMultiplier { + struct ShiftMultiplier { static const Result multiplier() { return static_cast(1.0/9007199254740992.0); } }; template - struct ShiftMultiplier { + struct ShiftMultiplier { static const Result multiplier() { return static_cast(1.0/18446744073709551616.0); } @@ -413,7 +403,7 @@ static const int bits = std::numeric_limits::digits; static Result convert(RandomCore& rnd) { - return Shifting:: + return Shifting:: shift(static_cast(rnd() >> (bits - rest))); } }; @@ -423,7 +413,7 @@ static const int bits = std::numeric_limits::digits; static Result convert(RandomCore& rnd) { - return Shifting:: + return Shifting:: shift(static_cast(rnd())) + RealConversion:: convert(rnd); @@ -613,7 +603,7 @@ /// By default, this function calls the \c seedFromFile() member /// function with the /dev/urandom file. If it does not success, /// it uses the \c seedFromTime(). - /// \return Currently always true. + /// \return Currently always \c true. bool seed() { #ifndef WIN32 if (seedFromFile("/dev/urandom", 0)) return true; @@ -634,7 +624,7 @@ /// entropy). /// \param file The source file /// \param offset The offset, from the file read. - /// \return True when the seeding successes. + /// \return \c true when the seeding successes. #ifndef WIN32 bool seedFromFile(const std::string& file = "/dev/urandom", int offset = 0) #else @@ -655,23 +645,21 @@ /// Seding from process id and time. This function uses the /// current process id and the current time for initialize the /// random sequence. - /// \return Currently always true. + /// \return Currently always \c true. bool seedFromTime() { #ifndef WIN32 timeval tv; gettimeofday(&tv, 0); seed(getpid() + tv.tv_sec + tv.tv_usec); #else - FILETIME time; - GetSystemTimeAsFileTime(&time); - seed(GetCurrentProcessId() + time.dwHighDateTime + time.dwLowDateTime); + seed(bits::getWinRndSeed()); #endif return true; } /// @} - ///\name Uniform distributions + ///\name Uniform Distributions /// /// @{ @@ -774,7 +762,7 @@ /// @} - ///\name Non-uniform distributions + ///\name Non-uniform Distributions /// ///@{ @@ -950,7 +938,7 @@ ///@} - ///\name Two dimensional distributions + ///\name Two Dimensional Distributions /// ///@{ diff -r c35afa9e89e7 -r ef88c0a30f85 lemon/smart_graph.h --- a/lemon/smart_graph.h Mon Jan 12 23:11:39 2009 +0100 +++ b/lemon/smart_graph.h Thu Nov 05 15:48:01 2009 +0100 @@ -32,10 +32,7 @@ namespace lemon { class SmartDigraph; - ///Base of SmartDigraph - ///Base of SmartDigraph - /// class SmartDigraphBase { protected: @@ -55,7 +52,7 @@ public: - typedef SmartDigraphBase Graph; + typedef SmartDigraphBase Digraph; class Node; class Arc; @@ -187,32 +184,26 @@ /// ///\brief A smart directed graph class. /// - ///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 conforms to the \ref concepts::Digraph "Digraph concept" with - ///an important extra feature that its maps are real \ref - ///concepts::ReferenceMap "reference map"s. + ///\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). /// - ///\sa concepts::Digraph. + ///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. + /// + ///\sa concepts::Digraph + ///\sa SmartGraph class SmartDigraph : public ExtendedSmartDigraphBase { - public: - typedef ExtendedSmartDigraphBase Parent; private: - - ///SmartDigraph is \e not copy constructible. Use DigraphCopy() instead. - - ///SmartDigraph is \e not copy constructible. Use DigraphCopy() instead. - /// + /// Digraphs are \e not copy constructible. Use DigraphCopy instead. SmartDigraph(const SmartDigraph &) : ExtendedSmartDigraphBase() {}; - ///\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. + /// \brief Assignment of a digraph to another one is \e not allowed. + /// Use DigraphCopy instead. void operator=(const SmartDigraph &) {} public: @@ -225,79 +216,49 @@ ///Add a new node to the digraph. - /// \return the new node. - /// + ///This function adds a new node to the digraph. + ///\return The new node. Node addNode() { return Parent::addNode(); } ///Add a new arc to the digraph. - ///Add a new arc to the digraph with source node \c s + ///This function adds a new arc to the digraph with source node \c s ///and target node \c t. - ///\return the new arc. - Arc addArc(const Node& s, const Node& t) { + ///\return The new arc. + Arc addArc(Node s, 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 true if the given node is valid, - /// ie. it is a real node of the graph. + /// 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 (using Snapshot) could become valid again - /// when new nodes are added to the graph. + /// if new nodes are added to the digraph. 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. + /// 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 (using Snapshot) could become valid again - /// when new arcs are added to the graph. + /// if 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 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. + ///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. ///\return The newly created node. /// - ///\note The Arcs - ///referencing a moved arc remain - ///valid. However InArc's and OutArc's - ///may be invalidated. + ///\note All iterators remain valid. + /// ///\warning This functionality cannot be used together with the Snapshot ///feature. Node split(Node n, bool connect = true) @@ -312,6 +273,34 @@ return b; } + ///Clear the digraph. + + ///This function erases all nodes and arcs from the digraph. + /// + void clear() { + Parent::clear(); + } + + /// Reserve memory for nodes. + + /// Using this function, it is possible to avoid superfluous memory + /// allocation: if you know that the digraph you want to build will + /// be large (e.g. it will contain millions of nodes and/or arcs), + /// then it is worth reserving space for this amount before starting + /// to build the digraph. + /// \sa reserveArc() + void reserveNode(int n) { nodes.reserve(n); }; + + /// Reserve memory for arcs. + + /// Using this function, it is possible to avoid superfluous memory + /// allocation: if you know that the digraph you want to build will + /// be large (e.g. it will contain millions of nodes and/or arcs), + /// then it is worth reserving space for this amount before starting + /// to build the digraph. + /// \sa reserveNode() + void reserveArc(int m) { arcs.reserve(m); }; + public: class Snapshot; @@ -336,20 +325,23 @@ public: - ///Class to make a snapshot of the digraph and to restrore to 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 restore 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. + ///restore() function. This is the only way for deleting nodes and/or + ///arcs from a SmartDigraph structure. /// - ///\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. + ///\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. class Snapshot { SmartDigraph *_graph; @@ -361,39 +353,32 @@ ///Default constructor. ///Default constructor. - ///To actually make a snapshot you must call save(). - /// + ///You have to call save() to actually make a snapshot. Snapshot() : _graph(0) {} ///Constructor that immediately makes a snapshot - ///This constructor immediately makes a snapshot of the digraph. - ///\param graph The digraph we make a snapshot of. - Snapshot(SmartDigraph &graph) : _graph(&graph) { + ///This constructor immediately makes a snapshot of the given digraph. + /// + Snapshot(SmartDigraph &gr) : _graph(&gr) { node_num=_graph->nodes.size(); arc_num=_graph->arcs.size(); } ///Make a snapshot. - ///Make a snapshot of the digraph. - /// - ///This function can be called more than once. In case of a repeated + ///This function makes a snapshot of the given digraph. + ///It can be called more than once. In case of a repeated ///call, the previous snapshot gets lost. - ///\param graph The digraph we make the snapshot of. - void save(SmartDigraph &graph) - { - _graph=&graph; + void save(SmartDigraph &gr) { + _graph=&gr; node_num=_graph->nodes.size(); arc_num=_graph->arcs.size(); } ///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(). + ///This function undos the changes until the last snapshot + ///created by save() or Snapshot(SmartDigraph&). void restore() { _graph->restoreSnapshot(*this); @@ -422,7 +407,7 @@ public: - typedef SmartGraphBase Digraph; + typedef SmartGraphBase Graph; class Node; class Arc; @@ -512,7 +497,7 @@ node._id = nodes.size() - 1; } - void next(Node& node) const { + static void next(Node& node) { --node._id; } @@ -520,7 +505,7 @@ arc._id = arcs.size() - 1; } - void next(Arc& arc) const { + static void next(Arc& arc) { --arc._id; } @@ -528,7 +513,7 @@ arc._id = arcs.size() / 2 - 1; } - void next(Edge& arc) const { + static void next(Edge& arc) { --arc._id; } @@ -625,95 +610,107 @@ /// /// \brief A smart undirected graph class. /// - /// 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. - /// Except from this it conforms to - /// the \ref concepts::Graph "Graph concept". + /// \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). /// - /// It also has an - /// important extra feature that - /// its maps are real \ref concepts::ReferenceMap "reference map"s. + /// 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. /// - /// \sa concepts::Graph. - /// + /// \sa concepts::Graph + /// \sa SmartDigraph class SmartGraph : public ExtendedSmartGraphBase { + typedef ExtendedSmartGraphBase Parent; + private: - - ///SmartGraph is \e not copy constructible. Use GraphCopy() instead. - - ///SmartGraph is \e not copy constructible. Use GraphCopy() instead. - /// + /// Graphs are \e not copy constructible. Use GraphCopy instead. SmartGraph(const SmartGraph &) : ExtendedSmartGraphBase() {}; - - ///\brief Assignment of SmartGraph to another one is \e not allowed. - ///Use GraphCopy() instead. - - ///Assignment of SmartGraph to another one is \e not allowed. - ///Use GraphCopy() instead. + /// \brief Assignment of a graph to another one is \e not allowed. + /// Use GraphCopy instead. void operator=(const SmartGraph &) {} public: - typedef ExtendedSmartGraphBase Parent; - /// Constructor /// Constructor. /// SmartGraph() {} - ///Add a new node to the graph. - - /// \return the new node. + /// \brief Add a new node to the graph. /// + /// This function adds a new node to the graph. + /// \return The new node. Node addNode() { return Parent::addNode(); } - ///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 Add a new edge to the graph. + /// + /// This function adds a new edge to the graph between nodes + /// \c u and \c v with inherent orientation from node \c u to + /// node \c v. + /// \return The new edge. + Edge addEdge(Node u, Node v) { + return Parent::addEdge(u, v); } /// \brief Node validity check /// - /// This function gives back true if the given node is valid, - /// ie. it is a real node of the graph. + /// This function gives back \c true if the given node is valid, + /// i.e. it is a real node of the graph. /// /// \warning A removed node (using Snapshot) could become valid again - /// when new nodes are added to the graph. + /// if new nodes are added to the graph. bool valid(Node n) const { return Parent::valid(n); } + /// \brief Edge validity check + /// + /// This function gives back \c true if the given edge is valid, + /// i.e. it is a real edge of the graph. + /// + /// \warning A removed edge (using Snapshot) could become valid again + /// if new edges are added to the graph. + bool valid(Edge e) const { return Parent::valid(e); } + /// \brief Arc validity check /// - /// This function gives back true if the given arc is valid, - /// ie. it is a real arc of the graph. + /// 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 - /// when new edges are added to the graph. + /// if new edges are added to the graph. bool valid(Arc a) const { return Parent::valid(a); } - /// \brief Edge validity check - /// - /// 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 - /// when new edges are added to the graph. - bool valid(Edge e) const { return Parent::valid(e); } - ///Clear the graph. - ///Erase all the nodes and edges from the graph. + ///This function erases all nodes and arcs from the graph. /// void clear() { Parent::clear(); } + /// Reserve memory for nodes. + + /// Using this function, it is possible to avoid superfluous memory + /// allocation: if you know that the graph you want to build will + /// be large (e.g. it will contain millions of nodes and/or edges), + /// then it is worth reserving space for this amount before starting + /// to build the graph. + /// \sa reserveEdge() + void reserveNode(int n) { nodes.reserve(n); }; + + /// Reserve memory for edges. + + /// Using this function, it is possible to avoid superfluous memory + /// allocation: if you know that the graph you want to build will + /// be large (e.g. it will contain millions of nodes and/or edges), + /// then it is worth reserving space for this amount before starting + /// to build the graph. + /// \sa reserveNode() + void reserveEdge(int m) { arcs.reserve(2 * m); }; + public: class Snapshot; @@ -752,21 +749,22 @@ public: - ///Class to make a snapshot of the digraph and to restrore to it later. + ///Class to make a snapshot of the graph 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 graph and to restore it later. /// - ///The newly added nodes and arcs can be removed using the - ///restore() function. + ///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 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. + ///\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 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. + ///\warning The validity of the snapshot is not stored due to + ///performance reasons. If you do not use the snapshot correctly, + ///it can cause broken program, invalid or not restored state of + ///the graph or no change. class Snapshot { SmartGraph *_graph; @@ -778,36 +776,30 @@ ///Default constructor. ///Default constructor. - ///To actually make a snapshot you must call save(). - /// + ///You have to call save() to actually make a snapshot. Snapshot() : _graph(0) {} ///Constructor that immediately makes a snapshot - ///This constructor immediately makes a snapshot of the digraph. - ///\param graph The digraph we make a snapshot of. - Snapshot(SmartGraph &graph) { - graph.saveSnapshot(*this); + /// This constructor immediately makes a snapshot of the given graph. + /// + Snapshot(SmartGraph &gr) { + gr.saveSnapshot(*this); } ///Make a snapshot. - ///Make a snapshot of the graph. - /// - ///This function can be called more than once. In case of a repeated + ///This function makes a snapshot of the given graph. + ///It can be called more than once. In case of a repeated ///call, the previous snapshot gets lost. - ///\param graph The digraph we make the snapshot of. - void save(SmartGraph &graph) + void save(SmartGraph &gr) { - graph.saveSnapshot(*this); + gr.saveSnapshot(*this); } - ///Undo the changes until a snapshot. + ///Undo the changes until the last 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(). + ///This function undos the changes until the last snapshot + ///created by save() or Snapshot(SmartGraph&). void restore() { _graph->restoreSnapshot(*this); diff -r c35afa9e89e7 -r ef88c0a30f85 lemon/soplex.cc --- a/lemon/soplex.cc Mon Jan 12 23:11:39 2009 +0100 +++ b/lemon/soplex.cc Thu Nov 05 15:48:01 2009 +0100 @@ -19,7 +19,8 @@ #include #include -#include +#include +#include ///\file @@ -28,6 +29,7 @@ SoplexLp::SoplexLp() { soplex = new soplex::SoPlex; + messageLevel(MESSAGE_NOTHING); } SoplexLp::~SoplexLp() { @@ -47,6 +49,7 @@ _row_names = lp._row_names; _row_names_ref = lp._row_names_ref; + messageLevel(MESSAGE_NOTHING); } void SoplexLp::_clear_temporals() { @@ -54,12 +57,12 @@ _dual_values.clear(); } - SoplexLp* SoplexLp::_newSolver() const { + SoplexLp* SoplexLp::newSolver() const { SoplexLp* newlp = new SoplexLp(); return newlp; } - SoplexLp* SoplexLp::_cloneSolver() const { + SoplexLp* SoplexLp::cloneSolver() const { SoplexLp* newlp = new SoplexLp(*this); return newlp; } @@ -88,6 +91,19 @@ return soplex->nRows() - 1; } + int SoplexLp::_addRow(Value l, ExprIterator b, ExprIterator e, Value u) { + soplex::DSVector v; + for (ExprIterator it = b; it != e; ++it) { + v.add(it->first, it->second); + } + soplex::LPRow r(l, v, u); + soplex->addRow(r); + + _row_names.push_back(std::string()); + + return soplex->nRows() - 1; + } + void SoplexLp::_eraseCol(int i) { soplex->removeCol(i); @@ -271,6 +287,8 @@ SoplexLp::SolveExitStatus SoplexLp::_solve() { _clear_temporals(); + + _applyMessageLevel(); soplex::SPxSolver::Status status = soplex->solve(); @@ -419,5 +437,29 @@ _clear_temporals(); } + void SoplexLp::_messageLevel(MessageLevel level) { + switch (level) { + case MESSAGE_NOTHING: + _message_level = -1; + break; + case MESSAGE_ERROR: + _message_level = soplex::SPxOut::ERROR; + break; + case MESSAGE_WARNING: + _message_level = soplex::SPxOut::WARNING; + break; + case MESSAGE_NORMAL: + _message_level = soplex::SPxOut::INFO2; + break; + case MESSAGE_VERBOSE: + _message_level = soplex::SPxOut::DEBUG; + break; + } + } + + void SoplexLp::_applyMessageLevel() { + soplex::Param::setVerbose(_message_level); + } + } //namespace lemon diff -r c35afa9e89e7 -r ef88c0a30f85 lemon/soplex.h --- a/lemon/soplex.h Mon Jan 12 23:11:39 2009 +0100 +++ b/lemon/soplex.h Thu Nov 05 15:48:01 2009 +0100 @@ -73,16 +73,18 @@ SoplexLp(const SoplexLp&); /// \e ~SoplexLp(); + /// \e + virtual SoplexLp* newSolver() const; + /// \e + virtual SoplexLp* cloneSolver() const; protected: - virtual SoplexLp* _newSolver() const; - virtual SoplexLp* _cloneSolver() const; - virtual const char* _solverName() const; virtual int _addCol(); virtual int _addRow(); + virtual int _addRow(Value l, ExprIterator b, ExprIterator e, Value u); virtual void _eraseCol(int i); virtual void _eraseRow(int i); @@ -143,6 +145,11 @@ virtual void _clear(); + void _messageLevel(MessageLevel m); + void _applyMessageLevel(); + + int _message_level; + }; } //END OF NAMESPACE LEMON diff -r c35afa9e89e7 -r ef88c0a30f85 lemon/static_graph.h --- /dev/null Thu Jan 01 00:00:00 1970 +0000 +++ b/lemon/static_graph.h Thu Nov 05 15:48:01 2009 +0100 @@ -0,0 +1,474 @@ +/* -*- C++ -*- + * + * This file is a part of LEMON, a generic C++ optimization library + * + * Copyright (C) 2003-2008 + * Egervary Jeno Kombinatorikus Optimalizalasi Kutatocsoport + * (Egervary Research Group on Combinatorial Optimization, EGRES). + * + * Permission to use, modify and distribute this software is granted + * provided that this copyright notice appears in all copies. For + * precise terms see the accompanying LICENSE file. + * + * This software is provided "AS IS" with no warranty of any kind, + * express or implied, and with no claim as to its suitability for any + * purpose. + * + */ + +#ifndef LEMON_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. + /// + /// \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 diff -r c35afa9e89e7 -r ef88c0a30f85 lemon/suurballe.h --- a/lemon/suurballe.h Mon Jan 12 23:11:39 2009 +0100 +++ b/lemon/suurballe.h Thu Nov 05 15:48:01 2009 +0100 @@ -25,8 +25,11 @@ /// nodes having minimum total length. #include +#include #include #include +#include +#include namespace lemon { @@ -40,51 +43,65 @@ /// finding arc-disjoint paths having minimum total length (cost) /// from a given source node to a given target node in a digraph. /// - /// In fact, this implementation is the specialization of the - /// \ref CapacityScaling "successive shortest path" algorithm. + /// Note that this problem is a special case of the \ref min_cost_flow + /// "minimum cost flow problem". This implementation is actually an + /// efficient specialized version of the \ref CapacityScaling + /// "Successive Shortest Path" algorithm directly for this problem. + /// Therefore this class provides query functions for flow values and + /// node potentials (the dual solution) just like the minimum cost flow + /// algorithms. /// - /// \tparam Digraph The digraph type the algorithm runs on. - /// The default value is \c ListDigraph. - /// \tparam LengthMap The type of the length (cost) map. - /// The default value is Digraph::ArcMap. + /// \tparam GR The digraph type the algorithm runs on. + /// \tparam LEN The type of the length map. + /// The default value is GR::ArcMap. /// /// \warning Length values should be \e non-negative \e integers. /// /// \note For finding node-disjoint paths this algorithm can be used - /// with \ref SplitNodes. + /// along with the \ref SplitNodes adaptor. #ifdef DOXYGEN - template + template #else - template < typename Digraph = ListDigraph, - typename LengthMap = typename Digraph::template ArcMap > + template < typename GR, + typename LEN = typename GR::template ArcMap > #endif class Suurballe { - TEMPLATE_DIGRAPH_TYPEDEFS(Digraph); + TEMPLATE_DIGRAPH_TYPEDEFS(GR); - typedef typename LengthMap::Value Length; typedef ConstMap ConstArcMap; - typedef typename Digraph::template NodeMap PredMap; + typedef typename GR::template NodeMap PredMap; public: + /// The type of the digraph the algorithm runs on. + typedef GR Digraph; + /// The type of the length map. + typedef LEN LengthMap; + /// The type of the lengths. + typedef typename LengthMap::Value Length; +#ifdef DOXYGEN + /// The type of the flow map. + typedef GR::ArcMap FlowMap; + /// The type of the potential map. + 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 SimplePath Path; + typedef SimplePath Path; private: - /// \brief Special implementation of the Dijkstra algorithm - /// for finding shortest paths in the residual network. - /// - /// \ref ResidualDijkstra is a special implementation of the - /// \ref Dijkstra algorithm for finding shortest paths in the - /// residual network of the digraph with respect to the reduced arc - /// lengths and modifying the node potentials according to the - /// distance of the nodes. + // ResidualDijkstra is a special implementation of the + // Dijkstra algorithm for finding shortest paths in the + // residual network with respect to the reduced arc lengths + // and modifying the node potentials according to the + // distance of the nodes. class ResidualDijkstra { typedef typename Digraph::template NodeMap HeapCrossRef; @@ -113,14 +130,14 @@ public: /// Constructor. - ResidualDijkstra( const Digraph &digraph, + ResidualDijkstra( const Digraph &graph, const FlowMap &flow, const LengthMap &length, PotentialMap &potential, PredMap &pred, Node s, Node t ) : - _graph(digraph), _flow(flow), _length(length), _potential(potential), - _dist(digraph), _pred(pred), _s(s), _t(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. @@ -229,16 +246,16 @@ /// /// Constructor. /// - /// \param digraph The digraph the algorithm runs on. + /// \param graph The digraph the algorithm runs on. /// \param length The length (cost) values of the arcs. - /// \param s The source node. - /// \param t The target node. - Suurballe( const Digraph &digraph, - const LengthMap &length, - Node s, Node t ) : - _graph(digraph), _length(length), _flow(0), _local_flow(false), - _potential(0), _local_potential(false), _source(s), _target(t), - _pred(digraph) {} + Suurballe( const Digraph &graph, + const LengthMap &length ) : + _graph(graph), _length(length), _flow(0), _local_flow(false), + _potential(0), _local_potential(false), _pred(graph) + { + LEMON_ASSERT(std::numeric_limits::is_integer, + "The length type of Suurballe must be integer"); + } /// Destructor. ~Suurballe() { @@ -250,11 +267,14 @@ /// \brief Set the flow map. /// /// This function sets the flow map. + /// If it is not used before calling \ref run() or \ref init(), + /// an instance will be allocated automatically. The destructor + /// deallocates this automatically allocated map, of course. /// - /// The found flow contains only 0 and 1 values. It is the union of - /// the found arc-disjoint paths. + /// The found flow contains only 0 and 1 values, since it is the + /// union of the found arc-disjoint paths. /// - /// \return \c (*this) + /// \return (*this) Suurballe& flowMap(FlowMap &map) { if (_local_flow) { delete _flow; @@ -267,11 +287,14 @@ /// \brief Set the potential map. /// /// This function sets the potential map. + /// If it is not used before calling \ref run() or \ref init(), + /// an instance will be allocated automatically. The destructor + /// deallocates this automatically allocated map, of course. /// - /// The potentials provide the dual solution of the underlying - /// minimum cost flow problem. + /// The node potentials provide the dual solution of the underlying + /// \ref min_cost_flow "minimum cost flow problem". /// - /// \return \c (*this) + /// \return (*this) Suurballe& potentialMap(PotentialMap &map) { if (_local_potential) { delete _potential; @@ -281,7 +304,7 @@ return *this; } - /// \name Execution control + /// \name Execution Control /// The simplest way to execute the algorithm is to call the run() /// function. /// \n @@ -294,22 +317,24 @@ /// /// This function runs the algorithm. /// + /// \param s The source node. + /// \param t The target node. /// \param k The number of paths to be found. /// /// \return \c k if there are at least \c k arc-disjoint paths from /// \c s to \c t in the digraph. Otherwise it returns the number of /// arc-disjoint paths found. /// - /// \note Apart from the return value, s.run(k) is just a - /// shortcut of the following code. + /// \note Apart from the return value, s.run(s, t, k) is + /// just a shortcut of the following code. /// \code - /// s.init(); - /// s.findFlow(k); + /// s.init(s); + /// s.findFlow(t, k); /// s.findPaths(); /// \endcode - int run(int k = 2) { - init(); - findFlow(k); + int run(const Node& s, const Node& t, int k = 2) { + init(s); + findFlow(t, k); findPaths(); return _path_num; } @@ -317,7 +342,11 @@ /// \brief Initialize the algorithm. /// /// This function initializes the algorithm. - void init() { + /// + /// \param s The source node. + void init(const Node& s) { + _source = s; + // Initialize maps if (!_flow) { _flow = new FlowMap(_graph); @@ -329,25 +358,28 @@ } for (ArcIt e(_graph); e != INVALID; ++e) (*_flow)[e] = 0; for (NodeIt n(_graph); n != INVALID; ++n) (*_potential)[n] = 0; - - _dijkstra = new ResidualDijkstra( _graph, *_flow, _length, - *_potential, _pred, - _source, _target ); } - /// \brief Execute the successive shortest path algorithm to find - /// an optimal flow. + /// \brief Execute the algorithm to find an optimal flow. /// /// This function executes the successive shortest path algorithm to - /// find a minimum cost flow, which is the union of \c k or less + /// find a minimum cost flow, which is the union of \c k (or less) /// arc-disjoint paths. /// + /// \param t The target node. + /// \param k The number of paths to be found. + /// /// \return \c k if there are at least \c k arc-disjoint paths from - /// \c s to \c t in the digraph. Otherwise it returns the number of - /// arc-disjoint paths found. + /// the source node to the given node \c t in the digraph. + /// Otherwise it returns the number of arc-disjoint paths found. /// /// \pre \ref init() must be called before using this function. - int findFlow(int k = 2) { + int findFlow(const Node& t, int k = 2) { + _target = t; + _dijkstra = + new ResidualDijkstra( _graph, *_flow, _length, *_potential, _pred, + _source, _target ); + // Find shortest paths _path_num = 0; while (_path_num < k) { @@ -373,13 +405,12 @@ /// \brief Compute the paths from the flow. /// - /// This function computes the paths from the flow. + /// This function computes the paths from the found minimum cost flow, + /// which is the union of some arc-disjoint paths. /// /// \pre \ref init() and \ref findFlow() must be called before using /// this function. void findPaths() { - // Create the residual flow map (the union of the paths not found - // so far) FlowMap res_flow(_graph); for(ArcIt a(_graph); a != INVALID; ++a) res_flow[a] = (*_flow)[a]; @@ -406,10 +437,37 @@ /// @{ - /// \brief Return a const reference to the arc map storing the + /// \brief Return the total length of the found paths. + /// + /// This function returns the total length of the found paths, i.e. + /// the total cost of the found flow. + /// The complexity of the function is O(e). + /// + /// \pre \ref run() or \ref findFlow() must be called before using + /// this function. + Length totalLength() const { + Length c = 0; + for (ArcIt e(_graph); e != INVALID; ++e) + c += (*_flow)[e] * _length[e]; + return c; + } + + /// \brief Return the flow value on the given arc. + /// + /// This function returns the flow value on the given arc. + /// It is \c 1 if the arc is involved in one of the found arc-disjoint + /// paths, otherwise it is \c 0. + /// + /// \pre \ref run() or \ref findFlow() must be called before using + /// this function. + int flow(const Arc& arc) const { + return (*_flow)[arc]; + } + + /// \brief Return a const reference to an arc map storing the /// found flow. /// - /// This function returns a const reference to the arc map storing + /// This function returns a const reference to an arc map storing /// the flow that is the union of the found arc-disjoint paths. /// /// \pre \ref run() or \ref findFlow() must be called before using @@ -418,34 +476,11 @@ return *_flow; } - /// \brief Return a const reference to the node map storing the - /// found potentials (the dual solution). - /// - /// This function returns a const reference to the node map storing - /// the found potentials that provide the dual solution of the - /// underlying minimum cost flow problem. - /// - /// \pre \ref run() or \ref findFlow() must be called before using - /// this function. - const PotentialMap& potentialMap() const { - return *_potential; - } - - /// \brief Return the flow on the given arc. - /// - /// This function returns the flow on the given arc. - /// It is \c 1 if the arc is involved in one of the found paths, - /// otherwise it is \c 0. - /// - /// \pre \ref run() or \ref findFlow() must be called before using - /// this function. - int flow(const Arc& arc) const { - return (*_flow)[arc]; - } - /// \brief Return the potential of the given node. /// /// This function returns the potential of the given node. + /// The node potentials provide the dual solution of the + /// underlying \ref min_cost_flow "minimum cost flow problem". /// /// \pre \ref run() or \ref findFlow() must be called before using /// this function. @@ -453,18 +488,17 @@ return (*_potential)[node]; } - /// \brief Return the total length (cost) of the found paths (flow). + /// \brief Return a const reference to a node map storing the + /// found potentials (the dual solution). /// - /// This function returns the total length (cost) of the found paths - /// (flow). The complexity of the function is \f$ O(e) \f$. + /// This function returns a const reference to a node map storing + /// the found potentials that provide the dual solution of the + /// underlying \ref min_cost_flow "minimum cost flow problem". /// /// \pre \ref run() or \ref findFlow() must be called before using /// this function. - Length totalLength() const { - Length c = 0; - for (ArcIt e(_graph); e != INVALID; ++e) - c += (*_flow)[e] * _length[e]; - return c; + const PotentialMap& potentialMap() const { + return *_potential; } /// \brief Return the number of the found paths. @@ -481,7 +515,7 @@ /// /// This function returns a const reference to the specified path. /// - /// \param i The function returns the \c i-th path. + /// \param i The function returns the i-th path. /// \c i must be between \c 0 and %pathNum()-1. /// /// \pre \ref run() or \ref findPaths() must be called before using diff -r c35afa9e89e7 -r ef88c0a30f85 lemon/time_measure.h --- a/lemon/time_measure.h Mon Jan 12 23:11:39 2009 +0100 +++ b/lemon/time_measure.h Thu Nov 05 15:48:01 2009 +0100 @@ -24,11 +24,9 @@ ///\brief Tools for measuring cpu usage #ifdef WIN32 -#define WIN32_LEAN_AND_MEAN -#define NOMINMAX -#include -#include +#include #else +#include #include #include #endif @@ -87,26 +85,7 @@ cutime=ts.tms_cutime/tck; cstime=ts.tms_cstime/tck; #else - static const double ch = 4294967296.0e-7; - static const double cl = 1.0e-7; - - FILETIME system; - GetSystemTimeAsFileTime(&system); - rtime = ch * system.dwHighDateTime + cl * system.dwLowDateTime; - - FILETIME create, exit, kernel, user; - if (GetProcessTimes(GetCurrentProcess(),&create, &exit, &kernel, &user)) { - utime = ch * user.dwHighDateTime + cl * user.dwLowDateTime; - stime = ch * kernel.dwHighDateTime + cl * kernel.dwLowDateTime; - cutime = 0; - cstime = 0; - } else { - rtime = 0; - utime = 0; - stime = 0; - cutime = 0; - cstime = 0; - } + bits::getWinProcTimes(rtime, utime, stime, cutime, cstime); #endif } @@ -223,7 +202,7 @@ double realTime() const {return rtime;} }; - TimeStamp operator*(double b,const TimeStamp &t) + inline TimeStamp operator*(double b,const TimeStamp &t) { return t*b; } @@ -308,7 +287,7 @@ /// Timer(bool run=true) :_running(run) {_reset();} - ///\name Control the state of the timer + ///\name Control the State of the Timer ///Basically a Timer can be either running or stopped, ///but it provides a bit finer control on the execution. ///The \ref lemon::Timer "Timer" also counts the number of @@ -416,7 +395,7 @@ ///@} - ///\name Query Functions for the ellapsed time + ///\name Query Functions for the Ellapsed Time ///@{ diff -r c35afa9e89e7 -r ef88c0a30f85 lemon/tolerance.h --- a/lemon/tolerance.h Mon Jan 12 23:11:39 2009 +0100 +++ b/lemon/tolerance.h Thu Nov 05 15:48:01 2009 +0100 @@ -38,17 +38,14 @@ ///handle the comparison of numbers that are obtained ///as a result of a probably inexact computation. /// - ///This is an abstract class, it should be specialized for all - ///numerical data types. These specialized classes like + ///The general implementation is suitable only if the data type is exact, + ///like the integer types, otherwise a specialized version must be + ///implemented. These specialized classes like ///Tolerance may offer additional tuning parameters. /// ///\sa Tolerance ///\sa Tolerance ///\sa Tolerance - ///\sa Tolerance - ///\sa Tolerance - ///\sa Tolerance - ///\sa Tolerance template class Tolerance @@ -64,20 +61,20 @@ ///@{ ///Returns \c true if \c a is \e surely strictly less than \c b - static bool less(Value a,Value b) {return false;} + static bool less(Value a,Value b) {return a(0) < a;} ///Returns \c true if \c a is \e surely negative - static bool negative(Value a) {return false;} + static bool negative(Value a) {return a < static_cast(0);} ///Returns \c true if \c a is \e surely non-zero - static bool nonZero(Value a) {return false;} + static bool nonZero(Value a) {return a != static_cast(0);} ///@} ///Returns the zero value. - static Value zero() {return T();} + static Value zero() {return static_cast(0);} // static bool finite(Value a) {} // static Value big() {} @@ -238,213 +235,6 @@ static Value zero() {return 0;} }; - ///Integer specialization of Tolerance. - - ///Integer specialization of Tolerance. - ///\sa Tolerance - template<> - class Tolerance - { - public: - ///\e - typedef int Value; - - ///\name Comparisons - ///See \ref lemon::Tolerance "Tolerance" for more details. - - ///@{ - - ///Returns \c true if \c a is \e surely strictly less than \c b - static bool less(Value a,Value b) { return aa; } - ///Returns \c true if \c a is \e surely non-zero - static bool nonZero(Value a) { return a!=0; } - - ///@} - - ///Returns zero - static Value zero() {return 0;} - }; - - ///Unsigned integer specialization of Tolerance. - - ///Unsigned integer specialization of Tolerance. - ///\sa Tolerance - template<> - class Tolerance - { - public: - ///\e - typedef unsigned int Value; - - ///\name Comparisons - ///See \ref lemon::Tolerance "Tolerance" for more details. - - ///@{ - - ///Returns \c true if \c a is \e surely strictly less than \c b - static bool less(Value a,Value b) { return a - class Tolerance - { - public: - ///\e - typedef long int Value; - - ///\name Comparisons - ///See \ref lemon::Tolerance "Tolerance" for more details. - - ///@{ - - ///Returns \c true if \c a is \e surely strictly less than \c b - static bool less(Value a,Value b) { return aa; } - ///Returns \c true if \c a is \e surely non-zero - static bool nonZero(Value a) { return a!=0;} - - ///@} - - ///Returns zero - static Value zero() {return 0;} - }; - - ///Unsigned long integer specialization of Tolerance. - - ///Unsigned long integer specialization of Tolerance. - ///\sa Tolerance - template<> - class Tolerance - { - public: - ///\e - typedef unsigned long int Value; - - ///\name Comparisons - ///See \ref lemon::Tolerance "Tolerance" for more details. - - ///@{ - - ///Returns \c true if \c a is \e surely strictly less than \c b - static bool less(Value a,Value b) { return along long) - ///is not ansi compatible. - ///\sa Tolerance - template<> - class Tolerance - { - public: - ///\e - typedef long long int Value; - - ///\name Comparisons - ///See \ref lemon::Tolerance "Tolerance" for more details. - - ///@{ - - ///Returns \c true if \c a is \e surely strictly less than \c b - static bool less(Value a,Value b) { return aa; } - ///Returns \c true if \c a is \e surely non-zero - static bool nonZero(Value a) { return a!=0;} - - ///@} - - ///Returns zero - static Value zero() {return 0;} - }; - - ///Unsigned long long integer specialization of Tolerance. - - ///Unsigned long long integer specialization of Tolerance. - ///\warning This class (more exactly, type unsigned long long) - ///is not ansi compatible. - ///\sa Tolerance - template<> - class Tolerance - { - public: - ///\e - typedef unsigned long long int Value; - - ///\name Comparisons - ///See \ref lemon::Tolerance "Tolerance" for more details. - - ///@{ - - ///Returns \c true if \c a is \e surely strictly less than \c b - static bool less(Value a,Value b) { return a + template class UnionFind { public: - typedef _ItemIntMap ItemIntMap; + ///\e + typedef IM ItemIntMap; + ///\e typedef typename ItemIntMap::Key Item; private: @@ -170,11 +172,13 @@ /// \pre You need to add all the elements by the \ref insert() /// method. /// - template + template class UnionFindEnum { public: - typedef _ItemIntMap ItemIntMap; + ///\e + typedef IM ItemIntMap; + ///\e typedef typename ItemIntMap::Key Item; private: @@ -627,11 +631,13 @@ /// /// \pre You need to add all the elements by the \ref insert() /// method. - template + template class ExtendFindEnum { public: - typedef _ItemIntMap ItemIntMap; + ///\e + typedef IM ItemIntMap; + ///\e typedef typename ItemIntMap::Key Item; private: @@ -948,18 +954,18 @@ /// /// \pre You need to add all the elements by the \ref insert() /// method. - /// - template > + template > class HeapUnionFind { public: - typedef _Value Value; - typedef typename _ItemIntMap::Key Item; - - typedef _ItemIntMap ItemIntMap; - - typedef _Comp Comp; + ///\e + typedef V Value; + ///\e + typedef typename IM::Key Item; + ///\e + typedef IM ItemIntMap; + ///\e + typedef Comp Compare; private: @@ -1601,7 +1607,7 @@ /// \brief Gives back the priority of the current item. /// - /// \return Gives back the priority of the current item. + /// Gives back the priority of the current item. const Value& operator[](const Item& item) const { return nodes[index[item]].prio; } @@ -1646,7 +1652,7 @@ /// \brief Gives back the minimum priority of the class. /// - /// \return Gives back the minimum priority of the class. + /// Gives back the minimum priority of the class. const Value& classPrio(int cls) const { return nodes[~(classes[cls].parent)].prio; } @@ -1660,9 +1666,9 @@ /// \brief Gives back a representant item of the class. /// + /// Gives back a representant item of the class. /// The representant is indpendent from the priorities of the /// items. - /// \return Gives back a representant item of the class. const Item& classRep(int id) const { int parent = classes[id].parent; return nodes[parent >= 0 ? classes[id].depth : leftNode(id)].item; diff -r c35afa9e89e7 -r ef88c0a30f85 m4/lx_check_clp.m4 --- a/m4/lx_check_clp.m4 Mon Jan 12 23:11:39 2009 +0100 +++ /dev/null Thu Jan 01 00:00:00 1970 +0000 @@ -1,73 +0,0 @@ -AC_DEFUN([LX_CHECK_CLP], -[ - AC_ARG_WITH([clp], -AS_HELP_STRING([--with-clp@<:@=PREFIX@:>@], [search for CLP under PREFIX or under the default search paths if PREFIX is not given @<:@default@:>@]) -AS_HELP_STRING([--without-clp], [disable checking for CLP]), - [], [with_clp=yes]) - - AC_ARG_WITH([clp-includedir], -AS_HELP_STRING([--with-clp-includedir=DIR], [search for CLP headers in DIR]), - [], [with_clp_includedir=no]) - - AC_ARG_WITH([clp-libdir], -AS_HELP_STRING([--with-clp-libdir=DIR], [search for CLP libraries in DIR]), - [], [with_clp_libdir=no]) - - lx_clp_found=no - if test x"$with_clp" != x"no"; then - AC_MSG_CHECKING([for CLP]) - - if test x"$with_clp_includedir" != x"no"; then - CLP_CXXFLAGS="-I$with_clp_includedir" - elif test x"$with_clp" != x"yes"; then - CLP_CXXFLAGS="-I$with_clp/include" - fi - - if test x"$with_clp_libdir" != x"no"; then - CLP_LDFLAGS="-L$with_clp_libdir" - elif test x"$with_clp" != x"yes"; then - CLP_LDFLAGS="-L$with_clp/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([HAVE_CLP], [1], [Define to 1 if you have CLP.]) - lx_lp_found=yes - AC_DEFINE([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"]) -]) diff -r c35afa9e89e7 -r ef88c0a30f85 m4/lx_check_coin.m4 --- /dev/null Thu Jan 01 00:00:00 1970 +0000 +++ b/m4/lx_check_coin.m4 Thu Nov 05 15:48:01 2009 +0100 @@ -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"]) +]) diff -r c35afa9e89e7 -r ef88c0a30f85 m4/lx_check_cplex.m4 --- a/m4/lx_check_cplex.m4 Mon Jan 12 23:11:39 2009 +0100 +++ b/m4/lx_check_cplex.m4 Thu Nov 05 15:48:01 2009 +0100 @@ -61,11 +61,11 @@ LIBS="$lx_save_libs" if test x"$lx_cplex_found" = x"yes"; then - AC_DEFINE([HAVE_CPLEX], [1], [Define to 1 if you have CPLEX.]) + AC_DEFINE([LEMON_HAVE_CPLEX], [1], [Define to 1 if you have CPLEX.]) lx_lp_found=yes - AC_DEFINE([HAVE_LP], [1], [Define to 1 if you have any LP solver.]) + AC_DEFINE([LEMON_HAVE_LP], [1], [Define to 1 if you have any LP solver.]) lx_mip_found=yes - AC_DEFINE([HAVE_MIP], [1], [Define to 1 if you have any MIP solver.]) + AC_DEFINE([LEMON_HAVE_MIP], [1], [Define to 1 if you have any MIP solver.]) AC_MSG_RESULT([yes]) else CPLEX_CFLAGS="" diff -r c35afa9e89e7 -r ef88c0a30f85 m4/lx_check_glpk.m4 --- a/m4/lx_check_glpk.m4 Mon Jan 12 23:11:39 2009 +0100 +++ b/m4/lx_check_glpk.m4 Thu Nov 05 15:48:01 2009 +0100 @@ -64,11 +64,11 @@ LIBS="$lx_save_libs" if test x"$lx_glpk_found" = x"yes"; then - AC_DEFINE([HAVE_GLPK], [1], [Define to 1 if you have GLPK.]) + AC_DEFINE([LEMON_HAVE_GLPK], [1], [Define to 1 if you have GLPK.]) lx_lp_found=yes - AC_DEFINE([HAVE_LP], [1], [Define to 1 if you have any LP solver.]) + AC_DEFINE([LEMON_HAVE_LP], [1], [Define to 1 if you have any LP solver.]) lx_mip_found=yes - AC_DEFINE([HAVE_MIP], [1], [Define to 1 if you have any MIP solver.]) + AC_DEFINE([LEMON_HAVE_MIP], [1], [Define to 1 if you have any MIP solver.]) AC_MSG_RESULT([yes]) else GLPK_CFLAGS="" diff -r c35afa9e89e7 -r ef88c0a30f85 m4/lx_check_soplex.m4 --- a/m4/lx_check_soplex.m4 Mon Jan 12 23:11:39 2009 +0100 +++ b/m4/lx_check_soplex.m4 Thu Nov 05 15:48:01 2009 +0100 @@ -20,7 +20,7 @@ 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/include" + SOPLEX_CXXFLAGS="-I$with_soplex/src" fi if test x"$with_soplex_libdir" != x"no"; then @@ -38,7 +38,7 @@ LIBS="$SOPLEX_LIBS" lx_soplex_test_prog=' - #include + #include int main(int argc, char** argv) { @@ -55,9 +55,9 @@ LIBS="$lx_save_libs" if test x"$lx_soplex_found" = x"yes"; then - AC_DEFINE([HAVE_SOPLEX], [1], [Define to 1 if you have SOPLEX.]) + AC_DEFINE([LEMON_HAVE_SOPLEX], [1], [Define to 1 if you have SOPLEX.]) lx_lp_found=yes - AC_DEFINE([HAVE_LP], [1], [Define to 1 if you have any LP solver.]) + AC_DEFINE([LEMON_HAVE_LP], [1], [Define to 1 if you have any LP solver.]) AC_MSG_RESULT([yes]) else SOPLEX_CXXFLAGS="" diff -r c35afa9e89e7 -r ef88c0a30f85 scripts/bib2dox.py --- /dev/null Thu Jan 01 00:00:00 1970 +0000 +++ b/scripts/bib2dox.py Thu Nov 05 15:48:01 2009 +0100 @@ -0,0 +1,811 @@ +#!/usr/bin/env /usr/local/Python/bin/python2.1 +""" + BibTeX to Doxygen converter + Usage: python bib2dox.py bibfile.bib > bibfile.dox + + 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 diff -r c35afa9e89e7 -r ef88c0a30f85 scripts/bootstrap.sh --- /dev/null Thu Jan 01 00:00:00 1970 +0000 +++ b/scripts/bootstrap.sh Thu Nov 05 15:48:01 2009 +0100 @@ -0,0 +1,134 @@ +#!/bin/bash +# +# This file is a part of LEMON, a generic C++ optimization library. +# +# Copyright (C) 2003-2009 +# Egervary Jeno Kombinatorikus Optimalizalasi Kutatocsoport +# (Egervary Research Group on Combinatorial Optimization, EGRES). +# +# Permission to use, modify and distribute this software is granted +# provided that this copyright notice appears in all copies. For +# precise terms see the accompanying LICENSE file. +# +# This software is provided "AS IS" with no warranty of any kind, +# express or implied, and with no claim as to its suitability for any +# purpose. + + +if [ ! -f ~/.lemon-bootstrap ]; then + echo 'Create ~/.lemon-bootstrap'. + cat >~/.lemon-bootstrap <>~/.lemon-bootstrap + echo $3 >>~/.lemon-bootstrap + echo $1=$2 >>~/.lemon-bootstrap + fi +} + +augment_config LEMON_INSTALL_PREFIX /usr/local \ + "# LEMON installation prefix" + +augment_config COIN_OR_PREFIX /usr/local/coin-or \ + "# COIN-OR installation root prefix (used for CLP/CBC)" + +augment_config SOPLEX_PREFIX /usr/local/soplex \ + "# Soplex build prefix" + + +function ask() { +echo -n "$1 [$2]? " +read _an +if [ "x$_an" == "x" ]; then + ret="$2" +else + ret=$_an +fi +} + +function yesorno() { + ret='rossz' + while [ "$ret" != "y" -a "$ret" != "n" -a "$ret" != "yes" -a "$ret" != "no" ]; do + ask "$1" "$2" + done + if [ "$ret" != "y" -a "$ret" != "yes" ]; then + return 1 + else + return 0 + fi +} + +if yesorno "External build" "n" +then + CONFIGURE_PATH=".." +else + CONFIGURE_PATH="." + if yesorno "Autoreconf" "y" + then + AUTORE=yes + else + AUTORE=no + fi +fi + +if yesorno "Optimize" "n" +then + opt_flags=' -O2' +else + opt_flags='' +fi + +if yesorno "Stop on warning" "y" +then + werror_flags=' -Werror' +else + werror_flags='' +fi + +cxx_flags="CXXFLAGS=-ggdb$opt_flags$werror_flags" + +if [ -f ${COIN_OR_PREFIX}/include/coin/config_coinutils.h ]; then + if yesorno "Use COIN-OR (CBC/CLP)" "n" + then + coin_flag="--with-coin=$COIN_OR_PREFIX" + else + coin_flag="" + fi +else + coin_flag="" +fi + +if [ -f ${SOPLEX_PREFIX}/src/soplex.h ]; then + if yesorno "Use Soplex" "n" + then + soplex_flag="--with-soplex=$SOPLEX_PREFIX" + else + soplex_flag="" + fi +else + soplex_flag="" +fi + +if [ "x$AUTORE" == "xyes" ]; then + autoreconf -vif; +fi +${CONFIGURE_PATH}/configure --prefix=$LEMON_INSTALL_PREFIX \ +"$cxx_flags" \ +$coin_flag \ +$soplex_flag \ +$* diff -r c35afa9e89e7 -r ef88c0a30f85 scripts/chg-len.py --- a/scripts/chg-len.py Mon Jan 12 23:11:39 2009 +0100 +++ b/scripts/chg-len.py Thu Nov 05 15:48:01 2009 +0100 @@ -1,4 +1,18 @@ #! /usr/bin/env python +# +# This file is a part of LEMON, a generic C++ optimization library. +# +# Copyright (C) 2003-2009 +# Egervary Jeno Kombinatorikus Optimalizalasi Kutatocsoport +# (Egervary Research Group on Combinatorial Optimization, EGRES). +# +# Permission to use, modify and distribute this software is granted +# provided that this copyright notice appears in all copies. For +# precise terms see the accompanying LICENSE file. +# +# This software is provided "AS IS" with no warranty of any kind, +# express or implied, and with no claim as to its suitability for any +# purpose. import sys diff -r c35afa9e89e7 -r ef88c0a30f85 scripts/mk-release.sh --- /dev/null Thu Jan 01 00:00:00 1970 +0000 +++ b/scripts/mk-release.sh Thu Nov 05 15:48:01 2009 +0100 @@ -0,0 +1,49 @@ +#!/bin/bash +# +# This file is a part of LEMON, a generic C++ optimization library. +# +# Copyright (C) 2003-2009 +# Egervary Jeno Kombinatorikus Optimalizalasi Kutatocsoport +# (Egervary Research Group on Combinatorial Optimization, EGRES). +# +# Permission to use, modify and distribute this software is granted +# provided that this copyright notice appears in all copies. For +# precise terms see the accompanying LICENSE file. +# +# This software is provided "AS IS" with no warranty of any kind, +# express or implied, and with no claim as to its suitability for any +# purpose. + +set -e + +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 '*****************************************************************' diff -r c35afa9e89e7 -r ef88c0a30f85 scripts/unify-sources.sh --- a/scripts/unify-sources.sh Mon Jan 12 23:11:39 2009 +0100 +++ b/scripts/unify-sources.sh Thu Nov 05 15:48:01 2009 +0100 @@ -1,8 +1,31 @@ #!/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 +2003-%Y` +YEAR=`date +%Y` HGROOT=`hg root` +function hg_year() { + if [ -n "$(hg st $1)" ]; then + echo $YEAR + else + hg log -l 1 --template='{date|isodate}\n' $1 | + cut -d '-' -f 1 + fi +} + # file enumaration modes function all_files() { @@ -88,7 +111,12 @@ function check_action() { if [ "$3" == 'tabs' ] then - PATTERN=$(echo -e '\t') + if echo $2 | grep -q -v -E 'Makefile\.am$' + then + PATTERN=$(echo -e '\t') + else + PATTERN=' ' + fi elif [ "$3" == 'trailing spaces' ] then PATTERN='\ +$' @@ -186,7 +214,7 @@ * * This file is a part of LEMON, a generic C++ optimization library. * - * Copyright (C) "$YEAR" + * Copyright (C) 2003-"$(hg_year $1)" * Egervary Jeno Kombinatorikus Optimalizalasi Kutatocsoport * (Egervary Research Group on Combinatorial Optimization, EGRES). * diff -r c35afa9e89e7 -r ef88c0a30f85 test/CMakeLists.txt --- a/test/CMakeLists.txt Mon Jan 12 23:11:39 2009 +0100 +++ b/test/CMakeLists.txt Thu Nov 05 15:48:01 2009 +0100 @@ -1,38 +1,121 @@ -INCLUDE_DIRECTORIES(${CMAKE_SOURCE_DIR}) +INCLUDE_DIRECTORIES( + ${PROJECT_SOURCE_DIR} + ${PROJECT_BINARY_DIR} +) -LINK_DIRECTORIES(${CMAKE_BINARY_DIR}/lemon) +LINK_DIRECTORIES( + ${PROJECT_BINARY_DIR}/lemon +) SET(TESTS adaptors_test + bellman_ford_test bfs_test circulation_test + connectivity_test counter_test dfs_test digraph_test dijkstra_test dim_test + edge_set_test error_test - edge_set_test + euler_test + gomory_hu_test graph_copy_test graph_test graph_utils_test hao_orlin_test heap_test kruskal_test - lp_test - mip_test maps_test - max_matching_test - radix_sort_test + matching_test + min_cost_arborescence_test + min_cost_flow_test + min_mean_cycle_test path_test preflow_test + radix_sort_test random_test suurballe_test time_measure_test - unionfind_test) + unionfind_test +) + +IF(LEMON_HAVE_LP) + ADD_EXECUTABLE(lp_test lp_test.cc) + SET(LP_TEST_LIBS lemon) + + IF(LEMON_HAVE_GLPK) + SET(LP_TEST_LIBS ${LP_TEST_LIBS} ${GLPK_LIBRARIES}) + ENDIF() + IF(LEMON_HAVE_CPLEX) + SET(LP_TEST_LIBS ${LP_TEST_LIBS} ${CPLEX_LIBRARIES}) + ENDIF() + IF(LEMON_HAVE_CLP) + SET(LP_TEST_LIBS ${LP_TEST_LIBS} ${COIN_CLP_LIBRARIES}) + ENDIF() + + TARGET_LINK_LIBRARIES(lp_test ${LP_TEST_LIBS}) + ADD_TEST(lp_test lp_test) + + IF(WIN32 AND LEMON_HAVE_GLPK) + GET_TARGET_PROPERTY(TARGET_LOC lp_test LOCATION) + GET_FILENAME_COMPONENT(TARGET_PATH ${TARGET_LOC} PATH) + ADD_CUSTOM_COMMAND(TARGET lp_test POST_BUILD + COMMAND ${CMAKE_COMMAND} -E copy ${GLPK_BIN_DIR}/glpk.dll ${TARGET_PATH} + COMMAND ${CMAKE_COMMAND} -E copy ${GLPK_BIN_DIR}/libltdl3.dll ${TARGET_PATH} + COMMAND ${CMAKE_COMMAND} -E copy ${GLPK_BIN_DIR}/zlib1.dll ${TARGET_PATH} + ) + ENDIF() + + IF(WIN32 AND LEMON_HAVE_CPLEX) + GET_TARGET_PROPERTY(TARGET_LOC lp_test LOCATION) + GET_FILENAME_COMPONENT(TARGET_PATH ${TARGET_LOC} PATH) + ADD_CUSTOM_COMMAND(TARGET lp_test POST_BUILD + COMMAND ${CMAKE_COMMAND} -E copy ${CPLEX_BIN_DIR}/cplex91.dll ${TARGET_PATH} + ) + ENDIF() +ENDIF() + +IF(LEMON_HAVE_MIP) + ADD_EXECUTABLE(mip_test mip_test.cc) + SET(MIP_TEST_LIBS lemon) + + IF(LEMON_HAVE_GLPK) + SET(MIP_TEST_LIBS ${MIP_TEST_LIBS} ${GLPK_LIBRARIES}) + ENDIF() + IF(LEMON_HAVE_CPLEX) + SET(MIP_TEST_LIBS ${MIP_TEST_LIBS} ${CPLEX_LIBRARIES}) + ENDIF() + IF(LEMON_HAVE_CBC) + SET(MIP_TEST_LIBS ${MIP_TEST_LIBS} ${COIN_CBC_LIBRARIES}) + ENDIF() + + TARGET_LINK_LIBRARIES(mip_test ${MIP_TEST_LIBS}) + ADD_TEST(mip_test mip_test) + + IF(WIN32 AND LEMON_HAVE_GLPK) + GET_TARGET_PROPERTY(TARGET_LOC mip_test LOCATION) + GET_FILENAME_COMPONENT(TARGET_PATH ${TARGET_LOC} PATH) + ADD_CUSTOM_COMMAND(TARGET mip_test POST_BUILD + COMMAND ${CMAKE_COMMAND} -E copy ${GLPK_BIN_DIR}/glpk.dll ${TARGET_PATH} + COMMAND ${CMAKE_COMMAND} -E copy ${GLPK_BIN_DIR}/libltdl3.dll ${TARGET_PATH} + COMMAND ${CMAKE_COMMAND} -E copy ${GLPK_BIN_DIR}/zlib1.dll ${TARGET_PATH} + ) + ENDIF() + + IF(WIN32 AND LEMON_HAVE_CPLEX) + GET_TARGET_PROPERTY(TARGET_LOC mip_test LOCATION) + GET_FILENAME_COMPONENT(TARGET_PATH ${TARGET_LOC} PATH) + ADD_CUSTOM_COMMAND(TARGET mip_test POST_BUILD + COMMAND ${CMAKE_COMMAND} -E copy ${CPLEX_BIN_DIR}/cplex91.dll ${TARGET_PATH} + ) + ENDIF() +ENDIF() FOREACH(TEST_NAME ${TESTS}) ADD_EXECUTABLE(${TEST_NAME} ${TEST_NAME}.cc) TARGET_LINK_LIBRARIES(${TEST_NAME} lemon) ADD_TEST(${TEST_NAME} ${TEST_NAME}) -ENDFOREACH(TEST_NAME) +ENDFOREACH() diff -r c35afa9e89e7 -r ef88c0a30f85 test/Makefile.am --- a/test/Makefile.am Mon Jan 12 23:11:39 2009 +0100 +++ b/test/Makefile.am Thu Nov 05 15:48:01 2009 +0100 @@ -7,8 +7,10 @@ check_PROGRAMS += \ test/adaptors_test \ + test/bellman_ford_test \ test/bfs_test \ test/circulation_test \ + test/connectivity_test \ test/counter_test \ test/dfs_test \ test/digraph_test \ @@ -16,6 +18,8 @@ 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 \ @@ -23,7 +27,10 @@ test/heap_test \ test/kruskal_test \ test/maps_test \ - test/max_matching_test \ + test/matching_test \ + test/min_cost_arborescence_test \ + test/min_cost_flow_test \ + test/min_mean_cycle_test \ test/path_test \ test/preflow_test \ test/radix_sort_test \ @@ -34,6 +41,8 @@ test/time_measure_test \ test/unionfind_test +test_test_tools_pass_DEPENDENCIES = demo + if HAVE_LP check_PROGRAMS += test/lp_test endif HAVE_LP @@ -45,15 +54,19 @@ XFAIL_TESTS += test/test_tools_fail$(EXEEXT) test_adaptors_test_SOURCES = test/adaptors_test.cc +test_bellman_ford_test_SOURCES = test/bellman_ford_test.cc test_bfs_test_SOURCES = test/bfs_test.cc test_circulation_test_SOURCES = test/circulation_test.cc test_counter_test_SOURCES = test/counter_test.cc +test_connectivity_test_SOURCES = test/connectivity_test.cc test_dfs_test_SOURCES = test/dfs_test.cc test_digraph_test_SOURCES = test/digraph_test.cc test_dijkstra_test_SOURCES = test/dijkstra_test.cc test_dim_test_SOURCES = test/dim_test.cc test_edge_set_test_SOURCES = test/edge_set_test.cc test_error_test_SOURCES = test/error_test.cc +test_euler_test_SOURCES = test/euler_test.cc +test_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 @@ -63,7 +76,10 @@ 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_max_matching_test_SOURCES = test/max_matching_test.cc +test_matching_test_SOURCES = test/matching_test.cc +test_min_cost_arborescence_test_SOURCES = test/min_cost_arborescence_test.cc +test_min_cost_flow_test_SOURCES = test/min_cost_flow_test.cc +test_min_mean_cycle_test_SOURCES = test/min_mean_cycle_test.cc test_path_test_SOURCES = test/path_test.cc test_preflow_test_SOURCES = test/preflow_test.cc test_radix_sort_test_SOURCES = test/radix_sort_test.cc diff -r c35afa9e89e7 -r ef88c0a30f85 test/bellman_ford_test.cc --- /dev/null Thu Jan 01 00:00:00 1970 +0000 +++ b/test/bellman_ford_test.cc Thu Nov 05 15:48:01 2009 +0100 @@ -0,0 +1,285 @@ +/* -*- 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 "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; + 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; + 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; +} diff -r c35afa9e89e7 -r ef88c0a30f85 test/bfs_test.cc --- a/test/bfs_test.cc Mon Jan 12 23:11:39 2009 +0100 +++ b/test/bfs_test.cc Thu Nov 05 15:48:01 2009 +0100 @@ -58,41 +58,80 @@ typedef Digraph::Arc Arc; Digraph G; - Node s, t; + Node s, t, n; Arc e; - int l; + int l, i; bool b; BType::DistMap d(G); BType::PredMap p(G); Path pp; + concepts::ReadMap nm; { BType bfs_test(G); + const BType& const_bfs_test = bfs_test; bfs_test.run(s); bfs_test.run(s,t); bfs_test.run(); - l = bfs_test.dist(t); - e = bfs_test.predArc(t); - s = bfs_test.predNode(t); - b = bfs_test.reached(t); - d = bfs_test.distMap(); - p = bfs_test.predMap(); - pp = bfs_test.path(t); + bfs_test.init(); + bfs_test.addSource(s); + n = bfs_test.processNextNode(); + n = bfs_test.processNextNode(t, b); + n = bfs_test.processNextNode(nm, n); + n = const_bfs_test.nextNode(); + b = const_bfs_test.emptyQueue(); + i = const_bfs_test.queueSize(); + + bfs_test.start(); + bfs_test.start(t); + bfs_test.start(nm); + + l = const_bfs_test.dist(t); + e = const_bfs_test.predArc(t); + s = const_bfs_test.predNode(t); + b = const_bfs_test.reached(t); + d = const_bfs_test.distMap(); + p = const_bfs_test.predMap(); + pp = const_bfs_test.path(t); } { BType ::SetPredMap > ::SetDistMap > ::SetReachedMap > + ::SetStandardProcessedMap ::SetProcessedMap > - ::SetStandardProcessedMap ::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) + .distMap(dist_map) + .reachedMap(reached_map) + .processedMap(processed_map); bfs_test.run(s); bfs_test.run(s,t); bfs_test.run(); + + bfs_test.init(); + bfs_test.addSource(s); + n = bfs_test.processNextNode(); + n = bfs_test.processNextNode(t, b); + n = bfs_test.processNextNode(nm, n); + n = bfs_test.nextNode(); + b = bfs_test.emptyQueue(); + i = bfs_test.queueSize(); + + bfs_test.start(); + bfs_test.start(t); + bfs_test.start(nm); l = bfs_test.dist(t); e = bfs_test.predArc(t); diff -r c35afa9e89e7 -r ef88c0a30f85 test/circulation_test.cc --- a/test/circulation_test.cc Mon Jan 12 23:11:39 2009 +0100 +++ b/test/circulation_test.cc Thu Nov 05 15:48:01 2009 +0100 @@ -57,7 +57,7 @@ typedef Digraph::Node Node; typedef Digraph::Arc Arc; typedef concepts::ReadMap CapMap; - typedef concepts::ReadMap DeltaMap; + typedef concepts::ReadMap SupplyMap; typedef concepts::ReadWriteMap FlowMap; typedef concepts::WriteMap BarrierMap; @@ -68,30 +68,42 @@ Node n; Arc a; CapMap lcap, ucap; - DeltaMap delta; + SupplyMap supply; FlowMap flow; BarrierMap bar; + VType v; + bool b; - Circulation - ::SetFlowMap - ::SetElevator - ::SetStandardElevator - ::Create circ_test(g,lcap,ucap,delta); - - circ_test.lowerCapMap(lcap); - circ_test.upperCapMap(ucap); - circ_test.deltaMap(delta); - flow = circ_test.flowMap(); - circ_test.flowMap(flow); + typedef Circulation + ::SetFlowMap + ::SetElevator + ::SetStandardElevator + ::Create CirculationType; + CirculationType circ_test(g, lcap, ucap, supply); + const CirculationType& const_circ_test = circ_test; + + circ_test + .lowerMap(lcap) + .upperMap(ucap) + .supplyMap(supply) + .flowMap(flow); + + const CirculationType::Elevator& elev = const_circ_test.elevator(); + circ_test.elevator(const_cast(elev)); + CirculationType::Tolerance tol = const_circ_test.tolerance(); + circ_test.tolerance(tol); circ_test.init(); circ_test.greedyInit(); circ_test.start(); circ_test.run(); - circ_test.barrier(n); - circ_test.barrierMap(bar); - circ_test.flow(a); + v = const_circ_test.flow(a); + const FlowMap& fm = const_circ_test.flowMap(); + b = const_circ_test.barrier(n); + const_circ_test.barrierMap(bar); + + ignore_unused_variable_warning(fm); } template diff -r c35afa9e89e7 -r ef88c0a30f85 test/connectivity_test.cc --- /dev/null Thu Jan 01 00:00:00 1970 +0000 +++ b/test/connectivity_test.cc Thu Nov 05 15:48:01 2009 +0100 @@ -0,0 +1,297 @@ +/* -*- 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 "test_tools.h" + +using namespace lemon; + + +int main() +{ + typedef ListDigraph Digraph; + typedef Undirector Graph; + + { + Digraph d; + Digraph::NodeMap order(d); + Graph g(d); + + check(stronglyConnected(d), "The empty digraph is strongly connected"); + check(countStronglyConnectedComponents(d) == 0, + "The empty digraph has 0 strongly connected component"); + check(connected(g), "The empty graph is connected"); + check(countConnectedComponents(g) == 0, + "The empty graph has 0 connected component"); + + check(biNodeConnected(g), "The empty graph is bi-node-connected"); + check(countBiNodeConnectedComponents(g) == 0, + "The empty graph has 0 bi-node-connected component"); + check(biEdgeConnected(g), "The empty graph is bi-edge-connected"); + check(countBiEdgeConnectedComponents(g) == 0, + "The empty graph has 0 bi-edge-connected component"); + + check(dag(d), "The empty digraph is DAG."); + check(checkedTopologicalSort(d, order), "The empty digraph is DAG."); + check(loopFree(d), "The empty digraph is loop-free."); + check(parallelFree(d), "The empty digraph is parallel-free."); + check(simpleGraph(d), "The empty digraph is simple."); + + check(acyclic(g), "The empty graph is acyclic."); + check(tree(g), "The empty graph is tree."); + check(bipartite(g), "The empty graph is bipartite."); + check(loopFree(g), "The empty graph is loop-free."); + check(parallelFree(g), "The empty graph is parallel-free."); + check(simpleGraph(g), "The empty graph is simple."); + } + + { + Digraph d; + Digraph::NodeMap order(d); + Graph g(d); + Digraph::Node n = d.addNode(); + + check(stronglyConnected(d), "This digraph is strongly connected"); + check(countStronglyConnectedComponents(d) == 1, + "This digraph has 1 strongly connected component"); + check(connected(g), "This graph is connected"); + check(countConnectedComponents(g) == 1, + "This graph has 1 connected component"); + + check(biNodeConnected(g), "This graph is bi-node-connected"); + check(countBiNodeConnectedComponents(g) == 0, + "This graph has 0 bi-node-connected component"); + check(biEdgeConnected(g), "This graph is bi-edge-connected"); + check(countBiEdgeConnectedComponents(g) == 1, + "This graph has 1 bi-edge-connected component"); + + check(dag(d), "This digraph is DAG."); + check(checkedTopologicalSort(d, order), "This digraph is DAG."); + check(loopFree(d), "This digraph is loop-free."); + check(parallelFree(d), "This digraph is parallel-free."); + check(simpleGraph(d), "This digraph is simple."); + + check(acyclic(g), "This graph is acyclic."); + check(tree(g), "This graph is tree."); + check(bipartite(g), "This graph is bipartite."); + check(loopFree(g), "This graph is loop-free."); + check(parallelFree(g), "This graph is parallel-free."); + check(simpleGraph(g), "This graph is simple."); + } + + { + Digraph d; + Digraph::NodeMap order(d); + Graph g(d); + + Digraph::Node n1 = d.addNode(); + Digraph::Node n2 = d.addNode(); + Digraph::Node n3 = d.addNode(); + Digraph::Node n4 = d.addNode(); + Digraph::Node n5 = d.addNode(); + Digraph::Node n6 = d.addNode(); + + d.addArc(n1, n3); + d.addArc(n3, n2); + d.addArc(n2, n1); + d.addArc(n4, n2); + d.addArc(n4, n3); + d.addArc(n5, n6); + d.addArc(n6, n5); + + check(!stronglyConnected(d), "This digraph is not strongly connected"); + check(countStronglyConnectedComponents(d) == 3, + "This digraph has 3 strongly connected components"); + check(!connected(g), "This graph is not connected"); + check(countConnectedComponents(g) == 2, + "This graph has 2 connected components"); + + check(!dag(d), "This digraph is not DAG."); + check(!checkedTopologicalSort(d, order), "This digraph is not DAG."); + check(loopFree(d), "This digraph is loop-free."); + check(parallelFree(d), "This digraph is parallel-free."); + check(simpleGraph(d), "This digraph is simple."); + + check(!acyclic(g), "This graph is not acyclic."); + check(!tree(g), "This graph is not tree."); + check(!bipartite(g), "This graph is not bipartite."); + check(loopFree(g), "This graph is loop-free."); + check(!parallelFree(g), "This graph is not parallel-free."); + check(!simpleGraph(g), "This graph is not simple."); + + d.addArc(n3, n3); + + check(!loopFree(d), "This digraph is not loop-free."); + check(!loopFree(g), "This graph is not loop-free."); + check(!simpleGraph(d), "This digraph is not simple."); + + d.addArc(n3, n2); + + check(!parallelFree(d), "This digraph is not parallel-free."); + } + + { + Digraph d; + Digraph::ArcMap cutarcs(d, false); + Graph g(d); + + Digraph::Node n1 = d.addNode(); + Digraph::Node n2 = d.addNode(); + Digraph::Node n3 = d.addNode(); + Digraph::Node n4 = d.addNode(); + Digraph::Node n5 = d.addNode(); + Digraph::Node n6 = d.addNode(); + Digraph::Node n7 = d.addNode(); + Digraph::Node n8 = d.addNode(); + + d.addArc(n1, n2); + d.addArc(n5, n1); + d.addArc(n2, n8); + d.addArc(n8, n5); + d.addArc(n6, n4); + d.addArc(n4, n6); + d.addArc(n2, n5); + d.addArc(n1, n8); + d.addArc(n6, n7); + d.addArc(n7, n6); + + check(!stronglyConnected(d), "This digraph is not strongly connected"); + check(countStronglyConnectedComponents(d) == 3, + "This digraph has 3 strongly connected components"); + Digraph::NodeMap scomp1(d); + check(stronglyConnectedComponents(d, scomp1) == 3, + "This digraph has 3 strongly connected components"); + check(scomp1[n1] != scomp1[n3] && scomp1[n1] != scomp1[n4] && + scomp1[n3] != scomp1[n4], "Wrong stronglyConnectedComponents()"); + check(scomp1[n1] == scomp1[n2] && scomp1[n1] == scomp1[n5] && + scomp1[n1] == scomp1[n8], "Wrong stronglyConnectedComponents()"); + check(scomp1[n4] == scomp1[n6] && scomp1[n4] == scomp1[n7], + "Wrong stronglyConnectedComponents()"); + Digraph::ArcMap scut1(d, false); + check(stronglyConnectedCutArcs(d, scut1) == 0, + "This digraph has 0 strongly connected cut arc."); + for (Digraph::ArcIt a(d); a != INVALID; ++a) { + check(!scut1[a], "Wrong stronglyConnectedCutArcs()"); + } + + check(!connected(g), "This graph is not connected"); + check(countConnectedComponents(g) == 3, + "This graph has 3 connected components"); + Graph::NodeMap comp(g); + check(connectedComponents(g, comp) == 3, + "This graph has 3 connected components"); + check(comp[n1] != comp[n3] && comp[n1] != comp[n4] && + comp[n3] != comp[n4], "Wrong connectedComponents()"); + check(comp[n1] == comp[n2] && comp[n1] == comp[n5] && + comp[n1] == comp[n8], "Wrong connectedComponents()"); + check(comp[n4] == comp[n6] && comp[n4] == comp[n7], + "Wrong connectedComponents()"); + + cutarcs[d.addArc(n3, n1)] = true; + cutarcs[d.addArc(n3, n5)] = true; + cutarcs[d.addArc(n3, n8)] = true; + cutarcs[d.addArc(n8, n6)] = true; + cutarcs[d.addArc(n8, n7)] = true; + + check(!stronglyConnected(d), "This digraph is not strongly connected"); + check(countStronglyConnectedComponents(d) == 3, + "This digraph has 3 strongly connected components"); + Digraph::NodeMap scomp2(d); + check(stronglyConnectedComponents(d, scomp2) == 3, + "This digraph has 3 strongly connected components"); + check(scomp2[n3] == 0, "Wrong stronglyConnectedComponents()"); + check(scomp2[n1] == 1 && scomp2[n2] == 1 && scomp2[n5] == 1 && + scomp2[n8] == 1, "Wrong stronglyConnectedComponents()"); + check(scomp2[n4] == 2 && scomp2[n6] == 2 && scomp2[n7] == 2, + "Wrong stronglyConnectedComponents()"); + Digraph::ArcMap scut2(d, false); + check(stronglyConnectedCutArcs(d, scut2) == 5, + "This digraph has 5 strongly connected cut arcs."); + for (Digraph::ArcIt a(d); a != INVALID; ++a) { + check(scut2[a] == cutarcs[a], "Wrong stronglyConnectedCutArcs()"); + } + } + + { + // DAG example for topological sort from the book New Algorithms + // (T. H. Cormen, C. E. Leiserson, R. L. Rivest, C. Stein) + Digraph d; + Digraph::NodeMap order(d); + + Digraph::Node belt = d.addNode(); + Digraph::Node trousers = d.addNode(); + Digraph::Node necktie = d.addNode(); + Digraph::Node coat = d.addNode(); + Digraph::Node socks = d.addNode(); + Digraph::Node shirt = d.addNode(); + Digraph::Node shoe = d.addNode(); + Digraph::Node watch = d.addNode(); + Digraph::Node pants = d.addNode(); + + d.addArc(socks, shoe); + d.addArc(pants, shoe); + d.addArc(pants, trousers); + d.addArc(trousers, shoe); + d.addArc(trousers, belt); + d.addArc(belt, coat); + d.addArc(shirt, belt); + d.addArc(shirt, necktie); + d.addArc(necktie, coat); + + check(dag(d), "This digraph is DAG."); + topologicalSort(d, order); + for (Digraph::ArcIt a(d); a != INVALID; ++a) { + check(order[d.source(a)] < order[d.target(a)], + "Wrong topologicalSort()"); + } + } + + { + ListGraph g; + ListGraph::NodeMap map(g); + + ListGraph::Node n1 = g.addNode(); + ListGraph::Node n2 = g.addNode(); + ListGraph::Node n3 = g.addNode(); + ListGraph::Node n4 = g.addNode(); + ListGraph::Node n5 = g.addNode(); + ListGraph::Node n6 = g.addNode(); + ListGraph::Node n7 = g.addNode(); + + g.addEdge(n1, n3); + g.addEdge(n1, n4); + g.addEdge(n2, n5); + g.addEdge(n3, n6); + g.addEdge(n4, n6); + g.addEdge(n4, n7); + g.addEdge(n5, n7); + + check(bipartite(g), "This graph is bipartite"); + check(bipartitePartitions(g, map), "This graph is bipartite"); + + check(map[n1] == map[n2] && map[n1] == map[n6] && map[n1] == map[n7], + "Wrong bipartitePartitions()"); + check(map[n3] == map[n4] && map[n3] == map[n5], + "Wrong bipartitePartitions()"); + } + + return 0; +} diff -r c35afa9e89e7 -r ef88c0a30f85 test/counter_test.cc --- a/test/counter_test.cc Mon Jan 12 23:11:39 2009 +0100 +++ b/test/counter_test.cc Thu Nov 05 15:48:01 2009 +0100 @@ -18,59 +18,86 @@ #include #include +#include + +#include "test/test_tools.h" using namespace lemon; template void bubbleSort(std::vector& v) { - Counter op("Bubble Sort - Operations: "); - Counter::NoSubCounter as(op, "Assignments: "); - Counter::NoSubCounter co(op, "Comparisons: "); - for (int i = v.size()-1; i > 0; --i) { - for (int j = 0; j < i; ++j) { - if (v[j] > v[j+1]) { - T tmp = v[j]; - v[j] = v[j+1]; - v[j+1] = tmp; - as += 3; + std::stringstream s1, s2, s3; + { + Counter op("Bubble Sort - Operations: ", s1); + Counter::SubCounter as(op, "Assignments: ", s2); + Counter::SubCounter co(op, "Comparisons: ", s3); + for (int i = v.size()-1; i > 0; --i) { + for (int j = 0; j < i; ++j) { + if (v[j] > v[j+1]) { + T tmp = v[j]; + v[j] = v[j+1]; + v[j+1] = tmp; + as += 3; + } + ++co; } - ++co; } } + check(s1.str() == "Bubble Sort - Operations: 102\n", "Wrong counter"); + check(s2.str() == "Assignments: 57\n", "Wrong subcounter"); + check(s3.str() == "Comparisons: 45\n", "Wrong subcounter"); } template void insertionSort(std::vector& v) { - Counter op("Insertion Sort - Operations: "); - Counter::NoSubCounter as(op, "Assignments: "); - Counter::NoSubCounter co(op, "Comparisons: "); - for (int i = 1; i < int(v.size()); ++i) { - T value = v[i]; - ++as; - int j = i; - while (j > 0 && v[j-1] > value) { - v[j] = v[j-1]; - --j; - ++co; ++as; + std::stringstream s1, s2, s3; + { + Counter op("Insertion Sort - Operations: ", s1); + Counter::SubCounter as(op, "Assignments: ", s2); + Counter::SubCounter co(op, "Comparisons: ", s3); + for (int i = 1; i < int(v.size()); ++i) { + T value = v[i]; + ++as; + int j = i; + while (j > 0 && v[j-1] > value) { + v[j] = v[j-1]; + --j; + ++co; ++as; + } + v[j] = value; + ++as; } - v[j] = value; - ++as; } + check(s1.str() == "Insertion Sort - Operations: 56\n", "Wrong counter"); + check(s2.str() == "Assignments: 37\n", "Wrong subcounter"); + check(s3.str() == "Comparisons: 19\n", "Wrong subcounter"); } template -void counterTest() { - MyCounter c("Main Counter: "); - c++; - typename MyCounter::SubCounter d(c, "SubCounter: "); - d++; - typename MyCounter::SubCounter::NoSubCounter e(d, "SubSubCounter: "); - e++; - d+=3; - c-=4; - e-=2; - c.reset(2); - c.reset(); +void counterTest(bool output) { + std::stringstream s1, s2, s3; + { + MyCounter c("Main Counter: ", s1); + c++; + typename MyCounter::SubCounter d(c, "SubCounter: ", s2); + d++; + typename MyCounter::SubCounter::NoSubCounter e(d, "SubSubCounter: ", s3); + e++; + d+=3; + c-=4; + e-=2; + c.reset(2); + c.reset(); + } + if (output) { + check(s1.str() == "Main Counter: 3\n", "Wrong Counter"); + check(s2.str() == "SubCounter: 3\n", "Wrong SubCounter"); + check(s3.str() == "", "Wrong NoSubCounter"); + } else { + check(s1.str() == "", "Wrong NoCounter"); + check(s2.str() == "", "Wrong SubCounter"); + check(s3.str() == "", "Wrong NoSubCounter"); + } } void init(std::vector& v) { @@ -80,8 +107,8 @@ int main() { - counterTest(); - counterTest(); + counterTest(true); + counterTest(false); std::vector x(10); init(x); bubbleSort(x); diff -r c35afa9e89e7 -r ef88c0a30f85 test/dfs_test.cc --- a/test/dfs_test.cc Mon Jan 12 23:11:39 2009 +0100 +++ b/test/dfs_test.cc Thu Nov 05 15:48:01 2009 +0100 @@ -62,39 +62,74 @@ Digraph G; Node s, t; Arc e; - int l; + int l, i; bool b; DType::DistMap d(G); DType::PredMap p(G); Path pp; + concepts::ReadMap am; { DType dfs_test(G); + const DType& const_dfs_test = dfs_test; dfs_test.run(s); dfs_test.run(s,t); dfs_test.run(); - l = dfs_test.dist(t); - e = dfs_test.predArc(t); - s = dfs_test.predNode(t); - b = dfs_test.reached(t); - d = dfs_test.distMap(); - p = dfs_test.predMap(); - pp = dfs_test.path(t); + dfs_test.init(); + dfs_test.addSource(s); + e = dfs_test.processNextArc(); + e = const_dfs_test.nextArc(); + b = const_dfs_test.emptyQueue(); + i = const_dfs_test.queueSize(); + + dfs_test.start(); + dfs_test.start(t); + dfs_test.start(am); + + l = const_dfs_test.dist(t); + e = const_dfs_test.predArc(t); + s = const_dfs_test.predNode(t); + b = const_dfs_test.reached(t); + d = const_dfs_test.distMap(); + p = const_dfs_test.predMap(); + pp = const_dfs_test.path(t); } { DType ::SetPredMap > ::SetDistMap > ::SetReachedMap > + ::SetStandardProcessedMap ::SetProcessedMap > - ::SetStandardProcessedMap ::Create dfs_test(G); + concepts::ReadWriteMap pred_map; + concepts::ReadWriteMap dist_map; + concepts::ReadWriteMap reached_map; + concepts::WriteMap processed_map; + + dfs_test + .predMap(pred_map) + .distMap(dist_map) + .reachedMap(reached_map) + .processedMap(processed_map); + dfs_test.run(s); dfs_test.run(s,t); dfs_test.run(); + dfs_test.init(); + + dfs_test.addSource(s); + e = dfs_test.processNextArc(); + e = dfs_test.nextArc(); + b = dfs_test.emptyQueue(); + i = dfs_test.queueSize(); + + dfs_test.start(); + dfs_test.start(t); + dfs_test.start(am); l = dfs_test.dist(t); e = dfs_test.predArc(t); diff -r c35afa9e89e7 -r ef88c0a30f85 test/digraph_test.cc --- a/test/digraph_test.cc Mon Jan 12 23:11:39 2009 +0100 +++ b/test/digraph_test.cc Thu Nov 05 15:48:01 2009 +0100 @@ -19,6 +19,7 @@ #include #include #include +#include #include #include "test_tools.h" @@ -35,6 +36,9 @@ checkGraphNodeList(G, 0); checkGraphArcList(G, 0); + G.reserveNode(3); + G.reserveArc(4); + Node n1 = G.addNode(), n2 = G.addNode(), @@ -283,6 +287,14 @@ G.addArc(G.addNode(), G.addNode()); snapshot.restore(); + snapshot.save(G); + + checkGraphNodeList(G, 4); + checkGraphArcList(G, 4); + + G.addArc(G.addNode(), G.addNode()); + + snapshot.restore(); checkGraphNodeList(G, 4); checkGraphArcList(G, 4); @@ -317,6 +329,10 @@ checkConcept, SmartDigraph>(); checkConcept, SmartDigraph>(); } + { // Checking StaticDigraph + checkConcept(); + checkConcept, StaticDigraph>(); + } { // Checking FullDigraph checkConcept(); } @@ -372,10 +388,122 @@ check(!g.valid(g.arcFromId(-1)), "Wrong validity check"); } +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); + + 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); checkGraphArcList(G, num * num); @@ -419,6 +547,9 @@ checkDigraphSnapshot(); checkDigraphValidity(); } + { // Checking StaticDigraph + checkStaticDigraph(); + } { // Checking FullDigraph checkFullDigraph(8); } diff -r c35afa9e89e7 -r ef88c0a30f85 test/dijkstra_test.cc --- a/test/dijkstra_test.cc Mon Jan 12 23:11:39 2009 +0100 +++ b/test/dijkstra_test.cc Thu Nov 05 15:48:01 2009 +0100 @@ -60,48 +60,94 @@ typedef Digraph::Arc Arc; Digraph G; - Node s, t; + Node s, t, n; Arc e; VType l; + int i; bool b; DType::DistMap d(G); DType::PredMap p(G); LengthMap length; Path pp; + concepts::ReadMap nm; { DType dijkstra_test(G,length); + const DType& const_dijkstra_test = dijkstra_test; dijkstra_test.run(s); dijkstra_test.run(s,t); + dijkstra_test.init(); + dijkstra_test.addSource(s); + dijkstra_test.addSource(s, 1); + n = dijkstra_test.processNextNode(); + n = const_dijkstra_test.nextNode(); + b = const_dijkstra_test.emptyQueue(); + i = const_dijkstra_test.queueSize(); + + dijkstra_test.start(); + dijkstra_test.start(t); + dijkstra_test.start(nm); + + l = const_dijkstra_test.dist(t); + e = const_dijkstra_test.predArc(t); + s = const_dijkstra_test.predNode(t); + b = const_dijkstra_test.reached(t); + b = const_dijkstra_test.processed(t); + d = const_dijkstra_test.distMap(); + p = const_dijkstra_test.predMap(); + pp = const_dijkstra_test.path(t); + l = const_dijkstra_test.currentDist(t); + } + { + DType + ::SetPredMap > + ::SetDistMap > + ::SetStandardProcessedMap + ::SetProcessedMap > + ::SetOperationTraits > + ::SetHeap > > + ::SetStandardHeap > > + ::SetHeap >, + concepts::ReadWriteMap > + ::Create dijkstra_test(G,length); + + LengthMap length_map; + concepts::ReadWriteMap pred_map; + concepts::ReadWriteMap dist_map; + concepts::WriteMap processed_map; + concepts::ReadWriteMap heap_cross_ref; + BinHeap > heap(heap_cross_ref); + + dijkstra_test + .lengthMap(length_map) + .predMap(pred_map) + .distMap(dist_map) + .processedMap(processed_map) + .heap(heap, heap_cross_ref); + + dijkstra_test.run(s); + dijkstra_test.run(s,t); + + dijkstra_test.addSource(s); + dijkstra_test.addSource(s, 1); + n = dijkstra_test.processNextNode(); + n = dijkstra_test.nextNode(); + b = dijkstra_test.emptyQueue(); + i = dijkstra_test.queueSize(); + + dijkstra_test.start(); + dijkstra_test.start(t); + dijkstra_test.start(nm); + l = dijkstra_test.dist(t); e = dijkstra_test.predArc(t); s = dijkstra_test.predNode(t); b = dijkstra_test.reached(t); - d = dijkstra_test.distMap(); - p = dijkstra_test.predMap(); + b = dijkstra_test.processed(t); pp = dijkstra_test.path(t); - } - { - DType - ::SetPredMap > - ::SetDistMap > - ::SetProcessedMap > - ::SetStandardProcessedMap - ::SetOperationTraits > - ::SetHeap > > - ::SetStandardHeap > > - ::Create dijkstra_test(G,length); - - dijkstra_test.run(s); - dijkstra_test.run(s,t); - - l = dijkstra_test.dist(t); - e = dijkstra_test.predArc(t); - s = dijkstra_test.predNode(t); - b = dijkstra_test.reached(t); - pp = dijkstra_test.path(t); + l = dijkstra_test.currentDist(t); } } diff -r c35afa9e89e7 -r ef88c0a30f85 test/edge_set_test.cc --- a/test/edge_set_test.cc Mon Jan 12 23:11:39 2009 +0100 +++ b/test/edge_set_test.cc Thu Nov 05 15:48:01 2009 +0100 @@ -33,7 +33,7 @@ using namespace lemon; void checkSmartArcSet() { - checkConcept >(); + checkConcept >(); typedef ListDigraph Digraph; typedef SmartArcSet ArcSet; @@ -99,7 +99,7 @@ } void checkListArcSet() { - checkConcept >(); + checkConcept >(); typedef ListDigraph Digraph; typedef ListArcSet ArcSet; @@ -179,7 +179,7 @@ } void checkSmartEdgeSet() { - checkConcept >(); + checkConcept >(); typedef ListDigraph Digraph; typedef SmartEdgeSet EdgeSet; @@ -263,7 +263,7 @@ } void checkListEdgeSet() { - checkConcept >(); + checkConcept >(); typedef ListDigraph Digraph; typedef ListEdgeSet EdgeSet; diff -r c35afa9e89e7 -r ef88c0a30f85 test/euler_test.cc --- /dev/null Thu Jan 01 00:00:00 1970 +0000 +++ b/test/euler_test.cc Thu Nov 05 15:48:01 2009 +0100 @@ -0,0 +1,223 @@ +/* -*- 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 "test_tools.h" + +using namespace lemon; + +template +void checkDiEulerIt(const Digraph& g, + const typename Digraph::Node& start = INVALID) +{ + typename Digraph::template ArcMap visitationNumber(g, 0); + + DiEulerIt e(g, start); + if (e == INVALID) return; + typename Digraph::Node firstNode = g.source(e); + typename Digraph::Node lastNode = g.target(e); + if (start != INVALID) { + check(firstNode == start, "checkDiEulerIt: Wrong first node"); + } + + for (; e != INVALID; ++e) { + if (e != INVALID) lastNode = g.target(e); + ++visitationNumber[e]; + } + + check(firstNode == lastNode, + "checkDiEulerIt: First and last nodes are not the same"); + + for (typename Digraph::ArcIt a(g); a != INVALID; ++a) + { + check(visitationNumber[a] == 1, + "checkDiEulerIt: Not visited or multiple times visited arc found"); + } +} + +template +void checkEulerIt(const Graph& g, + const typename Graph::Node& start = INVALID) +{ + typename Graph::template EdgeMap visitationNumber(g, 0); + + EulerIt e(g, start); + if (e == INVALID) return; + typename Graph::Node firstNode = g.source(typename Graph::Arc(e)); + typename Graph::Node lastNode = g.target(typename Graph::Arc(e)); + if (start != INVALID) { + check(firstNode == start, "checkEulerIt: Wrong first node"); + } + + for (; e != INVALID; ++e) { + if (e != INVALID) lastNode = g.target(typename Graph::Arc(e)); + ++visitationNumber[e]; + } + + check(firstNode == lastNode, + "checkEulerIt: First and last nodes are not the same"); + + for (typename Graph::EdgeIt e(g); e != INVALID; ++e) + { + check(visitationNumber[e] == 1, + "checkEulerIt: Not visited or multiple times visited edge found"); + } +} + +int main() +{ + typedef ListDigraph Digraph; + typedef Undirector Graph; + + { + Digraph d; + Graph g(d); + + checkDiEulerIt(d); + checkDiEulerIt(g); + checkEulerIt(g); + + check(eulerian(d), "This graph is Eulerian"); + check(eulerian(g), "This graph is Eulerian"); + } + { + Digraph d; + Graph g(d); + Digraph::Node n = d.addNode(); + + checkDiEulerIt(d); + checkDiEulerIt(g); + checkEulerIt(g); + + check(eulerian(d), "This graph is Eulerian"); + check(eulerian(g), "This graph is Eulerian"); + } + { + Digraph d; + Graph g(d); + Digraph::Node n = d.addNode(); + d.addArc(n, n); + + checkDiEulerIt(d); + checkDiEulerIt(g); + checkEulerIt(g); + + check(eulerian(d), "This graph is Eulerian"); + check(eulerian(g), "This graph is Eulerian"); + } + { + Digraph d; + Graph g(d); + Digraph::Node n1 = d.addNode(); + Digraph::Node n2 = d.addNode(); + Digraph::Node n3 = d.addNode(); + + d.addArc(n1, n2); + d.addArc(n2, n1); + d.addArc(n2, n3); + d.addArc(n3, n2); + + checkDiEulerIt(d); + checkDiEulerIt(d, n2); + checkDiEulerIt(g); + checkDiEulerIt(g, n2); + checkEulerIt(g); + checkEulerIt(g, n2); + + check(eulerian(d), "This graph is Eulerian"); + check(eulerian(g), "This graph is Eulerian"); + } + { + Digraph d; + Graph g(d); + Digraph::Node n1 = d.addNode(); + Digraph::Node n2 = d.addNode(); + Digraph::Node n3 = d.addNode(); + Digraph::Node n4 = d.addNode(); + Digraph::Node n5 = d.addNode(); + Digraph::Node n6 = d.addNode(); + + d.addArc(n1, n2); + d.addArc(n2, n4); + d.addArc(n1, n3); + d.addArc(n3, n4); + d.addArc(n4, n1); + d.addArc(n3, n5); + d.addArc(n5, n2); + d.addArc(n4, n6); + d.addArc(n2, n6); + d.addArc(n6, n1); + d.addArc(n6, n3); + + checkDiEulerIt(d); + checkDiEulerIt(d, n1); + checkDiEulerIt(d, n5); + + checkDiEulerIt(g); + checkDiEulerIt(g, n1); + checkDiEulerIt(g, n5); + checkEulerIt(g); + checkEulerIt(g, n1); + checkEulerIt(g, n5); + + check(eulerian(d), "This graph is Eulerian"); + check(eulerian(g), "This graph is Eulerian"); + } + { + Digraph d; + Graph g(d); + Digraph::Node n0 = d.addNode(); + Digraph::Node n1 = d.addNode(); + Digraph::Node n2 = d.addNode(); + Digraph::Node n3 = d.addNode(); + Digraph::Node n4 = d.addNode(); + Digraph::Node n5 = d.addNode(); + + d.addArc(n1, n2); + d.addArc(n2, n3); + d.addArc(n3, n1); + + checkDiEulerIt(d); + checkDiEulerIt(d, n2); + + checkDiEulerIt(g); + checkDiEulerIt(g, n2); + checkEulerIt(g); + checkEulerIt(g, n2); + + check(!eulerian(d), "This graph is not Eulerian"); + check(!eulerian(g), "This graph is not Eulerian"); + } + { + Digraph d; + Graph g(d); + Digraph::Node n1 = d.addNode(); + Digraph::Node n2 = d.addNode(); + Digraph::Node n3 = d.addNode(); + + d.addArc(n1, n2); + d.addArc(n2, n3); + + check(!eulerian(d), "This graph is not Eulerian"); + check(!eulerian(g), "This graph is not Eulerian"); + } + + return 0; +} diff -r c35afa9e89e7 -r ef88c0a30f85 test/gomory_hu_test.cc --- /dev/null Thu Jan 01 00:00:00 1970 +0000 +++ b/test/gomory_hu_test.cc Thu Nov 05 15:48:01 2009 +0100 @@ -0,0 +1,123 @@ +#include + +#include "test_tools.h" +#include +#include +#include +#include +#include +#include + +using namespace std; +using namespace lemon; + +typedef SmartGraph Graph; + +char test_lgf[] = + "@nodes\n" + "label\n" + "0\n" + "1\n" + "2\n" + "3\n" + "4\n" + "@arcs\n" + " label capacity\n" + "0 1 0 1\n" + "1 2 1 1\n" + "2 3 2 1\n" + "0 3 4 5\n" + "0 3 5 10\n" + "0 3 6 7\n" + "4 2 7 1\n" + "@attributes\n" + "source 0\n" + "target 3\n"; + +void checkGomoryHuCompile() +{ + typedef int Value; + typedef concepts::Graph Graph; + + typedef Graph::Node Node; + typedef Graph::Edge Edge; + typedef concepts::ReadMap CapMap; + typedef concepts::ReadWriteMap CutMap; + + Graph g; + Node n; + CapMap cap; + CutMap cut; + Value v; + int d; + + GomoryHu gh_test(g, cap); + const GomoryHu& + const_gh_test = gh_test; + + gh_test.run(); + + n = const_gh_test.predNode(n); + v = const_gh_test.predValue(n); + d = const_gh_test.rootDist(n); + v = const_gh_test.minCutValue(n, n); + v = const_gh_test.minCutMap(n, n, cut); +} + +GRAPH_TYPEDEFS(Graph); +typedef Graph::EdgeMap IntEdgeMap; +typedef Graph::NodeMap BoolNodeMap; + +int cutValue(const Graph& graph, const BoolNodeMap& cut, + const IntEdgeMap& capacity) { + + int sum = 0; + for (EdgeIt e(graph); e != INVALID; ++e) { + Node s = graph.u(e); + Node t = graph.v(e); + + if (cut[s] != cut[t]) { + sum += capacity[e]; + } + } + return sum; +} + + +int main() { + Graph graph; + IntEdgeMap capacity(graph); + + std::istringstream input(test_lgf); + GraphReader(graph, input). + edgeMap("capacity", capacity).run(); + + GomoryHu ght(graph, capacity); + ght.run(); + + for (NodeIt u(graph); u != INVALID; ++u) { + for (NodeIt v(graph); v != u; ++v) { + Preflow pf(graph, capacity, u, v); + pf.runMinCut(); + BoolNodeMap cm(graph); + ght.minCutMap(u, v, cm); + check(pf.flowValue() == ght.minCutValue(u, v), "Wrong cut 1"); + check(cm[u] != cm[v], "Wrong cut 2"); + check(pf.flowValue() == cutValue(graph, cm, capacity), "Wrong cut 3"); + + int sum=0; + for(GomoryHu::MinCutEdgeIt a(ght, u, v);a!=INVALID;++a) + sum+=capacity[a]; + check(sum == ght.minCutValue(u, v), "Problem with MinCutEdgeIt"); + + sum=0; + for(GomoryHu::MinCutNodeIt n(ght, u, v,true);n!=INVALID;++n) + sum++; + for(GomoryHu::MinCutNodeIt n(ght, u, v,false);n!=INVALID;++n) + sum++; + check(sum == countNodes(graph), "Problem with MinCutNodeIt"); + } + } + + return 0; +} diff -r c35afa9e89e7 -r ef88c0a30f85 test/graph_test.cc --- a/test/graph_test.cc Mon Jan 12 23:11:39 2009 +0100 +++ b/test/graph_test.cc Thu Nov 05 15:48:01 2009 +0100 @@ -38,6 +38,9 @@ checkGraphEdgeList(G, 0); checkGraphArcList(G, 0); + G.reserveNode(3); + G.reserveEdge(3); + Node n1 = G.addNode(), n2 = G.addNode(), @@ -256,6 +259,15 @@ G.addEdge(G.addNode(), G.addNode()); snapshot.restore(); + snapshot.save(G); + + checkGraphNodeList(G, 4); + checkGraphEdgeList(G, 3); + checkGraphArcList(G, 6); + + G.addEdge(G.addNode(), G.addNode()); + + snapshot.restore(); checkGraphNodeList(G, 4); checkGraphEdgeList(G, 3); @@ -267,6 +279,13 @@ GRAPH_TYPEDEFS(Graph); Graph G(num); + check(G.nodeNum() == num && G.edgeNum() == num * (num - 1) / 2, + "Wrong size"); + + G.resize(num); + check(G.nodeNum() == num && G.edgeNum() == num * (num - 1) / 2, + "Wrong size"); + checkGraphNodeList(G, num); checkGraphEdgeList(G, num * (num - 1) / 2); @@ -411,6 +430,10 @@ check(G.width() == width, "Wrong column number"); check(G.height() == height, "Wrong row number"); + G.resize(width, height); + check(G.width() == width, "Wrong column number"); + check(G.height() == height, "Wrong row number"); + for (int i = 0; i < width; ++i) { for (int j = 0; j < height; ++j) { check(G.col(G(i, j)) == i, "Wrong column"); @@ -486,6 +509,11 @@ GRAPH_TYPEDEFS(HypercubeGraph); HypercubeGraph G(dim); + check(G.dimension() == dim, "Wrong dimension"); + + G.resize(dim); + check(G.dimension() == dim, "Wrong dimension"); + checkGraphNodeList(G, 1 << dim); checkGraphEdgeList(G, dim * (1 << (dim-1))); checkGraphArcList(G, dim * (1 << dim)); diff -r c35afa9e89e7 -r ef88c0a30f85 test/graph_utils_test.cc --- a/test/graph_utils_test.cc Mon Jan 12 23:11:39 2009 +0100 +++ b/test/graph_utils_test.cc Thu Nov 05 15:48:01 2009 +0100 @@ -38,15 +38,15 @@ for (int i = 0; i < 10; ++i) { digraph.addNode(); } - DescriptorMap nodes(digraph); - typename DescriptorMap::InverseMap invNodes(nodes); + RangeIdMap nodes(digraph); + typename RangeIdMap::InverseMap invNodes(nodes); for (int i = 0; i < 100; ++i) { int src = rnd[invNodes.size()]; int trg = rnd[invNodes.size()]; digraph.addArc(invNodes[src], invNodes[trg]); } typename Digraph::template ArcMap found(digraph, false); - DescriptorMap arcs(digraph); + RangeIdMap arcs(digraph); for (NodeIt src(digraph); src != INVALID; ++src) { for (NodeIt trg(digraph); trg != INVALID; ++trg) { for (ConArcIt con(digraph, src, trg); con != INVALID; ++con) { @@ -113,15 +113,15 @@ for (int i = 0; i < 10; ++i) { graph.addNode(); } - DescriptorMap nodes(graph); - typename DescriptorMap::InverseMap invNodes(nodes); + RangeIdMap nodes(graph); + typename RangeIdMap::InverseMap invNodes(nodes); for (int i = 0; i < 100; ++i) { int src = rnd[invNodes.size()]; int trg = rnd[invNodes.size()]; graph.addEdge(invNodes[src], invNodes[trg]); } typename Graph::template EdgeMap found(graph, 0); - DescriptorMap edges(graph); + RangeIdMap edges(graph); for (NodeIt src(graph); src != INVALID; ++src) { for (NodeIt trg(graph); trg != INVALID; ++trg) { for (ConEdgeIt con(graph, src, trg); con != INVALID; ++con) { diff -r c35afa9e89e7 -r ef88c0a30f85 test/hao_orlin_test.cc --- a/test/hao_orlin_test.cc Mon Jan 12 23:11:39 2009 +0100 +++ b/test/hao_orlin_test.cc Thu Nov 05 15:48:01 2009 +0100 @@ -19,9 +19,12 @@ #include #include +#include +#include +#include +#include #include -#include #include "test_tools.h" using namespace lemon; @@ -37,27 +40,124 @@ "4\n" "5\n" "@edges\n" - " label capacity\n" - "0 1 0 2\n" - "1 2 1 2\n" - "2 0 2 2\n" - "3 4 3 2\n" - "4 5 4 2\n" - "5 3 5 2\n" - "2 3 6 3\n"; + " cap1 cap2 cap3\n" + "0 1 1 1 1 \n" + "0 2 2 2 4 \n" + "1 2 4 4 4 \n" + "3 4 1 1 1 \n" + "3 5 2 2 4 \n" + "4 5 4 4 4 \n" + "5 4 4 4 4 \n" + "2 3 1 6 6 \n" + "4 0 1 6 6 \n"; + +void checkHaoOrlinCompile() +{ + typedef int Value; + typedef concepts::Digraph Digraph; + + typedef Digraph::Node Node; + typedef Digraph::Arc Arc; + typedef concepts::ReadMap CapMap; + typedef concepts::WriteMap CutMap; + + Digraph g; + Node n; + CapMap cap; + CutMap cut; + Value v; + + HaoOrlin ho_test(g, cap); + const HaoOrlin& + const_ho_test = ho_test; + + ho_test.init(); + ho_test.init(n); + ho_test.calculateOut(); + ho_test.calculateIn(); + ho_test.run(); + ho_test.run(n); + + v = const_ho_test.minCutValue(); + v = const_ho_test.minCutMap(cut); +} + +template +typename CapMap::Value + cutValue(const Graph& graph, const CapMap& cap, const CutMap& cut) +{ + typename CapMap::Value sum = 0; + for (typename Graph::ArcIt a(graph); a != INVALID; ++a) { + if (cut[graph.source(a)] && !cut[graph.target(a)]) + sum += cap[a]; + } + return sum; +} int main() { - SmartGraph graph; - SmartGraph::EdgeMap capacity(graph); + SmartDigraph graph; + SmartDigraph::ArcMap cap1(graph), cap2(graph), cap3(graph); + SmartDigraph::NodeMap cut(graph); - istringstream lgfs(lgf); - graphReader(graph, lgfs). - edgeMap("capacity", capacity).run(); + istringstream input(lgf); + digraphReader(graph, input) + .arcMap("cap1", cap1) + .arcMap("cap2", cap2) + .arcMap("cap3", cap3) + .run(); - HaoOrlin > ho(graph, capacity); - ho.run(); + { + HaoOrlin ho(graph, cap1); + ho.run(); + ho.minCutMap(cut); + + check(ho.minCutValue() == 1, "Wrong cut value"); + check(ho.minCutValue() == cutValue(graph, cap1, cut), "Wrong cut value"); + } + { + HaoOrlin ho(graph, cap2); + ho.run(); + ho.minCutMap(cut); - check(ho.minCutValue() == 3, "Wrong cut value"); + check(ho.minCutValue() == 1, "Wrong cut value"); + check(ho.minCutValue() == cutValue(graph, cap2, cut), "Wrong cut value"); + } + { + HaoOrlin ho(graph, cap3); + ho.run(); + ho.minCutMap(cut); + + check(ho.minCutValue() == 1, "Wrong cut value"); + check(ho.minCutValue() == cutValue(graph, cap3, cut), "Wrong cut value"); + } + + typedef Undirector 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"); + } + { + HaoOrlin > ho(ugraph, cap2); + ho.run(); + ho.minCutMap(cut); + + check(ho.minCutValue() == 5, "Wrong cut value"); + check(ho.minCutValue() == cutValue(ugraph, cap2, cut), "Wrong cut value"); + } + { + HaoOrlin > ho(ugraph, cap3); + ho.run(); + ho.minCutMap(cut); + + check(ho.minCutValue() == 5, "Wrong cut value"); + check(ho.minCutValue() == cutValue(ugraph, cap3, cut), "Wrong cut value"); + } return 0; } diff -r c35afa9e89e7 -r ef88c0a30f85 test/heap_test.cc --- a/test/heap_test.cc Mon Jan 12 23:11:39 2009 +0100 +++ b/test/heap_test.cc Thu Nov 05 15:48:01 2009 +0100 @@ -25,12 +25,18 @@ #include #include - #include #include #include #include +#include +#include +#include +#include +#include +#include +#include #include "test_tools.h" @@ -86,18 +92,16 @@ template 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]; heap.push(i, v[i]); } 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(); } } @@ -109,7 +113,6 @@ Heap heap(map); std::vector v(test_len); - for (int i = 0; i < test_len; ++i) { v[i] = test_seq[i]; heap.push(i, v[i]); @@ -120,13 +123,11 @@ } 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 void dijkstraHeapTest(const Digraph& digraph, const IntArcMap& length, Node source) { @@ -141,7 +142,7 @@ Node t = digraph.target(a); if (dijkstra.reached(s)) { check( dijkstra.dist(t) - dijkstra.dist(s) <= length[a], - "Error in a shortest path tree!"); + "Error in shortest path tree."); } } @@ -150,7 +151,7 @@ Arc a = dijkstra.predArc(n); Node s = digraph.source(a); check( dijkstra.dist(n) - dijkstra.dist(s) == length[a], - "Error in a shortest path tree!"); + "Error in shortest path tree."); } } @@ -172,6 +173,7 @@ node("source", source). run(); + // BinHeap { typedef BinHeap IntHeap; checkConcept, IntHeap>(); @@ -183,5 +185,92 @@ dijkstraHeapTest(digraph, length, source); } + // FouraryHeap + { + typedef FouraryHeap IntHeap; + checkConcept, IntHeap>(); + heapSortTest(); + heapIncreaseTest(); + + typedef FouraryHeap NodeHeap; + checkConcept, NodeHeap>(); + dijkstraHeapTest(digraph, length, source); + } + + // KaryHeap + { + typedef KaryHeap IntHeap; + checkConcept, IntHeap>(); + heapSortTest(); + heapIncreaseTest(); + + typedef KaryHeap NodeHeap; + checkConcept, NodeHeap>(); + dijkstraHeapTest(digraph, length, source); + } + + // FibHeap + { + typedef FibHeap IntHeap; + checkConcept, IntHeap>(); + heapSortTest(); + heapIncreaseTest(); + + typedef FibHeap NodeHeap; + checkConcept, NodeHeap>(); + dijkstraHeapTest(digraph, length, source); + } + + // PairingHeap + { + typedef PairingHeap IntHeap; + checkConcept, IntHeap>(); + heapSortTest(); + heapIncreaseTest(); + + typedef PairingHeap NodeHeap; + checkConcept, NodeHeap>(); + dijkstraHeapTest(digraph, length, source); + } + + // RadixHeap + { + typedef RadixHeap IntHeap; + checkConcept, IntHeap>(); + heapSortTest(); + heapIncreaseTest(); + + typedef RadixHeap NodeHeap; + checkConcept, NodeHeap>(); + dijkstraHeapTest(digraph, length, source); + } + + // BinomHeap + { + typedef BinomHeap IntHeap; + checkConcept, IntHeap>(); + heapSortTest(); + heapIncreaseTest(); + + typedef BinomHeap NodeHeap; + checkConcept, NodeHeap>(); + dijkstraHeapTest(digraph, length, source); + } + + // BucketHeap, SimpleBucketHeap + { + typedef BucketHeap IntHeap; + checkConcept, IntHeap>(); + heapSortTest(); + heapIncreaseTest(); + + typedef BucketHeap NodeHeap; + checkConcept, NodeHeap>(); + dijkstraHeapTest(digraph, length, source); + + typedef SimpleBucketHeap SimpleIntHeap; + heapSortTest(); + } + return 0; } diff -r c35afa9e89e7 -r ef88c0a30f85 test/kruskal_test.cc --- a/test/kruskal_test.cc Mon Jan 12 23:11:39 2009 +0100 +++ b/test/kruskal_test.cc Thu Nov 05 15:48:01 2009 +0100 @@ -99,16 +99,16 @@ check(kruskal(G, edge_cost_map, tree_map)==10, "Total cost should be 10"); - edge_cost_map.set(e1, -10); - edge_cost_map.set(e2, -9); - edge_cost_map.set(e3, -8); - edge_cost_map.set(e4, -7); - edge_cost_map.set(e5, -6); - edge_cost_map.set(e6, -5); - edge_cost_map.set(e7, -4); - edge_cost_map.set(e8, -3); - edge_cost_map.set(e9, -2); - edge_cost_map.set(e10, -1); + edge_cost_map[e1] = -10; + edge_cost_map[e2] = -9; + edge_cost_map[e3] = -8; + edge_cost_map[e4] = -7; + edge_cost_map[e5] = -6; + edge_cost_map[e6] = -5; + edge_cost_map[e7] = -4; + edge_cost_map[e8] = -3; + edge_cost_map[e9] = -2; + edge_cost_map[e10] = -1; vector tree_edge_vec(5); diff -r c35afa9e89e7 -r ef88c0a30f85 test/lp_test.cc --- a/test/lp_test.cc Mon Jan 12 23:11:39 2009 +0100 +++ b/test/lp_test.cc Thu Nov 05 15:48:01 2009 +0100 @@ -2,7 +2,7 @@ * * This file is a part of LEMON, a generic C++ optimization library. * - * Copyright (C) 2003-2008 + * Copyright (C) 2003-2009 * Egervary Jeno Kombinatorikus Optimalizalasi Kutatocsoport * (Egervary Research Group on Combinatorial Optimization, EGRES). * @@ -21,23 +21,21 @@ #include "test_tools.h" #include -#ifdef HAVE_CONFIG_H #include -#endif -#ifdef HAVE_GLPK +#ifdef LEMON_HAVE_GLPK #include #endif -#ifdef HAVE_CPLEX +#ifdef LEMON_HAVE_CPLEX #include #endif -#ifdef HAVE_SOPLEX +#ifdef LEMON_HAVE_SOPLEX #include #endif -#ifdef HAVE_CLP +#ifdef LEMON_HAVE_CLP #include #endif @@ -197,6 +195,11 @@ buf << "Coeff. of p2 should be 0"; check(const_cast(e)[p2]==0, buf.str()); + //Test for clone/new + LP* lpnew = lp.newSolver(); + LP* lpclone = lp.cloneSolver(); + delete lpnew; + delete lpclone; } @@ -247,7 +250,8 @@ if (stat == LpSolver::OPTIMAL) { std::ostringstream sbuf; - sbuf << "Wrong optimal value: the right optimum is " << exp_opt; + sbuf << "Wrong optimal value (" << lp.primal() <<") with " + << lp.solverName() <<"\n the right optimum is " << exp_opt; check(std::abs(lp.primal()-exp_opt) < 1e-3, sbuf.str()); } } @@ -355,47 +359,59 @@ } +template +void cloneTest() +{ + //Test for clone/new + + LP* lp = new LP(); + LP* lpnew = lp->newSolver(); + LP* lpclone = lp->cloneSolver(); + delete lp; + delete lpnew; + delete lpclone; +} + int main() { LpSkeleton lp_skel; lpTest(lp_skel); -#ifdef HAVE_GLPK +#ifdef LEMON_HAVE_GLPK { GlpkLp lp_glpk1,lp_glpk2; lpTest(lp_glpk1); aTest(lp_glpk2); + cloneTest(); } #endif -#ifdef HAVE_CPLEX +#ifdef LEMON_HAVE_CPLEX try { CplexLp lp_cplex1,lp_cplex2; lpTest(lp_cplex1); aTest(lp_cplex2); + cloneTest(); } catch (CplexEnv::LicenseError& error) { -#ifdef LEMON_FORCE_CPLEX_CHECK check(false, error.what()); -#else - std::cerr << error.what() << std::endl; - std::cerr << "Cplex license check failed, lp check skipped" << std::endl; -#endif } #endif -#ifdef HAVE_SOPLEX +#ifdef LEMON_HAVE_SOPLEX { SoplexLp lp_soplex1,lp_soplex2; lpTest(lp_soplex1); aTest(lp_soplex2); + cloneTest(); } #endif -#ifdef HAVE_CLP +#ifdef LEMON_HAVE_CLP { ClpLp lp_clp1,lp_clp2; lpTest(lp_clp1); aTest(lp_clp2); + cloneTest(); } #endif diff -r c35afa9e89e7 -r ef88c0a30f85 test/maps_test.cc --- a/test/maps_test.cc Mon Jan 12 23:11:39 2009 +0100 +++ b/test/maps_test.cc Thu Nov 05 15:48:01 2009 +0100 @@ -22,6 +22,10 @@ #include #include #include +#include +#include +#include +#include #include "test_tools.h" @@ -60,6 +64,12 @@ typedef ReadWriteMap BoolWriteMap; typedef ReferenceMap BoolRefMap; +template +void compareMap(const Map1& map1, const Map2& map2, ItemIt it) { + for (; it != INVALID; ++it) + check(map1[it] == map2[it], "The maps are not equal"); +} + int main() { // Map concepts @@ -170,7 +180,7 @@ { typedef ComposeMap > CompMap; checkConcept, CompMap>(); - CompMap map1(DoubleMap(),ReadMap()); + CompMap map1 = CompMap(DoubleMap(),ReadMap()); CompMap map2 = composeMap(DoubleMap(), ReadMap()); SparseMap m1(false); m1[3.14] = true; @@ -183,7 +193,7 @@ { typedef CombineMap > CombMap; checkConcept, CombMap>(); - CombMap map1(DoubleMap(), DoubleMap()); + CombMap map1 = CombMap(DoubleMap(), DoubleMap()); CombMap map2 = combineMap(DoubleMap(), DoubleMap(), std::plus()); check(combineMap(constMap(), identityMap(), &binc)[B()] == 3, @@ -195,11 +205,11 @@ checkConcept, FunctorToMap >(); checkConcept, FunctorToMap >(); FunctorToMap map1; - FunctorToMap map2(F()); + FunctorToMap map2 = FunctorToMap(F()); B b = functorToMap(F())[A()]; checkConcept, MapToFunctor > >(); - MapToFunctor > map(ReadMap()); + MapToFunctor > map = MapToFunctor >(ReadMap()); check(functorToMap(&func)[A()] == 3, "Something is wrong with FunctorToMap"); @@ -328,6 +338,10 @@ // LoggerBoolMap { typedef std::vector vec; + checkConcept, LoggerBoolMap >(); + checkConcept, + LoggerBoolMap > >(); + vec v1; vec v2(10); LoggerBoolMap > @@ -347,7 +361,444 @@ for ( LoggerBoolMap::Iterator it = map2.begin(); it != map2.end(); ++it ) check(v1[i++] == *it, "Something is wrong with LoggerBoolMap"); + + typedef ListDigraph Graph; + DIGRAPH_TYPEDEFS(Graph); + Graph gr; + + Node n0 = gr.addNode(); + Node n1 = gr.addNode(); + Node n2 = gr.addNode(); + Node n3 = gr.addNode(); + + gr.addArc(n3, n0); + gr.addArc(n3, n2); + gr.addArc(n0, n2); + gr.addArc(n2, n1); + gr.addArc(n0, n1); + + { + std::vector 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"); + } + + compareMap(sourceMap(orienter(gr, constMap(true))), + targetMap(orienter(gr, constMap(false))), + EdgeIt(gr)); + + 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'); + + check(map[n0] == 'C' && map[n1] == 'B' && map[n2] == 'A', + "Wrong CrossRefMap"); + check(map('A') == n2 && map.inverse()['A'] == n2, "Wrong CrossRefMap"); + check(map('B') == n1 && map.inverse()['B'] == n1, "Wrong CrossRefMap"); + check(map('C') == n0 && map.inverse()['C'] == n0, "Wrong CrossRefMap"); + check(map.count('A') == 1 && map.count('B') == 1 && map.count('C') == 1, + "Wrong CrossRefMap::count()"); + + it = map.beginValue(); + check(*it++ == 'A' && *it++ == 'B' && *it++ == 'C' && + it == map.endValue(), "Wrong value iterator"); } + // CrossRefMap + { + typedef SmartDigraph Graph; + DIGRAPH_TYPEDEFS(Graph); + + checkConcept, + 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(); + check(*it++ == 'A' && *it++ == 'B' && *it++ == 'C' && + it == map.endValue(), "Wrong value iterator"); + } + + // Iterable bool map + { + typedef SmartGraph Graph; + typedef SmartGraph::Node Item; + + typedef IterableBoolMap Ibm; + checkConcept, Ibm>(); + + const int num = 10; + Graph g; + 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; + 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; + 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"); + + } return 0; } diff -r c35afa9e89e7 -r ef88c0a30f85 test/matching_test.cc --- /dev/null Thu Jan 01 00:00:00 1970 +0000 +++ b/test/matching_test.cc Thu Nov 05 15:48:01 2009 +0100 @@ -0,0 +1,424 @@ +/* -*- 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 +#include +#include +#include +#include + +#include "test_tools.h" + +using namespace std; +using namespace lemon; + +GRAPH_TYPEDEFS(SmartGraph); + + +const int lgfn = 3; +const std::string lgf[lgfn] = { + "@nodes\n" + "label\n" + "0\n" + "1\n" + "2\n" + "3\n" + "4\n" + "5\n" + "6\n" + "7\n" + "@edges\n" + " label weight\n" + "7 4 0 984\n" + "0 7 1 73\n" + "7 1 2 204\n" + "2 3 3 583\n" + "2 7 4 565\n" + "2 1 5 582\n" + "0 4 6 551\n" + "2 5 7 385\n" + "1 5 8 561\n" + "5 3 9 484\n" + "7 5 10 904\n" + "3 6 11 47\n" + "7 6 12 888\n" + "3 0 13 747\n" + "6 1 14 310\n", + + "@nodes\n" + "label\n" + "0\n" + "1\n" + "2\n" + "3\n" + "4\n" + "5\n" + "6\n" + "7\n" + "@edges\n" + " label weight\n" + "2 5 0 710\n" + "0 5 1 241\n" + "2 4 2 856\n" + "2 6 3 762\n" + "4 1 4 747\n" + "6 1 5 962\n" + "4 7 6 723\n" + "1 7 7 661\n" + "2 3 8 376\n" + "1 0 9 416\n" + "6 7 10 391\n", + + "@nodes\n" + "label\n" + "0\n" + "1\n" + "2\n" + "3\n" + "4\n" + "5\n" + "6\n" + "7\n" + "@edges\n" + " label weight\n" + "6 2 0 553\n" + "0 7 1 653\n" + "6 3 2 22\n" + "4 7 3 846\n" + "7 2 4 981\n" + "7 6 5 250\n" + "5 2 6 539\n", +}; + +void checkMaxMatchingCompile() +{ + typedef concepts::Graph Graph; + typedef Graph::Node Node; + typedef Graph::Edge Edge; + typedef Graph::EdgeMap MatMap; + + Graph g; + Node n; + Edge e; + MatMap mat(g); + + MaxMatching mat_test(g); + const MaxMatching& + const_mat_test = mat_test; + + mat_test.init(); + mat_test.greedyInit(); + mat_test.matchingInit(mat); + mat_test.startSparse(); + mat_test.startDense(); + mat_test.run(); + + const_mat_test.matchingSize(); + const_mat_test.matching(e); + const_mat_test.matching(n); + const MaxMatching::MatchingMap& mmap = + const_mat_test.matchingMap(); + e = mmap[n]; + const_mat_test.mate(n); + + MaxMatching::Status stat = + const_mat_test.status(n); + const MaxMatching::StatusMap& smap = + const_mat_test.statusMap(); + stat = smap[n]; + const_mat_test.barrier(n); +} + +void checkMaxWeightedMatchingCompile() +{ + typedef concepts::Graph Graph; + typedef Graph::Node Node; + typedef Graph::Edge Edge; + typedef Graph::EdgeMap WeightMap; + + Graph g; + Node n; + Edge e; + WeightMap w(g); + + MaxWeightedMatching mat_test(g, w); + const MaxWeightedMatching& + const_mat_test = mat_test; + + mat_test.init(); + mat_test.start(); + mat_test.run(); + + const_mat_test.matchingWeight(); + const_mat_test.matchingSize(); + const_mat_test.matching(e); + const_mat_test.matching(n); + const MaxWeightedMatching::MatchingMap& mmap = + const_mat_test.matchingMap(); + e = mmap[n]; + const_mat_test.mate(n); + + int k = 0; + const_mat_test.dualValue(); + const_mat_test.nodeValue(n); + const_mat_test.blossomNum(); + const_mat_test.blossomSize(k); + const_mat_test.blossomValue(k); +} + +void checkMaxWeightedPerfectMatchingCompile() +{ + typedef concepts::Graph Graph; + typedef Graph::Node Node; + typedef Graph::Edge Edge; + typedef Graph::EdgeMap WeightMap; + + Graph g; + Node n; + Edge e; + WeightMap w(g); + + MaxWeightedPerfectMatching mat_test(g, w); + const MaxWeightedPerfectMatching& + const_mat_test = mat_test; + + mat_test.init(); + mat_test.start(); + mat_test.run(); + + const_mat_test.matchingWeight(); + const_mat_test.matching(e); + const_mat_test.matching(n); + const MaxWeightedPerfectMatching::MatchingMap& mmap = + const_mat_test.matchingMap(); + e = mmap[n]; + const_mat_test.mate(n); + + int k = 0; + const_mat_test.dualValue(); + const_mat_test.nodeValue(n); + const_mat_test.blossomNum(); + const_mat_test.blossomSize(k); + const_mat_test.blossomValue(k); +} + +void checkMatching(const SmartGraph& graph, + const MaxMatching& mm) { + int num = 0; + + IntNodeMap comp_index(graph); + UnionFind comp(comp_index); + + int barrier_num = 0; + + for (NodeIt n(graph); n != INVALID; ++n) { + check(mm.status(n) == MaxMatching::EVEN || + mm.matching(n) != INVALID, "Wrong Gallai-Edmonds decomposition"); + if (mm.status(n) == MaxMatching::ODD) { + ++barrier_num; + } else { + comp.insert(n); + } + } + + for (EdgeIt e(graph); e != INVALID; ++e) { + if (mm.matching(e)) { + check(e == mm.matching(graph.u(e)), "Wrong matching"); + check(e == mm.matching(graph.v(e)), "Wrong matching"); + ++num; + } + check(mm.status(graph.u(e)) != MaxMatching::EVEN || + mm.status(graph.v(e)) != MaxMatching::MATCHED, + "Wrong Gallai-Edmonds decomposition"); + + check(mm.status(graph.v(e)) != MaxMatching::EVEN || + mm.status(graph.u(e)) != MaxMatching::MATCHED, + "Wrong Gallai-Edmonds decomposition"); + + if (mm.status(graph.u(e)) != MaxMatching::ODD && + mm.status(graph.v(e)) != MaxMatching::ODD) { + comp.join(graph.u(e), graph.v(e)); + } + } + + std::set comp_root; + int odd_comp_num = 0; + for (NodeIt n(graph); n != INVALID; ++n) { + if (mm.status(n) != MaxMatching::ODD) { + int root = comp.find(n); + if (comp_root.find(root) == comp_root.end()) { + comp_root.insert(root); + if (comp.size(n) % 2 == 1) { + ++odd_comp_num; + } + } + } + } + + check(mm.matchingSize() == num, "Wrong matching"); + check(2 * num == countNodes(graph) - (odd_comp_num - barrier_num), + "Wrong matching"); + return; +} + +void checkWeightedMatching(const SmartGraph& graph, + const SmartGraph::EdgeMap& weight, + const MaxWeightedMatching& mwm) { + for (SmartGraph::EdgeIt e(graph); e != INVALID; ++e) { + if (graph.u(e) == graph.v(e)) continue; + int rw = mwm.nodeValue(graph.u(e)) + mwm.nodeValue(graph.v(e)); + + for (int i = 0; i < mwm.blossomNum(); ++i) { + bool s = false, t = false; + for (MaxWeightedMatching::BlossomIt n(mwm, i); + n != INVALID; ++n) { + if (graph.u(e) == n) s = true; + if (graph.v(e) == n) t = true; + } + if (s == true && t == true) { + rw += mwm.blossomValue(i); + } + } + rw -= weight[e] * mwm.dualScale; + + check(rw >= 0, "Negative reduced weight"); + check(rw == 0 || !mwm.matching(e), + "Non-zero reduced weight on matching edge"); + } + + int pv = 0; + for (SmartGraph::NodeIt n(graph); n != INVALID; ++n) { + if (mwm.matching(n) != INVALID) { + check(mwm.nodeValue(n) >= 0, "Invalid node value"); + pv += weight[mwm.matching(n)]; + SmartGraph::Node o = graph.target(mwm.matching(n)); + check(mwm.mate(n) == o, "Invalid matching"); + check(mwm.matching(n) == graph.oppositeArc(mwm.matching(o)), + "Invalid matching"); + } else { + check(mwm.mate(n) == INVALID, "Invalid matching"); + check(mwm.nodeValue(n) == 0, "Invalid matching"); + } + } + + int dv = 0; + for (SmartGraph::NodeIt n(graph); n != INVALID; ++n) { + dv += mwm.nodeValue(n); + } + + for (int i = 0; i < mwm.blossomNum(); ++i) { + check(mwm.blossomValue(i) >= 0, "Invalid blossom value"); + check(mwm.blossomSize(i) % 2 == 1, "Even blossom size"); + dv += mwm.blossomValue(i) * ((mwm.blossomSize(i) - 1) / 2); + } + + check(pv * mwm.dualScale == dv * 2, "Wrong duality"); + + return; +} + +void checkWeightedPerfectMatching(const SmartGraph& graph, + const SmartGraph::EdgeMap& weight, + const MaxWeightedPerfectMatching& mwpm) { + for (SmartGraph::EdgeIt e(graph); e != INVALID; ++e) { + if (graph.u(e) == graph.v(e)) continue; + int rw = mwpm.nodeValue(graph.u(e)) + mwpm.nodeValue(graph.v(e)); + + for (int i = 0; i < mwpm.blossomNum(); ++i) { + bool s = false, t = false; + for (MaxWeightedPerfectMatching::BlossomIt n(mwpm, i); + n != INVALID; ++n) { + if (graph.u(e) == n) s = true; + if (graph.v(e) == n) t = true; + } + if (s == true && t == true) { + rw += mwpm.blossomValue(i); + } + } + rw -= weight[e] * mwpm.dualScale; + + check(rw >= 0, "Negative reduced weight"); + check(rw == 0 || !mwpm.matching(e), + "Non-zero reduced weight on matching edge"); + } + + int pv = 0; + for (SmartGraph::NodeIt n(graph); n != INVALID; ++n) { + check(mwpm.matching(n) != INVALID, "Non perfect"); + pv += weight[mwpm.matching(n)]; + SmartGraph::Node o = graph.target(mwpm.matching(n)); + check(mwpm.mate(n) == o, "Invalid matching"); + check(mwpm.matching(n) == graph.oppositeArc(mwpm.matching(o)), + "Invalid matching"); + } + + int dv = 0; + for (SmartGraph::NodeIt n(graph); n != INVALID; ++n) { + dv += mwpm.nodeValue(n); + } + + for (int i = 0; i < mwpm.blossomNum(); ++i) { + check(mwpm.blossomValue(i) >= 0, "Invalid blossom value"); + check(mwpm.blossomSize(i) % 2 == 1, "Even blossom size"); + dv += mwpm.blossomValue(i) * ((mwpm.blossomSize(i) - 1) / 2); + } + + check(pv * mwpm.dualScale == dv * 2, "Wrong duality"); + + return; +} + + +int main() { + + for (int i = 0; i < lgfn; ++i) { + SmartGraph graph; + SmartGraph::EdgeMap weight(graph); + + istringstream lgfs(lgf[i]); + graphReader(graph, lgfs). + edgeMap("weight", weight).run(); + + 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); + } + } + + return 0; +} diff -r c35afa9e89e7 -r ef88c0a30f85 test/max_matching_test.cc --- a/test/max_matching_test.cc Mon Jan 12 23:11:39 2009 +0100 +++ /dev/null Thu Jan 01 00:00:00 1970 +0000 @@ -1,310 +0,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 -#include -#include - -#include "test_tools.h" - -using namespace std; -using namespace lemon; - -GRAPH_TYPEDEFS(SmartGraph); - - -const int lgfn = 3; -const std::string lgf[lgfn] = { - "@nodes\n" - "label\n" - "0\n" - "1\n" - "2\n" - "3\n" - "4\n" - "5\n" - "6\n" - "7\n" - "@edges\n" - " label weight\n" - "7 4 0 984\n" - "0 7 1 73\n" - "7 1 2 204\n" - "2 3 3 583\n" - "2 7 4 565\n" - "2 1 5 582\n" - "0 4 6 551\n" - "2 5 7 385\n" - "1 5 8 561\n" - "5 3 9 484\n" - "7 5 10 904\n" - "3 6 11 47\n" - "7 6 12 888\n" - "3 0 13 747\n" - "6 1 14 310\n", - - "@nodes\n" - "label\n" - "0\n" - "1\n" - "2\n" - "3\n" - "4\n" - "5\n" - "6\n" - "7\n" - "@edges\n" - " label weight\n" - "2 5 0 710\n" - "0 5 1 241\n" - "2 4 2 856\n" - "2 6 3 762\n" - "4 1 4 747\n" - "6 1 5 962\n" - "4 7 6 723\n" - "1 7 7 661\n" - "2 3 8 376\n" - "1 0 9 416\n" - "6 7 10 391\n", - - "@nodes\n" - "label\n" - "0\n" - "1\n" - "2\n" - "3\n" - "4\n" - "5\n" - "6\n" - "7\n" - "@edges\n" - " label weight\n" - "6 2 0 553\n" - "0 7 1 653\n" - "6 3 2 22\n" - "4 7 3 846\n" - "7 2 4 981\n" - "7 6 5 250\n" - "5 2 6 539\n", -}; - -void checkMatching(const SmartGraph& graph, - const MaxMatching& mm) { - int num = 0; - - IntNodeMap comp_index(graph); - UnionFind comp(comp_index); - - int barrier_num = 0; - - for (NodeIt n(graph); n != INVALID; ++n) { - check(mm.decomposition(n) == MaxMatching::EVEN || - mm.matching(n) != INVALID, "Wrong Gallai-Edmonds decomposition"); - if (mm.decomposition(n) == MaxMatching::ODD) { - ++barrier_num; - } else { - comp.insert(n); - } - } - - for (EdgeIt e(graph); e != INVALID; ++e) { - if (mm.matching(e)) { - check(e == mm.matching(graph.u(e)), "Wrong matching"); - check(e == mm.matching(graph.v(e)), "Wrong matching"); - ++num; - } - check(mm.decomposition(graph.u(e)) != MaxMatching::EVEN || - mm.decomposition(graph.v(e)) != MaxMatching::MATCHED, - "Wrong Gallai-Edmonds decomposition"); - - check(mm.decomposition(graph.v(e)) != MaxMatching::EVEN || - mm.decomposition(graph.u(e)) != MaxMatching::MATCHED, - "Wrong Gallai-Edmonds decomposition"); - - if (mm.decomposition(graph.u(e)) != MaxMatching::ODD && - mm.decomposition(graph.v(e)) != MaxMatching::ODD) { - comp.join(graph.u(e), graph.v(e)); - } - } - - std::set comp_root; - int odd_comp_num = 0; - for (NodeIt n(graph); n != INVALID; ++n) { - if (mm.decomposition(n) != MaxMatching::ODD) { - int root = comp.find(n); - if (comp_root.find(root) == comp_root.end()) { - comp_root.insert(root); - if (comp.size(n) % 2 == 1) { - ++odd_comp_num; - } - } - } - } - - check(mm.matchingSize() == num, "Wrong matching"); - check(2 * num == countNodes(graph) - (odd_comp_num - barrier_num), - "Wrong matching"); - return; -} - -void checkWeightedMatching(const SmartGraph& graph, - const SmartGraph::EdgeMap& weight, - const MaxWeightedMatching& mwm) { - for (SmartGraph::EdgeIt e(graph); e != INVALID; ++e) { - if (graph.u(e) == graph.v(e)) continue; - int rw = mwm.nodeValue(graph.u(e)) + mwm.nodeValue(graph.v(e)); - - for (int i = 0; i < mwm.blossomNum(); ++i) { - bool s = false, t = false; - for (MaxWeightedMatching::BlossomIt n(mwm, i); - n != INVALID; ++n) { - if (graph.u(e) == n) s = true; - if (graph.v(e) == n) t = true; - } - if (s == true && t == true) { - rw += mwm.blossomValue(i); - } - } - rw -= weight[e] * mwm.dualScale; - - check(rw >= 0, "Negative reduced weight"); - check(rw == 0 || !mwm.matching(e), - "Non-zero reduced weight on matching edge"); - } - - int pv = 0; - for (SmartGraph::NodeIt n(graph); n != INVALID; ++n) { - if (mwm.matching(n) != INVALID) { - check(mwm.nodeValue(n) >= 0, "Invalid node value"); - pv += weight[mwm.matching(n)]; - SmartGraph::Node o = graph.target(mwm.matching(n)); - check(mwm.mate(n) == o, "Invalid matching"); - check(mwm.matching(n) == graph.oppositeArc(mwm.matching(o)), - "Invalid matching"); - } else { - check(mwm.mate(n) == INVALID, "Invalid matching"); - check(mwm.nodeValue(n) == 0, "Invalid matching"); - } - } - - int dv = 0; - for (SmartGraph::NodeIt n(graph); n != INVALID; ++n) { - dv += mwm.nodeValue(n); - } - - for (int i = 0; i < mwm.blossomNum(); ++i) { - check(mwm.blossomValue(i) >= 0, "Invalid blossom value"); - check(mwm.blossomSize(i) % 2 == 1, "Even blossom size"); - dv += mwm.blossomValue(i) * ((mwm.blossomSize(i) - 1) / 2); - } - - check(pv * mwm.dualScale == dv * 2, "Wrong duality"); - - return; -} - -void checkWeightedPerfectMatching(const SmartGraph& graph, - const SmartGraph::EdgeMap& weight, - const MaxWeightedPerfectMatching& mwpm) { - for (SmartGraph::EdgeIt e(graph); e != INVALID; ++e) { - if (graph.u(e) == graph.v(e)) continue; - int rw = mwpm.nodeValue(graph.u(e)) + mwpm.nodeValue(graph.v(e)); - - for (int i = 0; i < mwpm.blossomNum(); ++i) { - bool s = false, t = false; - for (MaxWeightedPerfectMatching::BlossomIt n(mwpm, i); - n != INVALID; ++n) { - if (graph.u(e) == n) s = true; - if (graph.v(e) == n) t = true; - } - if (s == true && t == true) { - rw += mwpm.blossomValue(i); - } - } - rw -= weight[e] * mwpm.dualScale; - - check(rw >= 0, "Negative reduced weight"); - check(rw == 0 || !mwpm.matching(e), - "Non-zero reduced weight on matching edge"); - } - - int pv = 0; - for (SmartGraph::NodeIt n(graph); n != INVALID; ++n) { - check(mwpm.matching(n) != INVALID, "Non perfect"); - pv += weight[mwpm.matching(n)]; - SmartGraph::Node o = graph.target(mwpm.matching(n)); - check(mwpm.mate(n) == o, "Invalid matching"); - check(mwpm.matching(n) == graph.oppositeArc(mwpm.matching(o)), - "Invalid matching"); - } - - int dv = 0; - for (SmartGraph::NodeIt n(graph); n != INVALID; ++n) { - dv += mwpm.nodeValue(n); - } - - for (int i = 0; i < mwpm.blossomNum(); ++i) { - check(mwpm.blossomValue(i) >= 0, "Invalid blossom value"); - check(mwpm.blossomSize(i) % 2 == 1, "Even blossom size"); - dv += mwpm.blossomValue(i) * ((mwpm.blossomSize(i) - 1) / 2); - } - - check(pv * mwpm.dualScale == dv * 2, "Wrong duality"); - - return; -} - - -int main() { - - for (int i = 0; i < lgfn; ++i) { - SmartGraph graph; - SmartGraph::EdgeMap weight(graph); - - istringstream lgfs(lgf[i]); - graphReader(graph, lgfs). - edgeMap("weight", weight).run(); - - 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); - } - } - - return 0; -} diff -r c35afa9e89e7 -r ef88c0a30f85 test/min_cost_arborescence_test.cc --- /dev/null Thu Jan 01 00:00:00 1970 +0000 +++ b/test/min_cost_arborescence_test.cc Thu Nov 05 15:48:01 2009 +0100 @@ -0,0 +1,206 @@ +/* -*- mode: C++; indent-tabs-mode: nil; -*- + * + * This file is a part of LEMON, a generic C++ optimization library. + * + * Copyright (C) 2003-2008 + * Egervary Jeno Kombinatorikus Optimalizalasi Kutatocsoport + * (Egervary Research Group on Combinatorial Optimization, EGRES). + * + * Permission to use, modify and distribute this software is granted + * provided that this copyright notice appears in all copies. For + * precise terms see the accompanying LICENSE file. + * + * This software is provided "AS IS" with no warranty of any kind, + * express or implied, and with no claim as to its suitability for any + * purpose. + * + */ + +#include +#include +#include +#include + +#include +#include +#include +#include + +#include "test_tools.h" + +using namespace lemon; +using namespace std; + +const char test_lgf[] = + "@nodes\n" + "label\n" + "0\n" + "1\n" + "2\n" + "3\n" + "4\n" + "5\n" + "6\n" + "7\n" + "8\n" + "9\n" + "@arcs\n" + " label cost\n" + "1 8 0 107\n" + "0 3 1 70\n" + "2 1 2 46\n" + "4 1 3 28\n" + "4 4 4 91\n" + "3 9 5 76\n" + "9 8 6 61\n" + "8 1 7 39\n" + "9 8 8 74\n" + "8 0 9 39\n" + "4 3 10 45\n" + "2 2 11 34\n" + "0 1 12 100\n" + "6 3 13 95\n" + "4 1 14 22\n" + "1 1 15 31\n" + "7 2 16 51\n" + "2 6 17 29\n" + "8 3 18 115\n" + "6 9 19 32\n" + "1 1 20 60\n" + "0 3 21 40\n" + "@attributes\n" + "source 0\n"; + + +void checkMinCostArborescenceCompile() +{ + typedef double VType; + typedef concepts::Digraph Digraph; + typedef concepts::ReadMap CostMap; + typedef Digraph::Node Node; + typedef Digraph::Arc Arc; + typedef concepts::WriteMap ArbMap; + typedef concepts::ReadWriteMap PredMap; + + typedef MinCostArborescence:: + SetArborescenceMap:: + SetPredMap::Create MinCostArbType; + + Digraph g; + Node s, n; + Arc e; + VType c; + bool b; + int i; + CostMap cost; + ArbMap arb; + PredMap pred; + + MinCostArbType mcarb_test(g, cost); + const MinCostArbType& const_mcarb_test = mcarb_test; + + mcarb_test + .arborescenceMap(arb) + .predMap(pred) + .run(s); + + mcarb_test.init(); + mcarb_test.addSource(s); + mcarb_test.start(); + n = mcarb_test.processNextNode(); + b = const_mcarb_test.emptyQueue(); + i = const_mcarb_test.queueSize(); + + c = const_mcarb_test.arborescenceCost(); + b = const_mcarb_test.arborescence(e); + e = const_mcarb_test.pred(n); + const MinCostArbType::ArborescenceMap &am = + const_mcarb_test.arborescenceMap(); + const MinCostArbType::PredMap &pm = + const_mcarb_test.predMap(); + b = const_mcarb_test.reached(n); + b = const_mcarb_test.processed(n); + + i = const_mcarb_test.dualNum(); + c = const_mcarb_test.dualValue(); + i = const_mcarb_test.dualSize(i); + c = const_mcarb_test.dualValue(i); + + ignore_unused_variable_warning(am); + ignore_unused_variable_warning(pm); +} + +int main() { + typedef SmartDigraph Digraph; + DIGRAPH_TYPEDEFS(Digraph); + + typedef Digraph::ArcMap CostMap; + + Digraph digraph; + CostMap cost(digraph); + Node source; + + std::istringstream is(test_lgf); + digraphReader(digraph, is). + arcMap("cost", cost). + node("source", source).run(); + + MinCostArborescence mca(digraph, cost); + mca.run(source); + + vector > > dualSolution(mca.dualNum()); + + for (int i = 0; i < mca.dualNum(); ++i) { + dualSolution[i].first = mca.dualValue(i); + for (MinCostArborescence::DualIt it(mca, i); + it != INVALID; ++it) { + dualSolution[i].second.insert(it); + } + } + + for (ArcIt it(digraph); it != INVALID; ++it) { + if (mca.reached(digraph.source(it))) { + double sum = 0.0; + for (int i = 0; i < int(dualSolution.size()); ++i) { + if (dualSolution[i].second.find(digraph.target(it)) + != dualSolution[i].second.end() && + dualSolution[i].second.find(digraph.source(it)) + == dualSolution[i].second.end()) { + sum += dualSolution[i].first; + } + } + if (mca.arborescence(it)) { + check(sum == cost[it], "Invalid dual solution"); + } + check(sum <= cost[it], "Invalid dual solution"); + } + } + + + check(mca.dualValue() == mca.arborescenceCost(), "Invalid dual solution"); + + check(mca.reached(source), "Invalid arborescence"); + for (ArcIt a(digraph); a != INVALID; ++a) { + check(!mca.reached(digraph.source(a)) || + mca.reached(digraph.target(a)), "Invalid arborescence"); + } + + for (NodeIt n(digraph); n != INVALID; ++n) { + if (!mca.reached(n)) continue; + int cnt = 0; + for (InArcIt a(digraph, n); a != INVALID; ++a) { + if (mca.arborescence(a)) { + check(mca.pred(n) == a, "Invalid arborescence"); + ++cnt; + } + } + check((n == source ? cnt == 0 : cnt == 1), "Invalid arborescence"); + } + + Digraph::ArcMap arborescence(digraph); + check(mca.arborescenceCost() == + minCostArborescence(digraph, cost, source, arborescence), + "Wrong result of the function interface"); + + return 0; +} diff -r c35afa9e89e7 -r ef88c0a30f85 test/min_cost_flow_test.cc --- /dev/null Thu Jan 01 00:00:00 1970 +0000 +++ b/test/min_cost_flow_test.cc Thu Nov 05 15:48:01 2009 +0100 @@ -0,0 +1,450 @@ +/* -*- 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 +#include + +#include "test_tools.h" + +using namespace lemon; + +char test_lgf[] = + "@nodes\n" + "label sup1 sup2 sup3 sup4 sup5 sup6\n" + " 1 20 27 0 30 20 30\n" + " 2 -4 0 0 0 -8 -3\n" + " 3 0 0 0 0 0 0\n" + " 4 0 0 0 0 0 0\n" + " 5 9 0 0 0 6 11\n" + " 6 -6 0 0 0 -5 -6\n" + " 7 0 0 0 0 0 0\n" + " 8 0 0 0 0 0 3\n" + " 9 3 0 0 0 0 0\n" + " 10 -2 0 0 0 -7 -2\n" + " 11 0 0 0 0 -10 0\n" + " 12 -20 -27 0 -30 -30 -20\n" + "\n" + "@arcs\n" + " cost cap low1 low2 low3\n" + " 1 2 70 11 0 8 8\n" + " 1 3 150 3 0 1 0\n" + " 1 4 80 15 0 2 2\n" + " 2 8 80 12 0 0 0\n" + " 3 5 140 5 0 3 1\n" + " 4 6 60 10 0 1 0\n" + " 4 7 80 2 0 0 0\n" + " 4 8 110 3 0 0 0\n" + " 5 7 60 14 0 0 0\n" + " 5 11 120 12 0 0 0\n" + " 6 3 0 3 0 0 0\n" + " 6 9 140 4 0 0 0\n" + " 6 10 90 8 0 0 0\n" + " 7 1 30 5 0 0 -5\n" + " 8 12 60 16 0 4 3\n" + " 9 12 50 6 0 0 0\n" + "10 12 70 13 0 5 2\n" + "10 2 100 7 0 0 0\n" + "10 7 60 10 0 0 -3\n" + "11 10 20 14 0 6 -20\n" + "12 11 30 10 0 0 -10\n" + "\n" + "@attributes\n" + "source 1\n" + "target 12\n"; + + +enum SupplyType { + EQ, + GEQ, + LEQ +}; + +// Check the interface of an MCF algorithm +template +class McfClassConcept +{ +public: + + template + struct Constraints { + void constraints() { + checkConcept(); + + const Constraints& me = *this; + + MCF mcf(me.g); + const MCF& const_mcf = mcf; + + b = mcf.reset() + .lowerMap(me.lower) + .upperMap(me.upper) + .costMap(me.cost) + .supplyMap(me.sup) + .stSupply(me.n, me.n, me.k) + .run(); + + c = const_mcf.totalCost(); + x = const_mcf.template totalCost(); + v = const_mcf.flow(me.a); + c = const_mcf.potential(me.n); + const_mcf.flowMap(fm); + const_mcf.potentialMap(pm); + } + + typedef typename GR::Node Node; + typedef typename GR::Arc Arc; + typedef concepts::ReadMap NM; + typedef concepts::ReadMap VAM; + typedef concepts::ReadMap CAM; + typedef concepts::WriteMap FlowMap; + typedef concepts::WriteMap PotMap; + + GR g; + VAM lower; + VAM upper; + CAM cost; + NM sup; + Node n; + Arc a; + Value k; + + FlowMap fm; + PotMap pm; + bool b; + double x; + typename MCF::Value v; + typename MCF::Cost c; + }; + +}; + + +// Check the feasibility of the given flow (primal soluiton) +template < typename GR, typename LM, typename UM, + typename SM, typename FM > +bool checkFlow( const GR& gr, const LM& lower, const UM& upper, + const SM& supply, const FM& flow, + SupplyType type = EQ ) +{ + TEMPLATE_DIGRAPH_TYPEDEFS(GR); + + for (ArcIt e(gr); e != INVALID; ++e) { + if (flow[e] < lower[e] || flow[e] > upper[e]) return false; + } + + for (NodeIt n(gr); n != INVALID; ++n) { + typename SM::Value sum = 0; + for (OutArcIt e(gr, n); e != INVALID; ++e) + sum += flow[e]; + for (InArcIt e(gr, n); e != INVALID; ++e) + sum -= flow[e]; + bool b = (type == EQ && sum == supply[n]) || + (type == GEQ && sum >= supply[n]) || + (type == LEQ && sum <= supply[n]); + if (!b) return false; + } + + return true; +} + +// Check the feasibility of the given potentials (dual soluiton) +// using the "Complementary Slackness" optimality condition +template < typename GR, typename LM, typename UM, + typename CM, typename SM, typename FM, typename PM > +bool checkPotential( const GR& gr, const LM& lower, const UM& upper, + const CM& cost, const SM& supply, const FM& flow, + const PM& pi, SupplyType type ) +{ + TEMPLATE_DIGRAPH_TYPEDEFS(GR); + + bool opt = true; + for (ArcIt e(gr); opt && e != INVALID; ++e) { + typename CM::Value red_cost = + cost[e] + pi[gr.source(e)] - pi[gr.target(e)]; + opt = red_cost == 0 || + (red_cost > 0 && flow[e] == lower[e]) || + (red_cost < 0 && flow[e] == upper[e]); + } + + for (NodeIt n(gr); opt && n != INVALID; ++n) { + typename SM::Value sum = 0; + for (OutArcIt e(gr, n); e != INVALID; ++e) + sum += flow[e]; + for (InArcIt e(gr, n); e != INVALID; ++e) + sum -= flow[e]; + if (type != LEQ) { + opt = (pi[n] <= 0) && (sum == supply[n] || pi[n] == 0); + } else { + opt = (pi[n] >= 0) && (sum == supply[n] || pi[n] == 0); + } + } + + return opt; +} + +// Check whether the dual cost is equal to the primal cost +template < typename GR, typename LM, typename UM, + typename CM, typename SM, typename PM > +bool checkDualCost( const GR& gr, const LM& lower, const UM& upper, + const CM& cost, const SM& supply, const PM& pi, + typename CM::Value total ) +{ + TEMPLATE_DIGRAPH_TYPEDEFS(GR); + + typename CM::Value dual_cost = 0; + SM red_supply(gr); + for (NodeIt n(gr); n != INVALID; ++n) { + red_supply[n] = supply[n]; + } + for (ArcIt a(gr); a != INVALID; ++a) { + if (lower[a] != 0) { + dual_cost += lower[a] * cost[a]; + red_supply[gr.source(a)] -= lower[a]; + red_supply[gr.target(a)] += lower[a]; + } + } + + for (NodeIt n(gr); n != INVALID; ++n) { + dual_cost -= red_supply[n] * pi[n]; + } + for (ArcIt a(gr); a != INVALID; ++a) { + typename CM::Value red_cost = + cost[a] + pi[gr.source(a)] - pi[gr.target(a)]; + dual_cost -= (upper[a] - lower[a]) * std::max(-red_cost, 0); + } + + return dual_cost == total; +} + +// Run a minimum cost flow algorithm and check the results +template < typename MCF, typename GR, + typename LM, typename UM, + typename CM, typename SM, + typename PT > +void checkMcf( const MCF& mcf, PT mcf_result, + const GR& gr, const LM& lower, const UM& upper, + const CM& cost, const SM& supply, + PT result, bool optimal, typename CM::Value total, + const std::string &test_id = "", + SupplyType type = EQ ) +{ + check(mcf_result == result, "Wrong result " + test_id); + if (optimal) { + typename GR::template ArcMap flow(gr); + typename GR::template NodeMap pi(gr); + mcf.flowMap(flow); + mcf.potentialMap(pi); + check(checkFlow(gr, lower, upper, supply, flow, type), + "The flow is not feasible " + test_id); + check(mcf.totalCost() == total, "The flow is not optimal " + test_id); + check(checkPotential(gr, lower, upper, cost, supply, flow, pi, type), + "Wrong potentials " + test_id); + check(checkDualCost(gr, lower, upper, cost, supply, pi, total), + "Wrong dual cost " + test_id); + } +} + +int main() +{ + // 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) + .arcMap("cost", c) + .arcMap("cap", u) + .arcMap("low1", l1) + .arcMap("low2", l2) + .arcMap("low3", l3) + .nodeMap("sup1", s1) + .nodeMap("sup2", s2) + .nodeMap("sup3", s3) + .nodeMap("sup4", s4) + .nodeMap("sup5", s5) + .nodeMap("sup6", s6) + .node("source", v) + .node("target", w) + .run(); + + // 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 + { + 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 + { + 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"); + } + + return 0; +} diff -r c35afa9e89e7 -r ef88c0a30f85 test/min_mean_cycle_test.cc --- /dev/null Thu Jan 01 00:00:00 1970 +0000 +++ b/test/min_mean_cycle_test.cc Thu Nov 05 15:48:01 2009 +0100 @@ -0,0 +1,216 @@ +/* -*- 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 + +#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 SetLargeValue + ::Create MmcAlg; + MmcAlg mmc(me.g, me.length); + const MmcAlg& const_mmc = mmc; + + typename MmcAlg::Tolerance tol = const_mmc.tolerance(); + mmc.tolerance(tol); + + b = mmc.cycle(p).run(); + b = mmc.findMinMean(); + b = mmc.findCycle(); + + v = const_mmc.cycleLength(); + i = const_mmc.cycleArcNum(); + d = const_mmc.cycleMean(); + p = const_mmc.cycle(); + } + + typedef concepts::ReadMap LM; + + GR g; + LM length; + ListPath p; + Value 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 length, int size) { + MMC alg(gr, lm); + alg.findMinMean(); + check(alg.cycleMean() == static_cast(length) / size, + "Wrong cycle mean"); + alg.findCycle(); + check(alg.cycleLength() == length && alg.cycleArcNum() == 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; + + // Karp + checkConcept< MmcClassConcept, + Karp > >(); + checkConcept< MmcClassConcept, + Karp > >(); + + // HartmannOrlin + checkConcept< MmcClassConcept, + HartmannOrlin > >(); + checkConcept< MmcClassConcept, + HartmannOrlin > >(); + + // Howard + checkConcept< MmcClassConcept, + Howard > >(); + checkConcept< MmcClassConcept, + Howard > >(); + + if (IsSameType >::LargeValue, + long_int>::result == 0) check(false, "Wrong LargeValue type"); + if (IsSameType >::LargeValue, + double>::result == 0) check(false, "Wrong LargeValue 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; +} diff -r c35afa9e89e7 -r ef88c0a30f85 test/mip_test.cc --- a/test/mip_test.cc Mon Jan 12 23:11:39 2009 +0100 +++ b/test/mip_test.cc Thu Nov 05 15:48:01 2009 +0100 @@ -2,7 +2,7 @@ * * This file is a part of LEMON, a generic C++ optimization library. * - * Copyright (C) 2003-2008 + * Copyright (C) 2003-2009 * Egervary Jeno Kombinatorikus Optimalizalasi Kutatocsoport * (Egervary Research Group on Combinatorial Optimization, EGRES). * @@ -18,19 +18,20 @@ #include "test_tools.h" +#include -#ifdef HAVE_CONFIG_H -#include -#endif - -#ifdef HAVE_CPLEX +#ifdef LEMON_HAVE_CPLEX #include #endif -#ifdef HAVE_GLPK +#ifdef LEMON_HAVE_GLPK #include #endif +#ifdef LEMON_HAVE_CBC +#include +#endif + using namespace lemon; @@ -49,7 +50,8 @@ if (stat == MipSolver::OPTIMAL) { std::ostringstream sbuf; - buf << "Wrong optimal value: the right optimum is " << exp_opt; + sbuf << "Wrong optimal value ("<< mip.solValue() + <<" instead of " << exp_opt << ")"; check(std::abs(mip.solValue()-exp_opt) < 1e-3, sbuf.str()); //+ecvt(exp_opt,2) } @@ -57,14 +59,13 @@ void aTest(MipSolver& mip) { - //The following example is very simple + //The following example is very simple typedef MipSolver::Row Row; typedef MipSolver::Col Col; - Col x1 = mip.addCol(); Col x2 = mip.addCol(); @@ -74,23 +75,24 @@ mip.max(); - //Unconstrained optimization mip.solve(); //Check it out! //Constraints - mip.addRow(2*x1+x2 <=2); - mip.addRow(x1-2*x2 <=0); + mip.addRow(2 * x1 + x2 <= 2); + Row y2 = mip.addRow(x1 - 2 * x2 <= 0); //Nonnegativity of the variable x1 mip.colLowerBound(x1, 0); + //Maximization of x1 //over the triangle with vertices (0,0),(4/5,2/5),(0,2) double expected_opt=4.0/5.0; solveAndCheck(mip, MipSolver::OPTIMAL, expected_opt); + //Restrict x2 to integer mip.colType(x2,MipSolver::INTEGER); expected_opt=1.0/2.0; @@ -102,32 +104,53 @@ expected_opt=0; solveAndCheck(mip, MipSolver::OPTIMAL, expected_opt); - + //Erase a variable + mip.erase(x2); + mip.rowUpperBound(y2, 8); + expected_opt=1; + solveAndCheck(mip, MipSolver::OPTIMAL, expected_opt); } +template +void cloneTest() +{ + + MIP* mip = new MIP(); + MIP* mipnew = mip->newSolver(); + MIP* mipclone = mip->cloneSolver(); + delete mip; + delete mipnew; + delete mipclone; +} + int main() { -#ifdef HAVE_GLPK +#ifdef LEMON_HAVE_GLPK { GlpkMip mip1; aTest(mip1); + cloneTest(); } #endif -#ifdef HAVE_CPLEX +#ifdef LEMON_HAVE_CPLEX try { CplexMip mip2; aTest(mip2); + cloneTest(); } catch (CplexEnv::LicenseError& error) { -#ifdef LEMON_FORCE_CPLEX_CHECK check(false, error.what()); -#else - std::cerr << error.what() << std::endl; - std::cerr << "Cplex license check failed, lp check skipped" << std::endl; + } #endif + +#ifdef LEMON_HAVE_CBC + { + CbcMip mip1; + aTest(mip1); + cloneTest(); } #endif diff -r c35afa9e89e7 -r ef88c0a30f85 test/preflow_test.cc --- a/test/preflow_test.cc Mon Jan 12 23:11:39 2009 +0100 +++ b/test/preflow_test.cc Thu Nov 05 15:48:01 2009 +0100 @@ -84,18 +84,27 @@ CapMap cap; FlowMap flow; CutMap cut; + VType v; + bool b; - Preflow - ::SetFlowMap - ::SetElevator - ::SetStandardElevator - ::Create preflow_test(g,cap,n,n); + typedef Preflow + ::SetFlowMap + ::SetElevator + ::SetStandardElevator + ::Create PreflowType; + PreflowType preflow_test(g, cap, n, n); + const PreflowType& const_preflow_test = preflow_test; + + const PreflowType::Elevator& elev = const_preflow_test.elevator(); + preflow_test.elevator(const_cast(elev)); + PreflowType::Tolerance tol = const_preflow_test.tolerance(); + preflow_test.tolerance(tol); - preflow_test.capacityMap(cap); - flow = preflow_test.flowMap(); - preflow_test.flowMap(flow); - preflow_test.source(n); - preflow_test.target(n); + preflow_test + .capacityMap(cap) + .flowMap(flow) + .source(n) + .target(n); preflow_test.init(); preflow_test.init(cap); @@ -104,11 +113,13 @@ preflow_test.run(); preflow_test.runMinCut(); - preflow_test.flowValue(); - preflow_test.minCut(n); - preflow_test.minCutMap(cut); - preflow_test.flow(e); - + v = const_preflow_test.flowValue(); + v = const_preflow_test.flow(e); + const FlowMap& fm = const_preflow_test.flowMap(); + b = const_preflow_test.minCut(n); + const_preflow_test.minCutMap(cut); + + ignore_unused_variable_warning(fm); } int cutValue (const SmartDigraph& g, diff -r c35afa9e89e7 -r ef88c0a30f85 test/suurballe_test.cc --- a/test/suurballe_test.cc Mon Jan 12 23:11:39 2009 +0100 +++ b/test/suurballe_test.cc Thu Nov 05 15:48:01 2009 +0100 @@ -22,6 +22,7 @@ #include #include #include +#include #include "test_tools.h" @@ -29,47 +30,97 @@ char test_lgf[] = "@nodes\n" - "label supply1 supply2 supply3\n" - "1 0 20 27\n" - "2 0 -4 0\n" - "3 0 0 0\n" - "4 0 0 0\n" - "5 0 9 0\n" - "6 0 -6 0\n" - "7 0 0 0\n" - "8 0 0 0\n" - "9 0 3 0\n" - "10 0 -2 0\n" - "11 0 0 0\n" - "12 0 -20 -27\n" + "label\n" + "1\n" + "2\n" + "3\n" + "4\n" + "5\n" + "6\n" + "7\n" + "8\n" + "9\n" + "10\n" + "11\n" + "12\n" "@arcs\n" - " cost capacity lower1 lower2\n" - " 1 2 70 11 0 8\n" - " 1 3 150 3 0 1\n" - " 1 4 80 15 0 2\n" - " 2 8 80 12 0 0\n" - " 3 5 140 5 0 3\n" - " 4 6 60 10 0 1\n" - " 4 7 80 2 0 0\n" - " 4 8 110 3 0 0\n" - " 5 7 60 14 0 0\n" - " 5 11 120 12 0 0\n" - " 6 3 0 3 0 0\n" - " 6 9 140 4 0 0\n" - " 6 10 90 8 0 0\n" - " 7 1 30 5 0 0\n" - " 8 12 60 16 0 4\n" - " 9 12 50 6 0 0\n" - "10 12 70 13 0 5\n" - "10 2 100 7 0 0\n" - "10 7 60 10 0 0\n" - "11 10 20 14 0 6\n" - "12 11 30 10 0 0\n" + " length\n" + " 1 2 70\n" + " 1 3 150\n" + " 1 4 80\n" + " 2 8 80\n" + " 3 5 140\n" + " 4 6 60\n" + " 4 7 80\n" + " 4 8 110\n" + " 5 7 60\n" + " 5 11 120\n" + " 6 3 0\n" + " 6 9 140\n" + " 6 10 90\n" + " 7 1 30\n" + " 8 12 60\n" + " 9 12 50\n" + "10 12 70\n" + "10 2 100\n" + "10 7 60\n" + "11 10 20\n" + "12 11 30\n" "@attributes\n" "source 1\n" "target 12\n" "@end\n"; +// Check the interface of Suurballe +void checkSuurballeCompile() +{ + typedef int VType; + typedef concepts::Digraph Digraph; + + typedef Digraph::Node Node; + typedef Digraph::Arc Arc; + typedef concepts::ReadMap LengthMap; + + typedef Suurballe SuurballeType; + + Digraph g; + Node n; + Arc e; + LengthMap len; + SuurballeType::FlowMap flow(g); + SuurballeType::PotentialMap pi(g); + + SuurballeType suurb_test(g, len); + const SuurballeType& const_suurb_test = suurb_test; + + suurb_test + .flowMap(flow) + .potentialMap(pi); + + int k; + k = suurb_test.run(n, n); + k = suurb_test.run(n, n, k); + suurb_test.init(n); + k = suurb_test.findFlow(n); + k = suurb_test.findFlow(n, k); + suurb_test.findPaths(); + + int f; + VType c; + c = const_suurb_test.totalLength(); + f = const_suurb_test.flow(e); + const SuurballeType::FlowMap& fm = + const_suurb_test.flowMap(); + c = const_suurb_test.potential(n); + const SuurballeType::PotentialMap& pm = + const_suurb_test.potentialMap(); + k = const_suurb_test.pathNum(); + Path p = const_suurb_test.path(k); + + ignore_unused_variable_warning(fm); + ignore_unused_variable_warning(pm); +} + // Check the feasibility of the flow template bool checkFlow( const Digraph& gr, const FlowMap& flow, @@ -118,7 +169,6 @@ bool checkPath( const Digraph& gr, const Path& path, typename Digraph::Node s, typename Digraph::Node t) { - // Check the "Complementary Slackness" optimality condition TEMPLATE_DIGRAPH_TYPEDEFS(Digraph); Node n = s; for (int i = 0; i < path.length(); ++i) { @@ -136,58 +186,55 @@ // Read the test digraph ListDigraph digraph; ListDigraph::ArcMap length(digraph); - Node source, target; + Node s, t; std::istringstream input(test_lgf); DigraphReader(digraph, input). - arcMap("cost", length). - node("source", source). - node("target", target). + arcMap("length", length). + node("source", s). + node("target", t). run(); // Find 2 paths { - Suurballe suurballe(digraph, length, source, target); - check(suurballe.run(2) == 2, "Wrong number of paths"); - check(checkFlow(digraph, suurballe.flowMap(), source, target, 2), + Suurballe suurballe(digraph, length); + check(suurballe.run(s, t) == 2, "Wrong number of paths"); + check(checkFlow(digraph, suurballe.flowMap(), s, t, 2), "The flow is not feasible"); check(suurballe.totalLength() == 510, "The flow is not optimal"); check(checkOptimality(digraph, length, suurballe.flowMap(), suurballe.potentialMap()), "Wrong potentials"); for (int i = 0; i < suurballe.pathNum(); ++i) - check(checkPath(digraph, suurballe.path(i), source, target), - "Wrong path"); + check(checkPath(digraph, suurballe.path(i), s, t), "Wrong path"); } // Find 3 paths { - Suurballe suurballe(digraph, length, source, target); - check(suurballe.run(3) == 3, "Wrong number of paths"); - check(checkFlow(digraph, suurballe.flowMap(), source, target, 3), + Suurballe suurballe(digraph, length); + check(suurballe.run(s, t, 3) == 3, "Wrong number of paths"); + check(checkFlow(digraph, suurballe.flowMap(), s, t, 3), "The flow is not feasible"); check(suurballe.totalLength() == 1040, "The flow is not optimal"); check(checkOptimality(digraph, length, suurballe.flowMap(), suurballe.potentialMap()), "Wrong potentials"); for (int i = 0; i < suurballe.pathNum(); ++i) - check(checkPath(digraph, suurballe.path(i), source, target), - "Wrong path"); + check(checkPath(digraph, suurballe.path(i), s, t), "Wrong path"); } // Find 5 paths (only 3 can be found) { - Suurballe suurballe(digraph, length, source, target); - check(suurballe.run(5) == 3, "Wrong number of paths"); - check(checkFlow(digraph, suurballe.flowMap(), source, target, 3), + Suurballe suurballe(digraph, length); + check(suurballe.run(s, t, 5) == 3, "Wrong number of paths"); + check(checkFlow(digraph, suurballe.flowMap(), s, t, 3), "The flow is not feasible"); check(suurballe.totalLength() == 1040, "The flow is not optimal"); check(checkOptimality(digraph, length, suurballe.flowMap(), suurballe.potentialMap()), "Wrong potentials"); for (int i = 0; i < suurballe.pathNum(); ++i) - check(checkPath(digraph, suurballe.path(i), source, target), - "Wrong path"); + check(checkPath(digraph, suurballe.path(i), s, t), "Wrong path"); } return 0; diff -r c35afa9e89e7 -r ef88c0a30f85 test/test_tools.h --- a/test/test_tools.h Mon Jan 12 23:11:39 2009 +0100 +++ b/test/test_tools.h Thu Nov 05 15:48:01 2009 +0100 @@ -37,10 +37,14 @@ ///\code check(0==1,"This is obviously false.");\endcode will ///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 diff -r c35afa9e89e7 -r ef88c0a30f85 test/time_measure_test.cc --- a/test/time_measure_test.cc Mon Jan 12 23:11:39 2009 +0100 +++ b/test/time_measure_test.cc Thu Nov 05 15:48:01 2009 +0100 @@ -39,18 +39,16 @@ { Timer T; unsigned int n; - for(n=0;T.realTime()<1.0;n++) ; + for(n=0;T.realTime()<0.1;n++) ; std::cout << T << " (" << n << " time queries)\n"; - T.restart(); - while(T.realTime()<2.0) ; - std::cout << T << '\n'; + TimeStamp full; TimeStamp t; - t=runningTimeTest(f,1,&n,&full); + t=runningTimeTest(f,0.1,&n,&full); std::cout << t << " (" << n << " tests)\n"; std::cout << "Total: " << full << "\n"; - t=runningTimeTest(g,1,&n,&full); + t=runningTimeTest(g,0.1,&n,&full); std::cout << t << " (" << n << " tests)\n"; std::cout << "Total: " << full << "\n"; diff -r c35afa9e89e7 -r ef88c0a30f85 tools/CMakeLists.txt --- /dev/null Thu Jan 01 00:00:00 1970 +0000 +++ b/tools/CMakeLists.txt Thu Nov 05 15:48:01 2009 +0100 @@ -0,0 +1,31 @@ +INCLUDE_DIRECTORIES( + ${PROJECT_SOURCE_DIR} + ${PROJECT_BINARY_DIR} +) + +LINK_DIRECTORIES( + ${PROJECT_BINARY_DIR}/lemon +) + +ADD_EXECUTABLE(lgf-gen lgf-gen.cc) +TARGET_LINK_LIBRARIES(lgf-gen lemon) + +ADD_EXECUTABLE(dimacs-to-lgf dimacs-to-lgf.cc) +TARGET_LINK_LIBRARIES(dimacs-to-lgf lemon) + +ADD_EXECUTABLE(dimacs-solver dimacs-solver.cc) +TARGET_LINK_LIBRARIES(dimacs-solver lemon) + +INSTALL( + TARGETS lgf-gen dimacs-to-lgf dimacs-solver + RUNTIME DESTINATION bin + COMPONENT bin +) + +IF(NOT WIN32) + INSTALL( + PROGRAMS ${CMAKE_CURRENT_SOURCE_DIR}/lemon-0.x-to-1.x.sh + DESTINATION bin + COMPONENT bin + ) +ENDIF() diff -r c35afa9e89e7 -r ef88c0a30f85 tools/Makefile.am --- a/tools/Makefile.am Mon Jan 12 23:11:39 2009 +0100 +++ b/tools/Makefile.am Thu Nov 05 15:48:01 2009 +0100 @@ -1,10 +1,17 @@ +EXTRA_DIST += \ + tools/CMakeLists.txt + if WANT_TOOLS bin_PROGRAMS += \ - tools/dimacs-to-lgf + 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 diff -r c35afa9e89e7 -r ef88c0a30f85 tools/dimacs-solver.cc --- /dev/null Thu Jan 01 00:00:00 1970 +0000 +++ b/tools/dimacs-solver.cc Thu Nov 05 15:48:01 2009 +0100 @@ -0,0 +1,277 @@ +/* -*- mode: C++; indent-tabs-mode: nil; -*- + * + * This file is a part of LEMON, a generic C++ optimization library. + * + * Copyright (C) 2003-2009 + * Egervary Jeno Kombinatorikus Optimalizalasi Kutatocsoport + * (Egervary Research Group on Combinatorial Optimization, EGRES). + * + * Permission to use, modify and distribute this software is granted + * provided that this copyright notice appears in all copies. For + * precise terms see the accompanying LICENSE file. + * + * This software is provided "AS IS" with no warranty of any kind, + * express or implied, and with no claim as to its suitability for any + * purpose. + * + */ + +///\ingroup tools +///\file +///\brief DIMACS problem solver. +/// +/// This program solves various problems given in DIMACS format. +/// +/// See +/// \code +/// dimacs-solver --help +/// \endcode +/// for more info on usage. + +#include +#include +#include + +#include +#include +#include +#include + +#include +#include + +#include +#include +#include +#include + +using namespace lemon; +typedef SmartDigraph Digraph; +DIGRAPH_TYPEDEFS(Digraph); +typedef SmartGraph Graph; + +template +void solve_sp(ArgParser &ap, std::istream &is, std::ostream &, + DimacsDescriptor &desc) +{ + bool report = !ap.given("q"); + Digraph g; + Node s; + Digraph::ArcMap len(g); + Timer t; + t.restart(); + readDimacsSp(is, g, len, s, desc); + if(report) std::cerr << "Read the file: " << t << '\n'; + t.restart(); + Dijkstra > dij(g,len); + if(report) std::cerr << "Setup Dijkstra class: " << t << '\n'; + t.restart(); + dij.run(s); + if(report) std::cerr << "Run Dijkstra: " << t << '\n'; +} + +template +void solve_max(ArgParser &ap, std::istream &is, std::ostream &, + Value infty, DimacsDescriptor &desc) +{ + bool report = !ap.given("q"); + Digraph g; + Node s,t; + Digraph::ArcMap cap(g); + Timer ti; + ti.restart(); + readDimacsMax(is, g, cap, s, t, infty, desc); + if(report) std::cerr << "Read the file: " << ti << '\n'; + ti.restart(); + Preflow > pre(g,cap,s,t); + if(report) std::cerr << "Setup Preflow class: " << ti << '\n'; + ti.restart(); + pre.run(); + if(report) std::cerr << "Run Preflow: " << ti << '\n'; + if(report) std::cerr << "\nMax flow value: " << pre.flowValue() << '\n'; +} + +template +void solve_min(ArgParser &ap, std::istream &is, std::ostream &, + Value infty, DimacsDescriptor &desc) +{ + bool report = !ap.given("q"); + Digraph g; + Digraph::ArcMap lower(g), cap(g), cost(g); + Digraph::NodeMap sup(g); + Timer ti; + + ti.restart(); + readDimacsMin(is, g, lower, cap, cost, sup, infty, desc); + ti.stop(); + Value sum_sup = 0; + for (Digraph::NodeIt n(g); n != INVALID; ++n) { + sum_sup += sup[n]; + } + if (report) { + std::cerr << "Sum of supply values: " << sum_sup << "\n"; + if (sum_sup <= 0) + std::cerr << "GEQ supply contraints are used for NetworkSimplex\n\n"; + else + std::cerr << "LEQ supply contraints are used for NetworkSimplex\n\n"; + } + if (report) std::cerr << "Read the file: " << ti << '\n'; + + ti.restart(); + NetworkSimplex ns(g); + ns.lowerMap(lower).upperMap(cap).costMap(cost).supplyMap(sup); + if (sum_sup > 0) ns.supplyType(ns.LEQ); + if (report) std::cerr << "Setup NetworkSimplex class: " << ti << '\n'; + ti.restart(); + bool res = ns.run(); + if (report) { + std::cerr << "Run NetworkSimplex: " << ti << "\n\n"; + std::cerr << "Feasible flow: " << (res ? "found" : "not found") << '\n'; + if (res) std::cerr << "Min flow cost: " << ns.totalCost() << '\n'; + } +} + +void solve_mat(ArgParser &ap, std::istream &is, std::ostream &, + DimacsDescriptor &desc) +{ + bool report = !ap.given("q"); + Graph g; + Timer ti; + ti.restart(); + readDimacsMat(is, g, desc); + if(report) std::cerr << "Read the file: " << ti << '\n'; + ti.restart(); + MaxMatching mat(g); + if(report) std::cerr << "Setup MaxMatching class: " << ti << '\n'; + ti.restart(); + mat.run(); + if(report) std::cerr << "Run MaxMatching: " << ti << '\n'; + if(report) std::cerr << "\nCardinality of max matching: " + << mat.matchingSize() << '\n'; +} + + +template +void solve(ArgParser &ap, std::istream &is, std::ostream &os, + DimacsDescriptor &desc) +{ + std::stringstream iss(static_cast(ap["infcap"])); + Value infty; + iss >> infty; + if(iss.fail()) + { + std::cerr << "Cannot interpret '" + << static_cast(ap["infcap"]) << "' as infinite" + << std::endl; + exit(1); + } + + switch(desc.type) + { + case DimacsDescriptor::MIN: + solve_min(ap,is,os,infty,desc); + break; + case DimacsDescriptor::MAX: + solve_max(ap,is,os,infty,desc); + break; + case DimacsDescriptor::SP: + solve_sp(ap,is,os,desc); + break; + case DimacsDescriptor::MAT: + solve_mat(ap,is,os,desc); + break; + default: + break; + } +} + +int main(int argc, const char *argv[]) { + typedef SmartDigraph Digraph; + + typedef Digraph::Arc Arc; + + std::string inputName; + std::string outputName; + + ArgParser ap(argc, argv); + ap.other("[INFILE [OUTFILE]]", + "If either the INFILE or OUTFILE file is missing the standard\n" + " input/output will be used instead.") + .boolOption("q", "Do not print any report") + .boolOption("int","Use 'int' for capacities, costs etc. (default)") + .optionGroup("datatype","int") +#ifdef LEMON_HAVE_LONG_LONG + .boolOption("long","Use 'long long' for capacities, costs etc.") + .optionGroup("datatype","long") +#endif + .boolOption("double","Use 'double' for capacities, costs etc.") + .optionGroup("datatype","double") + .boolOption("ldouble","Use 'long double' for capacities, costs etc.") + .optionGroup("datatype","ldouble") + .onlyOneGroup("datatype") + .stringOption("infcap","Value used for 'very high' capacities","0") + .run(); + + std::ifstream input; + std::ofstream output; + + switch(ap.files().size()) + { + case 2: + output.open(ap.files()[1].c_str()); + if (!output) { + throw IoError("Cannot open the file for writing", ap.files()[1]); + } + case 1: + input.open(ap.files()[0].c_str()); + if (!input) { + throw IoError("File cannot be found", ap.files()[0]); + } + case 0: + break; + default: + std::cerr << ap.commandName() << ": too many arguments\n"; + return 1; + } + std::istream& is = (ap.files().size()<1 ? std::cin : input); + std::ostream& os = (ap.files().size()<2 ? std::cout : output); + + DimacsDescriptor desc = dimacsType(is); + + if(!ap.given("q")) + { + std::cout << "Problem type: "; + switch(desc.type) + { + case DimacsDescriptor::MIN: + std::cout << "min"; + break; + case DimacsDescriptor::MAX: + std::cout << "max"; + break; + case DimacsDescriptor::SP: + std::cout << "sp"; + case DimacsDescriptor::MAT: + std::cout << "mat"; + break; + default: + exit(1); + break; + } + std::cout << "\nNum of nodes: " << desc.nodeNum; + std::cout << "\nNum of arcs: " << desc.edgeNum; + std::cout << "\n\n"; + } + + if(ap.given("double")) + solve(ap,is,os,desc); + else if(ap.given("ldouble")) + solve(ap,is,os,desc); +#ifdef LEMON_HAVE_LONG_LONG + else if(ap.given("long")) + solve(ap,is,os,desc); +#endif + else solve(ap,is,os,desc); + + return 0; +} diff -r c35afa9e89e7 -r ef88c0a30f85 tools/dimacs-to-lgf.cc --- a/tools/dimacs-to-lgf.cc Mon Jan 12 23:11:39 2009 +0100 +++ b/tools/dimacs-to-lgf.cc Thu Nov 05 15:48:01 2009 +0100 @@ -24,11 +24,10 @@ /// (LGF). /// /// See -/// \verbatim -/// dimacs-to-lgf --help -/// \endverbatim -/// for more info on usage. -/// +/// \code +/// dimacs-to-lgf --help +/// \endcode +/// for more info on the usage. #include #include @@ -96,7 +95,7 @@ Digraph digraph; DoubleArcMap lower(digraph), capacity(digraph), cost(digraph); DoubleNodeMap supply(digraph); - readDimacsMin(is, digraph, lower, capacity, cost, supply, desc); + readDimacsMin(is, digraph, lower, capacity, cost, supply, 0, desc); DigraphWriter(digraph, os). nodeMap("supply", supply). arcMap("lower", lower). @@ -111,7 +110,7 @@ Digraph digraph; Node s, t; DoubleArcMap capacity(digraph); - readDimacsMax(is, digraph, capacity, s, t, desc); + readDimacsMax(is, digraph, capacity, s, t, 0, desc); DigraphWriter(digraph, os). arcMap("capacity", capacity). node("source", s). diff -r c35afa9e89e7 -r ef88c0a30f85 tools/lemon-0.x-to-1.x.sh --- a/tools/lemon-0.x-to-1.x.sh Mon Jan 12 23:11:39 2009 +0100 +++ b/tools/lemon-0.x-to-1.x.sh Thu Nov 05 15:48:01 2009 +0100 @@ -22,26 +22,25 @@ -e "s/\/_ar_c_label_s/g"\ -e "s/UGraph/_Gr_aph_label_/g"\ -e "s/u[Gg]raph/_gr_aph_label_/g"\ - -e "s/\/_Digr_aph_label_/g"\ + -e "s/Graph\>/_Digr_aph_label_/g"\ -e "s/\/_digr_aph_label_/g"\ - -e "s/\/_Digr_aph_label_s/g"\ + -e "s/Graphs\>/_Digr_aph_label_s/g"\ -e "s/\/_digr_aph_label_s/g"\ - -e "s/_Graph/__Gr_aph_label_/g"\ - -e "s/\([Gg]\)raph\([a-z_]\)/_\1r_aph_label_\2/g"\ + -e "s/\([Gg]\)raph\([a-z]\)/_\1r_aph_label_\2/g"\ -e "s/\([a-z_]\)graph/\1_gr_aph_label_/g"\ -e "s/Graph/_Digr_aph_label_/g"\ -e "s/graph/_digr_aph_label_/g"\ -e "s/UEdge/_Ed_ge_label_/g"\ -e "s/u[Ee]dge/_ed_ge_label_/g"\ -e "s/IncEdgeIt/_In_cEd_geIt_label_/g"\ - -e "s/\/_Ar_c_label_/g"\ + -e "s/Edge\>/_Ar_c_label_/g"\ -e "s/\/_ar_c_label_/g"\ - -e "s/\/_Ar_c_label_s/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/_Edge/__Ed_ge_label_/g"\ - -e "s/Edge\([a-z_]\)/_Ed_ge_label_\1/g"\ - -e "s/edge\([a-z_]\)/_ed_ge_label_\1/g"\ - -e "s/\([a-z_]\)edge/\1_ed_ge_label_/g"\ + -e "s/_edges\>/__ar_c_label_s/g"\ + -e "s/\([Ee]\)dge\([a-z]\)/_\1d_ge_label_\2/g"\ + -e "s/\([a-z]\)edge/\1_ed_ge_label_/g"\ -e "s/Edge/_Ar_c_label_/g"\ -e "s/edge/_ar_c_label_/g"\ -e "s/A[Nn]ode/_Re_d_label_/g"\ @@ -69,6 +68,11 @@ -e "s/_blu_e_label_/blue/g"\ -e "s/_GR_APH_TY_PEDE_FS_label_/GRAPH_TYPEDEFS/g"\ -e "s/_DIGR_APH_TY_PEDE_FS_label_/DIGRAPH_TYPEDEFS/g"\ + -e "s/\/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"\ -e "s/\/SetPredMap/g"\ @@ -90,6 +94,10 @@ -e "s/\<\([Ff]\)orkWriteMap\>/\1orkMap/g"\ -e "s/\/LoggerBoolMap/g"\ -e "s/\/loggerBoolMap/g"\ + -e "s/\/CrossRefMap/g"\ + -e "s/\/crossRefMap/g"\ + -e "s/\/RangeIdMap/g"\ + -e "s/\/rangeIdMap/g"\ -e "s/\/Box/g"\ -e "s/\/readNautyGraph/g"\ -e "s/\/ReverseDigraph/g"\ @@ -116,6 +124,11 @@ -e "s/\/filterEdges/g"\ -e "s/\/Orienter/g"\ -e "s/\/orienter/g"\ + -e "s/\/CplexLp/g"\ + -e "s/\/CplexMip/g"\ + -e "s/\/GlpkLp/g"\ + -e "s/\/GlpkMip/g"\ + -e "s/\/SoplexLp/g"\ <$i > $TMP mv $TMP $i done diff -r c35afa9e89e7 -r ef88c0a30f85 tools/lgf-gen.cc --- /dev/null Thu Jan 01 00:00:00 1970 +0000 +++ b/tools/lgf-gen.cc Thu Nov 05 15:48:01 2009 +0100 @@ -0,0 +1,834 @@ +/* -*- mode: C++; indent-tabs-mode: nil; -*- + * + * This file is a part of LEMON, a generic C++ optimization library. + * + * Copyright (C) 2003-2009 + * Egervary Jeno Kombinatorikus Optimalizalasi Kutatocsoport + * (Egervary Research Group on Combinatorial Optimization, EGRES). + * + * Permission to use, modify and distribute this software is granted + * provided that this copyright notice appears in all copies. For + * precise terms see the accompanying LICENSE file. + * + * This software is provided "AS IS" with no warranty of any kind, + * express or implied, and with no claim as to its suitability for any + * purpose. + * + */ + +/// \ingroup tools +/// \file +/// \brief Special plane graph generator. +/// +/// Graph generator application for various types of plane graphs. +/// +/// See +/// \code +/// lgf-gen --help +/// \endcode +/// for more information on the usage. + +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include + +using namespace lemon; + +typedef dim2::Point Point; + +GRAPH_TYPEDEFS(ListGraph); + +bool progress=true; + +int N; +// int girth; + +ListGraph g; + +std::vector nodes; +ListGraph::NodeMap coords(g); + + +double totalLen(){ + double tlen=0; + for(EdgeIt e(g);e!=INVALID;++e) + tlen+=std::sqrt((coords[g.v(e)]-coords[g.u(e)]).normSquare()); + return tlen; +} + +int tsp_impr_num=0; + +const double EPSILON=1e-8; +bool tsp_improve(Node u, Node v) +{ + double luv=std::sqrt((coords[v]-coords[u]).normSquare()); + Node u2=u; + Node v2=v; + do { + Node n; + for(IncEdgeIt e(g,v2);(n=g.runningNode(e))==u2;++e) { } + u2=v2; + v2=n; + if(luv+std::sqrt((coords[v2]-coords[u2]).normSquare())-EPSILON> + std::sqrt((coords[u]-coords[u2]).normSquare())+ + std::sqrt((coords[v]-coords[v2]).normSquare())) + { + g.erase(findEdge(g,u,v)); + g.erase(findEdge(g,u2,v2)); + g.addEdge(u2,u); + g.addEdge(v,v2); + tsp_impr_num++; + return true; + } + } while(v2!=u); + return false; +} + +bool tsp_improve(Node u) +{ + for(IncEdgeIt e(g,u);e!=INVALID;++e) + if(tsp_improve(u,g.runningNode(e))) return true; + return false; +} + +void tsp_improve() +{ + bool b; + do { + b=false; + for(NodeIt n(g);n!=INVALID;++n) + if(tsp_improve(n)) b=true; + } while(b); +} + +void tsp() +{ + for(int i=0;i" << l.b; + return os; +} + +bool cross(Line a, Line b) +{ + Point ao=rot90(a.b-a.a); + Point bo=rot90(b.b-b.a); + return (ao*(b.a-a.a))*(ao*(b.b-a.a))<0 && + (bo*(a.a-b.a))*(bo*(a.b-b.a))<0; +} + +struct Parc +{ + Node a; + Node b; + double len; +}; + +bool pedgeLess(Parc a,Parc b) +{ + return a.len arcs; + +namespace _delaunay_bits { + + struct Part { + int prev, curr, next; + + Part(int p, int c, int n) : prev(p), curr(c), next(n) {} + }; + + inline std::ostream& operator<<(std::ostream& os, const Part& part) { + os << '(' << part.prev << ',' << part.curr << ',' << part.next << ')'; + return os; + } + + inline double circle_point(const Point& p, const Point& q, const Point& r) { + double a = p.x * (q.y - r.y) + q.x * (r.y - p.y) + r.x * (p.y - q.y); + if (a == 0) return std::numeric_limits::quiet_NaN(); + + double d = (p.x * p.x + p.y * p.y) * (q.y - r.y) + + (q.x * q.x + q.y * q.y) * (r.y - p.y) + + (r.x * r.x + r.y * r.y) * (p.y - q.y); + + double e = (p.x * p.x + p.y * p.y) * (q.x - r.x) + + (q.x * q.x + q.y * q.y) * (r.x - p.x) + + (r.x * r.x + r.y * r.y) * (p.x - q.x); + + double f = (p.x * p.x + p.y * p.y) * (q.x * r.y - r.x * q.y) + + (q.x * q.x + q.y * q.y) * (r.x * p.y - p.x * r.y) + + (r.x * r.x + r.y * r.y) * (p.x * q.y - q.x * p.y); + + return d / (2 * a) + std::sqrt((d * d + e * e) / (4 * a * a) + f / a); + } + + inline bool circle_form(const Point& p, const Point& q, const Point& r) { + return rot90(q - p) * (r - q) < 0.0; + } + + inline double intersection(const Point& p, const Point& q, double sx) { + const double epsilon = 1e-8; + + if (p.x == q.x) return (p.y + q.y) / 2.0; + + if (sx < p.x + epsilon) return p.y; + if (sx < q.x + epsilon) return q.y; + + double a = q.x - p.x; + double b = (q.x - sx) * p.y - (p.x - sx) * q.y; + double d = (q.x - sx) * (p.x - sx) * (p - q).normSquare(); + return (b - std::sqrt(d)) / a; + } + + struct YLess { + + + YLess(const std::vector& points, double& sweep) + : _points(points), _sweep(sweep) {} + + bool operator()(const Part& l, const Part& r) const { + const double epsilon = 1e-8; + + // std::cerr << l << " vs " << r << std::endl; + double lbx = l.prev != -1 ? + intersection(_points[l.prev], _points[l.curr], _sweep) : + - std::numeric_limits::infinity(); + double rbx = r.prev != -1 ? + intersection(_points[r.prev], _points[r.curr], _sweep) : + - std::numeric_limits::infinity(); + double lex = l.next != -1 ? + intersection(_points[l.curr], _points[l.next], _sweep) : + std::numeric_limits::infinity(); + double rex = r.next != -1 ? + intersection(_points[r.curr], _points[r.next], _sweep) : + std::numeric_limits::infinity(); + + if (lbx > lex) std::swap(lbx, lex); + if (rbx > rex) std::swap(rbx, rex); + + if (lex < epsilon + rex && lbx + epsilon < rex) return true; + if (rex < epsilon + lex && rbx + epsilon < lex) return false; + return lex < rex; + } + + const std::vector& _points; + double& _sweep; + }; + + struct BeachIt; + + typedef std::multimap SpikeHeap; + + typedef std::multimap Beach; + + struct BeachIt { + Beach::iterator it; + + BeachIt(Beach::iterator iter) : it(iter) {} + }; + +} + +inline void delaunay() { + Counter cnt("Number of arcs added: "); + + using namespace _delaunay_bits; + + typedef _delaunay_bits::Part Part; + typedef std::vector > SiteHeap; + + + std::vector points; + std::vector nodes; + + for (NodeIt it(g); it != INVALID; ++it) { + nodes.push_back(it); + points.push_back(coords[it]); + } + + SiteHeap siteheap(points.size()); + + double sweep; + + + for (int i = 0; i < int(siteheap.size()); ++i) { + siteheap[i] = std::make_pair(points[i].x, i); + } + + std::sort(siteheap.begin(), siteheap.end()); + sweep = siteheap.front().first; + + YLess yless(points, sweep); + Beach beach(yless); + + SpikeHeap spikeheap; + + std::set > arcs; + + int siteindex = 0; + { + SiteHeap front; + + while (siteindex < int(siteheap.size()) && + siteheap[0].first == siteheap[siteindex].first) { + front.push_back(std::make_pair(points[siteheap[siteindex].second].y, + siteheap[siteindex].second)); + ++siteindex; + } + + std::sort(front.begin(), front.end()); + + for (int i = 0; i < int(front.size()); ++i) { + int prev = (i == 0 ? -1 : front[i - 1].second); + int curr = front[i].second; + int next = (i + 1 == int(front.size()) ? -1 : front[i + 1].second); + + beach.insert(std::make_pair(Part(prev, curr, next), + spikeheap.end())); + } + } + + while (siteindex < int(points.size()) || !spikeheap.empty()) { + + SpikeHeap::iterator spit = spikeheap.begin(); + + if (siteindex < int(points.size()) && + (spit == spikeheap.end() || siteheap[siteindex].first < spit->first)) { + int site = siteheap[siteindex].second; + sweep = siteheap[siteindex].first; + + Beach::iterator bit = beach.upper_bound(Part(site, site, site)); + + if (bit->second != spikeheap.end()) { + spikeheap.erase(bit->second); + } + + int prev = bit->first.prev; + int curr = bit->first.curr; + int next = bit->first.next; + + beach.erase(bit); + + SpikeHeap::iterator pit = spikeheap.end(); + if (prev != -1 && + circle_form(points[prev], points[curr], points[site])) { + double x = circle_point(points[prev], points[curr], points[site]); + pit = spikeheap.insert(std::make_pair(x, BeachIt(beach.end()))); + pit->second.it = + beach.insert(std::make_pair(Part(prev, curr, site), pit)); + } else { + beach.insert(std::make_pair(Part(prev, curr, site), pit)); + } + + beach.insert(std::make_pair(Part(curr, site, curr), spikeheap.end())); + + SpikeHeap::iterator nit = spikeheap.end(); + if (next != -1 && + circle_form(points[site], points[curr],points[next])) { + double x = circle_point(points[site], points[curr], points[next]); + nit = spikeheap.insert(std::make_pair(x, BeachIt(beach.end()))); + nit->second.it = + beach.insert(std::make_pair(Part(site, curr, next), nit)); + } else { + beach.insert(std::make_pair(Part(site, curr, next), nit)); + } + + ++siteindex; + } else { + sweep = spit->first; + + Beach::iterator bit = spit->second.it; + + int prev = bit->first.prev; + int curr = bit->first.curr; + int next = bit->first.next; + + { + std::pair arc; + + arc = prev < curr ? + std::make_pair(prev, curr) : std::make_pair(curr, prev); + + if (arcs.find(arc) == arcs.end()) { + arcs.insert(arc); + g.addEdge(nodes[prev], nodes[curr]); + ++cnt; + } + + arc = curr < next ? + std::make_pair(curr, next) : std::make_pair(next, curr); + + if (arcs.find(arc) == arcs.end()) { + arcs.insert(arc); + g.addEdge(nodes[curr], nodes[next]); + ++cnt; + } + } + + Beach::iterator pbit = bit; --pbit; + int ppv = pbit->first.prev; + Beach::iterator nbit = bit; ++nbit; + int nnt = nbit->first.next; + + if (bit->second != spikeheap.end()) spikeheap.erase(bit->second); + if (pbit->second != spikeheap.end()) spikeheap.erase(pbit->second); + if (nbit->second != spikeheap.end()) spikeheap.erase(nbit->second); + + beach.erase(nbit); + beach.erase(bit); + beach.erase(pbit); + + SpikeHeap::iterator pit = spikeheap.end(); + if (ppv != -1 && ppv != next && + circle_form(points[ppv], points[prev], points[next])) { + double x = circle_point(points[ppv], points[prev], points[next]); + if (x < sweep) x = sweep; + pit = spikeheap.insert(std::make_pair(x, BeachIt(beach.end()))); + pit->second.it = + beach.insert(std::make_pair(Part(ppv, prev, next), pit)); + } else { + beach.insert(std::make_pair(Part(ppv, prev, next), pit)); + } + + SpikeHeap::iterator nit = spikeheap.end(); + if (nnt != -1 && prev != nnt && + circle_form(points[prev], points[next], points[nnt])) { + double x = circle_point(points[prev], points[next], points[nnt]); + if (x < sweep) x = sweep; + nit = spikeheap.insert(std::make_pair(x, BeachIt(beach.end()))); + nit->second.it = + beach.insert(std::make_pair(Part(prev, next, nnt), nit)); + } else { + beach.insert(std::make_pair(Part(prev, next, nnt), nit)); + } + + } + } + + for (Beach::iterator it = beach.begin(); it != beach.end(); ++it) { + int curr = it->first.curr; + int next = it->first.next; + + if (next == -1) continue; + + std::pair arc; + + arc = curr < next ? + std::make_pair(curr, next) : std::make_pair(next, curr); + + if (arcs.find(arc) == arcs.end()) { + arcs.insert(arc); + g.addEdge(nodes[curr], nodes[next]); + ++cnt; + } + } +} + +void sparse(int d) +{ + Counter cnt("Number of arcs removed: "); + Bfs bfs(g); + for(std::vector::reverse_iterator ei=arcs.rbegin(); + ei!=arcs.rend();++ei) + { + Node a=g.u(*ei); + Node b=g.v(*ei); + g.erase(*ei); + bfs.run(a,b); + if(bfs.predArc(b)==INVALID || bfs.dist(b)>d) + g.addEdge(a,b); + else cnt++; + } +} + +void sparse2(int d) +{ + Counter cnt("Number of arcs removed: "); + for(std::vector::reverse_iterator ei=arcs.rbegin(); + ei!=arcs.rend();++ei) + { + Node a=g.u(*ei); + Node b=g.v(*ei); + g.erase(*ei); + ConstMap cegy(1); + Suurballe > sur(g,cegy); + int k=sur.run(a,b,2); + if(k<2 || sur.totalLength()>d) + g.addEdge(a,b); + else cnt++; +// else std::cout << "Remove arc " << g.id(a) << "-" << g.id(b) << '\n'; + } +} + +void sparseTriangle(int d) +{ + Counter cnt("Number of arcs added: "); + std::vector pedges; + for(NodeIt n(g);n!=INVALID;++n) + for(NodeIt m=++(NodeIt(n));m!=INVALID;++m) + { + Parc p; + p.a=n; + p.b=m; + p.len=(coords[m]-coords[n]).normSquare(); + pedges.push_back(p); + } + std::sort(pedges.begin(),pedges.end(),pedgeLess); + for(std::vector::iterator pi=pedges.begin();pi!=pedges.end();++pi) + { + Line li(pi->a,pi->b); + EdgeIt e(g); + for(;e!=INVALID && !cross(e,li);++e) ; + Edge ne; + if(e==INVALID) { + ConstMap cegy(1); + Suurballe > sur(g,cegy); + int k=sur.run(pi->a,pi->b,2); + if(k<2 || sur.totalLength()>d) + { + ne=g.addEdge(pi->a,pi->b); + arcs.push_back(ne); + cnt++; + } + } + } +} + +template +class LengthSquareMap { +public: + typedef typename Graph::Edge Key; + typedef typename CoordMap::Value::Value Value; + + LengthSquareMap(const Graph& graph, const CoordMap& coords) + : _graph(graph), _coords(coords) {} + + Value operator[](const Key& key) const { + return (_coords[_graph.v(key)] - + _coords[_graph.u(key)]).normSquare(); + } + +private: + + const Graph& _graph; + const CoordMap& _coords; +}; + +void minTree() { + std::vector pedges; + Timer T; + std::cout << T.realTime() << "s: Creating delaunay triangulation...\n"; + delaunay(); + std::cout << T.realTime() << "s: Calculating spanning tree...\n"; + LengthSquareMap > ls(g, coords); + ListGraph::EdgeMap tree(g); + kruskal(g, ls, tree); + std::cout << T.realTime() << "s: Removing non tree arcs...\n"; + std::vector remove; + for (EdgeIt e(g); e != INVALID; ++e) { + if (!tree[e]) remove.push_back(e); + } + for(int i = 0; i < int(remove.size()); ++i) { + g.erase(remove[i]); + } + std::cout << T.realTime() << "s: Done\n"; +} + +void tsp2() +{ + std::cout << "Find a tree..." << std::endl; + + minTree(); + + std::cout << "Total arc length (tree) : " << totalLen() << std::endl; + + std::cout << "Make it Euler..." << std::endl; + + { + std::vector leafs; + for(NodeIt n(g);n!=INVALID;++n) + if(countIncEdges(g,n)%2==1) leafs.push_back(n); + +// for(unsigned int i=0;i pedges; + for(unsigned int i=0;i enext(g); + { + EulerIt e(g); + Arc eo=e; + Arc ef=e; +// std::cout << "Tour arc: " << g.id(Edge(e)) << std::endl; + for(++e;e!=INVALID;++e) + { +// std::cout << "Tour arc: " << g.id(Edge(e)) << std::endl; + enext[eo]=e; + eo=e; + } + enext[eo]=ef; + } + + std::cout << "Creating a tour from that..." << std::endl; + + int nnum = countNodes(g); + int ednum = countEdges(g); + + for(Arc p=enext[EdgeIt(g)];ednum>nnum;p=enext[p]) + { +// std::cout << "Checking arc " << g.id(p) << std::endl; + Arc e=enext[p]; + Arc f=enext[e]; + Node n2=g.source(f); + Node n1=g.oppositeNode(n2,e); + Node n3=g.oppositeNode(n2,f); + if(countIncEdges(g,n2)>2) + { +// std::cout << "Remove an Arc" << std::endl; + Arc ff=enext[f]; + g.erase(e); + g.erase(f); + if(n1!=n3) + { + Arc ne=g.direct(g.addEdge(n1,n3),n1); + enext[p]=ne; + enext[ne]=ff; + ednum--; + } + else { + enext[p]=ff; + ednum-=2; + } + } + } + + std::cout << "Total arc length (tour) : " << totalLen() << std::endl; + + std::cout << "2-opt the tour..." << std::endl; + + tsp_improve(); + + std::cout << "Total arc length (2-opt tour) : " << totalLen() << std::endl; +} + + +int main(int argc,const char **argv) +{ + ArgParser ap(argc,argv); + +// bool eps; + bool disc_d, square_d, gauss_d; +// bool tsp_a,two_a,tree_a; + int num_of_cities=1; + double area=1; + N=100; +// girth=10; + std::string ndist("disc"); + ap.refOption("n", "Number of nodes (default is 100)", N) + .intOption("g", "Girth parameter (default is 10)", 10) + .refOption("cities", "Number of cities (default is 1)", num_of_cities) + .refOption("area", "Full relative area of the cities (default is 1)", area) + .refOption("disc", "Nodes are evenly distributed on a unit disc (default)", + disc_d) + .optionGroup("dist", "disc") + .refOption("square", "Nodes are evenly distributed on a unit square", + square_d) + .optionGroup("dist", "square") + .refOption("gauss", "Nodes are located according to a two-dim Gauss " + "distribution", gauss_d) + .optionGroup("dist", "gauss") + .onlyOneGroup("dist") + .boolOption("eps", "Also generate .eps output (.eps)") + .boolOption("nonodes", "Draw only the edges in the generated .eps output") + .boolOption("dir", "Directed graph is generated (each edge is replaced by " + "two directed arcs)") + .boolOption("2con", "Create a two connected planar graph") + .optionGroup("alg","2con") + .boolOption("tree", "Create a min. cost spanning tree") + .optionGroup("alg","tree") + .boolOption("tsp", "Create a TSP tour") + .optionGroup("alg","tsp") + .boolOption("tsp2", "Create a TSP tour (tree based)") + .optionGroup("alg","tsp2") + .boolOption("dela", "Delaunay triangulation graph") + .optionGroup("alg","dela") + .onlyOneGroup("alg") + .boolOption("rand", "Use time seed for random number generator") + .optionGroup("rand", "rand") + .intOption("seed", "Random seed", -1) + .optionGroup("rand", "seed") + .onlyOneGroup("rand") + .other("[prefix]","Prefix of the output files. Default is 'lgf-gen-out'") + .run(); + + if (ap["rand"]) { + int seed = int(time(0)); + std::cout << "Random number seed: " << seed << std::endl; + rnd = Random(seed); + } + if (ap.given("seed")) { + int seed = ap["seed"]; + std::cout << "Random number seed: " << seed << std::endl; + rnd = Random(seed); + } + + std::string prefix; + switch(ap.files().size()) + { + case 0: + prefix="lgf-gen-out"; + break; + case 1: + prefix=ap.files()[0]; + break; + default: + std::cerr << "\nAt most one prefix can be given\n\n"; + exit(1); + } + + double sum_sizes=0; + std::vector sizes; + std::vector cum_sizes; + for(int s=0;s(g,prefix+".lgf"). + nodeMap("coordinates_x",scaleMap(xMap(coords),600)). + nodeMap("coordinates_y",scaleMap(yMap(coords),600)). + run(); + else GraphWriter(g,prefix+".lgf"). + nodeMap("coordinates_x",scaleMap(xMap(coords),600)). + nodeMap("coordinates_y",scaleMap(yMap(coords),600)). + run(); +} +