COIN-OR::LEMON - Graph Library

About

Downloads

Documentation

Development

Issue Tracker

Browse Tickets

Custom Query

Roadmap

Browse Source

Local Info

Mailing Lists

Search

Changes in / [962:4efe7b32b134:685:a27356ceb5bd] in lemon-main


Ignore:
Files:
1 added
6 deleted
40 edited

Legend:

Unmodified
Added
Removed

  • AUTHORS

    r951 r320  
    2424
    2525Again, please visit the history of the old LEMON repository for more
    26 details: http://lemon.cs.elte.hu/hg/lemon-0.x
     26details: http://lemon.cs.elte.hu/svn/lemon/trunk

  • CMakeLists.txt

    r940 r680  
    33SET(PROJECT_NAME "LEMON")
    44PROJECT(${PROJECT_NAME})
    5 
    6 INCLUDE(FindPythonInterp)
    7 INCLUDE(FindWget)
    85
    96IF(EXISTS ${PROJECT_SOURCE_DIR}/cmake/version.cmake)
    … …  
    129  SET(LEMON_VERSION $ENV{LEMON_VERSION} CACHE STRING "LEMON version string.")
    1310ELSE()
    14   EXECUTE_PROCESS(
    15     COMMAND ${PYTHON_EXECUTABLE} ./scripts/chg-len.py
    16     WORKING_DIRECTORY ${PROJECT_SOURCE_DIR}
    17     OUTPUT_VARIABLE HG_REVISION_PATH
    18     ERROR_QUIET
    19     OUTPUT_STRIP_TRAILING_WHITESPACE
    20   )
    2111  EXECUTE_PROCESS(
    2212    COMMAND hg id -i
    … …  
    2717  )
    2818  IF(HG_REVISION STREQUAL "")
    29     SET(HG_REVISION_ID "hg-tip")
    30   ELSE()
    31     IF(HG_REVISION_PATH STREQUAL "")
    32       SET(HG_REVISION_ID ${HG_REVISION})
    33     ELSE()
    34       SET(HG_REVISION_ID ${HG_REVISION_PATH}.${HG_REVISION})
    35     ENDIF()
     19    SET(HG_REVISION "hg-tip")
    3620  ENDIF()
    37   SET(LEMON_VERSION ${HG_REVISION_ID} CACHE STRING "LEMON version string.")
     21  SET(LEMON_VERSION ${HG_REVISION} CACHE STRING "LEMON version string.")
    3822ENDIF()
    3923
    … …  
    4832FIND_PACKAGE(COIN)
    4933
    50 IF(DEFINED ENV{LEMON_CXX_WARNING})
    51   SET(CXX_WARNING $ENV{LEMON_CXX_WARNING})
    52 ELSE()
    53   IF(CMAKE_COMPILER_IS_GNUCXX)
    54     SET(CXX_WARNING "-Wall -W -Wunused -Wformat=2 -Wctor-dtor-privacy -Wnon-virtual-dtor -Wno-char-subscripts -Wwrite-strings -Wno-char-subscripts -Wreturn-type -Wcast-qual -Wcast-align -Wsign-promo -Woverloaded-virtual -fno-strict-aliasing -Wold-style-cast -Wno-unknown-pragmas")
    55     SET(CMAKE_CXX_FLAGS_DEBUG CACHE STRING "-ggdb")
    56     SET(CMAKE_C_FLAGS_DEBUG CACHE STRING "-ggdb")
    57   ELSEIF(MSVC)
    58     # This part is unnecessary 'casue the same is set by the lemon/core.h.
    59     # Still keep it as an example.
    60     SET(CXX_WARNING "/wd4250 /wd4355 /wd4503 /wd4800 /wd4996")
    61     # Suppressed warnings:
    62     # C4250: 'class1' : inherits 'class2::member' via dominance
    63     # C4355: 'this' : used in base member initializer list
    64     # C4503: 'function' : decorated name length exceeded, name was truncated
    65     # C4800: 'type' : forcing value to bool 'true' or 'false'
    66     #        (performance warning)
    67     # C4996: 'function': was declared deprecated
    68   ELSE()
    69     SET(CXX_WARNING "-Wall -W")
    70   ENDIF()
    71 ENDIF()
    72 SET(LEMON_CXX_WARNING_FLAGS ${CXX_WARNING} CACHE STRING "LEMON warning flags.")
    73 
    74 SET(CMAKE_CXX_FLAGS "${CMAKE_CXX_FLAGS} ${LEMON_CXX_WARNING_FLAGS}")
    75 
    76 SET( CMAKE_CXX_FLAGS_MAINTAINER "-Werror -ggdb" CACHE STRING
    77     "Flags used by the C++ compiler during maintainer builds."
    78     FORCE )
    79 SET( CMAKE_C_FLAGS_MAINTAINER "-Werror" CACHE STRING
    80     "Flags used by the C compiler during maintainer builds."
    81     FORCE )
    82 SET( CMAKE_EXE_LINKER_FLAGS_MAINTAINER
    83     "-Wl,--warn-unresolved-symbols,--warn-once" CACHE STRING
    84     "Flags used for linking binaries during maintainer builds."
    85     FORCE )
    86 SET( CMAKE_SHARED_LINKER_FLAGS_MAINTAINER
    87     "-Wl,--warn-unresolved-symbols,--warn-once" CACHE STRING
    88     "Flags used by the shared libraries linker during maintainer builds."
    89     FORCE )
    90 MARK_AS_ADVANCED(
    91     CMAKE_CXX_FLAGS_MAINTAINER
    92     CMAKE_C_FLAGS_MAINTAINER
    93     CMAKE_EXE_LINKER_FLAGS_MAINTAINER
    94     CMAKE_SHARED_LINKER_FLAGS_MAINTAINER )
    95 
    96 IF(CMAKE_CONFIGURATION_TYPES)
    97   LIST(APPEND CMAKE_CONFIGURATION_TYPES Maintainer)
    98   LIST(REMOVE_DUPLICATES CMAKE_CONFIGURATION_TYPES)
    99   SET(CMAKE_CONFIGURATION_TYPES "${CMAKE_CONFIGURATION_TYPES}" CACHE STRING
    100       "Add the configurations that we need"
    101       FORCE)
    102  endif()
    103 
    104 IF(NOT CMAKE_BUILD_TYPE)
    105   SET(CMAKE_BUILD_TYPE "Release")
    106 ENDIF()
    107 
    108 SET( CMAKE_BUILD_TYPE "${CMAKE_BUILD_TYPE}" CACHE STRING
    109     "Choose the type of build, options are: None(CMAKE_CXX_FLAGS or CMAKE_C_FLAGS used) Debug Release RelWithDebInfo MinSizeRel Maintainer."
    110     FORCE )
    111 
    112 
    11334INCLUDE(CheckTypeSize)
    11435CHECK_TYPE_SIZE("long long" LONG_LONG)
    … …  
    11637
    11738ENABLE_TESTING()
    118 
    119 IF(${CMAKE_BUILD_TYPE} STREQUAL "Maintainer")
    120   ADD_CUSTOM_TARGET(check ALL COMMAND ${CMAKE_CTEST_COMMAND})
    121 ELSE()
    122   ADD_CUSTOM_TARGET(check COMMAND ${CMAKE_CTEST_COMMAND})
    123 ENDIF()
    12439
    12540ADD_SUBDIRECTORY(lemon)
    … …  
    14863ENDIF()
    14964
    150 IF(${CMAKE_SOURCE_DIR} STREQUAL ${PROJECT_SOURCE_DIR})
     65IF(${CMAKE_SOURCE_DIR} STREQUAL ${PROJECT_SOURCE_DIR} AND WIN32)
    15166  SET(CPACK_PACKAGE_NAME ${PROJECT_NAME})
    15267  SET(CPACK_PACKAGE_VENDOR "EGRES")

  • Makefile.am

    r752 r629  
    1818        cmake/FindGLPK.cmake \
    1919        cmake/FindCOIN.cmake \
    20         cmake/LEMONConfig.cmake.in \
    2120        cmake/version.cmake.in \
    2221        cmake/version.cmake \

  • cmake/FindCOIN.cmake

    r947 r634  
    66FIND_LIBRARY(COIN_CBC_LIBRARY
    77  NAMES Cbc libCbc
    8   HINTS ${COIN_ROOT_DIR}/lib/coin
    98  HINTS ${COIN_ROOT_DIR}/lib
    109)
    1110FIND_LIBRARY(COIN_CBC_SOLVER_LIBRARY
    1211  NAMES CbcSolver libCbcSolver
    13   HINTS ${COIN_ROOT_DIR}/lib/coin
    1412  HINTS ${COIN_ROOT_DIR}/lib
    1513)
    1614FIND_LIBRARY(COIN_CGL_LIBRARY
    1715  NAMES Cgl libCgl
    18   HINTS ${COIN_ROOT_DIR}/lib/coin
    1916  HINTS ${COIN_ROOT_DIR}/lib
    2017)
    2118FIND_LIBRARY(COIN_CLP_LIBRARY
    2219  NAMES Clp libClp
    23   HINTS ${COIN_ROOT_DIR}/lib/coin
    2420  HINTS ${COIN_ROOT_DIR}/lib
    2521)
    2622FIND_LIBRARY(COIN_COIN_UTILS_LIBRARY
    2723  NAMES CoinUtils libCoinUtils
    28   HINTS ${COIN_ROOT_DIR}/lib/coin
    2924  HINTS ${COIN_ROOT_DIR}/lib
    3025)
    3126FIND_LIBRARY(COIN_OSI_LIBRARY
    3227  NAMES Osi libOsi
    33   HINTS ${COIN_ROOT_DIR}/lib/coin
    3428  HINTS ${COIN_ROOT_DIR}/lib
    3529)
    3630FIND_LIBRARY(COIN_OSI_CBC_LIBRARY
    3731  NAMES OsiCbc libOsiCbc
    38   HINTS ${COIN_ROOT_DIR}/lib/coin
    3932  HINTS ${COIN_ROOT_DIR}/lib
    4033)
    4134FIND_LIBRARY(COIN_OSI_CLP_LIBRARY
    4235  NAMES OsiClp libOsiClp
    43   HINTS ${COIN_ROOT_DIR}/lib/coin
    4436  HINTS ${COIN_ROOT_DIR}/lib
    4537)
    4638FIND_LIBRARY(COIN_OSI_VOL_LIBRARY
    4739  NAMES OsiVol libOsiVol
    48   HINTS ${COIN_ROOT_DIR}/lib/coin
    4940  HINTS ${COIN_ROOT_DIR}/lib
    5041)
    5142FIND_LIBRARY(COIN_VOL_LIBRARY
    5243  NAMES Vol libVol
    53   HINTS ${COIN_ROOT_DIR}/lib/coin
    5444  HINTS ${COIN_ROOT_DIR}/lib
    5545)
    … …  
    6656  COIN_OSI_CBC_LIBRARY
    6757  COIN_OSI_CLP_LIBRARY
    68   # COIN_OSI_VOL_LIBRARY
    69   # COIN_VOL_LIBRARY
     58  COIN_OSI_VOL_LIBRARY
     59  COIN_VOL_LIBRARY
    7060)
    7161
    7262IF(COIN_FOUND)
    7363  SET(COIN_INCLUDE_DIRS ${COIN_INCLUDE_DIR})
    74   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}")
     64  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}")
    7565  SET(COIN_CLP_LIBRARIES "${COIN_CLP_LIBRARY};${COIN_COIN_UTILS_LIBRARY}")
    7666  SET(COIN_CBC_LIBRARIES ${COIN_LIBRARIES})

  • configure.ac

    r929 r680  
    9999dnl Add dependencies on files generated by configure.
    100100AC_SUBST([CONFIG_STATUS_DEPENDENCIES],
    101   ['$(top_srcdir)/doc/Doxyfile.in $(top_srcdir)/doc/mainpage.dox.in $(top_srcdir)/lemon/lemon.pc.in $(top_srcdir)/cmake/version.cmake.in'])
     101  ['$(top_srcdir)/doc/Doxyfile.in $(top_srcdir)/lemon/lemon.pc.in $(top_srcdir)/cmake/version.cmake.in'])
    102102
    103103AC_CONFIG_FILES([
    … …  
    106106cmake/version.cmake
    107107doc/Doxyfile
    108 doc/mainpage.dox
    109108lemon/lemon.pc
    110109])

  • doc/CMakeLists.txt

    r929 r679  
    44SET(abs_top_builddir ${PROJECT_BINARY_DIR})
    55
    6 SET(LEMON_DOC_SOURCE_BROWSER "NO" CACHE STRING "Include source into the doc (YES/NO).")
    7 
    86CONFIGURE_FILE(
    97  ${PROJECT_SOURCE_DIR}/doc/Doxyfile.in
    108  ${PROJECT_BINARY_DIR}/doc/Doxyfile
    11   @ONLY
    12 )
    13 
    14 CONFIGURE_FILE(
    15   ${PROJECT_SOURCE_DIR}/doc/mainpage.dox.in
    16   ${PROJECT_BINARY_DIR}/doc/mainpage.dox
    179  @ONLY
    1810)
    … …  
    5850
    5951ENDIF()
    60 
    61 IF(WGET_FOUND)
    62 ADD_CUSTOM_TARGET(update-external-tags
    63   COMMAND ${CMAKE_COMMAND} -E make_directory dl
    64   # COMMAND ${CMAKE_COMMAND} -E copy libstdc++.tag dl
    65   COMMAND ${WGET_EXECUTABLE} wget -P dl -N libstdc++.tag.tmp http://gcc.gnu.org/onlinedocs/libstdc++/latest-doxygen/libstdc++.tag
    66   COMMAND ${CMAKE_COMMAND} -E rename dl/libstdc++.tag libstdc++.tag
    67   COMMAND ${CMAKE_COMMAND} -E remove dl/libstdc++.tag
    68   COMMAND ${CMAKE_COMMAND} -E remove_directory dl
    69   WORKING_DIRECTORY ${CMAKE_CURRENT_BINARY_DIR}
    70   )
    71 ENDIF()

  • doc/Doxyfile.in

    r929 r367  
    1 # Doxyfile 1.7.3
     1# Doxyfile 1.5.7.1
    22
    33#---------------------------------------------------------------------------
    … …  
    55#---------------------------------------------------------------------------
    66DOXYFILE_ENCODING      = UTF-8
    7 PROJECT_NAME           =
    8 PROJECT_NUMBER         =
    9 PROJECT_BRIEF          =
    10 PROJECT_LOGO           =
     7PROJECT_NAME           = @PACKAGE_NAME@
     8PROJECT_NUMBER         = @PACKAGE_VERSION@
    119OUTPUT_DIRECTORY       =
    1210CREATE_SUBDIRS         = NO
    … …  
    2422QT_AUTOBRIEF           = NO
    2523MULTILINE_CPP_IS_BRIEF = NO
     24DETAILS_AT_TOP         = YES
    2625INHERIT_DOCS           = NO
    2726SEPARATE_MEMBER_PAGES  = NO
    … …  
    3231OPTIMIZE_FOR_FORTRAN   = NO
    3332OPTIMIZE_OUTPUT_VHDL   = NO
    34 EXTENSION_MAPPING      =
    3533BUILTIN_STL_SUPPORT    = YES
    3634CPP_CLI_SUPPORT        = NO
    … …  
    5856HIDE_SCOPE_NAMES       = YES
    5957SHOW_INCLUDE_FILES     = YES
    60 FORCE_LOCAL_INCLUDES   = NO
    6158INLINE_INFO            = YES
    6259SORT_MEMBER_DOCS       = NO
    6360SORT_BRIEF_DOCS        = NO
    64 SORT_MEMBERS_CTORS_1ST = NO
    6561SORT_GROUP_NAMES       = NO
    6662SORT_BY_SCOPE_NAME     = NO
    67 STRICT_PROTO_MATCHING  = NO
    6863GENERATE_TODOLIST      = YES
    6964GENERATE_TESTLIST      = YES
    … …  
    7772SHOW_NAMESPACES        = YES
    7873FILE_VERSION_FILTER    =
    79 LAYOUT_FILE            = "@abs_top_srcdir@/doc/DoxygenLayout.xml"
     74LAYOUT_FILE            = DoxygenLayout.xml
    8075#---------------------------------------------------------------------------
    8176# configuration options related to warning and progress messages
    … …  
    9792                         "@abs_top_srcdir@/demo" \
    9893                         "@abs_top_srcdir@/tools" \
    99                          "@abs_top_srcdir@/test/test_tools.h" \
    100                          "@abs_top_builddir@/doc/mainpage.dox"
     94                         "@abs_top_srcdir@/test/test_tools.h"
    10195INPUT_ENCODING         = UTF-8
    10296FILE_PATTERNS          = *.h \
    … …  
    118112FILTER_PATTERNS        =
    119113FILTER_SOURCE_FILES    = NO
    120 FILTER_SOURCE_PATTERNS =
    121114#---------------------------------------------------------------------------
    122115# configuration options related to source browsing
    123116#---------------------------------------------------------------------------
    124 SOURCE_BROWSER         = @LEMON_DOC_SOURCE_BROWSER@
     117SOURCE_BROWSER         = NO
    125118INLINE_SOURCES         = NO
    126119STRIP_CODE_COMMENTS    = YES
    … …  
    145138HTML_FOOTER            =
    146139HTML_STYLESHEET        =
    147 HTML_COLORSTYLE_HUE    = 220
    148 HTML_COLORSTYLE_SAT    = 100
    149 HTML_COLORSTYLE_GAMMA  = 80
    150 HTML_TIMESTAMP         = YES
    151140HTML_ALIGN_MEMBERS     = YES
    152 HTML_DYNAMIC_SECTIONS  = YES
     141HTML_DYNAMIC_SECTIONS  = NO
    153142GENERATE_DOCSET        = NO
    154143DOCSET_FEEDNAME        = "Doxygen generated docs"
    155144DOCSET_BUNDLE_ID       = org.doxygen.Project
    156 DOCSET_PUBLISHER_ID    = org.doxygen.Publisher
    157 DOCSET_PUBLISHER_NAME  = Publisher
    158145GENERATE_HTMLHELP      = NO
    159146CHM_FILE               =
    … …  
    167154QHP_NAMESPACE          = org.doxygen.Project
    168155QHP_VIRTUAL_FOLDER     = doc
    169 QHP_CUST_FILTER_NAME   =
    170 QHP_CUST_FILTER_ATTRS  =
    171 QHP_SECT_FILTER_ATTRS  =
    172156QHG_LOCATION           =
    173 GENERATE_ECLIPSEHELP   = NO
    174 ECLIPSE_DOC_ID         = org.doxygen.Project
    175157DISABLE_INDEX          = NO
    176158ENUM_VALUES_PER_LINE   = 4
    177159GENERATE_TREEVIEW      = NO
    178 USE_INLINE_TREES       = NO
    179160TREEVIEW_WIDTH         = 250
    180 EXT_LINKS_IN_WINDOW    = NO
    181161FORMULA_FONTSIZE       = 10
    182 FORMULA_TRANSPARENT    = YES
    183 USE_MATHJAX            = NO
    184 MATHJAX_RELPATH        = http://www.mathjax.org/mathjax
    185 SEARCHENGINE           = YES
    186 SERVER_BASED_SEARCH    = NO
    187162#---------------------------------------------------------------------------
    188163# configuration options related to the LaTeX output
    … …  
    201176LATEX_BATCHMODE        = NO
    202177LATEX_HIDE_INDICES     = NO
    203 LATEX_SOURCE_CODE      = NO
    204178#---------------------------------------------------------------------------
    205179# configuration options related to the RTF output
    … …  
    250224SKIP_FUNCTION_MACROS   = YES
    251225#---------------------------------------------------------------------------
    252 # Configuration::additions related to external references
    253 #---------------------------------------------------------------------------
    254 TAGFILES               = "@abs_top_builddir@/doc/libstdc++.tag = http://gcc.gnu.org/onlinedocs/libstdc++/latest-doxygen/  "
     226# Configuration::additions related to external references   
     227#---------------------------------------------------------------------------
     228TAGFILES               = "@abs_top_srcdir@/doc/libstdc++.tag = http://gcc.gnu.org/onlinedocs/libstdc++/latest-doxygen/  "
    255229GENERATE_TAGFILE       = html/lemon.tag
    256230ALLEXTERNALS           = NO
    … …  
    264238HIDE_UNDOC_RELATIONS   = YES
    265239HAVE_DOT               = YES
    266 DOT_NUM_THREADS        = 0
    267240DOT_FONTNAME           = FreeSans
    268241DOT_FONTSIZE           = 10
    … …  
    282255DOT_PATH               =
    283256DOTFILE_DIRS           =
    284 MSCFILE_DIRS           =
    285257DOT_GRAPH_MAX_NODES    = 50
    286258MAX_DOT_GRAPH_DEPTH    = 0
    … …  
    289261GENERATE_LEGEND        = YES
    290262DOT_CLEANUP            = YES
     263#---------------------------------------------------------------------------
     264# Configuration::additions related to the search engine   
     265#---------------------------------------------------------------------------
     266SEARCHENGINE           = NO

  • doc/DoxygenLayout.xml

    r928 r316  
    33  <navindex>
    44    <tab type="mainpage" visible="yes" title=""/>
    5     <tab type="modules" visible="yes" title="" intro=""/>
     5    <tab type="modules" visible="yes" title=""/>
    66    <tab type="classes" visible="yes" title="">
    7       <tab type="classes" visible="yes" title="" intro=""/>
    8       <tab type="classindex" visible="$ALPHABETICAL_INDEX" title=""/>
    9       <tab type="hierarchy" visible="yes" title="" intro=""/>
    10       <tab type="classmembers" visible="yes" title="" intro=""/>
     7      <tab type="classes" visible="yes" title=""/>
     8      <tab type="classindex" visible="$ALPHABETICAL_INDEX" title=""/> 
     9      <tab type="hierarchy" visible="yes" title=""/>
     10      <tab type="classmembers" visible="yes" title=""/>
    1111    </tab>
    1212    <tab type="namespaces" visible="yes" title="">
    13       <tab type="namespaces" visible="yes" title="" intro=""/>
    14       <tab type="namespacemembers" visible="yes" title="" intro=""/>
     13      <tab type="namespaces" visible="yes" title=""/>
     14      <tab type="namespacemembers" visible="yes" title=""/>
    1515    </tab>
    1616    <tab type="files" visible="yes" title="">
    17       <tab type="files" visible="yes" title="" intro=""/>
    18       <tab type="globals" visible="yes" title="" intro=""/>
     17      <tab type="files" visible="yes" title=""/>
     18      <tab type="globals" visible="yes" title=""/>
    1919    </tab>
    20     <tab type="dirs" visible="yes" title="" intro=""/>
    21     <tab type="examples" visible="yes" title="" intro=""/>
    22     <tab type="pages" visible="yes" title="" intro=""/>
     20    <tab type="dirs" visible="yes" title=""/>
     21    <tab type="examples" visible="yes" title=""/> 
     22    <tab type="pages" visible="yes" title=""/>
    2323  </navindex>
    2424

  • doc/lgf.dox

    r950 r440  
    6464\endcode
    6565
    66 The \c \@arcs section is very similar to the \c \@nodes section, it
    67 again starts with a header line describing the names of the maps, but
    68 the \c "label" map is not obligatory here. The following lines
    69 describe the arcs. The first two tokens of each line are the source
    70 and the target node of the arc, respectively, then come the map
     66The \c \@arcs section is very similar to the \c \@nodes section,
     67it again starts with a header line describing the names of the maps,
     68but the \c "label" map is not obligatory here. The following lines
     69describe the arcs. The first two tokens of each line are
     70the source and the target node of the arc, respectively, then come the map
    7171values. The source and target tokens must be node labels.
    7272
    … …  
    7979\endcode
    8080
    81 If there is no map in the \c \@arcs section at all, then it must be
    82 indicated by a sole '-' sign in the first line.
    83 
    84 \code
    85  @arcs
    86          -
    87  1   2
    88  1   3
    89  2   3
    90 \endcode
    91 
    9281The \c \@edges is just a synonym of \c \@arcs. The \@arcs section can
    9382also store the edge set of an undirected graph. In such case there is
    9483a conventional method for store arc maps in the file, if two columns
    95 have the same caption with \c '+' and \c '-' prefix, then these columns
     84has the same caption with \c '+' and \c '-' prefix, then these columns
    9685can be regarded as the values of an arc map.
    9786

  • lemon/CMakeLists.txt

    r908 r679  
    77  ${CMAKE_CURRENT_SOURCE_DIR}/config.h.cmake
    88  ${CMAKE_CURRENT_BINARY_DIR}/config.h
    9 )
    10 
    11 CONFIGURE_FILE(
    12   ${CMAKE_CURRENT_SOURCE_DIR}/lemon.pc.cmake
    13   ${CMAKE_CURRENT_BINARY_DIR}/lemon.pc
    14   @ONLY
    159)
    1610
    … …  
    7367  COMPONENT headers
    7468)
    75 
    76 INSTALL(
    77   FILES ${CMAKE_CURRENT_BINARY_DIR}/lemon.pc
    78   DESTINATION lib/pkgconfig
    79 )
    80 

  • lemon/Makefile.am

    r959 r667  
    11EXTRA_DIST += \
    22        lemon/lemon.pc.in \
    3         lemon/lemon.pc.cmake \
    43        lemon/CMakeLists.txt \
    54        lemon/config.h.cmake
    … …  
    6160        lemon/bfs.h \
    6261        lemon/bin_heap.h \
    63         lemon/bucket_heap.h \
    6462        lemon/cbc.h \
    6563        lemon/circulation.h \
    … …  
    7977        lemon/error.h \
    8078        lemon/euler.h \
    81         lemon/fib_heap.h \
    8279        lemon/full_graph.h \
    8380        lemon/glpk.h \
    … …  
    103100        lemon/path.h \
    104101        lemon/preflow.h \
    105         lemon/radix_heap.h \
    106102        lemon/radix_sort.h \
    107103        lemon/random.h \

  • lemon/bin_heap.h

    r683 r584  
    3434  ///\brief A Binary Heap implementation.
    3535  ///
    36   ///This class implements the \e binary \e heap data structure.
    37   ///
     36  ///This class implements the \e binary \e heap data structure. 
     37  /// 
    3838  ///A \e heap is a data structure for storing items with specified values
    3939  ///called \e priorities in such a way that finding the item with minimum
    40   ///priority is efficient. \c CMP specifies the ordering of the priorities.
     40  ///priority is efficient. \c Comp specifies the ordering of the priorities.
    4141  ///In a heap one can change the priority of an item, add or erase an
    4242  ///item, etc.
    … …  
    4545  ///\tparam IM A read and writable item map with int values, used internally
    4646  ///to handle the cross references.
    47   ///\tparam CMP A functor class for the ordering of the priorities.
     47  ///\tparam Comp A functor class for the ordering of the priorities.
    4848  ///The default is \c std::less<PR>.
    4949  ///
    5050  ///\sa FibHeap
    5151  ///\sa Dijkstra
    52   template <typename PR, typename IM, typename CMP = std::less<PR> >
     52  template <typename PR, typename IM, typename Comp = std::less<PR> >
    5353  class BinHeap {
    5454
    … …  
    6363    typedef std::pair<Item,Prio> Pair;
    6464    ///\e
    65     typedef CMP Compare;
     65    typedef Comp Compare;
    6666
    6767    /// \brief Type to represent the items states.

  • lemon/bits/edge_set_extender.h

    r962 r685  
    281281    typedef EdgeSetExtender Graph;
    282282
    283     typedef True UndirectedTag;
    284 
    285283    typedef typename Parent::Node Node;
    286284    typedef typename Parent::Arc Arc;

  • lemon/bits/graph_adaptor_extender.h

    r882 r617  
    182182    typedef GraphAdaptorExtender Adaptor;
    183183
    184     typedef True UndirectedTag;
    185 
    186184    typedef typename Parent::Node Node;
    187185    typedef typename Parent::Arc Arc;

  • lemon/bits/map_extender.h

    r802 r617  
    5050    typedef typename Parent::ConstReference ConstReference;
    5151
    52     typedef typename Parent::ReferenceMapTag ReferenceMapTag;
    53 
    5452    class MapIt;
    5553    class ConstMapIt;
    … …  
    8583      typedef typename Map::Value Value;
    8684
    87       MapIt() : map(NULL) {}
    88 
    89       MapIt(Invalid i) : Parent(i), map(NULL) {}
    90 
    91       explicit MapIt(Map& _map) : map(&_map) {
    92         map->notifier()->first(*this);
     85      MapIt() {}
     86
     87      MapIt(Invalid i) : Parent(i) { }
     88
     89      explicit MapIt(Map& _map) : map(_map) {
     90        map.notifier()->first(*this);
    9391      }
    9492
    9593      MapIt(const Map& _map, const Item& item)
    96         : Parent(item), map(&_map) {}
     94        : Parent(item), map(_map) {}
    9795
    9896      MapIt& operator++() {
    99         map->notifier()->next(*this);
     97        map.notifier()->next(*this);
    10098        return *this;
    10199      }
    102100
    103101      typename MapTraits<Map>::ConstReturnValue operator*() const {
    104         return (*map)[*this];
     102        return map[*this];
    105103      }
    106104
    107105      typename MapTraits<Map>::ReturnValue operator*() {
    108         return (*map)[*this];
     106        return map[*this];
    109107      }
    110108
    111109      void set(const Value& value) {
    112         map->set(*this, value);
    113       }
    114 
    115     protected:
    116       Map* map;
     110        map.set(*this, value);
     111      }
     112
     113    protected:
     114      Map& map;
    117115
    118116    };
    … …  
    125123      typedef typename Map::Value Value;
    126124
    127       ConstMapIt() : map(NULL) {}
    128 
    129       ConstMapIt(Invalid i) : Parent(i), map(NULL) {}
    130 
    131       explicit ConstMapIt(Map& _map) : map(&_map) {
    132         map->notifier()->first(*this);
     125      ConstMapIt() {}
     126
     127      ConstMapIt(Invalid i) : Parent(i) { }
     128
     129      explicit ConstMapIt(Map& _map) : map(_map) {
     130        map.notifier()->first(*this);
    133131      }
    134132
    … …  
    137135
    138136      ConstMapIt& operator++() {
    139         map->notifier()->next(*this);
     137        map.notifier()->next(*this);
    140138        return *this;
    141139      }
    … …  
    146144
    147145    protected:
    148       const Map* map;
     146      const Map& map;
    149147    };
    150148
    … …  
    153151
    154152    public:
    155       ItemIt() : map(NULL) {}
    156 
    157 
    158       ItemIt(Invalid i) : Parent(i), map(NULL) {}
    159 
    160       explicit ItemIt(Map& _map) : map(&_map) {
    161         map->notifier()->first(*this);
     153
     154      ItemIt() {}
     155
     156      ItemIt(Invalid i) : Parent(i) { }
     157
     158      explicit ItemIt(Map& _map) : map(_map) {
     159        map.notifier()->first(*this);
    162160      }
    163161
    164162      ItemIt(const Map& _map, const Item& item)
    165         : Parent(item), map(&_map) {}
     163        : Parent(item), map(_map) {}
    166164
    167165      ItemIt& operator++() {
    168         map->notifier()->next(*this);
    169         return *this;
    170       }
    171 
    172     protected:
    173       const Map* map;
     166        map.notifier()->next(*this);
     167        return *this;
     168      }
     169
     170    protected:
     171      const Map& map;
    174172
    175173    };
    … …  
    194192    typedef typename Parent::ConstReference ConstReference;
    195193
    196     typedef typename Parent::ReferenceMapTag ReferenceMapTag;
    197 
    198194    class MapIt;
    199195    class ConstMapIt;
    … …  
    232228      typedef typename Map::Value Value;
    233229
    234       MapIt() : map(NULL) {}
    235 
    236       MapIt(Invalid i) : Parent(i), map(NULL) { }
    237 
    238       explicit MapIt(Map& _map) : map(&_map) {
    239         map->graph.first(*this);
     230      MapIt() {}
     231
     232      MapIt(Invalid i) : Parent(i) { }
     233
     234      explicit MapIt(Map& _map) : map(_map) {
     235        map.graph.first(*this);
    240236      }
    241237
    242238      MapIt(const Map& _map, const Item& item)
    243         : Parent(item), map(&_map) {}
     239        : Parent(item), map(_map) {}
    244240
    245241      MapIt& operator++() {
    246         map->graph.next(*this);
     242        map.graph.next(*this);
    247243        return *this;
    248244      }
    249245
    250246      typename MapTraits<Map>::ConstReturnValue operator*() const {
    251         return (*map)[*this];
     247        return map[*this];
    252248      }
    253249
    254250      typename MapTraits<Map>::ReturnValue operator*() {
    255         return (*map)[*this];
     251        return map[*this];
    256252      }
    257253
    258254      void set(const Value& value) {
    259         map->set(*this, value);
    260       }
    261 
    262     protected:
    263       Map* map;
     255        map.set(*this, value);
     256      }
     257
     258    protected:
     259      Map& map;
    264260
    265261    };
    … …  
    272268      typedef typename Map::Value Value;
    273269
    274       ConstMapIt() : map(NULL) {}
    275 
    276       ConstMapIt(Invalid i) : Parent(i), map(NULL) { }
    277 
    278       explicit ConstMapIt(Map& _map) : map(&_map) {
    279         map->graph.first(*this);
     270      ConstMapIt() {}
     271
     272      ConstMapIt(Invalid i) : Parent(i) { }
     273
     274      explicit ConstMapIt(Map& _map) : map(_map) {
     275        map.graph.first(*this);
    280276      }
    281277
    282278      ConstMapIt(const Map& _map, const Item& item)
    283         : Parent(item), map(&_map) {}
     279        : Parent(item), map(_map) {}
    284280
    285281      ConstMapIt& operator++() {
    286         map->graph.next(*this);
     282        map.graph.next(*this);
    287283        return *this;
    288284      }
    289285
    290286      typename MapTraits<Map>::ConstReturnValue operator*() const {
    291         return (*map)[*this];
    292       }
    293 
    294     protected:
    295       const Map* map;
     287        return map[*this];
     288      }
     289
     290    protected:
     291      const Map& map;
    296292    };
    297293
    … …  
    300296
    301297    public:
    302       ItemIt() : map(NULL) {}
    303 
    304 
    305       ItemIt(Invalid i) : Parent(i), map(NULL) { }
    306 
    307       explicit ItemIt(Map& _map) : map(&_map) {
    308         map->graph.first(*this);
     298
     299      ItemIt() {}
     300
     301      ItemIt(Invalid i) : Parent(i) { }
     302
     303      explicit ItemIt(Map& _map) : map(_map) {
     304        map.graph.first(*this);
    309305      }
    310306
    311307      ItemIt(const Map& _map, const Item& item)
    312         : Parent(item), map(&_map) {}
     308        : Parent(item), map(_map) {}
    313309
    314310      ItemIt& operator++() {
    315         map->graph.next(*this);
    316         return *this;
    317       }
    318 
    319     protected:
    320       const Map* map;
     311        map.graph.next(*this);
     312        return *this;
     313      }
     314
     315    protected:
     316      const Map& map;
    321317
    322318    };

  • lemon/bits/path_dump.h

    r887 r529  
    5050
    5151    bool empty() const {
    52       return predMap[target] == INVALID;
     52      return predMap[target] != INVALID;
    5353    }
    5454
    … …  
    124124
    125125    bool empty() const {
    126       return predMatrixMap(source, target) == INVALID;
     126      return source != target;
    127127    }
    128128

  • lemon/bits/windows.cc

    r940 r493  
    4141#include <unistd.h>
    4242#include <ctime>
    43 #ifndef WIN32
    4443#include <sys/times.h>
    45 #endif
    4644#include <sys/time.h>
    4745#endif

  • lemon/circulation.h

    r688 r641  
    454454    ///
    455455    /// Sets the tolerance used by algorithm.
    456     Circulation& tolerance(const Tolerance& tolerance) {
     456    Circulation& tolerance(const Tolerance& tolerance) const {
    457457      _tol = tolerance;
    458458      return *this;
    … …  
    463463    /// Returns a const reference to the tolerance.
    464464    const Tolerance& tolerance() const {
    465       return _tol;
     465      return tolerance;
    466466    }
    467467

  • lemon/concepts/maps.h

    r718 r529  
    183183      template<typename _ReferenceMap>
    184184      struct Constraints {
    185         typename enable_if<typename _ReferenceMap::ReferenceMapTag, void>::type
    186         constraints() {
     185        void constraints() {
    187186          checkConcept<ReadWriteMap<K, T>, _ReferenceMap >();
    188187          ref = m[key];

  • lemon/core.h

    r959 r671  
    395395      static void copy(const From& from, Digraph &to,
    396396                       NodeRefMap& nodeRefMap, ArcRefMap& arcRefMap) {
    397         to.clear();
    398397        for (typename From::NodeIt it(from); it != INVALID; ++it) {
    399398          nodeRefMap[it] = to.addNode();
    … …  
    423422      static void copy(const From& from, Graph &to,
    424423                       NodeRefMap& nodeRefMap, EdgeRefMap& edgeRefMap) {
    425         to.clear();
    426424        for (typename From::NodeIt it(from); it != INVALID; ++it) {
    427425          nodeRefMap[it] = to.addNode();

  • lemon/dfs.h

    r959 r584  
    558558    void start(Node t)
    559559    {
    560       while ( !emptyQueue() && !(*_reached)[t] )
     560      while ( !emptyQueue() && G->target(_stack[_stack_head])!=t )
    561561        processNextArc();
    562562    }
    … …  
    15101510    /// with addSource() before using this function.
    15111511    void start(Node t) {
    1512       while ( !emptyQueue() && !(*_reached)[t] )
     1512      while ( !emptyQueue() && _digraph->target(_stack[_stack_head]) != t )
    15131513        processNextArc();
    15141514    }

  • lemon/glpk.h

    r832 r650  
    2626#include <lemon/lp_base.h>
    2727
     28// forward declaration
     29#if !defined _GLP_PROB && !defined GLP_PROB
     30#define _GLP_PROB
     31#define GLP_PROB
     32typedef struct { double _opaque_prob; } glp_prob;
     33/* LP/MIP problem object */
     34#endif
     35
    2836namespace lemon {
    2937
    30   namespace _solver_bits {
    31     class VoidPtr {
    32     private:
    33       void *_ptr;     
    34     public:
    35       VoidPtr() : _ptr(0) {}
    36 
    37       template <typename T>
    38       VoidPtr(T* ptr) : _ptr(reinterpret_cast<void*>(ptr)) {}
    39 
    40       template <typename T>
    41       VoidPtr& operator=(T* ptr) {
    42         _ptr = reinterpret_cast<void*>(ptr);
    43         return *this;
    44       }
    45 
    46       template <typename T>
    47       operator T*() const { return reinterpret_cast<T*>(_ptr); }
    48     };
    49   }
    5038
    5139  /// \brief Base interface for the GLPK LP and MIP solver
    … …  
    5644  protected:
    5745
    58     _solver_bits::VoidPtr lp;
     46    typedef glp_prob LPX;
     47    glp_prob* lp;
    5948
    6049    GlpkBase();
    … …  
    134123
    135124    ///Pointer to the underlying GLPK data structure.
    136     _solver_bits::VoidPtr lpx() {return lp;}
     125    LPX *lpx() {return lp;}
    137126    ///Const pointer to the underlying GLPK data structure.
    138     _solver_bits::VoidPtr lpx() const {return lp;}
     127    const LPX *lpx() const {return lp;}
    139128
    140129    ///Returns the constraint identifier understood by GLPK.

  • lemon/graph_to_eps.h

    r959 r617  
    685685#else
    686686      os << bits::getWinFormattedDate();
    687       os << std::endl;
    688687#endif
    689688    }
     689    os << std::endl;
    690690
    691691    if (_autoArcWidthScale) {

  • lemon/lgf_reader.h

    r959 r599  
    33 * This file is a part of LEMON, a generic C++ optimization library.
    44 *
    5  * Copyright (C) 2003-2011
     5 * Copyright (C) 2003-2009
    66 * Egervary Jeno Kombinatorikus Optimalizalasi Kutatocsoport
    77 * (Egervary Research Group on Combinatorial Optimization, EGRES).
    … …  
    965965        int index = 0;
    966966        while (_reader_bits::readToken(line, map)) {
    967           if(map == "-") {
    968               if(index!=0)
    969                 throw FormatError("'-' is not allowed as a map name");
    970               else if (line >> std::ws >> c)
    971                 throw FormatError("Extra character at the end of line");
    972               else break;
    973             }
    974967          if (maps.find(map) != maps.end()) {
    975968            std::ostringstream msg;
    … …  
    18421835        int index = 0;
    18431836        while (_reader_bits::readToken(line, map)) {
    1844           if(map == "-") {
    1845               if(index!=0)
    1846                 throw FormatError("'-' is not allowed as a map name");
    1847               else if (line >> std::ws >> c)
    1848                 throw FormatError("Extra character at the end of line");
    1849               else break;
    1850             }
    18511837          if (maps.find(map) != maps.end()) {
    18521838            std::ostringstream msg;

  • lemon/lp_base.h

    r957 r584  
    16051605  inline LpBase::Constr operator<=(const LpBase::Expr &e,
    16061606                                   const LpBase::Expr &f) {
    1607     return LpBase::Constr(0, f - e, LpBase::NaN);
     1607    return LpBase::Constr(0, f - e, LpBase::INF);
    16081608  }
    16091609
    … …  
    16231623  inline LpBase::Constr operator<=(const LpBase::Expr &e,
    16241624                                   const LpBase::Value &f) {
    1625     return LpBase::Constr(LpBase::NaN, e, f);
     1625    return LpBase::Constr(- LpBase::INF, e, f);
    16261626  }
    16271627
    … …  
    16321632  inline LpBase::Constr operator>=(const LpBase::Expr &e,
    16331633                                   const LpBase::Expr &f) {
    1634     return LpBase::Constr(0, e - f, LpBase::NaN);
     1634    return LpBase::Constr(0, e - f, LpBase::INF);
    16351635  }
    16361636
    … …  
    16521652  inline LpBase::Constr operator>=(const LpBase::Expr &e,
    16531653                                   const LpBase::Value &f) {
    1654     return LpBase::Constr(f, e, LpBase::NaN);
     1654    return LpBase::Constr(f, e, LpBase::INF);
    16551655  }
    16561656

  • lemon/matching.h

    r867 r651  
    806806        _matching = new MatchingMap(_graph);
    807807      }
    808 
    809808      if (!_node_potential) {
    810809        _node_potential = new NodePotential(_graph);
    811810      }
    812 
    813811      if (!_blossom_set) {
    814812        _blossom_index = new IntNodeMap(_graph);
    815813        _blossom_set = new BlossomSet(*_blossom_index);
    816814        _blossom_data = new RangeMap<BlossomData>(_blossom_num);
    817       } else if (_blossom_data->size() != _blossom_num) {
    818         delete _blossom_data;
    819         _blossom_data = new RangeMap<BlossomData>(_blossom_num);
    820815      }
    821816
    … …  
    824819        _node_heap_index = new IntArcMap(_graph);
    825820        _node_data = new RangeMap<NodeData>(_node_num,
    826                                             NodeData(*_node_heap_index));
    827       } else {
    828         delete _node_data;
    829         _node_data = new RangeMap<NodeData>(_node_num,
    830                                             NodeData(*_node_heap_index));
     821                                              NodeData(*_node_heap_index));
    831822      }
    832823
    … …  
    834825        _tree_set_index = new IntIntMap(_blossom_num);
    835826        _tree_set = new TreeSet(*_tree_set_index);
    836       } else {
    837         _tree_set_index->resize(_blossom_num);
    838       }
    839 
     827      }
    840828      if (!_delta1) {
    841829        _delta1_index = new IntNodeMap(_graph);
    842830        _delta1 = new BinHeap<Value, IntNodeMap>(*_delta1_index);
    843831      }
    844 
    845832      if (!_delta2) {
    846833        _delta2_index = new IntIntMap(_blossom_num);
    847834        _delta2 = new BinHeap<Value, IntIntMap>(*_delta2_index);
    848       } else {
    849         _delta2_index->resize(_blossom_num);
    850       }
    851 
     835      }
    852836      if (!_delta3) {
    853837        _delta3_index = new IntEdgeMap(_graph);
    854838        _delta3 = new BinHeap<Value, IntEdgeMap>(*_delta3_index);
    855839      }
    856 
    857840      if (!_delta4) {
    858841        _delta4_index = new IntIntMap(_blossom_num);
    859842        _delta4 = new BinHeap<Value, IntIntMap>(*_delta4_index);
    860       } else {
    861         _delta4_index->resize(_blossom_num);
    862843      }
    863844    }
    … …  
    17051686      createStructures();
    17061687
    1707       _blossom_node_list.clear();
    1708       _blossom_potential.clear();
    1709 
    17101688      for (ArcIt e(_graph); e != INVALID; ++e) {
    17111689        (*_node_heap_index)[e] = BinHeap<Value, IntArcMap>::PRE_HEAP;
    … …  
    17211699        (*_delta4_index)[i] = _delta4->PRE_HEAP;
    17221700      }
    1723      
    1724       _delta1->clear();
    1725       _delta2->clear();
    1726       _delta3->clear();
    1727       _delta4->clear();
    1728       _blossom_set->clear();
    1729       _tree_set->clear();
    17301701
    17311702      int index = 0;
    … …  
    17391710        }
    17401711        (*_node_index)[n] = index;
    1741         (*_node_data)[index].heap_index.clear();
    1742         (*_node_data)[index].heap.clear();
    17431712        (*_node_data)[index].pot = max;
    17441713        _delta1->push(n, max);
    … …  
    22302199        _matching = new MatchingMap(_graph);
    22312200      }
    2232 
    22332201      if (!_node_potential) {
    22342202        _node_potential = new NodePotential(_graph);
    22352203      }
    2236 
    22372204      if (!_blossom_set) {
    22382205        _blossom_index = new IntNodeMap(_graph);
    22392206        _blossom_set = new BlossomSet(*_blossom_index);
    2240         _blossom_data = new RangeMap<BlossomData>(_blossom_num);
    2241       } else if (_blossom_data->size() != _blossom_num) {
    2242         delete _blossom_data;
    22432207        _blossom_data = new RangeMap<BlossomData>(_blossom_num);
    22442208      }
    … …  
    22492213        _node_data = new RangeMap<NodeData>(_node_num,
    22502214                                            NodeData(*_node_heap_index));
    2251       } else if (_node_data->size() != _node_num) {
    2252         delete _node_data;
    2253         _node_data = new RangeMap<NodeData>(_node_num,
    2254                                             NodeData(*_node_heap_index));
    22552215      }
    22562216
    … …  
    22582218        _tree_set_index = new IntIntMap(_blossom_num);
    22592219        _tree_set = new TreeSet(*_tree_set_index);
    2260       } else {
    2261         _tree_set_index->resize(_blossom_num);
    2262       }
    2263 
     2220      }
    22642221      if (!_delta2) {
    22652222        _delta2_index = new IntIntMap(_blossom_num);
    22662223        _delta2 = new BinHeap<Value, IntIntMap>(*_delta2_index);
    2267       } else {
    2268         _delta2_index->resize(_blossom_num);
    2269       }
    2270 
     2224      }
    22712225      if (!_delta3) {
    22722226        _delta3_index = new IntEdgeMap(_graph);
    22732227        _delta3 = new BinHeap<Value, IntEdgeMap>(*_delta3_index);
    22742228      }
    2275 
    22762229      if (!_delta4) {
    22772230        _delta4_index = new IntIntMap(_blossom_num);
    22782231        _delta4 = new BinHeap<Value, IntIntMap>(*_delta4_index);
    2279       } else {
    2280         _delta4_index->resize(_blossom_num);
    22812232      }
    22822233    }
    … …  
    29762927      createStructures();
    29772928
    2978       _blossom_node_list.clear();
    2979       _blossom_potential.clear();
    2980 
    29812929      for (ArcIt e(_graph); e != INVALID; ++e) {
    29822930        (*_node_heap_index)[e] = BinHeap<Value, IntArcMap>::PRE_HEAP;
    … …  
    29892937        (*_delta4_index)[i] = _delta4->PRE_HEAP;
    29902938      }
    2991 
    2992       _delta2->clear();
    2993       _delta3->clear();
    2994       _delta4->clear();
    2995       _blossom_set->clear();
    2996       _tree_set->clear();
    29972939
    29982940      int index = 0;
    … …  
    30062948        }
    30072949        (*_node_index)[n] = index;
    3008         (*_node_data)[index].heap_index.clear();
    3009         (*_node_data)[index].heap.clear();
    30102950        (*_node_data)[index].pot = max;
    30112951        int blossom =

  • lemon/network_simplex.h

    r888 r663  
    10431043        ART_COST = std::numeric_limits<Cost>::max() / 2 + 1;
    10441044      } else {
    1045         ART_COST = 0;
     1045        ART_COST = std::numeric_limits<Cost>::min();
    10461046        for (int i = 0; i != _arc_num; ++i) {
    10471047          if (_cost[i] > ART_COST) ART_COST = _cost[i];
    … …  
    14581458      if (_sum_supply == 0) {
    14591459        if (_stype == GEQ) {
    1460           Cost max_pot = -std::numeric_limits<Cost>::max();
     1460          Cost max_pot = std::numeric_limits<Cost>::min();
    14611461          for (int i = 0; i != _node_num; ++i) {
    14621462            if (_pi[i] > max_pot) max_pot = _pi[i];

  • lemon/path.h

    r802 r559  
    7171    template <typename CPath>
    7272    Path(const CPath& cpath) {
    73       pathCopy(cpath, *this);
     73      copyPath(*this, cpath);
    7474    }
    7575
    … …  
    7979    template <typename CPath>
    8080    Path& operator=(const CPath& cpath) {
    81       pathCopy(cpath, *this);
     81      copyPath(*this, cpath);
    8282      return *this;
    8383    }
    … …  
    259259    template <typename CPath>
    260260    SimplePath(const CPath& cpath) {
    261       pathCopy(cpath, *this);
     261      copyPath(*this, cpath);
    262262    }
    263263
    … …  
    268268    template <typename CPath>
    269269    SimplePath& operator=(const CPath& cpath) {
    270       pathCopy(cpath, *this);
     270      copyPath(*this, cpath);
    271271      return *this;
    272272    }
    … …  
    438438    template <typename CPath>
    439439    ListPath(const CPath& cpath) : first(0), last(0) {
    440       pathCopy(cpath, *this);
     440      copyPath(*this, cpath);
    441441    }
    442442
    … …  
    454454    template <typename CPath>
    455455    ListPath& operator=(const CPath& cpath) {
    456       pathCopy(cpath, *this);
     456      copyPath(*this, cpath);
    457457      return *this;
    458458    }
    … …  
    764764    template <typename CPath>
    765765    StaticPath(const CPath& cpath) : arcs(0) {
    766       pathCopy(cpath, *this);
     766      copyPath(*this, cpath);
    767767    }
    768768
    … …  
    780780    template <typename CPath>
    781781    StaticPath& operator=(const CPath& cpath) {
    782       pathCopy(cpath, *this);
     782      copyPath(*this, cpath);
    783783      return *this;
    784784    }
    … …  
    929929    };
    930930
    931     template <typename From, typename To,
    932               bool buildEnable = BuildTagIndicator<To>::value>
     931    template <typename Target, typename Source,
     932              bool buildEnable = BuildTagIndicator<Target>::value>
    933933    struct PathCopySelectorForward {
    934       static void copy(const From& from, To& to) {
    935         to.clear();
    936         for (typename From::ArcIt it(from); it != INVALID; ++it) {
    937           to.addBack(it);
     934      static void copy(Target& target, const Source& source) {
     935        target.clear();
     936        for (typename Source::ArcIt it(source); it != INVALID; ++it) {
     937          target.addBack(it);
    938938        }
    939939      }
    940940    };
    941941
    942     template <typename From, typename To>
    943     struct PathCopySelectorForward<From, To, true> {
    944       static void copy(const From& from, To& to) {
    945         to.clear();
    946         to.build(from);
    947       }
    948     };
    949 
    950     template <typename From, typename To,
    951               bool buildEnable = BuildTagIndicator<To>::value>
     942    template <typename Target, typename Source>
     943    struct PathCopySelectorForward<Target, Source, true> {
     944      static void copy(Target& target, const Source& source) {
     945        target.clear();
     946        target.build(source);
     947      }
     948    };
     949
     950    template <typename Target, typename Source,
     951              bool buildEnable = BuildTagIndicator<Target>::value>
    952952    struct PathCopySelectorBackward {
    953       static void copy(const From& from, To& to) {
    954         to.clear();
    955         for (typename From::RevArcIt it(from); it != INVALID; ++it) {
    956           to.addFront(it);
     953      static void copy(Target& target, const Source& source) {
     954        target.clear();
     955        for (typename Source::RevArcIt it(source); it != INVALID; ++it) {
     956          target.addFront(it);
    957957        }
    958958      }
    959959    };
    960960
    961     template <typename From, typename To>
    962     struct PathCopySelectorBackward<From, To, true> {
    963       static void copy(const From& from, To& to) {
    964         to.clear();
    965         to.buildRev(from);
     961    template <typename Target, typename Source>
     962    struct PathCopySelectorBackward<Target, Source, true> {
     963      static void copy(Target& target, const Source& source) {
     964        target.clear();
     965        target.buildRev(source);
    966966      }
    967967    };
    968968
    969969   
    970     template <typename From, typename To,
    971               bool revEnable = RevPathTagIndicator<From>::value>
     970    template <typename Target, typename Source,
     971              bool revEnable = RevPathTagIndicator<Source>::value>
    972972    struct PathCopySelector {
    973       static void copy(const From& from, To& to) {
    974         PathCopySelectorForward<From, To>::copy(from, to);
     973      static void copy(Target& target, const Source& source) {
     974        PathCopySelectorForward<Target, Source>::copy(target, source);
    975975      }     
    976976    };
    977977
    978     template <typename From, typename To>
    979     struct PathCopySelector<From, To, true> {
    980       static void copy(const From& from, To& to) {
    981         PathCopySelectorBackward<From, To>::copy(from, to);
     978    template <typename Target, typename Source>
     979    struct PathCopySelector<Target, Source, true> {
     980      static void copy(Target& target, const Source& source) {
     981        PathCopySelectorBackward<Target, Source>::copy(target, source);
    982982      }     
    983983    };
    … …  
    988988  /// \brief Make a copy of a path.
    989989  ///
    990   /// This function makes a copy of a path.
    991   template <typename From, typename To>
    992   void pathCopy(const From& from, To& to) {
    993     checkConcept<concepts::PathDumper<typename From::Digraph>, From>();
    994     _path_bits::PathCopySelector<From, To>::copy(from, to);
    995   }
    996 
    997   /// \brief Deprecated version of \ref pathCopy().
    998   ///
    999   /// Deprecated version of \ref pathCopy() (only for reverse compatibility).
    1000   template <typename To, typename From>
    1001   void copyPath(To& to, const From& from) {
    1002     pathCopy(from, to);
     990  ///  This function makes a copy of a path.
     991  template <typename Target, typename Source>
     992  void copyPath(Target& target, const Source& source) {
     993    checkConcept<concepts::PathDumper<typename Source::Digraph>, Source>();
     994    _path_bits::PathCopySelector<Target, Source>::copy(target, source);
    1003995  }
    1004996
    … …  
    10241016  /// \brief The source of a path
    10251017  ///
    1026   /// This function returns the source node of the given path.
    1027   /// If the path is empty, then it returns \c INVALID.
     1018  /// This function returns the source of the given path.
    10281019  template <typename Digraph, typename Path>
    10291020  typename Digraph::Node pathSource(const Digraph& digraph, const Path& path) {
    1030     return path.empty() ? INVALID : digraph.source(path.front());
     1021    return digraph.source(path.front());
    10311022  }
    10321023
    10331024  /// \brief The target of a path
    10341025  ///
    1035   /// This function returns the target node of the given path.
    1036   /// If the path is empty, then it returns \c INVALID.
     1026  /// This function returns the target of the given path.
    10371027  template <typename Digraph, typename Path>
    10381028  typename Digraph::Node pathTarget(const Digraph& digraph, const Path& path) {
    1039     return path.empty() ? INVALID : digraph.target(path.back());
     1029    return digraph.target(path.back());
    10401030  }
    10411031

  • lemon/preflow.h

    r923 r641  
    375375    ///
    376376    /// Sets the tolerance used by algorithm.
    377     Preflow& tolerance(const Tolerance& tolerance) {
     377    Preflow& tolerance(const Tolerance& tolerance) const {
    378378      _tolerance = tolerance;
    379379      return *this;
    … …  
    384384    /// Returns a const reference to the tolerance.
    385385    const Tolerance& tolerance() const {
    386       return _tolerance;
     386      return tolerance;
    387387    }
    388388
    … …  
    526526          _flow->set(e, (*_capacity)[e]);
    527527          (*_excess)[u] += rem;
     528          if (u != _target && !_level->active(u)) {
     529            _level->activate(u);
     530          }
    528531        }
    529532      }
    … …  
    535538          _flow->set(e, 0);
    536539          (*_excess)[v] += rem;
    537         }
    538       }
    539       for (NodeIt n(_graph); n != INVALID; ++n)
    540         if(n!=_source && n!=_target && _tolerance.positive((*_excess)[n]))
    541           _level->activate(n);
    542          
     540          if (v != _target && !_level->active(v)) {
     541            _level->activate(v);
     542          }
     543        }
     544      }
    543545      return true;
    544546    }
    … …  
    557559      _phase = true;
    558560
    559       while (true) {
     561      Node n = _level->highestActive();
     562      int level = _level->highestActiveLevel();
     563      while (n != INVALID) {
    560564        int num = _node_num;
    561565
    562         Node n = INVALID;
    563         int level = -1;
    564 
    565         while (num > 0) {
    566           n = _level->highestActive();
    567           if (n == INVALID) goto first_phase_done;
    568           level = _level->highestActiveLevel();
    569           --num;
    570          
     566        while (num > 0 && n != INVALID) {
    571567          Value excess = (*_excess)[n];
    572568          int new_level = _level->maxLevel();
    … …  
    634630            _level->deactivate(n);
    635631          }
     632
     633          n = _level->highestActive();
     634          level = _level->highestActiveLevel();
     635          --num;
    636636        }
    637637
    638638        num = _node_num * 20;
    639         while (num > 0) {
    640           while (level >= 0 && _level->activeFree(level)) {
    641             --level;
    642           }
    643           if (level == -1) {
    644             n = _level->highestActive();
    645             level = _level->highestActiveLevel();
    646             if (n == INVALID) goto first_phase_done;
    647           } else {
    648             n = _level->activeOn(level);
    649           }
    650           --num;
    651 
     639        while (num > 0 && n != INVALID) {
    652640          Value excess = (*_excess)[n];
    653641          int new_level = _level->maxLevel();
    … …  
    715703            _level->deactivate(n);
    716704          }
    717         }
    718       }
    719     first_phase_done:;
     705
     706          while (level >= 0 && _level->activeFree(level)) {
     707            --level;
     708          }
     709          if (level == -1) {
     710            n = _level->highestActive();
     711            level = _level->highestActiveLevel();
     712          } else {
     713            n = _level->activeOn(level);
     714          }
     715          --num;
     716        }
     717      }
    720718    }
    721719

  • lemon/suurballe.h

    r852 r623  
    5656  /// The default value is <tt>GR::ArcMap<int></tt>.
    5757  ///
    58   /// \warning Length values should be \e non-negative.
     58  /// \warning Length values should be \e non-negative \e integers.
    5959  ///
    6060  /// \note For finding node-disjoint paths this algorithm can be used
    … …  
    253253      _graph(graph), _length(length), _flow(0), _local_flow(false),
    254254      _potential(0), _local_potential(false), _pred(graph)
    255     {}
     255    {
     256      LEMON_ASSERT(std::numeric_limits<Length>::is_integer,
     257        "The length type of Suurballe must be integer");
     258    }
    256259
    257260    /// Destructor.
    … …  
    518521    /// \pre \ref run() or \ref findPaths() must be called before using
    519522    /// this function.
    520     const Path& path(int i) const {
     523    Path path(int i) const {
    521524      return paths[i];
    522525    }

  • lemon/unionfind.h

    r867 r559  
    740740    void clear() {
    741741      items.clear();
    742       classes.clear();
     742      classes.clear;
    743743      firstClass = firstFreeClass = firstFreeItem = -1;
    744744    }
    … …  
    12891289        first_free_class(-1), first_free_node(-1) {}
    12901290
    1291     /// \brief Clears the union-find data structure
    1292     ///
    1293     /// Erase each item from the data structure.
    1294     void clear() {
    1295       nodes.clear();
    1296       classes.clear();
    1297       first_free_node = first_free_class = first_class = -1;
    1298     }
    1299 
    13001291    /// \brief Insert a new node into a new component.
    13011292    ///

  • m4/lx_check_coin.m4

    r749 r627  
    8989        CBC_LDFLAGS="-L$with_coin/lib"
    9090      fi
    91       CBC_LIBS="-lOsi -lCbc -lCbcSolver -lClp -lOsiClp -lCoinUtils -lVol -lOsiVol -lCgl -lm -llapack -lblas"
     91      CBC_LIBS="-lOsi -lCbc -lOsiCbc -lCbcSolver -lClp -lOsiClp -lCoinUtils -lVol -lOsiVol -lCgl -lm -llapack -lblas"
    9292
    9393      lx_save_cxxflags="$CXXFLAGS"

  • test/CMakeLists.txt

    r959 r679  
    77  ${PROJECT_BINARY_DIR}/lemon
    88)
    9 
    10 SET(TEST_WITH_VALGRIND "NO" CACHE STRING
    11   "Run the test with valgrind (YES/NO).")
    12 SET(VALGRIND_FLAGS "" CACHE STRING "Valgrind flags used by the tests.")
    139
    1410SET(TESTS
    … …  
    3228  heap_test
    3329  kruskal_test
    34   lgf_test
    3530  maps_test
    3631  matching_test
    … …  
    4742
    4843IF(LEMON_HAVE_LP)
    49   IF(${CMAKE_BUILD_TYPE} STREQUAL "Maintainer")
    50     ADD_EXECUTABLE(lp_test lp_test.cc)
    51   ELSE()
    52     ADD_EXECUTABLE(lp_test EXCLUDE_FROM_ALL lp_test.cc)
    53   ENDIF()
    54 
     44  ADD_EXECUTABLE(lp_test lp_test.cc)
    5545  SET(LP_TEST_LIBS lemon)
    5646
    … …  
    6757  TARGET_LINK_LIBRARIES(lp_test ${LP_TEST_LIBS})
    6858  ADD_TEST(lp_test lp_test)
    69   ADD_DEPENDENCIES(check lp_test)
    7059
    7160  IF(WIN32 AND LEMON_HAVE_GLPK)
    … …  
    8978
    9079IF(LEMON_HAVE_MIP)
    91   IF(${CMAKE_BUILD_TYPE} STREQUAL "Maintainer")
    92     ADD_EXECUTABLE(mip_test mip_test.cc)
    93   ELSE()
    94     ADD_EXECUTABLE(mip_test EXCLUDE_FROM_ALL mip_test.cc)
    95   ENDIF()
    96 
     80  ADD_EXECUTABLE(mip_test mip_test.cc)
    9781  SET(MIP_TEST_LIBS lemon)
    9882
    … …  
    10993  TARGET_LINK_LIBRARIES(mip_test ${MIP_TEST_LIBS})
    11094  ADD_TEST(mip_test mip_test)
    111   ADD_DEPENDENCIES(check mip_test)
    11295
    11396  IF(WIN32 AND LEMON_HAVE_GLPK)
    … …  
    131114
    132115FOREACH(TEST_NAME ${TESTS})
    133   IF(${CMAKE_BUILD_TYPE} STREQUAL "Maintainer")
    134     ADD_EXECUTABLE(${TEST_NAME} ${TEST_NAME}.cc)
    135   ELSE()
    136     ADD_EXECUTABLE(${TEST_NAME} EXCLUDE_FROM_ALL ${TEST_NAME}.cc)
    137   ENDIF()
     116  ADD_EXECUTABLE(${TEST_NAME} ${TEST_NAME}.cc)
    138117  TARGET_LINK_LIBRARIES(${TEST_NAME} lemon)
    139     IF(TEST_WITH_VALGRIND)
    140       ADD_TEST(${TEST_NAME}
    141         valgrind --error-exitcode=1 ${VALGRIND_FLAGS}
    142         ${CMAKE_CURRENT_BINARY_DIR}/${TEST_NAME} )
    143     ELSE()
    144       ADD_TEST(${TEST_NAME} ${TEST_NAME})
    145     ENDIF()
    146   ADD_DEPENDENCIES(check ${TEST_NAME})
     118  ADD_TEST(${TEST_NAME} ${TEST_NAME})
    147119ENDFOREACH()

  • test/Makefile.am

    r959 r649  
    2626        test/heap_test \
    2727        test/kruskal_test \
    28         test/lgf_test \
    2928        test/maps_test \
    3029        test/matching_test \
    … …  
    7271test_kruskal_test_SOURCES = test/kruskal_test.cc
    7372test_hao_orlin_test_SOURCES = test/hao_orlin_test.cc
    74 test_lgf_test_SOURCES = test/lgf_test.cc
    7573test_lp_test_SOURCES = test/lp_test.cc
    7674test_maps_test_SOURCES = test/maps_test.cc

  • test/dfs_test.cc

    r959 r585  
    5151  "@attributes\n"
    5252  "source 0\n"
    53   "target 5\n"
    54   "source1 6\n"
    55   "target1 3\n";
    56 
     53  "target 5\n";
    5754
    5855void checkDfsCompile()
    … …  
    183180  Digraph G;
    184181  Node s, t;
    185   Node s1, t1;
    186182
    187183  std::istringstream input(test_lgf);
    … …  
    189185    node("source", s).
    190186    node("target", t).
    191     node("source1", s1).
    192     node("target1", t1).
    193187    run();
    194188
    … …  
    217211
    218212  {
    219   Dfs<Digraph> dfs(G);
    220   check(dfs.run(s1,t1) && dfs.reached(t1),"Node 3 is reachable from Node 6.");
    221   }
    222  
    223   {
    224213    NullMap<Node,Arc> myPredMap;
    225214    dfs(G).predMap(myPredMap).run(s);

  • test/graph_copy_test.cc

    r893 r440  
    3030  const int nn = 10;
    3131
    32   // Build a digraph
    3332  SmartDigraph from;
    3433  SmartDigraph::NodeMap<int> fnm(from);
    … …  
    5352  }
    5453
    55   // Test digraph copy
    5654  ListDigraph to;
    5755  ListDigraph::NodeMap<int> tnm(to);
    … …  
    7169    nodeCrossRef(ncr).arcCrossRef(ecr).
    7270    node(fn, tn).arc(fa, ta).run();
    73  
    74   check(countNodes(from) == countNodes(to), "Wrong copy.");
    75   check(countArcs(from) == countArcs(to), "Wrong copy.");
    7671
    7772  for (SmartDigraph::NodeIt it(from); it != INVALID; ++it) {
    … …  
    9691  check(tn == nr[fn], "Wrong copy.");
    9792  check(ta == er[fa], "Wrong copy.");
    98 
    99   // Test repeated copy
    100   digraphCopy(from, to).run();
    101  
    102   check(countNodes(from) == countNodes(to), "Wrong copy.");
    103   check(countArcs(from) == countArcs(to), "Wrong copy.");
    10493}
    10594
    … …  
    10796  const int nn = 10;
    10897
    109   // Build a graph
    11098  SmartGraph from;
    11199  SmartGraph::NodeMap<int> fnm(from);
    … …  
    135123  }
    136124
    137   // Test graph copy
    138125  ListGraph to;
    139126  ListGraph::NodeMap<int> tnm(to);
    … …  
    157144    nodeCrossRef(ncr).arcCrossRef(acr).edgeCrossRef(ecr).
    158145    node(fn, tn).arc(fa, ta).edge(fe, te).run();
    159 
    160   check(countNodes(from) == countNodes(to), "Wrong copy.");
    161   check(countEdges(from) == countEdges(to), "Wrong copy.");
    162   check(countArcs(from) == countArcs(to), "Wrong copy.");
    163146
    164147  for (SmartGraph::NodeIt it(from); it != INVALID; ++it) {
    … …  
    198181  check(ta == ar[fa], "Wrong copy.");
    199182  check(te == er[fe], "Wrong copy.");
    200 
    201   // Test repeated copy
    202   graphCopy(from, to).run();
    203  
    204   check(countNodes(from) == countNodes(to), "Wrong copy.");
    205   check(countEdges(from) == countEdges(to), "Wrong copy.");
    206   check(countArcs(from) == countArcs(to), "Wrong copy.");
    207183}
    208184

  • test/heap_test.cc

    r681 r440  
    3232
    3333#include <lemon/bin_heap.h>
    34 #include <lemon/fib_heap.h>
    35 #include <lemon/radix_heap.h>
    36 #include <lemon/bucket_heap.h>
    3734
    3835#include "test_tools.h"
    … …  
    187184  }
    188185
    189   {
    190     typedef FibHeap<Prio, ItemIntMap> IntHeap;
    191     checkConcept<Heap<Prio, ItemIntMap>, IntHeap>();
    192     heapSortTest<IntHeap>();
    193     heapIncreaseTest<IntHeap>();
    194 
    195     typedef FibHeap<Prio, IntNodeMap > NodeHeap;
    196     checkConcept<Heap<Prio, IntNodeMap >, NodeHeap>();
    197     dijkstraHeapTest<NodeHeap>(digraph, length, source);
    198   }
    199 
    200   {
    201     typedef RadixHeap<ItemIntMap> IntHeap;
    202     checkConcept<Heap<Prio, ItemIntMap>, IntHeap>();
    203     heapSortTest<IntHeap>();
    204     heapIncreaseTest<IntHeap>();
    205 
    206     typedef RadixHeap<IntNodeMap > NodeHeap;
    207     checkConcept<Heap<Prio, IntNodeMap >, NodeHeap>();
    208     dijkstraHeapTest<NodeHeap>(digraph, length, source);
    209   }
    210 
    211   {
    212     typedef BucketHeap<ItemIntMap> IntHeap;
    213     checkConcept<Heap<Prio, ItemIntMap>, IntHeap>();
    214     heapSortTest<IntHeap>();
    215     heapIncreaseTest<IntHeap>();
    216 
    217     typedef BucketHeap<IntNodeMap > NodeHeap;
    218     checkConcept<Heap<Prio, IntNodeMap >, NodeHeap>();
    219     dijkstraHeapTest<NodeHeap>(digraph, length, source);
    220   }
    221 
    222 
    223186  return 0;
    224187}

  • test/lp_test.cc

    r957 r631  
    167167    c = ((2 >= p1) >= 3);
    168168
    169     { //Tests for #430
    170       LP::Col v=lp.addCol();
    171       LP::Constr c = v >= -3;
    172       c = c <= 4;
    173       LP::Constr c2;
    174       c2 = -3 <= v <= 4;
    175     }
    176 
    177169    e[x[3]]=2;
    178170    e[x[3]]=4;

  • test/mip_test.cc

    r748 r631  
    5151  if (stat ==  MipSolver::OPTIMAL) {
    5252    std::ostringstream sbuf;
    53     sbuf << "Wrong optimal value ("<< mip.solValue()
    54          <<" instead of " << exp_opt << ")";
     53    buf << "Wrong optimal value: the right optimum is " << exp_opt;
    5554    check(std::abs(mip.solValue()-exp_opt) < 1e-3, sbuf.str());
    5655    //+ecvt(exp_opt,2)

  • test/preflow_test.cc

    r923 r585  
    152152}
    153153
    154 void initFlowTest()
    155 {
    156   DIGRAPH_TYPEDEFS(SmartDigraph);
    157  
    158   SmartDigraph g;
    159   SmartDigraph::ArcMap<int> cap(g),iflow(g);
    160   Node s=g.addNode(); Node t=g.addNode();
    161   Node n1=g.addNode(); Node n2=g.addNode();
    162   Arc a;
    163   a=g.addArc(s,n1); cap[a]=20; iflow[a]=20;
    164   a=g.addArc(n1,n2); cap[a]=10; iflow[a]=0;
    165   a=g.addArc(n2,t); cap[a]=20; iflow[a]=0;
    166 
    167   Preflow<SmartDigraph> pre(g,cap,s,t);
    168   pre.init(iflow);
    169   pre.startFirstPhase();
    170   check(pre.flowValue() == 10, "The incorrect max flow value.");
    171   check(pre.minCut(s), "Wrong min cut (Node s).");
    172   check(pre.minCut(n1), "Wrong min cut (Node n1).");
    173   check(!pre.minCut(n2), "Wrong min cut (Node n2).");
    174   check(!pre.minCut(t), "Wrong min cut (Node t).");
    175 }
    176 
    177 
    178154int main() {
    179155
    … …  
    266242        "The max flow value or the three min cut values are incorrect.");
    267243
    268   initFlowTest();
    269  
    270244  return 0;
    271245}
Note: See TracChangeset for help on using the changeset viewer.