RhodeCode

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

	lemon/min_cost_arborescence.h \

	lemon/nauty_reader.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/concepts/graph.h \

	lemon/concepts/graph_components.h \

	lemon/concepts/heap.h \

	lemon/concepts/maps.h \

	lemon/concepts/path.h

INCLUDE_DIRECTORIES(

  ${PROJECT_SOURCE_DIR}

  ${PROJECT_BINARY_DIR}

)

IF(HAVE_GLPK)

  INCLUDE_DIRECTORIES(${GLPK_INCLUDE_DIR})

ENDIF(HAVE_GLPK)

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

  min_cost_arborescence_test

  path_test

  preflow_test

  radix_sort_test

  random_test

  suurballe_test

  time_measure_test

  unionfind_test)

IF(HAVE_LP)

  ADD_EXECUTABLE(lp_test lp_test.cc)

  IF(HAVE_GLPK)

    TARGET_LINK_LIBRARIES(lp_test lemon ${GLPK_LIBRARIES})

  ENDIF(HAVE_GLPK)

  ADD_TEST(lp_test lp_test)

  IF(WIN32 AND 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)

ENDIF(HAVE_LP)

IF(HAVE_MIP)

  ADD_EXECUTABLE(mip_test mip_test.cc)

  IF(HAVE_GLPK)

    TARGET_LINK_LIBRARIES(mip_test lemon ${GLPK_LIBRARIES})

  ENDIF(HAVE_GLPK)

  ADD_TEST(mip_test mip_test)

  IF(WIN32 AND 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)

ENDIF(HAVE_MIP)

FOREACH(TEST_NAME ${TESTS})

  ADD_EXECUTABLE(${TEST_NAME} ${TEST_NAME}.cc)

  TARGET_LINK_LIBRARIES(${TEST_NAME} lemon)

EXTRA_DIST += \

	test/CMakeLists.txt

noinst_HEADERS += \

	test/graph_test.h \

	test/test_tools.h

check_PROGRAMS += \

	test/adaptors_test \

	test/bfs_test \

	test/circulation_test \

	test/counter_test \

	test/dfs_test \

	test/digraph_test \

	test/dijkstra_test \

	test/dim_test \

	test/edge_set_test \

	test/error_test \

	test/euler_test \

	test/gomory_hu_test \

	test/graph_copy_test \

	test/graph_test \

	test/graph_utils_test \

	test/hao_orlin_test \

	test/heap_test \

	test/kruskal_test \

	test/maps_test \

	test/min_cost_arborescence_test \

	test/path_test \

	test/preflow_test \

	test/radix_sort_test \

	test/random_test \

	test/suurballe_test \

	test/test_tools_fail \

	test/test_tools_pass \

	test/time_measure_test \

	test/unionfind_test

test_test_tools_pass_DEPENDENCIES = demo

if HAVE_LP

check_PROGRAMS += test/lp_test

endif HAVE_LP

if HAVE_MIP

check_PROGRAMS += test/mip_test

endif HAVE_MIP

TESTS += $(check_PROGRAMS)

XFAIL_TESTS += test/test_tools_fail$(EXEEXT)

test_adaptors_test_SOURCES = test/adaptors_test.cc

test_bfs_test_SOURCES = test/bfs_test.cc

test_circulation_test_SOURCES = test/circulation_test.cc

test_counter_test_SOURCES = test/counter_test.cc

test_dfs_test_SOURCES = test/dfs_test.cc

test_digraph_test_SOURCES = test/digraph_test.cc

test_dijkstra_test_SOURCES = test/dijkstra_test.cc

test_dim_test_SOURCES = test/dim_test.cc

test_edge_set_test_SOURCES = test/edge_set_test.cc

test_error_test_SOURCES = test/error_test.cc

test_euler_test_SOURCES = test/euler_test.cc

test_gomory_hu_test_SOURCES = test/gomory_hu_test.cc

test_graph_copy_test_SOURCES = test/graph_copy_test.cc

test_graph_test_SOURCES = test/graph_test.cc

test_graph_utils_test_SOURCES = test/graph_utils_test.cc

test_heap_test_SOURCES = test/heap_test.cc

test_kruskal_test_SOURCES = test/kruskal_test.cc

test_hao_orlin_test_SOURCES = test/hao_orlin_test.cc

test_lp_test_SOURCES = test/lp_test.cc

test_maps_test_SOURCES = test/maps_test.cc

test_mip_test_SOURCES = test/mip_test.cc

test_min_cost_arborescence_test_SOURCES = test/min_cost_arborescence_test.cc

test_path_test_SOURCES = test/path_test.cc

test_preflow_test_SOURCES = test/preflow_test.cc

test_radix_sort_test_SOURCES = test/radix_sort_test.cc

