RhodeCode

  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)

INCLUDE(CheckTypeSize)

ENABLE_TESTING()

ADD_SUBDIRECTORY(lemon)

IF(${CMAKE_SOURCE_DIR} STREQUAL ${PROJECT_SOURCE_DIR})

  ADD_SUBDIRECTORY(demo)

  ADD_SUBDIRECTORY(tools)

  ADD_SUBDIRECTORY(doc)

  COIN_OSI_LIBRARY

  COIN_OSI_CBC_LIBRARY

  COIN_OSI_CLP_LIBRARY

  COIN_OSI_VOL_LIBRARY

  COIN_VOL_LIBRARY

)

IF(COIN_FOUND)

ENDIF(COIN_FOUND)

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)

ENDIF(CPLEX_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)

ENDIF(GLPK_FOUND)

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

fi

dnl Checks for programs.

AC_PROG_CXX

AC_PROG_CXXCPP

AC_PROG_INSTALL

AC_DISABLE_SHARED

AC_PROG_LIBTOOL

  base.cc

  color.cc

  lp_base.cc

  lp_skeleton.cc

  random.cc

  bits/windows.cc

)

  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)

  SET(LEMON_SOURCES ${LEMON_SOURCES} cplex.cc)

  INCLUDE_DIRECTORIES(${CPLEX_INCLUDE_DIRS})

  SET(LEMON_SOURCES ${LEMON_SOURCES} clp.cc)

  INCLUDE_DIRECTORIES(${COIN_INCLUDE_DIRS})

  SET(LEMON_SOURCES ${LEMON_SOURCES} cbc.cc)

  INCLUDE_DIRECTORIES(${COIN_INCLUDE_DIRS})

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")

	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/connectivity.h \

	lemon/counter.h \

	lemon/core.h \

	lemon/cplex.h \

	lemon/dfs.h \

	lemon/dijkstra.h \

	lemon/dim2.h \

	lemon/dimacs.h \

  };

  template <typename _Graph, typename _Item>

  struct DefaultMapSelector<_Graph, _Item, unsigned long> {

    typedef VectorMap<_Graph, _Item, unsigned long> Map;

  };

  // 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>

/* Define to 1 if you have long long */

/* Define to 1 if you have any LP solver. */

/* Define to 1 if you have any MIP solver. */

/* Define to 1 if you have CPLEX. */

/* Define to 1 if you have GLPK. */

/* Define to 1 if you have SOPLEX */

/* Define to 1 if you have CLP */

/* Define to 1 if you have CBC */

 */

#ifndef LEMON_LP_H

#define LEMON_LP_H

#include<lemon/config.h>

#include <lemon/glpk.h>

#include <lemon/cplex.h>

#include <lemon/soplex.h>

#include <lemon/clp.h>

#endif

///\file

///\brief Defines a default LP solver

///\ingroup lp_group

namespace lemon {

  ///The default MIP solver.

  ///The default MIP solver.

  ///\ingroup lp_group

  ///

  ///Currently, it is either \c GlpkMip or \c CplexMip

  typedef GlpkMip Mip;

#else

# define LEMON_DEFAULT_LP GLPK

  typedef GlpkLp Lp;

# define LEMON_DEFAULT_MIP GLPK

  typedef GlpkMip Mip;

# define LEMON_DEFAULT_LP CPLEX

  typedef CplexLp Lp;

# define LEMON_DEFAULT_MIP CPLEX

  typedef CplexMip Mip;

# define DEFAULT_LP SOPLEX

  typedef SoplexLp Lp;

# define DEFAULT_LP CLP

  typedef ClpLp Lp;  

#endif

#endif

} //namespace lemon

