LEMON/LEMON-official Changeset - r674:20dac2104519

CMakeLists.txt

Show inline comments

 		CMAKE_MINIMUM_REQUIRED(VERSION 2.6)
 		IF(EXISTS ${CMAKE_SOURCE_DIR}/cmake/version.cmake)
 		  INCLUDE(${CMAKE_SOURCE_DIR}/cmake/version.cmake)
 		ELSE(EXISTS ${CMAKE_SOURCE_DIR}/cmake/version.cmake)
 		  SET(PROJECT_NAME "LEMON")
 		  SET(PROJECT_VERSION "hg-tip" CACHE STRING "LEMON version string.")
 		ENDIF(EXISTS ${CMAKE_SOURCE_DIR}/cmake/version.cmake)
 		PROJECT(${PROJECT_NAME})
 		SET(CMAKE_MODULE_PATH ${PROJECT_SOURCE_DIR}/cmake)
 		INCLUDE(FindDoxygen)
 		INCLUDE(FindGhostscript)
 		FIND_PACKAGE(GLPK 4.33)
 		FIND_PACKAGE(CPLEX)
 		FIND_PACKAGE(COIN)
 		ADD_DEFINITIONS(-DHAVE_CONFIG_H)
 		IF(MSVC)
 		  SET(CMAKE_CXX_FLAGS "${CMAKE_CXX_FLAGS} /wd4250 /wd4355 /wd4800 /wd4996")
 		# Suppressed warnings:
 		# C4250: 'class1' : inherits 'class2::member' via dominance
 		# C4355: 'this' : used in base member initializer list
 		# C4800: 'type' : forcing value to bool 'true' or 'false' (performance warning)
 		# C4996: 'function': was declared deprecated
 		ENDIF(MSVC)
 		ADD_DEFINITIONS(-DHAVE_CONFIG_H)
 		INCLUDE(CheckTypeSize)
-		CHECK_TYPE_SIZE("long long" LONG_LONG)
+		CHECK_TYPE_SIZE("long long" LEMON_LONG_LONG)
 		ENABLE_TESTING()
 		ADD_SUBDIRECTORY(lemon)
 		IF(${CMAKE_SOURCE_DIR} STREQUAL ${PROJECT_SOURCE_DIR})
 		  ADD_SUBDIRECTORY(demo)
 		  ADD_SUBDIRECTORY(tools)
 		  ADD_SUBDIRECTORY(doc)
 		  ADD_SUBDIRECTORY(test)
 		ENDIF(${CMAKE_SOURCE_DIR} STREQUAL ${PROJECT_SOURCE_DIR})
 		IF(${CMAKE_SOURCE_DIR} STREQUAL ${PROJECT_SOURCE_DIR})
 		  IF(WIN32)
 		    SET(CPACK_PACKAGE_NAME ${PROJECT_NAME})
 		    SET(CPACK_PACKAGE_VENDOR "EGRES")
 		    SET(CPACK_PACKAGE_DESCRIPTION_SUMMARY
 		      "LEMON - Library of Efficient Models and Optimization in Networks")
 		    SET(CPACK_RESOURCE_FILE_LICENSE "${PROJECT_SOURCE_DIR}/LICENSE")
 		    SET(CPACK_PACKAGE_VERSION ${PROJECT_VERSION})
 		    SET(CPACK_PACKAGE_INSTALL_DIRECTORY
 		      "${PROJECT_NAME} ${PROJECT_VERSION}")
 		    SET(CPACK_PACKAGE_INSTALL_REGISTRY_KEY
 		      "${PROJECT_NAME} ${PROJECT_VERSION}")
 		    SET(CPACK_COMPONENTS_ALL headers library html_documentation bin)
 		    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")
 		    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_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_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_GENERATOR "NSIS")
 		    SET(CPACK_NSIS_MUI_ICON "${PROJECT_SOURCE_DIR}/cmake/nsis/lemon.ico")
 		    SET(CPACK_NSIS_MUI_UNIICON "${PROJECT_SOURCE_DIR}/cmake/nsis/uninstall.ico")
 		    #SET(CPACK_PACKAGE_ICON "${PROJECT_SOURCE_DIR}/cmake/nsis\\\\installer.bmp")
 		    SET(CPACK_NSIS_INSTALLED_ICON_NAME "bin\\\\lemon.ico")

cmake/FindCOIN.cmake

Show inline comments

 		SET(COIN_ROOT_DIR "" CACHE PATH "COIN root directory")
 		FIND_PATH(COIN_INCLUDE_DIR coin/CoinUtilsConfig.h
 		  PATHS ${COIN_ROOT_DIR}/include)
 		FIND_LIBRARY(COIN_CBC_LIBRARY libCbc
 		  PATHS ${COIN_ROOT_DIR}/lib)
 		FIND_LIBRARY(COIN_CBC_SOLVER_LIBRARY libCbcSolver
 		  PATHS ${COIN_ROOT_DIR}/lib)
 		FIND_LIBRARY(COIN_CGL_LIBRARY libCgl
 		  PATHS ${COIN_ROOT_DIR}/lib)
 		FIND_LIBRARY(COIN_CLP_LIBRARY libClp
 		  PATHS ${COIN_ROOT_DIR}/lib)
 		FIND_LIBRARY(COIN_COIN_UTILS_LIBRARY libCoinUtils
 		  PATHS ${COIN_ROOT_DIR}/lib)
 		FIND_LIBRARY(COIN_OSI_LIBRARY libOsi
 		  PATHS ${COIN_ROOT_DIR}/lib)
 		FIND_LIBRARY(COIN_OSI_CBC_LIBRARY libOsiCbc
 		  PATHS ${COIN_ROOT_DIR}/lib)
 		FIND_LIBRARY(COIN_OSI_CLP_LIBRARY libOsiClp
 		  PATHS ${COIN_ROOT_DIR}/lib)
 		FIND_LIBRARY(COIN_OSI_VOL_LIBRARY libOsiVol
 		  PATHS ${COIN_ROOT_DIR}/lib)
 		FIND_LIBRARY(COIN_VOL_LIBRARY libVol
 		  PATHS ${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(HAVE_LP TRUE)
 		  SET(HAVE_MIP TRUE)
 		  SET(HAVE_CLP TRUE)
 		  SET(HAVE_CBC TRUE)
 		  SET(LEMON_HAVE_LP TRUE)
 		  SET(LEMON_HAVE_MIP TRUE)
 		  SET(LEMON_HAVE_CLP TRUE)
 		  SET(LEMON_HAVE_CBC TRUE)
 		ENDIF(COIN_FOUND)

cmake/FindCPLEX.cmake

Show inline comments

 		FIND_PATH(CPLEX_INCLUDE_DIR
 		  ilcplex/cplex.h
 		  PATHS "C:/ILOG/CPLEX91/include")
 		FIND_LIBRARY(CPLEX_LIBRARY
 		  NAMES cplex91
 		  PATHS "C:/ILOG/CPLEX91/lib/msvc7/stat_mda")
 		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})
 		ENDIF(CPLEX_FOUND)
 		MARK_AS_ADVANCED(CPLEX_LIBRARY CPLEX_INCLUDE_DIR CPLEX_BIN_DIR)
 		IF(CPLEX_FOUND)
 		  SET(HAVE_LP TRUE)
 		  SET(HAVE_MIP TRUE)
-		  SET(HAVE_CPLEX TRUE)
+		  SET(LEMON_HAVE_LP TRUE)
 		  SET(LEMON_HAVE_MIP TRUE)
 		  SET(LEMON_HAVE_CPLEX TRUE)
 		ENDIF(CPLEX_FOUND)

cmake/FindGLPK.cmake

Show inline comments

 		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)
 		FIND_LIBRARY(GLPK_LIBRARY
 		  NAMES glpk
 		  PATHS ${GLPK_REGKEY}/lib)
 		INCLUDE(FindPackageHandleStandardArgs)
 		FIND_PACKAGE_HANDLE_STANDARD_ARGS(GLPK DEFAULT_MSG GLPK_LIBRARY GLPK_INCLUDE_DIR)
 		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(HAVE_LP TRUE)
 		  SET(HAVE_MIP TRUE)
