RhodeCode

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

 *

 */

#include <lemon/concepts/digraph.h>

#include <lemon/list_graph.h>

#include <lemon/smart_graph.h>

//#include <lemon/full_graph.h>

//#include <lemon/hypercube_graph.h>

#include "test_tools.h"

#include "graph_test.h"

using namespace lemon;

using namespace lemon::concepts;

template <class Digraph>

  TEMPLATE_DIGRAPH_TYPEDEFS(Digraph);

  Digraph G;

  checkGraphNodeList(G, 0);

  checkGraphArcList(G, 0);

  Node

    n1 = G.addNode(),

    n2 = G.addNode(),

    n3 = G.addNode();

  checkGraphNodeList(G, 3);

  checkGraphArcList(G, 0);

  Arc a1 = G.addArc(n1, n2);

  check(G.source(a1) == n1 && G.target(a1) == n2, "Wrong arc");

  checkGraphNodeList(G, 3);

  checkGraphArcList(G, 1);

  checkGraphOutArcList(G, n1, 1);

  checkGraphOutArcList(G, n2, 0);

  checkGraphOutArcList(G, n3, 0);

  checkGraphInArcList(G, n1, 0);

  checkGraphInArcList(G, n2, 1);

  checkGraphInArcList(G, n3, 0);

  checkGraphConArcList(G, 1);

  checkGraphNodeList(G, 3);

  checkGraphArcList(G, 4);

  checkGraphOutArcList(G, n1, 1);

  checkGraphOutArcList(G, n2, 3);

  checkGraphOutArcList(G, n3, 0);

  checkGraphInArcList(G, n1, 1);

  checkGraphInArcList(G, n2, 1);

  checkGraphInArcList(G, n3, 2);

  checkGraphConArcList(G, 4);

  checkNodeIds(G);

  checkArcIds(G);

  checkGraphNodeMap(G);

  checkGraphArcMap(G);

}

void checkConcepts() {

  { // Checking digraph components

    checkConcept<BaseDigraphComponent, BaseDigraphComponent >();

    checkConcept<IDableDigraphComponent<>,

      IDableDigraphComponent<> >();

    checkConcept<IterableDigraphComponent<>,

      IterableDigraphComponent<> >();

    checkConcept<MappableDigraphComponent<>,

      MappableDigraphComponent<> >();

  }

  { // Checking skeleton digraph

    checkConcept<Digraph, Digraph>();

  }

  { // Checking ListDigraph

    checkConcept<Digraph, ListDigraph>();

    checkConcept<AlterableDigraphComponent<>, ListDigraph>();

    checkConcept<ExtendableDigraphComponent<>, ListDigraph>();

    checkConcept<ClearableDigraphComponent<>, ListDigraph>();

    checkConcept<ErasableDigraphComponent<>, ListDigraph>();

  }

  { // Checking SmartDigraph

    checkConcept<Digraph, SmartDigraph>();

    checkConcept<AlterableDigraphComponent<>, SmartDigraph>();

    checkConcept<ExtendableDigraphComponent<>, SmartDigraph>();

    checkConcept<ClearableDigraphComponent<>, SmartDigraph>();

  }

//  { // Checking FullDigraph

//    checkConcept<Digraph, FullDigraph>();

//  }

//  { // Checking HyperCubeDigraph

//    checkConcept<Digraph, HyperCubeDigraph>();

//  }

}

template <typename Digraph>

void checkDigraphValidity() {

  TEMPLATE_DIGRAPH_TYPEDEFS(Digraph);

  Digraph g;

  Node

    n1 = g.addNode(),

    n2 = g.addNode(),

    n3 = g.addNode();

  Arc

    e1 = g.addArc(n1, n2),

    e2 = g.addArc(n2, n3);

  check(g.valid(n1), "Wrong validity check");

  check(g.valid(e1), "Wrong validity check");

  check(!g.valid(g.nodeFromId(-1)), "Wrong validity check");

  check(!g.valid(g.arcFromId(-1)), "Wrong validity check");

}

template <typename Digraph>