#endif //LEMON_LP_H

    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

      lx_lp_found=yes

      AC_MSG_RESULT([yes])

    else

      CLP_CXXFLAGS=""

      CLP_LDFLAGS=""

      CLP_LIBS=""

      AC_MSG_RESULT([no])

    fi

  fi

      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

        lx_lp_found=yes

        lx_mip_found=yes

        AC_MSG_RESULT([yes])

      else

        CBC_CXXFLAGS=""

        CBC_LDFLAGS=""

        CBC_LIBS=""

        AC_MSG_RESULT([no])

      fi

    fi

    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

      lx_lp_found=yes

      lx_mip_found=yes

      AC_MSG_RESULT([yes])

    else

      CPLEX_CFLAGS=""

      CPLEX_LDFLAGS=""

      CPLEX_LIBS=""

      AC_MSG_RESULT([no])

    fi

  fi

    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

      lx_lp_found=yes

      lx_mip_found=yes

      AC_MSG_RESULT([yes])

    else

      GLPK_CFLAGS=""

      GLPK_LDFLAGS=""

      GLPK_LIBS=""

      AC_MSG_RESULT([no])

    fi

  fi

    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

      lx_lp_found=yes

      AC_MSG_RESULT([yes])

    else

      SOPLEX_CXXFLAGS=""

      SOPLEX_LDFLAGS=""

      SOPLEX_LIBS=""

      AC_MSG_RESULT([no])

    fi

  fi

  path_test

  preflow_test

  radix_sort_test

  random_test

  suurballe_test

  time_measure_test

  unionfind_test)

  ADD_EXECUTABLE(lp_test lp_test.cc)

  SET(LP_TEST_LIBS lemon)

    SET(LP_TEST_LIBS ${LP_TEST_LIBS} ${GLPK_LIBRARIES})

    SET(LP_TEST_LIBS ${LP_TEST_LIBS} ${CPLEX_LIBRARIES})

    SET(LP_TEST_LIBS ${LP_TEST_LIBS} ${COIN_CLP_LIBRARIES})

  TARGET_LINK_LIBRARIES(lp_test ${LP_TEST_LIBS})

  ADD_TEST(lp_test lp_test)

    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}

    )

    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}

    )

  ADD_EXECUTABLE(mip_test mip_test.cc)

  SET(MIP_TEST_LIBS lemon)

    SET(MIP_TEST_LIBS ${MIP_TEST_LIBS} ${GLPK_LIBRARIES})

    SET(MIP_TEST_LIBS ${MIP_TEST_LIBS} ${CPLEX_LIBRARIES})

    SET(MIP_TEST_LIBS ${MIP_TEST_LIBS} ${COIN_CBC_LIBRARIES})

  TARGET_LINK_LIBRARIES(mip_test ${MIP_TEST_LIBS})

  ADD_TEST(mip_test mip_test)

    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}

    )

    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}

    )

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)

#include <lemon/lp_skeleton.h>

#include "test_tools.h"

#include <lemon/tolerance.h>

#ifdef HAVE_CONFIG_H

#include <lemon/config.h>

#endif

#include <lemon/glpk.h>

#endif

#include <lemon/cplex.h>

#endif

#include <lemon/soplex.h>

#endif

#include <lemon/clp.h>

#endif

using namespace lemon;

void lpTest(LpSolver& lp)

{

  delete lpclone;

}

int main()

{

  LpSkeleton lp_skel;

  lpTest(lp_skel);

  {

    GlpkLp lp_glpk1,lp_glpk2;

    lpTest(lp_glpk1);

    aTest(lp_glpk2);

    cloneTest<GlpkLp>();

  }

#endif

  try {

    CplexLp lp_cplex1,lp_cplex2;

    lpTest(lp_cplex1);

    aTest(lp_cplex2);

    cloneTest<CplexLp>();

  } catch (CplexEnv::LicenseError& error) {

    check(false, error.what());

  }

#endif

  {

    SoplexLp lp_soplex1,lp_soplex2;

    lpTest(lp_soplex1);

    aTest(lp_soplex2);

    cloneTest<SoplexLp>();

  }

#endif

  {

    ClpLp lp_clp1,lp_clp2;

    lpTest(lp_clp1);

    aTest(lp_clp2);

    cloneTest<ClpLp>();

  }

#endif

 */

#include "test_tools.h"

#ifdef HAVE_CONFIG_H

#include <lemon/config.h>

#endif

#include <lemon/cplex.h>

#endif

#include <lemon/glpk.h>

#endif

#include <lemon/cbc.h>

#endif

using namespace lemon;

void solveAndCheck(MipSolver& mip, MipSolver::ProblemType stat,

                   double exp_opt) {

  delete mip;

  delete mipnew;

  delete mipclone;

}

int main()

{

  {

    GlpkMip mip1;

    aTest(mip1);

    cloneTest<GlpkMip>();

  }

#endif

  try {

    CplexMip mip2;

    aTest(mip2);

    cloneTest<CplexMip>();

  } catch (CplexEnv::LicenseError& error) {

    check(false, error.what());

  }

#endif

  {

    CbcMip mip1;

    aTest(mip1);

    cloneTest<CbcMip>();

  }

#endif

  return 0;

  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")

    .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")

      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);

  else if(ap.given("long"))

    solve<long long>(ap,is,os,desc);

#endif

  else solve<int>(ap,is,os,desc);

  return 0;

}