-		  SET(HAVE_GLPK TRUE)
+		  SET(LEMON_HAVE_LP TRUE)
 		  SET(LEMON_HAVE_MIP TRUE)
 		  SET(LEMON_HAVE_GLPK TRUE)
 		ENDIF(GLPK_FOUND)

configure.ac

Show inline comments

 		dnl Process this file with autoconf to produce a configure script.
 		dnl Version information.
 		m4_define([lemon_version_number],
 			[m4_normalize(esyscmd([echo ${LEMON_VERSION}]))])
 		dnl m4_define([lemon_version_number], [])
 		m4_define([lemon_hg_path], [m4_normalize(esyscmd([./scripts/chg-len.py]))])
 		m4_define([lemon_hg_revision], [m4_normalize(esyscmd([hg id -i]))])
 		m4_define([lemon_version], [ifelse(lemon_version_number(),
 					   [],
 					   [lemon_hg_path().lemon_hg_revision()],
 					   [lemon_version_number()])])
 		AC_PREREQ([2.59])
 		AC_INIT([LEMON], [lemon_version()], [lemon-user@lemon.cs.elte.hu], [lemon])
 		AC_CONFIG_AUX_DIR([build-aux])
 		AC_CONFIG_MACRO_DIR([m4])
 		AM_INIT_AUTOMAKE([-Wall -Werror foreign subdir-objects nostdinc])
 		AC_CONFIG_SRCDIR([lemon/list_graph.h])
 		AC_CONFIG_HEADERS([config.h lemon/config.h])
 		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([HAVE_LONG_LONG], [1], [Define to 1 if you have long long.])