void checkDigraphValidityErase() {

  TEMPLATE_DIGRAPH_TYPEDEFS(Digraph);

  Digraph g;

  Node

    n1 = g.addNode(),

    n2 = g.addNode(),

    n3 = g.addNode();

  Arc

    e1 = g.addArc(n1, n2),

    e2 = g.addArc(n2, n3);

  check(g.valid(n1), "Wrong validity check");

  check(g.valid(e1), "Wrong validity check");

  g.erase(n1);

  check(!g.valid(n1), "Wrong validity check");

  check(g.valid(n2), "Wrong validity check");

  check(g.valid(n3), "Wrong validity check");

  check(!g.valid(e1), "Wrong validity check");

  check(g.valid(e2), "Wrong validity check");

  check(!g.valid(g.nodeFromId(-1)), "Wrong validity check");

  check(!g.valid(g.arcFromId(-1)), "Wrong validity check");

}

void checkDigraphs() {

  { // Checking ListDigraph

    checkDigraphValidityErase<ListDigraph>();

  }

  { // Checking SmartDigraph

    checkDigraphValidity<SmartDigraph>();

  }

}

int main() {

  checkDigraphs();

  checkConcepts();

  return 0;

}

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

 *

 */

#include <lemon/concepts/graph.h>

#include <lemon/list_graph.h>

#include <lemon/smart_graph.h>

// #include <lemon/full_graph.h>

// #include <lemon/grid_graph.h>

#include "test_tools.h"

#include "graph_test.h"

using namespace lemon;

using namespace lemon::concepts;

template <class Graph>

  TEMPLATE_GRAPH_TYPEDEFS(Graph);

  Graph G;

  checkGraphNodeList(G, 0);

  checkGraphEdgeList(G, 0);

  Node

    n1 = G.addNode(),

    n2 = G.addNode(),

    n3 = G.addNode();

  checkGraphNodeList(G, 3);

  checkGraphEdgeList(G, 0);

  Edge e1 = G.addEdge(n1, n2);

  check((G.u(e1) == n1 && G.v(e1) == n2) || (G.u(e1) == n2 && G.v(e1) == n1),

        "Wrong edge");

  checkGraphNodeList(G, 3);

  checkGraphArcList(G, 2);

  checkGraphConArcList(G, 6);

  checkArcDirections(G);

  checkNodeIds(G);

  checkArcIds(G);

  checkEdgeIds(G);

  checkGraphNodeMap(G);

  checkGraphArcMap(G);

  checkGraphEdgeMap(G);

}

void checkConcepts() {

  { // Checking graph components

    checkConcept<BaseGraphComponent, BaseGraphComponent >();

    checkConcept<IDableGraphComponent<>,

      IDableGraphComponent<> >();

    checkConcept<IterableGraphComponent<>,

      IterableGraphComponent<> >();

    checkConcept<MappableGraphComponent<>,

      MappableGraphComponent<> >();

  }

  { // Checking skeleton graph

    checkConcept<Graph, Graph>();

  }

  { // Checking ListGraph

    checkConcept<Graph, ListGraph>();

    checkConcept<AlterableGraphComponent<>, ListGraph>();

    checkConcept<ExtendableGraphComponent<>, ListGraph>();

    checkConcept<ClearableGraphComponent<>, ListGraph>();

    checkConcept<ErasableGraphComponent<>, ListGraph>();

  }

  { // Checking SmartGraph

    checkConcept<Graph, SmartGraph>();

    checkConcept<AlterableGraphComponent<>, SmartGraph>();

    checkConcept<ExtendableGraphComponent<>, SmartGraph>();

    checkConcept<ClearableGraphComponent<>, SmartGraph>();

  }

//  { // Checking FullGraph

//    checkConcept<Graph, FullGraph>();

//    checkGraphIterators<FullGraph>();

//  }

//  { // Checking GridGraph

//    checkConcept<Graph, GridGraph>();

//    checkGraphIterators<GridGraph>();

//  }

}

template <typename Graph>