test_suurballe_test_SOURCES = test/suurballe_test.cc

test_random_test_SOURCES = test/random_test.cc

test_test_tools_fail_SOURCES = test/test_tools_fail.cc

test_test_tools_pass_SOURCES = test/test_tools_pass.cc

test_time_measure_test_SOURCES = test/time_measure_test.cc

test_unionfind_test_SOURCES = test/unionfind_test.cc

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

#include <sstream>

#include <vector>

#include <queue>

#include <cstdlib>

#include <lemon/smart_graph.h>

#include <lemon/concepts/graph.h>

#include <lemon/concepts/maps.h>

#include <lemon/lgf_reader.h>

#include <lemon/math.h>

#include "test_tools.h"

using namespace std;

using namespace lemon;

GRAPH_TYPEDEFS(SmartGraph);

const int lgfn = 3;

const std::string lgf[lgfn] = {

  "@nodes\n"

  "label\n"

  "0\n"

  "1\n"

  "2\n"

  "3\n"

  "4\n"

  "5\n"

  "6\n"

  "7\n"

  "@edges\n"

  "     label  weight\n"

  "7 4  0      984\n"

  "0 7  1      73\n"

  "7 1  2      204\n"

  "2 3  3      583\n"

  "2 7  4      565\n"

  "2 1  5      582\n"

  "0 4  6      551\n"

  "2 5  7      385\n"

  "1 5  8      561\n"

  "5 3  9      484\n"

  "7 5  10     904\n"

  "3 6  11     47\n"

  "7 6  12     888\n"

  "3 0  13     747\n"

  "6 1  14     310\n",

  "@nodes\n"

  "label\n"

  "0\n"

  "1\n"

/* -*- mode: C++; indent-tabs-mode: nil; -*-

 *

 * This file is a part of LEMON, a generic C++ optimization library.

 *

 * Copyright (C) 2003-2009

 * Egervary Jeno Kombinatorikus Optimalizalasi Kutatocsoport

 * (Egervary Research Group on Combinatorial Optimization, EGRES).

 *

 * Permission to use, modify and distribute this software is granted

 * provided that this copyright notice appears in all copies. For

 * precise terms see the accompanying LICENSE file.

 *

 * This software is provided "AS IS" with no warranty of any kind,

 * express or implied, and with no claim as to its suitability for any

 * purpose.

 *

 */

///\ingroup tools

///\file

///\brief DIMACS problem solver.

///

/// This program solves various problems given in DIMACS format.

///

/// See

/// \code

///   dimacs-solver --help

/// \endcode

/// for more info on usage.

#include <iostream>

#include <fstream>

#include <cstring>

#include <lemon/smart_graph.h>

#include <lemon/dimacs.h>

#include <lemon/lgf_writer.h>

#include <lemon/time_measure.h>

#include <lemon/arg_parser.h>

#include <lemon/error.h>

#include <lemon/dijkstra.h>

#include <lemon/preflow.h>

using namespace lemon;

typedef SmartDigraph Digraph;

DIGRAPH_TYPEDEFS(Digraph);

typedef SmartGraph Graph;

template<class Value>

void solve_sp(ArgParser &ap, std::istream &is, std::ostream &,

              DimacsDescriptor &desc)

{

  bool report = !ap.given("q");

  Digraph g;

  Node s;

  Digraph::ArcMap<Value> len(g);

  Timer t;

  t.restart();

  readDimacsSp(is, g, len, s, desc);

  if(report) std::cerr << "Read the file: " << t << '\n';

  t.restart();

  Dijkstra<Digraph, Digraph::ArcMap<Value> > dij(g,len);

  if(report) std::cerr << "Setup Dijkstra class: " << t << '\n';

  t.restart();

  dij.run(s);

  if(report) std::cerr << "Run Dijkstra: " << t << '\n';

}

template<class Value>

void solve_max(ArgParser &ap, std::istream &is, std::ostream &,

               Value infty, DimacsDescriptor &desc)

{

  bool report = !ap.given("q");

  Digraph g;

  Node s,t;

  Digraph::ArcMap<Value> cap(g);

  Timer ti;

  ti.restart();

  readDimacsMax(is, g, cap, s, t, infty, desc);

  if(report) std::cerr << "Read the file: " << ti << '\n';

  ti.restart();

  Preflow<Digraph, Digraph::ArcMap<Value> > pre(g,cap,s,t);

  if(report) std::cerr << "Setup Preflow class: " << ti << '\n';

  ti.restart();

  pre.run();

  if(report) std::cerr << "Run Preflow: " << ti << '\n';

  if(report) std::cerr << "\nMax flow value: " << pre.flowValue() << '\n';  

}

void solve_mat(ArgParser &ap, std::istream &is, std::ostream &,