RhodeCode

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)

INCLUDE(CheckTypeSize)

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

  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)

ENDIF(COIN_FOUND)

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)

ENDIF(CPLEX_FOUND)

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)

ENDIF(GLPK_FOUND)

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

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

)

SET(LEMON_SOURCES

  arg_parser.cc

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

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

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

  };

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

  };

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

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

#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 {

#ifdef DOXYGEN

  ///The default LP solver identifier

  ///The default LP 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

# 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

        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

      lx_lp_found=yes

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

          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

        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

  fi

  CBC_LIBS="$CBC_LDFLAGS $CBC_LIBS"

  AC_SUBST(CBC_CXXFLAGS)

  AC_SUBST(CBC_LIBS)

        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

      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

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

        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

      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

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

        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

      lx_lp_found=yes

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

  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)

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

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

{

  typedef LpSolver LP;

  std::vector<LP::Col> x(10);

  //  for(int i=0;i<10;i++) x.push_back(lp.addCol());

  LP* lpnew = lp->newSolver();

  LP* lpclone = lp->cloneSolver();

  delete lp;

  delete lpnew;

  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

  return 0;

}

 * 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

#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) {

  using std::string;

  mip.solve();

  //int decimal,sign;

  MIP* mip = new MIP();

  MIP* mipnew = mip->newSolver();

  MIP* mipclone = mip->cloneSolver();

  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;

}

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

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

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

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

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

#endif

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

  return 0;

}