RhodeCode

 * Peter Kovacs <kpeter@inf.elte.hu>

 * Akos Ladanyi <ladanyi@tmit.bme.hu>

 * Marton Makai <marci@cs.elte.hu>

 * Jacint Szabo <jacint@cs.elte.hu>

Again, please visit the history of the old LEMON repository for more

 label  coordinates  size    title

 1      (10,20)      10      "First node"

 2      (80,80)      8       "Second node"

 3      (40,10)      10      "Third node"

\endcode

values. The source and target tokens must be node labels.

\code

 @arcs

         capacity

 1   2   16

 1   3   12

 2   3   18

\endcode

The \c \@edges is just a synonym of \c \@arcs. The \@arcs section can

also store the edge set of an undirected graph. In such case there is

a conventional method for store arc maps in the file, if two columns

can be regarded as the values of an arc map.

The \c \@attributes section contains key-value pairs, each line

consists of two tokens, an attribute name, and then an attribute

value. The value of the attribute could be also a label value of a

node or an edge, or even an edge label prefixed with \c '+' or \c '-',

EXTRA_DIST += \

	lemon/lemon.pc.in \

	lemon/CMakeLists.txt \

	lemon/config.h.cmake

pkgconfig_DATA += lemon/lemon.pc

lib_LTLIBRARIES += lemon/libemon.la

        ++len;

      }

      return len;

    }

    bool empty() const {

    }

    class RevArcIt {

    public:

      RevArcIt() {}

      RevArcIt(Invalid) : path(0), current(INVALID) {}

        ++len;

      }

      return len;

    }

    bool empty() const {

    }

    class RevArcIt {

    public:

      RevArcIt() {}

      RevArcIt(Invalid) : path(0), current(INVALID) {}

    template <typename Digraph, typename Enable = void>

    struct DigraphCopySelector {

      template <typename From, typename NodeRefMap, typename ArcRefMap>

      static void copy(const From& from, Digraph &to,

                       NodeRefMap& nodeRefMap, ArcRefMap& arcRefMap) {

        for (typename From::NodeIt it(from); it != INVALID; ++it) {

          nodeRefMap[it] = to.addNode();

        }

        for (typename From::ArcIt it(from); it != INVALID; ++it) {

          arcRefMap[it] = to.addArc(nodeRefMap[from.source(it)],

                                    nodeRefMap[from.target(it)]);

    template <typename Graph, typename Enable = void>

    struct GraphCopySelector {

      template <typename From, typename NodeRefMap, typename EdgeRefMap>

      static void copy(const From& from, Graph &to,

                       NodeRefMap& nodeRefMap, EdgeRefMap& edgeRefMap) {

        for (typename From::NodeIt it(from); it != INVALID; ++it) {

          nodeRefMap[it] = to.addNode();

        }

        for (typename From::EdgeIt it(from); it != INVALID; ++it) {

          edgeRefMap[it] = to.addEdge(nodeRefMap[from.u(it)],

                                      nodeRefMap[from.v(it)]);

    ///- the distance of \c t from the root in the %DFS tree.

    ///

    ///\pre init() must be called and a root node should be

    ///added with addSource() before using this function.

    void start(Node t)

    {

        processNextArc();

    }

    ///Executes the algorithm until a condition is met.

    ///Executes the algorithm until a condition is met.

    /// - the %DFS path to \c t,

    /// - the distance of \c t from the root in the %DFS tree.

    ///

    /// \pre init() must be called and a root node should be added

    /// with addSource() before using this function.

    void start(Node t) {

        processNextArc();

    }

    /// \brief Executes the algorithm until a condition is met.

    ///

    /// Executes the algorithm until a condition is met.

      char cbuf[26];

      ctime_r(&tv.tv_sec,cbuf);

      os << cbuf;

#else

      os << bits::getWinFormattedDate();

#endif

    }

    if (_autoArcWidthScale) {

      double max_w=0;

      for(ArcIt e(g);e!=INVALID;++e)

        max_w=std::max(double(_arcWidths[e]),max_w);

      if(max_w>EPSILON) {

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

 *

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

 *

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

      {

        std::map<std::string, int> maps;

        std::string map;

        int index = 0;

        while (_reader_bits::readToken(line, map)) {

          if (maps.find(map) != maps.end()) {

            std::ostringstream msg;

            msg << "Multiple occurence of arc map: " << map;

            throw FormatError(msg.str());

          }

          maps.insert(std::make_pair(map, index));

      {

        std::map<std::string, int> maps;

        std::string map;

        int index = 0;

        while (_reader_bits::readToken(line, map)) {

          if (maps.find(map) != maps.end()) {

            std::ostringstream msg;

            msg << "Multiple occurence of edge map: " << map;

            throw FormatError(msg.str());

          }

          maps.insert(std::make_pair(map, index));

  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

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

	test/min_cost_arborescence_test \

	test/min_cost_flow_test \

	test/path_test \

	test/preflow_test \

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_matching_test_SOURCES = test/matching_test.cc

test_min_cost_arborescence_test_SOURCES = test/min_cost_arborescence_test.cc

test_min_cost_flow_test_SOURCES = test/min_cost_flow_test.cc

  "4 2  4\n"

  "4 5  5\n"

  "5 0  6\n"

  "6 3  7\n"

  "@attributes\n"

  "source 0\n"

void checkDfsCompile()

{

  typedef concepts::Digraph Digraph;

  typedef Dfs<Digraph> DType;

  typedef Digraph::Node Node;

template <class Digraph>

void checkDfs() {

  TEMPLATE_DIGRAPH_TYPEDEFS(Digraph);

  Digraph G;

  Node s, t;

  std::istringstream input(test_lgf);

  digraphReader(G, input).

    node("source", s).

    node("target", t).

    run();

  Dfs<Digraph> dfs_test(G);

  dfs_test.run(s);

  Path<Digraph> p = dfs_test.path(t);

              << dfs_test.dist(v) << ")");

      }

    }

  }

  {

    NullMap<Node,Arc> myPredMap;

    dfs(G).predMap(myPredMap).run(s);

  }

}

int main()

using namespace std;

using namespace lemon;

void digraph_copy_test() {

  const int nn = 10;

  SmartDigraph from;

  SmartDigraph::NodeMap<int> fnm(from);

  SmartDigraph::ArcMap<int> fam(from);

  SmartDigraph::Node fn = INVALID;

  SmartDigraph::Arc fa = INVALID;

      SmartDigraph::Arc arc = from.addArc(fnv[i], fnv[j]);

      fam[arc] = i + j * j;

      if (i == 0 && j == 0) fa = arc;

    }

  }

  ListDigraph to;

  ListDigraph::NodeMap<int> tnm(to);

  ListDigraph::ArcMap<int> tam(to);

  ListDigraph::Node tn;

  ListDigraph::Arc ta;

  digraphCopy(from, to).

    nodeMap(fnm, tnm).arcMap(fam, tam).

    nodeRef(nr).arcRef(er).

    nodeCrossRef(ncr).arcCrossRef(ecr).

    node(fn, tn).arc(fa, ta).run();

  for (SmartDigraph::NodeIt it(from); it != INVALID; ++it) {

    check(ncr[nr[it]] == it, "Wrong copy.");

    check(fnm[it] == tnm[nr[it]], "Wrong copy.");

  }

  for (SmartDigraph::ArcIt it(from); it != INVALID; ++it) {

  for (ListDigraph::ArcIt it(to); it != INVALID; ++it) {

    check(er[ecr[it]] == it, "Wrong copy.");

  }

  check(tn == nr[fn], "Wrong copy.");

  check(ta == er[fa], "Wrong copy.");

}

void graph_copy_test() {

  const int nn = 10;

  SmartGraph from;

  SmartGraph::NodeMap<int> fnm(from);

  SmartGraph::ArcMap<int> fam(from);

  SmartGraph::EdgeMap<int> fem(from);

  SmartGraph::Node fn = INVALID;

  SmartGraph::Arc fa = INVALID;

      fam[from.direct(edge, false)] = i * i + j;

      if (i == 0 && j == 0) fa = from.direct(edge, true);

      if (i == 0 && j == 0) fe = edge;

    }

  }

  ListGraph to;

  ListGraph::NodeMap<int> tnm(to);

  ListGraph::ArcMap<int> tam(to);

  ListGraph::EdgeMap<int> tem(to);

  ListGraph::Node tn;

  ListGraph::Arc ta;

  graphCopy(from, to).

    nodeMap(fnm, tnm).arcMap(fam, tam).edgeMap(fem, tem).

    nodeRef(nr).arcRef(ar).edgeRef(er).

    nodeCrossRef(ncr).arcCrossRef(acr).edgeCrossRef(ecr).

    node(fn, tn).arc(fa, ta).edge(fe, te).run();

  for (SmartGraph::NodeIt it(from); it != INVALID; ++it) {

    check(ncr[nr[it]] == it, "Wrong copy.");

    check(fnm[it] == tnm[nr[it]], "Wrong copy.");

  }

  for (SmartGraph::ArcIt it(from); it != INVALID; ++it) {

  for (ListGraph::EdgeIt it(to); it != INVALID; ++it) {

    check(er[ecr[it]] == it, "Wrong copy.");

  }

  check(tn == nr[fn], "Wrong copy.");

  check(ta == ar[fa], "Wrong copy.");

  check(te == er[fe], "Wrong copy.");

}

int main() {

  digraph_copy_test();

  graph_copy_test();