void checkGraphValidity() {

  TEMPLATE_GRAPH_TYPEDEFS(Graph);

  Graph g;

  Node

    n1 = g.addNode(),

    n2 = g.addNode(),

    n3 = g.addNode();

  Edge

    e1 = g.addEdge(n1, n2),

    e2 = g.addEdge(n2, n3);

  check(g.valid(n1), "Wrong validity check");

  check(g.valid(e1), "Wrong validity check");

  check(g.valid(g.direct(e1, true)), "Wrong validity check");

  check(!g.valid(g.nodeFromId(-1)), "Wrong validity check");

  check(!g.valid(g.edgeFromId(-1)), "Wrong validity check");

  check(!g.valid(g.arcFromId(-1)), "Wrong validity check");

}

template <typename Graph>

void checkGraphValidityErase() {

  TEMPLATE_GRAPH_TYPEDEFS(Graph);

  Graph g;

  Node

    n1 = g.addNode(),

    n2 = g.addNode(),

    n3 = g.addNode();

  Edge

    e1 = g.addEdge(n1, n2),

    e2 = g.addEdge(n2, n3);

  check(g.valid(n1), "Wrong validity check");

  check(g.valid(e1), "Wrong validity check");

  check(g.valid(g.direct(e1, true)), "Wrong validity check");

  g.erase(n1);

  check(!g.valid(n1), "Wrong validity check");

  check(g.valid(n2), "Wrong validity check");

  check(g.valid(n3), "Wrong validity check");

  check(!g.valid(e1), "Wrong validity check");

  check(g.valid(e2), "Wrong validity check");

  check(!g.valid(g.nodeFromId(-1)), "Wrong validity check");

  check(!g.valid(g.edgeFromId(-1)), "Wrong validity check");

  check(!g.valid(g.arcFromId(-1)), "Wrong validity check");

}

// void checkGridGraph(const GridGraph& g, int w, int h) {

//   check(g.width() == w, "Wrong width");

//   check(g.height() == h, "Wrong height");

//   for (int i = 0; i < w; ++i) {

//     for (int j = 0; j < h; ++j) {

//       check(g.col(g(i, j)) == i, "Wrong col");

//       check(g.row(g(i, j)) == j, "Wrong row");

//     }

//   }

//   for (int i = 0; i < w; ++i) {

//     for (int j = 0; j < h - 1; ++j) {

//       check(g.source(g.down(g(i, j))) == g(i, j), "Wrong down");

//       check(g.target(g.down(g(i, j))) == g(i, j + 1), "Wrong down");

//     }

//     check(g.down(g(i, h - 1)) == INVALID, "Wrong down");

//   }

//   for (int i = 0; i < w; ++i) {

//     for (int j = 1; j < h; ++j) {

//       check(g.source(g.up(g(i, j))) == g(i, j), "Wrong up");

//       check(g.target(g.up(g(i, j))) == g(i, j - 1), "Wrong up");

//     }

//     check(g.up(g(i, 0)) == INVALID, "Wrong up");

//   }

//   for (int j = 0; j < h; ++j) {

//     for (int i = 0; i < w - 1; ++i) {

//       check(g.source(g.right(g(i, j))) == g(i, j), "Wrong right");

//       check(g.target(g.right(g(i, j))) == g(i + 1, j), "Wrong right");

//     }

//     check(g.right(g(w - 1, j)) == INVALID, "Wrong right");

//   }

//   for (int j = 0; j < h; ++j) {

//     for (int i = 1; i < w; ++i) {

//       check(g.source(g.left(g(i, j))) == g(i, j), "Wrong left");

//       check(g.target(g.left(g(i, j))) == g(i - 1, j), "Wrong left");

//     }

//     check(g.left(g(0, j)) == INVALID, "Wrong left");

//   }

// }