+		  AC_DEFINE([LEMON_HAVE_LONG_LONG], [1], [Define to 1 if you have long long.])
 		fi
 		dnl Checks for programs.
 		AC_PROG_CXX
 		AC_PROG_CXXCPP
 		AC_PROG_INSTALL
 		AC_DISABLE_SHARED
 		AC_PROG_LIBTOOL
 		AC_CHECK_PROG([doxygen_found],[doxygen],[yes],[no])
 		AC_CHECK_PROG([gs_found],[gs],[yes],[no])
 		dnl Detect Intel compiler.
 		AC_MSG_CHECKING([whether we are using the Intel C++ compiler])
 		AC_COMPILE_IFELSE([#ifndef __INTEL_COMPILER
 		choke me
 		#endif], [ICC=[yes]], [ICC=[no]])
 		if test x"$ICC" = x"yes"; then
 		  AC_MSG_RESULT([yes])
 		else
 		  AC_MSG_RESULT([no])
 		fi
 		dnl Set custom compiler flags when using g++.
 		if test "$GXX" = yes -a "$ICC" = no; then
 		  WARNINGCXXFLAGS="-Wall -W -Wall -W -Wunused -Wformat=2 -Wctor-dtor-privacy -Wnon-virtual-dtor -Wno-char-subscripts -Wwrite-strings -Wno-char-subscripts -Wreturn-type -Wcast-qual -Wcast-align -Wsign-promo -Woverloaded-virtual -ansi -fno-strict-aliasing -Wold-style-cast -Wno-unknown-pragmas"
 		fi
 		AC_SUBST([WARNINGCXXFLAGS])
 		dnl Checks for libraries.
 		LX_CHECK_GLPK
 		LX_CHECK_CPLEX
 		LX_CHECK_SOPLEX
 		LX_CHECK_COIN
 		AM_CONDITIONAL([HAVE_LP], [test x"$lx_lp_found" = x"yes"])
 		AM_CONDITIONAL([HAVE_MIP], [test x"$lx_mip_found" = x"yes"])
 		dnl Disable/enable building the binary tools.
 		AC_ARG_ENABLE([tools],
 		AS_HELP_STRING([--enable-tools], [build additional tools @<:@default@:>@])
 		AS_HELP_STRING([--disable-tools], [do not build additional tools]),
 		              [], [enable_tools=yes])
 		AC_MSG_CHECKING([whether to build the additional tools])
 		if test x"$enable_tools" != x"no"; then
 		  AC_MSG_RESULT([yes])
 		else
 		  AC_MSG_RESULT([no])
 		fi
 		AM_CONDITIONAL([WANT_TOOLS], [test x"$enable_tools" != x"no"])
 		dnl Checks for header files.
 		AC_CHECK_HEADERS(limits.h sys/time.h sys/times.h unistd.h)
 		dnl Checks for typedefs, structures, and compiler characteristics.
 		AC_C_CONST
 		AC_C_INLINE
 		AC_TYPE_SIZE_T
 		AC_HEADER_TIME
 		AC_STRUCT_TM
 		dnl Checks for library functions.
 		AC_HEADER_STDC
 		AC_CHECK_FUNCS(gettimeofday times ctime_r)

lemon/CMakeLists.txt

Show inline comments

 		INCLUDE_DIRECTORIES(
 		  ${PROJECT_SOURCE_DIR}
 		  ${PROJECT_BINARY_DIR}
+		)
 		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
 		  lp_base.cc
 		  lp_skeleton.cc
 		  random.cc
 		  bits/windows.cc
+		)
-		IF(HAVE_GLPK)
+		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(WIN32)
-		ENDIF(HAVE_GLPK)
+		ENDIF(LEMON_HAVE_GLPK)
-		IF(HAVE_CPLEX)
+		IF(LEMON_HAVE_CPLEX)
 		  SET(LEMON_SOURCES ${LEMON_SOURCES} cplex.cc)
 		  INCLUDE_DIRECTORIES(${CPLEX_INCLUDE_DIRS})
-		ENDIF(HAVE_CPLEX)
+		ENDIF(LEMON_HAVE_CPLEX)
-		IF(HAVE_CLP)
+		IF(LEMON_HAVE_CLP)
 		  SET(LEMON_SOURCES ${LEMON_SOURCES} clp.cc)
 		  INCLUDE_DIRECTORIES(${COIN_INCLUDE_DIRS})
-		ENDIF(HAVE_CLP)
+		ENDIF(LEMON_HAVE_CLP)
-		IF(HAVE_CBC)
+		IF(LEMON_HAVE_CBC)
 		  SET(LEMON_SOURCES ${LEMON_SOURCES} cbc.cc)
 		  INCLUDE_DIRECTORIES(${COIN_INCLUDE_DIRS})
-		ENDIF(HAVE_CBC)
+		ENDIF(LEMON_HAVE_CBC)
 		ADD_LIBRARY(lemon ${LEMON_SOURCES})
 		INSTALL(
 		  TARGETS lemon
 		  ARCHIVE DESTINATION lib
 		  COMPONENT library)
 		INSTALL(
 		  DIRECTORY . bits concepts
 		  DESTINATION include/lemon
 		  COMPONENT headers
 		  FILES_MATCHING PATTERN "*.h")
 		INSTALL(
 		  FILES ${CMAKE_CURRENT_BINARY_DIR}/config.h
 		  DESTINATION include/lemon
 		  COMPONENT headers)

lemon/Makefile.am

Show inline comments

 		EXTRA_DIST += \
 			lemon/lemon.pc.in \
 			lemon/CMakeLists.txt
 		pkgconfig_DATA += lemon/lemon.pc
 		lib_LTLIBRARIES += lemon/libemon.la
 		lemon_libemon_la_SOURCES = \
 			lemon/arg_parser.cc \
 			lemon/base.cc \
 			lemon/color.cc \
 			lemon/lp_base.cc \
 			lemon/lp_skeleton.cc \
 			lemon/random.cc \
 			lemon/bits/windows.cc
 		lemon_libemon_la_CXXFLAGS = \
 			$(AM_CXXFLAGS) \
 			$(GLPK_CFLAGS) \
 			$(CPLEX_CFLAGS) \
 			$(SOPLEX_CXXFLAGS) \
 			$(CLP_CXXFLAGS) \
 			$(CBC_CXXFLAGS)
 		lemon_libemon_la_LDFLAGS = \
 			$(GLPK_LIBS) \
 			$(CPLEX_LIBS) \
 			$(SOPLEX_LIBS) \
 			$(CLP_LIBS) \
 			$(CBC_LIBS)
 		if HAVE_GLPK
 		lemon_libemon_la_SOURCES += lemon/glpk.cc
 		endif
 		if HAVE_CPLEX
 		lemon_libemon_la_SOURCES += lemon/cplex.cc
 		endif
 		if HAVE_SOPLEX
 		lemon_libemon_la_SOURCES += lemon/soplex.cc
 		endif
 		if HAVE_CLP
 		lemon_libemon_la_SOURCES += lemon/clp.cc
 		endif
 		if HAVE_CBC
 		lemon_libemon_la_SOURCES += lemon/cbc.cc
 		endif
 		lemon_HEADERS += \
 			lemon/adaptors.h \
 			lemon/arg_parser.h \
 			lemon/assert.h \
 			lemon/bfs.h \
 			lemon/bin_heap.h \
 			lemon/circulation.h \
 			lemon/clp.h \
 			lemon/color.h \
 			lemon/concept_check.h \
 			lemon/config.h \
 			lemon/connectivity.h \
 			lemon/counter.h \
 			lemon/core.h \
 			lemon/cplex.h \
 			lemon/dfs.h \
 			lemon/dijkstra.h \
 			lemon/dim2.h \
 			lemon/dimacs.h \
 			lemon/edge_set.h \
 			lemon/elevator.h \
 			lemon/error.h \
 			lemon/euler.h \
 			lemon/full_graph.h \
 			lemon/glpk.h \
 			lemon/gomory_hu.h \
 			lemon/graph_to_eps.h \
 			lemon/grid_graph.h \
 			lemon/hypercube_graph.h \
 			lemon/kruskal.h \
 			lemon/hao_orlin.h \
 			lemon/lgf_reader.h \
 			lemon/lgf_writer.h \
 			lemon/list_graph.h \
 			lemon/lp.h \
 			lemon/lp_base.h \
 			lemon/lp_skeleton.h \
 			lemon/list_graph.h \
 			lemon/maps.h \
 			lemon/matching.h \
 			lemon/math.h \
 			lemon/min_cost_arborescence.h \
 			lemon/nauty_reader.h \
 			lemon/network_simplex.h \
 			lemon/path.h \
 			lemon/preflow.h \
 			lemon/radix_sort.h \
 			lemon/random.h \
 			lemon/smart_graph.h \
 			lemon/soplex.h \
 			lemon/suurballe.h \
 			lemon/time_measure.h \
 			lemon/tolerance.h \
 			lemon/unionfind.h \
 			lemon/bits/windows.h
 		bits_HEADERS += \
 			lemon/bits/alteration_notifier.h \
 			lemon/bits/array_map.h \
 			lemon/bits/base_extender.h \
 			lemon/bits/bezier.h \
 			lemon/bits/default_map.h \
 			lemon/bits/edge_set_extender.h \
 			lemon/bits/enable_if.h \
 			lemon/bits/graph_adaptor_extender.h \
 			lemon/bits/graph_extender.h \
 			lemon/bits/map_extender.h \
 			lemon/bits/path_dump.h \
 			lemon/bits/solver_bits.h \
 			lemon/bits/traits.h \
 			lemon/bits/variant.h \
 			lemon/bits/vector_map.h
 		concept_HEADERS += \
 			lemon/concepts/digraph.h \

lemon/bits/default_map.h

Show inline comments

@@ -36,129 +36,129 @@
 		  template <typename _Graph, typename _Item, typename _Value>
 		  struct DefaultMapSelector {
 		    typedef ArrayMap<_Graph, _Item, _Value> Map;
 		  };
 		  // bool
 		  template <typename _Graph, typename _Item>
 		  struct DefaultMapSelector<_Graph, _Item, bool> {
 		    typedef VectorMap<_Graph, _Item, bool> Map;
 		  };
 		  // char
 		  template <typename _Graph, typename _Item>
 		  struct DefaultMapSelector<_Graph, _Item, char> {
 		    typedef VectorMap<_Graph, _Item, char> Map;
 		  };
 		  template <typename _Graph, typename _Item>
 		  struct DefaultMapSelector<_Graph, _Item, signed char> {
 		    typedef VectorMap<_Graph, _Item, signed char> Map;
 		  };
 		  template <typename _Graph, typename _Item>
 		  struct DefaultMapSelector<_Graph, _Item, unsigned char> {
 		    typedef VectorMap<_Graph, _Item, unsigned char> Map;
 		  };
 		  // int
 		  template <typename _Graph, typename _Item>
 		  struct DefaultMapSelector<_Graph, _Item, signed int> {
 		    typedef VectorMap<_Graph, _Item, signed int> Map;
 		  };
 		  template <typename _Graph, typename _Item>
 		  struct DefaultMapSelector<_Graph, _Item, unsigned int> {
 		    typedef VectorMap<_Graph, _Item, unsigned int> Map;
 		  };
 		  // short
 		  template <typename _Graph, typename _Item>
 		  struct DefaultMapSelector<_Graph, _Item, signed short> {
 		    typedef VectorMap<_Graph, _Item, signed short> Map;
 		  };
 		  template <typename _Graph, typename _Item>
 		  struct DefaultMapSelector<_Graph, _Item, unsigned short> {
 		    typedef VectorMap<_Graph, _Item, unsigned short> Map;
 		  };
 		  // long
 		  template <typename _Graph, typename _Item>
 		  struct DefaultMapSelector<_Graph, _Item, signed long> {
 		    typedef VectorMap<_Graph, _Item, signed long> Map;
 		  };
 		  template <typename _Graph, typename _Item>
 		  struct DefaultMapSelector<_Graph, _Item, unsigned long> {
 		    typedef VectorMap<_Graph, _Item, unsigned long> Map;
 		  };
-		#if defined HAVE_LONG_LONG
+		#if defined LEMON_HAVE_LONG_LONG
 		  // long long
 		  template <typename _Graph, typename _Item>
 		  struct DefaultMapSelector<_Graph, _Item, signed long long> {
 		    typedef VectorMap<_Graph, _Item, signed long long> Map;
 		  };
 		  template <typename _Graph, typename _Item>
 		  struct DefaultMapSelector<_Graph, _Item, unsigned long long> {
 		    typedef VectorMap<_Graph, _Item, unsigned long long> Map;
 		  };
 		#endif
 		  // float
 		  template <typename _Graph, typename _Item>
 		  struct DefaultMapSelector<_Graph, _Item, float> {
 		    typedef VectorMap<_Graph, _Item, float> Map;
 		  };
 		  // double
 		  template <typename _Graph, typename _Item>
 		  struct DefaultMapSelector<_Graph, _Item, double> {
 		    typedef VectorMap<_Graph, _Item,  double> Map;
 		  };
 		  // long double
 		  template <typename _Graph, typename _Item>
 		  struct DefaultMapSelector<_Graph, _Item, long double> {
 		    typedef VectorMap<_Graph, _Item, long double> Map;
 		  };
 		  // pointer
 		  template <typename _Graph, typename _Item, typename _Ptr>
 		  struct DefaultMapSelector<_Graph, _Item, _Ptr*> {
 		    typedef VectorMap<_Graph, _Item, _Ptr*> Map;
 		  };
 		// #else
 		//   template <typename _Graph, typename _Item, typename _Value>
 		//   struct DefaultMapSelector {
 		//     typedef DebugMap<_Graph, _Item, _Value> Map;
 		//   };
 		// #endif
 		  // DefaultMap class
 		  template <typename _Graph, typename _Item, typename _Value>
 		  class DefaultMap
 		    : public DefaultMapSelector<_Graph, _Item, _Value>::Map {
 		    typedef typename DefaultMapSelector<_Graph, _Item, _Value>::Map Parent;
 		  public:
 		    typedef DefaultMap<_Graph, _Item, _Value> Map;
 		    typedef typename Parent::GraphType GraphType;
 		    typedef typename Parent::Value Value;
 		    explicit DefaultMap(const GraphType& graph) : Parent(graph) {}

lemon/config.h.cmake

Show inline comments

 		#cmakedefine HAVE_LONG_LONG 1
 		#cmakedefine HAVE_LP 1
 		#cmakedefine HAVE_MIP 1
 		#cmakedefine HAVE_GLPK 1
 		#cmakedefine HAVE_CPLEX 1
 		#cmakedefine HAVE_CLP 1
-		#cmakedefine HAVE_CBC 1
+		#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

lemon/config.h.in

Show inline comments

 		/* Define to 1 if you have long long */
-		#undef 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 HAVE_CBC
+		#undef LEMON_HAVE_CBC

lemon/lp.h

Show inline comments

 		/* -*- 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_LP_H
 		#define LEMON_LP_H
 		#include<lemon/config.h>
-		#ifdef HAVE_GLPK
+		#ifdef LEMON_HAVE_GLPK
 		#include <lemon/glpk.h>
-		#elif HAVE_CPLEX
+		#elif LEMON_HAVE_CPLEX
 		#include <lemon/cplex.h>
-		#elif HAVE_SOPLEX
+		#elif LEMON_HAVE_SOPLEX
 		#include <lemon/soplex.h>
-		#elif HAVE_CLP
+		#elif LEMON_HAVE_CLP
 		#include <lemon/clp.h>
 		#endif
 		///\file
 		///\brief Defines a default LP solver
 		///\ingroup lp_group
 		namespace lemon {
 		#ifdef DOXYGEN
 		  ///The default LP solver identifier
 		  ///The default LP solver identifier.
 		  ///\ingroup lp_group
 		  ///
 		  ///Currently, the possible values are \c GLPK, \c CPLEX,
 		  ///\c SOPLEX or \c CLP
 		#define LEMON_DEFAULT_LP SOLVER
 		  ///The default LP solver
 		  ///The default LP solver.
 		  ///\ingroup lp_group
 		  ///
 		  ///Currently, it is either \c GlpkLp, \c CplexLp, \c SoplexLp or \c ClpLp
 		  typedef GlpkLp Lp;
 		  ///The default MIP solver identifier
 		  ///The default MIP solver identifier.
 		  ///\ingroup lp_group
 		  ///
 		  ///Currently, the possible values are \c GLPK or \c CPLEX
 		#define LEMON_DEFAULT_MIP SOLVER
 		  ///The default MIP solver.
 		  ///The default MIP solver.
 		  ///\ingroup lp_group
 		  ///
 		  ///Currently, it is either \c GlpkMip or \c CplexMip
 		  typedef GlpkMip Mip;
 		#else
-		#ifdef 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
 		#endif
 		} //namespace lemon
 		#endif //LEMON_LP_H

m4/lx_check_coin.m4

Show inline comments

 		AC_DEFUN([LX_CHECK_COIN],
+		[
 		  AC_ARG_WITH([coin],
 		AS_HELP_STRING([--with-coin@<:@=PREFIX@:>@], [search for CLP under PREFIX or under the default search paths if PREFIX is not given @<:@default@:>@])
 		AS_HELP_STRING([--without-coin], [disable checking for CLP]),
 		              [], [with_coin=yes])
 		  AC_ARG_WITH([coin-includedir],
 		AS_HELP_STRING([--with-coin-includedir=DIR], [search for CLP headers in DIR]),
 		              [], [with_coin_includedir=no])
 		  AC_ARG_WITH([coin-libdir],
 		AS_HELP_STRING([--with-coin-libdir=DIR], [search for CLP libraries in DIR]),
 		              [], [with_coin_libdir=no])
 		  lx_clp_found=no
 		  if test x"$with_coin" != x"no"; then
 		    AC_MSG_CHECKING([for CLP])
 		    if test x"$with_coin_includedir" != x"no"; then
 		      CLP_CXXFLAGS="-I$with_coin_includedir"
 		    elif test x"$with_coin" != x"yes"; then
 		      CLP_CXXFLAGS="-I$with_coin/include"
 		    fi
 		    if test x"$with_coin_libdir" != x"no"; then
 		      CLP_LDFLAGS="-L$with_coin_libdir"
 		    elif test x"$with_coin" != x"yes"; then
 		      CLP_LDFLAGS="-L$with_coin/lib"
 		    fi
 		    CLP_LIBS="-lClp -lCoinUtils -lm"
 		    lx_save_cxxflags="$CXXFLAGS"
 		    lx_save_ldflags="$LDFLAGS"
 		    lx_save_libs="$LIBS"
 		    CXXFLAGS="$CLP_CXXFLAGS"
 		    LDFLAGS="$CLP_LDFLAGS"
 		    LIBS="$CLP_LIBS"
 		    lx_clp_test_prog='
 		      #include <coin/ClpModel.hpp>
 		      int main(int argc, char** argv)
+		      {
 		        ClpModel clp;
 		        return 0;
 		      }'
 		    AC_LANG_PUSH(C++)
 		    AC_LINK_IFELSE([$lx_clp_test_prog], [lx_clp_found=yes], [lx_clp_found=no])
 		    AC_LANG_POP(C++)
 		    CXXFLAGS="$lx_save_cxxflags"
 		    LDFLAGS="$lx_save_ldflags"
 		    LIBS="$lx_save_libs"
 		    if test x"$lx_clp_found" = x"yes"; then
-		      AC_DEFINE([HAVE_CLP], [1], [Define to 1 if you have CLP.])
+		      AC_DEFINE([LEMON_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_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 -lOsiCbc -lCbcSolver -lClp -lOsiClp -lCoinUtils -lVol -lOsiVol -lCgl -lm -llapack -lblas"
 		      lx_save_cxxflags="$CXXFLAGS"
 		      lx_save_ldflags="$LDFLAGS"
 		      lx_save_libs="$LIBS"
 		      CXXFLAGS="$CBC_CXXFLAGS"
 		      LDFLAGS="$CBC_LDFLAGS"
 		      LIBS="$CBC_LIBS"
 		      lx_cbc_test_prog='
 		        #include <coin/CbcModel.hpp>
 		        int main(int argc, char** argv)
+		        {
 		          CbcModel cbc;
 		          return 0;
 		        }'
 		      AC_LANG_PUSH(C++)
 		      AC_LINK_IFELSE([$lx_cbc_test_prog], [lx_cbc_found=yes], [lx_cbc_found=no])
 		      AC_LANG_POP(C++)
 		      CXXFLAGS="$lx_save_cxxflags"
 		      LDFLAGS="$lx_save_ldflags"
 		      LIBS="$lx_save_libs"
 		      if test x"$lx_cbc_found" = x"yes"; then
-		        AC_DEFINE([HAVE_CBC], [1], [Define to 1 if you have CBC.])
+		        AC_DEFINE([LEMON_HAVE_CBC], [1], [Define to 1 if you have CBC.])
 		        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
 		        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"])
 		])

m4/lx_check_cplex.m4

Show inline comments

 		AC_DEFUN([LX_CHECK_CPLEX],
+		[
 		  AC_ARG_WITH([cplex],
 		AS_HELP_STRING([--with-cplex@<:@=PREFIX@:>@], [search for CPLEX under PREFIX or under the default search paths if PREFIX is not given @<:@default@:>@])
 		AS_HELP_STRING([--without-cplex], [disable checking for CPLEX]),
 		              [], [with_cplex=yes])
 		  AC_ARG_WITH([cplex-includedir],
 		AS_HELP_STRING([--with-cplex-includedir=DIR], [search for CPLEX headers in DIR]),
 		              [], [with_cplex_includedir=no])
 		  AC_ARG_WITH([cplex-libdir],
 		AS_HELP_STRING([--with-cplex-libdir=DIR], [search for CPLEX libraries in DIR]),
 		              [], [with_cplex_libdir=no])
 		  lx_cplex_found=no
 		  if test x"$with_cplex" != x"no"; then
 		    AC_MSG_CHECKING([for CPLEX])
 		    if test x"$with_cplex_includedir" != x"no"; then
 		      CPLEX_CFLAGS="-I$with_cplex_includedir"
 		    elif test x"$with_cplex" != x"yes"; then
 		      CPLEX_CFLAGS="-I$with_cplex/include"
 		    elif test x"$CPLEX_INCLUDEDIR" != x; then
 		      CPLEX_CFLAGS="-I$CPLEX_INCLUDEDIR"
 		    fi
 		    if test x"$with_cplex_libdir" != x"no"; then
 		      CPLEX_LDFLAGS="-L$with_cplex_libdir"
 		    elif test x"$with_cplex" != x"yes"; then
 		      CPLEX_LDFLAGS="-L$with_cplex/lib"
 		    elif test x"$CPLEX_LIBDIR" != x; then
 		      CPLEX_LDFLAGS="-L$CPLEX_LIBDIR"
 		    fi
 		    CPLEX_LIBS="-lcplex -lm -lpthread"
 		    lx_save_cxxflags="$CXXFLAGS"
 		    lx_save_ldflags="$LDFLAGS"
 		    lx_save_libs="$LIBS"
 		    CXXFLAGS="$CPLEX_CFLAGS"
 		    LDFLAGS="$CPLEX_LDFLAGS"
 		    LIBS="$CPLEX_LIBS"
 		    lx_cplex_test_prog='
 		      extern "C" {
 		      #include <ilcplex/cplex.h>
+		      }
 		      int main(int argc, char** argv)
+		      {
 		        CPXENVptr env = NULL;
 		        return 0;
 		      }'
 		    AC_LANG_PUSH(C++)
 		    AC_LINK_IFELSE([$lx_cplex_test_prog], [lx_cplex_found=yes], [lx_cplex_found=no])
 		    AC_LANG_POP(C++)
 		    CXXFLAGS="$lx_save_cxxflags"
 		    LDFLAGS="$lx_save_ldflags"
 		    LIBS="$lx_save_libs"
 		    if test x"$lx_cplex_found" = x"yes"; then
-		      AC_DEFINE([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=""
 		      CPLEX_LDFLAGS=""
 		      CPLEX_LIBS=""
 		      AC_MSG_RESULT([no])
 		    fi
 		  fi
 		  CPLEX_LIBS="$CPLEX_LDFLAGS $CPLEX_LIBS"
 		  AC_SUBST(CPLEX_CFLAGS)
 		  AC_SUBST(CPLEX_LIBS)
 		  AM_CONDITIONAL([HAVE_CPLEX], [test x"$lx_cplex_found" = x"yes"])
 		])

m4/lx_check_glpk.m4

Show inline comments

@@ -3,82 +3,82 @@
 		  AC_ARG_WITH([glpk],
 		AS_HELP_STRING([--with-glpk@<:@=PREFIX@:>@], [search for GLPK under PREFIX or under the default search paths if PREFIX is not given @<:@default@:>@])
 		AS_HELP_STRING([--without-glpk], [disable checking for GLPK]),
 		              [], [with_glpk=yes])
 		  AC_ARG_WITH([glpk-includedir],
 		AS_HELP_STRING([--with-glpk-includedir=DIR], [search for GLPK headers in DIR]),
 		              [], [with_glpk_includedir=no])
 		  AC_ARG_WITH([glpk-libdir],
 		AS_HELP_STRING([--with-glpk-libdir=DIR], [search for GLPK libraries in DIR]),
 		              [], [with_glpk_libdir=no])
 		  lx_glpk_found=no
 		  if test x"$with_glpk" != x"no"; then
 		    AC_MSG_CHECKING([for GLPK])
 		    if test x"$with_glpk_includedir" != x"no"; then
 		      GLPK_CFLAGS="-I$with_glpk_includedir"
 		    elif test x"$with_glpk" != x"yes"; then
 		      GLPK_CFLAGS="-I$with_glpk/include"
 		    fi
 		    if test x"$with_glpk_libdir" != x"no"; then
 		      GLPK_LDFLAGS="-L$with_glpk_libdir"
 		    elif test x"$with_glpk" != x"yes"; then
 		      GLPK_LDFLAGS="-L$with_glpk/lib"
 		    fi
 		    GLPK_LIBS="-lglpk"
 		    lx_save_cxxflags="$CXXFLAGS"
 		    lx_save_ldflags="$LDFLAGS"
 		    lx_save_libs="$LIBS"
 		    CXXFLAGS="$GLPK_CFLAGS"
 		    LDFLAGS="$GLPK_LDFLAGS"
 		    LIBS="$GLPK_LIBS"
 		    lx_glpk_test_prog='
 		      extern "C" {
 		      #include <glpk.h>
+		      }
 		      #if (GLP_MAJOR_VERSION < 4) \
 		         || (GLP_MAJOR_VERSION == 4 && GLP_MINOR_VERSION < 33)
 		      #error Supported GLPK versions: 4.33 or above
 		      #endif
 		      int main(int argc, char** argv)
+		      {
 		        LPX *lp;
 		        lp = lpx_create_prob();
 		        lpx_delete_prob(lp);
 		        return 0;
 		      }'
 		    AC_LANG_PUSH(C++)
 		    AC_LINK_IFELSE([$lx_glpk_test_prog], [lx_glpk_found=yes], [lx_glpk_found=no])
 		    AC_LANG_POP(C++)
 		    CXXFLAGS="$lx_save_cxxflags"
 		    LDFLAGS="$lx_save_ldflags"
 		    LIBS="$lx_save_libs"
 		    if test x"$lx_glpk_found" = x"yes"; then
-		      AC_DEFINE([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=""
 		      GLPK_LDFLAGS=""
 		      GLPK_LIBS=""
 		      AC_MSG_RESULT([no])
 		    fi
 		  fi
 		  GLPK_LIBS="$GLPK_LDFLAGS $GLPK_LIBS"
 		  AC_SUBST(GLPK_CFLAGS)
 		  AC_SUBST(GLPK_LIBS)
 		  AM_CONDITIONAL([HAVE_GLPK], [test x"$lx_glpk_found" = x"yes"])
 		])

m4/lx_check_soplex.m4

Show inline comments

 		AC_DEFUN([LX_CHECK_SOPLEX],
+		[
 		  AC_ARG_WITH([soplex],
 		AS_HELP_STRING([--with-soplex@<:@=PREFIX@:>@], [search for SOPLEX under PREFIX or under the default search paths if PREFIX is not given @<:@default@:>@])
 		AS_HELP_STRING([--without-soplex], [disable checking for SOPLEX]),
 		              [], [with_soplex=yes])
 		  AC_ARG_WITH([soplex-includedir],
 		AS_HELP_STRING([--with-soplex-includedir=DIR], [search for SOPLEX headers in DIR]),
 		              [], [with_soplex_includedir=no])
 		  AC_ARG_WITH([soplex-libdir],
 		AS_HELP_STRING([--with-soplex-libdir=DIR], [search for SOPLEX libraries in DIR]),
 		              [], [with_soplex_libdir=no])
 		  lx_soplex_found=no
 		  if test x"$with_soplex" != x"no"; then
 		    AC_MSG_CHECKING([for SOPLEX])
 		    if test x"$with_soplex_includedir" != x"no"; then
 		      SOPLEX_CXXFLAGS="-I$with_soplex_includedir"
 		    elif test x"$with_soplex" != x"yes"; then
 		      SOPLEX_CXXFLAGS="-I$with_soplex/src"
 		    fi
 		    if test x"$with_soplex_libdir" != x"no"; then
 		      SOPLEX_LDFLAGS="-L$with_soplex_libdir"
 		    elif test x"$with_soplex" != x"yes"; then
 		      SOPLEX_LDFLAGS="-L$with_soplex/lib"
 		    fi
 		    SOPLEX_LIBS="-lsoplex -lz"
 		    lx_save_cxxflags="$CXXFLAGS"
 		    lx_save_ldflags="$LDFLAGS"
 		    lx_save_libs="$LIBS"
 		    CXXFLAGS="$SOPLEX_CXXFLAGS"
 		    LDFLAGS="$SOPLEX_LDFLAGS"
 		    LIBS="$SOPLEX_LIBS"
 		    lx_soplex_test_prog='
 		      #include <soplex.h>
 		      int main(int argc, char** argv)
+		      {
 		        soplex::SoPlex soplex;
 		        return 0;
 		      }'
 		    AC_LANG_PUSH(C++)
 		    AC_LINK_IFELSE([$lx_soplex_test_prog], [lx_soplex_found=yes], [lx_soplex_found=no])
 		    AC_LANG_POP(C++)
 		    CXXFLAGS="$lx_save_cxxflags"
 		    LDFLAGS="$lx_save_ldflags"
 		    LIBS="$lx_save_libs"
 		    if test x"$lx_soplex_found" = x"yes"; then
-		      AC_DEFINE([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=""
 		      SOPLEX_LDFLAGS=""
 		      SOPLEX_LIBS=""
 		      AC_MSG_RESULT([no])
 		    fi
 		  fi
 		  SOPLEX_LIBS="$SOPLEX_LDFLAGS $SOPLEX_LIBS"
 		  AC_SUBST(SOPLEX_CXXFLAGS)
 		  AC_SUBST(SOPLEX_LIBS)
 		  AM_CONDITIONAL([HAVE_SOPLEX], [test x"$lx_soplex_found" = x"yes"])
 		])

test/CMakeLists.txt

Show inline comments

 		INCLUDE_DIRECTORIES(
 		  ${PROJECT_SOURCE_DIR}
 		  ${PROJECT_BINARY_DIR}
+		)
 		LINK_DIRECTORIES(${PROJECT_BINARY_DIR}/lemon)
 		SET(TESTS
 		  adaptors_test
 		  bfs_test
 		  circulation_test
 		  counter_test
 		  dfs_test
 		  digraph_test
 		  dijkstra_test
 		  dim_test
 		  edge_set_test
 		  error_test
 		  euler_test
 		  gomory_hu_test
 		  graph_copy_test
 		  graph_test
 		  graph_utils_test
 		  hao_orlin_test
 		  heap_test
 		  kruskal_test
 		  maps_test
 		  matching_test
 		  min_cost_arborescence_test
 		  min_cost_flow_test
 		  path_test
 		  preflow_test
 		  radix_sort_test
 		  random_test
 		  suurballe_test
 		  time_measure_test
 		  unionfind_test)
-		IF(HAVE_LP)
+		IF(LEMON_HAVE_LP)
 		  ADD_EXECUTABLE(lp_test lp_test.cc)
 		  SET(LP_TEST_LIBS lemon)
-		  IF(HAVE_GLPK)
+		  IF(LEMON_HAVE_GLPK)
 		    SET(LP_TEST_LIBS ${LP_TEST_LIBS} ${GLPK_LIBRARIES})
 		  ENDIF(HAVE_GLPK)
 		  IF(HAVE_CPLEX)
 		  ENDIF(LEMON_HAVE_GLPK)
 		  IF(LEMON_HAVE_CPLEX)
 		    SET(LP_TEST_LIBS ${LP_TEST_LIBS} ${CPLEX_LIBRARIES})
 		  ENDIF(HAVE_CPLEX)
 		  IF(HAVE_CLP)
 		  ENDIF(LEMON_HAVE_CPLEX)
 		  IF(LEMON_HAVE_CLP)
 		    SET(LP_TEST_LIBS ${LP_TEST_LIBS} ${COIN_CLP_LIBRARIES})
-		  ENDIF(HAVE_CLP)
+		  ENDIF(LEMON_HAVE_CLP)
 		  TARGET_LINK_LIBRARIES(lp_test ${LP_TEST_LIBS})
 		  ADD_TEST(lp_test lp_test)
-		  IF(WIN32 AND HAVE_GLPK)
+		  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 -E copy ${GLPK_BIN_DIR}/glpk.dll ${TARGET_PATH}
 		      COMMAND cmake -E copy ${GLPK_BIN_DIR}/libltdl3.dll ${TARGET_PATH}
 		      COMMAND cmake -E copy ${GLPK_BIN_DIR}/zlib1.dll ${TARGET_PATH}
+		    )
 		  ENDIF(WIN32 AND HAVE_GLPK)
 		  IF(WIN32 AND HAVE_CPLEX)
 		  ENDIF(WIN32 AND LEMON_HAVE_GLPK)
 		  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 -E copy ${CPLEX_BIN_DIR}/cplex91.dll ${TARGET_PATH}
+		    )
 		  ENDIF(WIN32 AND HAVE_CPLEX)
 		ENDIF(HAVE_LP)
 		  ENDIF(WIN32 AND LEMON_HAVE_CPLEX)
 		ENDIF(LEMON_HAVE_LP)
-		IF(HAVE_MIP)
+		IF(LEMON_HAVE_MIP)
 		  ADD_EXECUTABLE(mip_test mip_test.cc)
 		  SET(MIP_TEST_LIBS lemon)
-		  IF(HAVE_GLPK)
+		  IF(LEMON_HAVE_GLPK)
 		    SET(MIP_TEST_LIBS ${MIP_TEST_LIBS} ${GLPK_LIBRARIES})
 		  ENDIF(HAVE_GLPK)
 		  IF(HAVE_CPLEX)
 		  ENDIF(LEMON_HAVE_GLPK)
 		  IF(LEMON_HAVE_CPLEX)
 		    SET(MIP_TEST_LIBS ${MIP_TEST_LIBS} ${CPLEX_LIBRARIES})
 		  ENDIF(HAVE_CPLEX)
 		  IF(HAVE_CBC)
 		  ENDIF(LEMON_HAVE_CPLEX)
 		  IF(LEMON_HAVE_CBC)
 		    SET(MIP_TEST_LIBS ${MIP_TEST_LIBS} ${COIN_CBC_LIBRARIES})
-		  ENDIF(HAVE_CBC)
+		  ENDIF(LEMON_HAVE_CBC)
 		  TARGET_LINK_LIBRARIES(mip_test ${MIP_TEST_LIBS})
 		  ADD_TEST(mip_test mip_test)
-		  IF(WIN32 AND HAVE_GLPK)
+		  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 -E copy ${GLPK_BIN_DIR}/glpk.dll ${TARGET_PATH}
 		      COMMAND cmake -E copy ${GLPK_BIN_DIR}/libltdl3.dll ${TARGET_PATH}
 		      COMMAND cmake -E copy ${GLPK_BIN_DIR}/zlib1.dll ${TARGET_PATH}
+		    )
 		  ENDIF(WIN32 AND HAVE_GLPK)
 		  IF(WIN32 AND HAVE_CPLEX)
 		  ENDIF(WIN32 AND LEMON_HAVE_GLPK)
 		  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 -E copy ${CPLEX_BIN_DIR}/cplex91.dll ${TARGET_PATH}
+		    )
 		  ENDIF(WIN32 AND HAVE_CPLEX)
 		ENDIF(HAVE_MIP)
 		  ENDIF(WIN32 AND LEMON_HAVE_CPLEX)
 		ENDIF(LEMON_HAVE_MIP)
 		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)

test/lp_test.cc

Show inline comments

 		/* -*- mode: C++; indent-tabs-mode: nil; -*-
+		 *
 		 * This file is a part of LEMON, a generic C++ optimization library.
+		 *
 		 * Copyright (C) 2003-2009
 		 * Egervary Jeno Kombinatorikus Optimalizalasi Kutatocsoport
 		 * (Egervary Research Group on Combinatorial Optimization, EGRES).
+		 *
 		 * Permission to use, modify and distribute this software is granted
 		 * provided that this copyright notice appears in all copies. For
 		 * precise terms see the accompanying LICENSE file.
+		 *
 		 * This software is provided "AS IS" with no warranty of any kind,
 		 * express or implied, and with no claim as to its suitability for any
 		 * purpose.
+		 *
 		 */
 		#include <sstream>
 		#include <lemon/lp_skeleton.h>
 		#include "test_tools.h"
 		#include <lemon/tolerance.h>
 		#ifdef HAVE_CONFIG_H
 		#include <lemon/config.h>
 		#endif
-		#ifdef HAVE_GLPK
+		#ifdef LEMON_HAVE_GLPK
 		#include <lemon/glpk.h>
 		#endif
-		#ifdef HAVE_CPLEX
+		#ifdef LEMON_HAVE_CPLEX
 		#include <lemon/cplex.h>
 		#endif
-		#ifdef HAVE_SOPLEX
+		#ifdef LEMON_HAVE_SOPLEX
 		#include <lemon/soplex.h>
 		#endif
-		#ifdef HAVE_CLP
+		#ifdef LEMON_HAVE_CLP
 		#include <lemon/clp.h>
 		#endif
 		using namespace lemon;
 		void lpTest(LpSolver& lp)
+		{
 		  typedef LpSolver LP;
 		  std::vector<LP::Col> x(10);
 		  //  for(int i=0;i<10;i++) x.push_back(lp.addCol());
 		  lp.addColSet(x);
 		  lp.colLowerBound(x,1);
 		  lp.colUpperBound(x,1);
 		  lp.colBounds(x,1,2);
 		  std::vector<LP::Col> y(10);
 		  lp.addColSet(y);
 		  lp.colLowerBound(y,1);
 		  lp.colUpperBound(y,1);
 		  lp.colBounds(y,1,2);
 		  std::map<int,LP::Col> z;
 		  z.insert(std::make_pair(12,INVALID));
 		  z.insert(std::make_pair(2,INVALID));
 		  z.insert(std::make_pair(7,INVALID));
 		  z.insert(std::make_pair(5,INVALID));
 		  lp.addColSet(z);
 		  lp.colLowerBound(z,1);
 		  lp.colUpperBound(z,1);
 		  lp.colBounds(z,1,2);
+		  {
 		    LP::Expr e,f,g;
 		    LP::Col p1,p2,p3,p4,p5;
 		    LP::Constr c;
 		    p1=lp.addCol();
 		    p2=lp.addCol();
 		    p3=lp.addCol();
 		    p4=lp.addCol();
 		    p5=lp.addCol();
 		    e[p1]=2;
 		    *e=12;
 		    e[p1]+=2;
 		    *e+=12;
 		    e[p1]-=2;
 		    *e-=12;
 		    e=2;
 		    e=2.2;
 		    e=p1;
 		    e=f;
 		    e+=2;
 		    e+=2.2;
 		    e+=p1;
 		    e+=f;
@@ -318,104 +318,104 @@
 		  //  std::cout<<lp.colLowerBound(x1)<<std::endl;
 		  check(clp->colLowerBound(x1)==0,
 		        "The lower bound for variable x1 should be 0.");
 		  check(clp->colUpperBound(x1)==LpSolver::INF,
 		        "The upper bound for variable x1 should be infty.");
 		  check(lp.rowLowerBound(upright)==-LpSolver::INF,
 		        "The lower bound for the first row should be -infty.");
 		  check(lp.rowUpperBound(upright)==1,
 		        "The upper bound for the first row should be 1.");
 		  e = clp->row(upright);
 		  check(e[x1] == 1, "The first coefficient should 1.");
 		  check(e[x2] == 1, "The second coefficient should 1.");
 		  de = clp->col(x1);
 		  check(de[upright] == 1, "The first coefficient should 1.");
 		  delete clp;
 		  //Maximization of x1+x2
 		  //over the triangle with vertices (0,0) (0,1) (1,0)
 		  double expected_opt=1;
 		  solveAndCheck(lp, LpSolver::OPTIMAL, expected_opt);
 		  //Minimization
 		  lp.sense(lp.MIN);
 		  expected_opt=0;
 		  solveAndCheck(lp, LpSolver::OPTIMAL, expected_opt);
 		  //Vertex (-1,0) instead of (0,0)
 		  lp.colLowerBound(x1, -LpSolver::INF);
 		  expected_opt=-1;
 		  solveAndCheck(lp, LpSolver::OPTIMAL, expected_opt);
 		  //Erase one constraint and return to maximization
 		  lp.erase(upright);
 		  lp.sense(lp.MAX);
 		  expected_opt=LpSolver::INF;
 		  solveAndCheck(lp, LpSolver::UNBOUNDED, expected_opt);
 		  //Infeasibilty
 		  lp.addRow(x1+x2 <=-2);
 		  solveAndCheck(lp, LpSolver::INFEASIBLE, expected_opt);
+		}
 		template<class LP>
 		void cloneTest()
+		{
 		  //Test for clone/new
 		  LP* lp = new LP();
 		  LP* lpnew = lp->newSolver();
 		  LP* lpclone = lp->cloneSolver();
 		  delete lp;
 		  delete lpnew;
 		  delete lpclone;
+		}
 		int main()
+		{
 		  LpSkeleton lp_skel;
 		  lpTest(lp_skel);
-		#ifdef HAVE_GLPK
+		#ifdef LEMON_HAVE_GLPK
+		  {
 		    GlpkLp lp_glpk1,lp_glpk2;
 		    lpTest(lp_glpk1);
 		    aTest(lp_glpk2);
 		    cloneTest<GlpkLp>();
+		  }
 		#endif
-		#ifdef HAVE_CPLEX
+		#ifdef LEMON_HAVE_CPLEX
 		  try {
 		    CplexLp lp_cplex1,lp_cplex2;
 		    lpTest(lp_cplex1);
 		    aTest(lp_cplex2);
 		    cloneTest<CplexLp>();
 		  } catch (CplexEnv::LicenseError& error) {
 		    check(false, error.what());
+		  }
 		#endif
-		#ifdef HAVE_SOPLEX
+		#ifdef LEMON_HAVE_SOPLEX
+		  {
 		    SoplexLp lp_soplex1,lp_soplex2;
 		    lpTest(lp_soplex1);
 		    aTest(lp_soplex2);
 		    cloneTest<SoplexLp>();
+		  }
 		#endif
-		#ifdef HAVE_CLP
+		#ifdef LEMON_HAVE_CLP
+		  {
 		    ClpLp lp_clp1,lp_clp2;
 		    lpTest(lp_clp1);
 		    aTest(lp_clp2);
 		    cloneTest<ClpLp>();
+		  }
 		#endif
 		  return 0;
+		}

test/mip_test.cc

Show inline comments

 		/* -*- mode: C++; indent-tabs-mode: nil; -*-
+		 *
 		 * This file is a part of LEMON, a generic C++ optimization library.
+		 *
 		 * Copyright (C) 2003-2009
 		 * Egervary Jeno Kombinatorikus Optimalizalasi Kutatocsoport
 		 * (Egervary Research Group on Combinatorial Optimization, EGRES).
+		 *
 		 * Permission to use, modify and distribute this software is granted
 		 * provided that this copyright notice appears in all copies. For
 		 * precise terms see the accompanying LICENSE file.
+		 *
 		 * This software is provided "AS IS" with no warranty of any kind,
 		 * express or implied, and with no claim as to its suitability for any
 		 * purpose.
+		 *
 		 */
 		#include "test_tools.h"
 		#ifdef HAVE_CONFIG_H
 		#include <lemon/config.h>
 		#endif
-		#ifdef HAVE_CPLEX
+		#ifdef LEMON_HAVE_CPLEX
 		#include <lemon/cplex.h>
 		#endif
-		#ifdef HAVE_GLPK
+		#ifdef LEMON_HAVE_GLPK
 		#include <lemon/glpk.h>
 		#endif
-		#ifdef HAVE_CBC
+		#ifdef LEMON_HAVE_CBC
 		#include <lemon/cbc.h>
 		#endif
 		using namespace lemon;
 		void solveAndCheck(MipSolver& mip, MipSolver::ProblemType stat,
 		                   double exp_opt) {
 		  using std::string;
 		  mip.solve();
 		  //int decimal,sign;
 		  std::ostringstream buf;
 		  buf << "Type should be: " << int(stat)<<" and it is "<<int(mip.type());
 		  //  itoa(stat,buf1, 10);
 		  check(mip.type()==stat, buf.str());
 		  if (stat ==  MipSolver::OPTIMAL) {
 		    std::ostringstream sbuf;
 		    buf << "Wrong optimal value: the right optimum is " << exp_opt;
 		    check(std::abs(mip.solValue()-exp_opt) < 1e-3, sbuf.str());
 		    //+ecvt(exp_opt,2)
+		  }
+		}
 		void aTest(MipSolver& mip)
+		{
 		  //The following example is very simple
 		  typedef MipSolver::Row Row;
 		  typedef MipSolver::Col Col;
 		  Col x1 = mip.addCol();
 		  Col x2 = mip.addCol();
 		  //Objective function
 		  mip.obj(x1);
 		  mip.max();
 		  //Unconstrained optimization
 		  mip.solve();
 		  //Check it out!
 		  //Constraints
 		  mip.addRow(2 * x1 + x2 <= 2);
 		  Row y2 = mip.addRow(x1 - 2 * x2 <= 0);
 		  //Nonnegativity of the variable x1
 		  mip.colLowerBound(x1, 0);
 		  //Maximization of x1
 		  //over the triangle with vertices (0,0),(4/5,2/5),(0,2)
 		  double expected_opt=4.0/5.0;
 		  solveAndCheck(mip, MipSolver::OPTIMAL, expected_opt);
 		  //Restrict x2 to integer
 		  mip.colType(x2,MipSolver::INTEGER);
 		  expected_opt=1.0/2.0;
 		  solveAndCheck(mip, MipSolver::OPTIMAL, expected_opt);
 		  //Restrict both to integer
 		  mip.colType(x1,MipSolver::INTEGER);
 		  expected_opt=0;
 		  solveAndCheck(mip, MipSolver::OPTIMAL, expected_opt);
 		  //Erase a variable
 		  mip.erase(x2);
 		  mip.rowUpperBound(y2, 8);
 		  expected_opt=1;
 		  solveAndCheck(mip, MipSolver::OPTIMAL, expected_opt);
+		}
 		template<class MIP>
 		void cloneTest()
+		{
 		  MIP* mip = new MIP();
 		  MIP* mipnew = mip->newSolver();
 		  MIP* mipclone = mip->cloneSolver();
 		  delete mip;
 		  delete mipnew;
 		  delete mipclone;
+		}
 		int main()
+		{
-		#ifdef HAVE_GLPK
+		#ifdef LEMON_HAVE_GLPK
+		  {
 		    GlpkMip mip1;
 		    aTest(mip1);
 		    cloneTest<GlpkMip>();
+		  }
 		#endif
-		#ifdef HAVE_CPLEX
+		#ifdef LEMON_HAVE_CPLEX
 		  try {
 		    CplexMip mip2;
 		    aTest(mip2);
 		    cloneTest<CplexMip>();
 		  } catch (CplexEnv::LicenseError& error) {
 		    check(false, error.what());
+		  }
 		#endif
-		#ifdef HAVE_CBC
+		#ifdef LEMON_HAVE_CBC
+		  {
 		    CbcMip mip1;
 		    aTest(mip1);
 		    cloneTest<CbcMip>();
+		  }
 		#endif
 		  return 0;
+		}

tools/dimacs-solver.cc

Show inline comments

@@ -139,139 +139,139 @@
 		  Timer ti;
 		  ti.restart();
 		  readDimacsMat(is, g, desc);
 		  if(report) std::cerr << "Read the file: " << ti << '\n';
 		  ti.restart();
 		  MaxMatching<Graph> mat(g);
 		  if(report) std::cerr << "Setup MaxMatching class: " << ti << '\n';
 		  ti.restart();
 		  mat.run();
 		  if(report) std::cerr << "Run MaxMatching: " << ti << '\n';
 		  if(report) std::cerr << "\nCardinality of max matching: "
 		                       << mat.matchingSize() << '\n';
+		}
 		template<class Value>
 		void solve(ArgParser &ap, std::istream &is, std::ostream &os,
 		           DimacsDescriptor &desc)
+		{
 		  std::stringstream iss(static_cast<std::string>(ap["infcap"]));
 		  Value infty;
 		  iss >> infty;
 		  if(iss.fail())
+		    {
 		      std::cerr << "Cannot interpret '"
 		                << static_cast<std::string>(ap["infcap"]) << "' as infinite"
 		                << std::endl;
 		      exit(1);
+		    }
 		  switch(desc.type)
+		    {
 		    case DimacsDescriptor::MIN:
 		      solve_min<Value>(ap,is,os,infty,desc);
 		      break;
 		    case DimacsDescriptor::MAX:
 		      solve_max<Value>(ap,is,os,infty,desc);
 		      break;
 		    case DimacsDescriptor::SP:
 		      solve_sp<Value>(ap,is,os,desc);
 		      break;
 		    case DimacsDescriptor::MAT:
 		      solve_mat(ap,is,os,desc);
 		      break;
 		    default:
 		      break;
+		    }
+		}
 		int main(int argc, const char *argv[]) {
 		  typedef SmartDigraph Digraph;
 		  typedef Digraph::Arc Arc;
 		  std::string inputName;
 		  std::string outputName;
 		  ArgParser ap(argc, argv);
 		  ap.other("[INFILE [OUTFILE]]",
 		           "If either the INFILE or OUTFILE file is missing the standard\n"
 		           "     input/output will be used instead.")
 		    .boolOption("q", "Do not print any report")
 		    .boolOption("int","Use 'int' for capacities, costs etc. (default)")
 		    .optionGroup("datatype","int")
-		#ifdef HAVE_LONG_LONG
+		#ifdef LEMON_HAVE_LONG_LONG
 		    .boolOption("long","Use 'long long' for capacities, costs etc.")
 		    .optionGroup("datatype","long")
 		#endif
 		    .boolOption("double","Use 'double' for capacities, costs etc.")
 		    .optionGroup("datatype","double")
 		    .boolOption("ldouble","Use 'long double' for capacities, costs etc.")
 		    .optionGroup("datatype","ldouble")
 		    .onlyOneGroup("datatype")
 		    .stringOption("infcap","Value used for 'very high' capacities","0")
 		    .run();
 		  std::ifstream input;
 		  std::ofstream output;
 		  switch(ap.files().size())
+		    {
 		    case 2:
 		      output.open(ap.files()[1].c_str());
 		      if (!output) {
 		        throw IoError("Cannot open the file for writing", ap.files()[1]);
+		      }
 		    case 1:
 		      input.open(ap.files()[0].c_str());
 		      if (!input) {
 		        throw IoError("File cannot be found", ap.files()[0]);
+		      }
 		    case 0:
 		      break;
 		    default:
 		      std::cerr << ap.commandName() << ": too many arguments\n";
 		      return 1;
+		    }
 		  std::istream& is = (ap.files().size()<1 ? std::cin : input);
 		  std::ostream& os = (ap.files().size()<2 ? std::cout : output);
 		  DimacsDescriptor desc = dimacsType(is);
 		  if(!ap.given("q"))
+		    {
 		      std::cout << "Problem type: ";
 		      switch(desc.type)
+		        {
 		        case DimacsDescriptor::MIN:
 		          std::cout << "min";
 		          break;
 		        case DimacsDescriptor::MAX:
 		          std::cout << "max";
 		          break;
 		        case DimacsDescriptor::SP:
 		          std::cout << "sp";
 		        case DimacsDescriptor::MAT:
 		          std::cout << "mat";
 		          break;
 		        default:
 		          exit(1);
 		          break;
+		        }
 		      std::cout << "\nNum of nodes: " << desc.nodeNum;
 		      std::cout << "\nNum of arcs:  " << desc.edgeNum;
 		      std::cout << "\n\n";
+		    }
 		  if(ap.given("double"))
 		    solve<double>(ap,is,os,desc);
 		  else if(ap.given("ldouble"))
 		    solve<long double>(ap,is,os,desc);
-		#ifdef HAVE_LONG_LONG
+		#ifdef LEMON_HAVE_LONG_LONG
 		  else if(ap.given("long"))
 		    solve<long long>(ap,is,os,desc);
 		#endif
 		  else solve<int>(ap,is,os,desc);
 		  return 0;
+		}

RhodeCode

Login to your account