void checkGraphs() {

  { // Checking ListGraph

    checkGraphValidityErase<ListGraph>();

  }

  { // Checking SmartGraph

    checkGraphValidity<SmartGraph>();

  }

//   { // Checking FullGraph

//     FullGraph g(5);

//     checkGraphNodeList(g, 5);

//     checkGraphEdgeList(g, 10);

//   }

//   { // Checking GridGraph

//     GridGraph g(5, 6);

//     checkGraphNodeList(g, 30);

//     checkGraphEdgeList(g, 49);

//     checkGridGraph(g, 5, 6);

//   }

}

int main() {

  checkConcepts();

  checkGraphs();

  return 0;

}

#include <lemon/core.h>

#include <lemon/maps.h>

#include "test_tools.h"

namespace lemon {

  template<class Graph>

  void checkGraphNodeList(const Graph &G, int cnt)

  {

    typename Graph::NodeIt n(G);

    for(int i=0;i<cnt;i++) {

      check(n!=INVALID,"Wrong Node list linking.");

      ++n;

    }

    check(n==INVALID,"Wrong Node list linking.");

    check(countNodes(G)==cnt,"Wrong Node number.");

  }

  template<class Graph>

  void checkGraphArcList(const Graph &G, int cnt)

  {

    typename Graph::ArcIt e(G);

    for(int i=0;i<cnt;i++) {

      check(e!=INVALID,"Wrong Arc list linking.");

      check(G.oppositeNode(G.source(e), e) == G.target(e),

            "Wrong opposite node");

      check(G.oppositeNode(G.target(e), e) == G.source(e),

            "Wrong opposite node");

      ++e;

    }

    check(e==INVALID,"Wrong Arc list linking.");

    check(countArcs(G)==cnt,"Wrong Arc number.");

  }

  template<class Graph>

  void checkGraphOutArcList(const Graph &G, typename Graph::Node n, int cnt)

  {

    typename Graph::OutArcIt e(G,n);

    for(int i=0;i<cnt;i++) {

      check(e!=INVALID,"Wrong OutArc list linking.");

      check(n==G.source(e),"Wrong OutArc list linking.");

      check(n==G.baseNode(e),"Wrong OutArc list linking.");

      check(G.target(e)==G.runningNode(e),"Wrong OutArc list linking.");

      ++e;

    }

    check(e==INVALID,"Wrong OutArc list linking.");

    check(countOutArcs(G,n)==cnt,"Wrong OutArc number.");

  }

  template<class Graph>

  void checkGraphInArcList(const Graph &G, typename Graph::Node n, int cnt)

  {

    typename Graph::InArcIt e(G,n);

    for(int i=0;i<cnt;i++) {

      check(e!=INVALID,"Wrong InArc list linking.");

      check(n==G.target(e),"Wrong InArc list linking.");

      check(n==G.baseNode(e),"Wrong OutArc list linking.");

      check(G.source(e)==G.runningNode(e),"Wrong OutArc list linking.");

      ++e;

    }

    check(e==INVALID,"Wrong InArc list linking.");

    check(countInArcs(G,n)==cnt,"Wrong InArc number.");

  }

  template<class Graph>

  void checkGraphEdgeList(const Graph &G, int cnt)

  {

    typename Graph::EdgeIt e(G);

    for(int i=0;i<cnt;i++) {

      check(e!=INVALID,"Wrong Edge list linking.");

      check(G.oppositeNode(G.u(e), e) == G.v(e), "Wrong opposite node");

      check(G.oppositeNode(G.v(e), e) == G.u(e), "Wrong opposite node");

      ++e;

    }

    check(e==INVALID,"Wrong Edge list linking.");

    check(countEdges(G)==cnt,"Wrong Edge number.");

  }

  template<class Graph>

  void checkGraphIncEdgeList(const Graph &G, typename Graph::Node n, int cnt)

  {

    typename Graph::IncEdgeIt e(G,n);

    for(int i=0;i<cnt;i++) {

      check(e!=INVALID,"Wrong IncEdge list linking.");

      check(n==G.u(e) || n==G.v(e),"Wrong IncEdge list linking.");

      check(n==G.baseNode(e),"Wrong OutArc list linking.");

      check(G.u(e)==G.runningNode(e) || G.v(e)==G.runningNode(e),

            "Wrong OutArc list linking.");

      ++e;

    }

    check(e==INVALID,"Wrong IncEdge list linking.");

    check(countIncEdges(G,n)==cnt,"Wrong IncEdge number.");

  }

  template <class Graph>

  void checkGraphConArcList(const Graph &G, int cnt) {

    int i = 0;

    for (typename Graph::NodeIt u(G); u != INVALID; ++u) {

      for (typename Graph::NodeIt v(G); v != INVALID; ++v) {

        for (ConArcIt<Graph> a(G, u, v); a != INVALID; ++a) {

          check(G.source(a) == u, "Wrong iterator.");

          check(G.target(a) == v, "Wrong iterator.");

          ++i;

        }

      }

    }

    check(cnt == i, "Wrong iterator.");

  }

  template <class Graph>

  void checkGraphConEdgeList(const Graph &G, int cnt) {

    int i = 0;

    for (typename Graph::NodeIt u(G); u != INVALID; ++u) {

      for (typename Graph::NodeIt v(G); v != INVALID; ++v) {

        for (ConEdgeIt<Graph> e(G, u, v); e != INVALID; ++e) {

          check((G.u(e) == u && G.v(e) == v) ||

                (G.u(e) == v && G.v(e) == u), "Wrong iterator.");

          i += u == v ? 2 : 1;

        }

      }

    }

    check(2 * cnt == i, "Wrong iterator.");

  }

  template <typename Graph>

  void checkArcDirections(const Graph& G) {

    for (typename Graph::ArcIt a(G); a != INVALID; ++a) {

      check(G.source(a) == G.target(G.oppositeArc(a)), "Wrong direction");

      check(G.target(a) == G.source(G.oppositeArc(a)), "Wrong direction");

      check(G.direct(a, G.direction(a)) == a, "Wrong direction");

    }

  }

  template <typename Graph>

  void checkNodeIds(const Graph& G) {

    std::set<int> values;

    for (typename Graph::NodeIt n(G); n != INVALID; ++n) {

      check(G.nodeFromId(G.id(n)) == n, "Wrong id");

      check(values.find(G.id(n)) == values.end(), "Wrong id");

      check(G.id(n) <= G.maxNodeId(), "Wrong maximum id");

      values.insert(G.id(n));

    }

  }

  template <typename Graph>

  void checkArcIds(const Graph& G) {

    std::set<int> values;

    for (typename Graph::ArcIt a(G); a != INVALID; ++a) {

      check(G.arcFromId(G.id(a)) == a, "Wrong id");

      check(values.find(G.id(a)) == values.end(), "Wrong id");

      check(G.id(a) <= G.maxArcId(), "Wrong maximum id");

      values.insert(G.id(a));

    }

  }

  template <typename Graph>

  void checkEdgeIds(const Graph& G) {

    std::set<int> values;

    for (typename Graph::EdgeIt e(G); e != INVALID; ++e) {

      check(G.edgeFromId(G.id(e)) == e, "Wrong id");

      check(values.find(G.id(e)) == values.end(), "Wrong id");

      check(G.id(e) <= G.maxEdgeId(), "Wrong maximum id");

      values.insert(G.id(e));

    }

  }

  template <typename Graph>

  void checkGraphNodeMap(const Graph& G) {

    typedef typename Graph::Node Node;

    typedef typename Graph::NodeIt NodeIt;

    typedef typename Graph::template NodeMap<int> IntNodeMap;

    IntNodeMap map(G, 42);

    for (NodeIt it(G); it != INVALID; ++it) {

      check(map[it] == 42, "Wrong map constructor.");

    }

    int s = 0;

    for (NodeIt it(G); it != INVALID; ++it) {

      map[it] = 0;

      check(map[it] == 0, "Wrong operator[].");

      map.set(it, s);

      check(map[it] == s, "Wrong set.");

      ++s;

    }

    s = s * (s - 1) / 2;

    for (NodeIt it(G); it != INVALID; ++it) {

      s -= map[it];

    }

    check(s == 0, "Wrong sum.");

    // map = constMap<Node>(12);