LEMON/LEMON-main Changeset - r585:65fbcf2f978a

Repositories » LEMON » LEMON-main

Summary
Changelog
Files
Switch To
- loading...
Options
- Lightweight changelog
- Search
Pull Requests

Changeset - r585:65fbcf2f978a

« 583:99a31b

589:630c48 »

r585:65fbcf2f978a

Wed, 15 Apr 2009 03:26:45

[Not Reviewed]

0 comments (0 inline)

kpeter (Peter Kovacs)
kpeter@inf.elte.hu

Improve test files for some algorithms (#263)

0 5 0

default

5 files changed with 196 insertions and 63 deletions:

test/bfs_test.cc

test/circulation_test.cc

test/dfs_test.cc

test/dijkstra_test.cc

test/preflow_test.cc

↑ Collapse diff ↑

test/bfs_test.cc

Show inline comments

@@ -29,100 +29,139 @@
 		using namespace lemon;
 		char test_lgf[] =
 		  "@nodes\n"
 		  "label\n"
 		  "0\n"
 		  "1\n"
 		  "2\n"
 		  "3\n"
 		  "4\n"
 		  "5\n"
 		  "@arcs\n"
 		  "     label\n"
 		  "0 1  0\n"
 		  "1 2  1\n"
 		  "2 3  2\n"
 		  "3 4  3\n"
 		  "0 3  4\n"
 		  "0 3  5\n"
 		  "5 2  6\n"
 		  "@attributes\n"
 		  "source 0\n"
 		  "target 4\n";
 		void checkBfsCompile()
+		{
 		  typedef concepts::Digraph Digraph;
 		  typedef Bfs<Digraph> BType;
 		  typedef Digraph::Node Node;
 		  typedef Digraph::Arc Arc;
 		  Digraph G;
 		  Node s, t;
+		  Node s, t, n;
 		  Arc e;
 		  int l;
+		  int l, i;
 		  bool b;
 		  BType::DistMap d(G);
 		  BType::PredMap p(G);
 		  Path<Digraph> pp;
 		  concepts::ReadMap<Node,bool> nm;
+		  {
 		    BType bfs_test(G);
 		    const BType& const_bfs_test = bfs_test;
 		    bfs_test.run(s);
 		    bfs_test.run(s,t);
 		    bfs_test.run();
 		    l  = bfs_test.dist(t);
 		    e  = bfs_test.predArc(t);
 		    s  = bfs_test.predNode(t);
 		    b  = bfs_test.reached(t);
 		    d  = bfs_test.distMap();
 		    p  = bfs_test.predMap();
-		    pp = bfs_test.path(t);
+		    bfs_test.init();
 		    bfs_test.addSource(s);
 		    n = bfs_test.processNextNode();
 		    n = bfs_test.processNextNode(t, b);
 		    n = bfs_test.processNextNode(nm, n);
 		    n = const_bfs_test.nextNode();
 		    b = const_bfs_test.emptyQueue();
 		    i = const_bfs_test.queueSize();
 		    bfs_test.start();
 		    bfs_test.start(t);
 		    bfs_test.start(nm);
 		    l  = const_bfs_test.dist(t);
 		    e  = const_bfs_test.predArc(t);
 		    s  = const_bfs_test.predNode(t);
 		    b  = const_bfs_test.reached(t);
 		    d  = const_bfs_test.distMap();
 		    p  = const_bfs_test.predMap();
 		    pp = const_bfs_test.path(t);
+		  }
+		  {
 		    BType
 		      ::SetPredMap<concepts::ReadWriteMap<Node,Arc> >
 		      ::SetDistMap<concepts::ReadWriteMap<Node,int> >
 		      ::SetReachedMap<concepts::ReadWriteMap<Node,bool> >
 		      ::SetStandardProcessedMap
 		      ::SetProcessedMap<concepts::WriteMap<Node,bool> >
 		      ::SetStandardProcessedMap
 		      ::Create bfs_test(G);
 		    concepts::ReadWriteMap<Node,Arc> pred_map;
 		    concepts::ReadWriteMap<Node,int> dist_map;
 		    concepts::ReadWriteMap<Node,bool> reached_map;
 		    concepts::WriteMap<Node,bool> processed_map;
 		    bfs_test
 		      .predMap(pred_map)
 		      .distMap(dist_map)
 		      .reachedMap(reached_map)
 		      .processedMap(processed_map);
 		    bfs_test.run(s);
 		    bfs_test.run(s,t);
 		    bfs_test.run();
 		    bfs_test.init();
 		    bfs_test.addSource(s);
 		    n = bfs_test.processNextNode();
 		    n = bfs_test.processNextNode(t, b);
 		    n = bfs_test.processNextNode(nm, n);
 		    n = bfs_test.nextNode();
 		    b = bfs_test.emptyQueue();
 		    i = bfs_test.queueSize();
 		    bfs_test.start();
 		    bfs_test.start(t);
 		    bfs_test.start(nm);
 		    l  = bfs_test.dist(t);
 		    e  = bfs_test.predArc(t);
 		    s  = bfs_test.predNode(t);
 		    b  = bfs_test.reached(t);
 		    pp = bfs_test.path(t);
+		  }
+		}
 		void checkBfsFunctionCompile()
+		{
 		  typedef int VType;
 		  typedef concepts::Digraph Digraph;
 		  typedef Digraph::Arc Arc;
 		  typedef Digraph::Node Node;
 		  Digraph g;
 		  bool b;
 		  bfs(g).run(Node());
 		  b=bfs(g).run(Node(),Node());
 		  bfs(g).run();
 		  bfs(g)
 		    .predMap(concepts::ReadWriteMap<Node,Arc>())
 		    .distMap(concepts::ReadWriteMap<Node,VType>())
 		    .reachedMap(concepts::ReadWriteMap<Node,bool>())
 		    .processedMap(concepts::WriteMap<Node,bool>())
 		    .run(Node());
 		  b=bfs(g)
 		    .predMap(concepts::ReadWriteMap<Node,Arc>())
 		    .distMap(concepts::ReadWriteMap<Node,VType>())
 		    .reachedMap(concepts::ReadWriteMap<Node,bool>())
 		    .processedMap(concepts::WriteMap<Node,bool>())
 		    .path(concepts::Path<Digraph>())

test/circulation_test.cc

Show inline comments

@@ -42,85 +42,92 @@
 		  "0 2  2  6\n"
 		  "1 3  4  7\n"
 		  "1 4  0  5\n"
 		  "2 4  1  3\n"
 		  "3 5  3  8\n"
 		  "4 5  3  7\n"
 		  "@attributes\n"
 		  "source 0\n"
 		  "sink   5\n";
 		void checkCirculationCompile()
+		{
 		  typedef int VType;
 		  typedef concepts::Digraph Digraph;
 		  typedef Digraph::Node Node;
 		  typedef Digraph::Arc Arc;
 		  typedef concepts::ReadMap<Arc,VType> CapMap;
 		  typedef concepts::ReadMap<Node,VType> DeltaMap;
 		  typedef concepts::ReadWriteMap<Arc,VType> FlowMap;
 		  typedef concepts::WriteMap<Node,bool> BarrierMap;
 		  typedef Elevator<Digraph, Digraph::Node> Elev;
 		  typedef LinkedElevator<Digraph, Digraph::Node> LinkedElev;
 		  Digraph g;
 		  Node n;
 		  Arc a;
 		  CapMap lcap, ucap;
 		  DeltaMap delta;
 		  FlowMap flow;
 		  BarrierMap bar;
 		  VType v;
 		  bool b;
 		  Circulation<Digraph, CapMap, CapMap, DeltaMap>
+		  typedef Circulation<Digraph, CapMap, CapMap, DeltaMap>
 		    ::SetFlowMap<FlowMap>
 		    ::SetElevator<Elev>
 		    ::SetStandardElevator<LinkedElev>
-		    ::Create circ_test(g,lcap,ucap,delta);
+		            ::Create CirculationType;
 		  CirculationType circ_test(g, lcap, ucap, delta);
 		  const CirculationType& const_circ_test = circ_test;
 		  circ_test.lowerCapMap(lcap);
 		  circ_test.upperCapMap(ucap);
 		  circ_test.deltaMap(delta);
 		  flow = circ_test.flowMap();
-		  circ_test.flowMap(flow);
 		  circ_test
 		    .lowerCapMap(lcap)
 		    .upperCapMap(ucap)
 		    .deltaMap(delta)
 		    .flowMap(flow);
 		  circ_test.init();
 		  circ_test.greedyInit();
 		  circ_test.start();
 		  circ_test.run();
 		  circ_test.barrier(n);
 		  circ_test.barrierMap(bar);
-		  circ_test.flow(a);
+		  v = const_circ_test.flow(a);
 		  const FlowMap& fm = const_circ_test.flowMap();
 		  b = const_circ_test.barrier(n);
 		  const_circ_test.barrierMap(bar);
 		  ignore_unused_variable_warning(fm);
+		}
 		template <class G, class LM, class UM, class DM>
 		void checkCirculation(const G& g, const LM& lm, const UM& um,
 		                      const DM& dm, bool find)
+		{
 		  Circulation<G, LM, UM, DM> circ(g, lm, um, dm);
 		  bool ret = circ.run();
 		  if (find) {
 		    check(ret, "A feasible solution should have been found.");
 		    check(circ.checkFlow(), "The found flow is corrupt.");
 		    check(!circ.checkBarrier(), "A barrier should not have been found.");
 		  } else {
 		    check(!ret, "A feasible solution should not have been found.");
 		    check(circ.checkBarrier(), "The found barrier is corrupt.");
+		  }
+		}
 		int main (int, char*[])
+		{
 		  typedef ListDigraph Digraph;
 		  DIGRAPH_TYPEDEFS(Digraph);
 		  Digraph g;
 		  IntArcMap lo(g), up(g);
 		  IntNodeMap delta(g, 0);
 		  Node s, t;
 		  std::istringstream input(test_lgf);
 		  DigraphReader<Digraph>(g,input).
 		    arcMap("lcap", lo).
 		    arcMap("ucap", up).

test/dfs_test.cc

Show inline comments

@@ -33,97 +33,132 @@
 		  "label\n"
 		  "0\n"
 		  "1\n"
 		  "2\n"
 		  "3\n"
 		  "4\n"
 		  "5\n"
 		  "6\n"
 		  "@arcs\n"
 		  "     label\n"
 		  "0 1  0\n"
 		  "1 2  1\n"
 		  "2 3  2\n"
 		  "1 4  3\n"
 		  "4 2  4\n"
 		  "4 5  5\n"
 		  "5 0  6\n"
 		  "6 3  7\n"
 		  "@attributes\n"
 		  "source 0\n"
 		  "target 5\n";
 		void checkDfsCompile()
+		{
 		  typedef concepts::Digraph Digraph;
 		  typedef Dfs<Digraph> DType;
 		  typedef Digraph::Node Node;
 		  typedef Digraph::Arc Arc;
 		  Digraph G;
 		  Node s, t;
 		  Arc e;
 		  int l;
+		  int l, i;
 		  bool b;
 		  DType::DistMap d(G);
 		  DType::PredMap p(G);
 		  Path<Digraph> pp;
 		  concepts::ReadMap<Arc,bool> am;
+		  {
 		    DType dfs_test(G);
 		    const DType& const_dfs_test = dfs_test;
 		    dfs_test.run(s);
 		    dfs_test.run(s,t);
 		    dfs_test.run();
 		    l  = dfs_test.dist(t);
 		    e  = dfs_test.predArc(t);
 		    s  = dfs_test.predNode(t);
 		    b  = dfs_test.reached(t);
 		    d  = dfs_test.distMap();
 		    p  = dfs_test.predMap();
-		    pp = dfs_test.path(t);
+		    dfs_test.init();
 		    dfs_test.addSource(s);
 		    e = dfs_test.processNextArc();
 		    e = const_dfs_test.nextArc();
 		    b = const_dfs_test.emptyQueue();
 		    i = const_dfs_test.queueSize();
 		    dfs_test.start();
 		    dfs_test.start(t);
 		    dfs_test.start(am);
 		    l  = const_dfs_test.dist(t);
 		    e  = const_dfs_test.predArc(t);
 		    s  = const_dfs_test.predNode(t);
 		    b  = const_dfs_test.reached(t);
 		    d  = const_dfs_test.distMap();
 		    p  = const_dfs_test.predMap();
 		    pp = const_dfs_test.path(t);
+		  }
+		  {
 		    DType
 		      ::SetPredMap<concepts::ReadWriteMap<Node,Arc> >
 		      ::SetDistMap<concepts::ReadWriteMap<Node,int> >
 		      ::SetReachedMap<concepts::ReadWriteMap<Node,bool> >
 		      ::SetStandardProcessedMap
 		      ::SetProcessedMap<concepts::WriteMap<Node,bool> >
 		      ::SetStandardProcessedMap
 		      ::Create dfs_test(G);
 		    concepts::ReadWriteMap<Node,Arc> pred_map;
 		    concepts::ReadWriteMap<Node,int> dist_map;
 		    concepts::ReadWriteMap<Node,bool> reached_map;
 		    concepts::WriteMap<Node,bool> processed_map;
 		    dfs_test
 		      .predMap(pred_map)
 		      .distMap(dist_map)
 		      .reachedMap(reached_map)
 		      .processedMap(processed_map);
 		    dfs_test.run(s);
 		    dfs_test.run(s,t);
 		    dfs_test.run();
 		    dfs_test.init();
 		    dfs_test.addSource(s);
 		    e = dfs_test.processNextArc();
 		    e = dfs_test.nextArc();
 		    b = dfs_test.emptyQueue();
 		    i = dfs_test.queueSize();
 		    dfs_test.start();
 		    dfs_test.start(t);
 		    dfs_test.start(am);
 		    l  = dfs_test.dist(t);
 		    e  = dfs_test.predArc(t);
 		    s  = dfs_test.predNode(t);
 		    b  = dfs_test.reached(t);
 		    pp = dfs_test.path(t);
+		  }
+		}
 		void checkDfsFunctionCompile()
+		{
 		  typedef int VType;
 		  typedef concepts::Digraph Digraph;
 		  typedef Digraph::Arc Arc;
 		  typedef Digraph::Node Node;
 		  Digraph g;
 		  bool b;
 		  dfs(g).run(Node());
 		  b=dfs(g).run(Node(),Node());
 		  dfs(g).run();
 		  dfs(g)
 		    .predMap(concepts::ReadWriteMap<Node,Arc>())
 		    .distMap(concepts::ReadWriteMap<Node,VType>())
 		    .reachedMap(concepts::ReadWriteMap<Node,bool>())
 		    .processedMap(concepts::WriteMap<Node,bool>())
 		    .run(Node());
 		  b=dfs(g)
 		    .predMap(concepts::ReadWriteMap<Node,Arc>())
 		    .distMap(concepts::ReadWriteMap<Node,VType>())
 		    .reachedMap(concepts::ReadWriteMap<Node,bool>())
 		    .processedMap(concepts::WriteMap<Node,bool>())

test/dijkstra_test.cc

Show inline comments

@@ -31,106 +31,152 @@
 		char test_lgf[] =
 		  "@nodes\n"
 		  "label\n"
 		  "0\n"
 		  "1\n"
 		  "2\n"
 		  "3\n"
 		  "4\n"
 		  "@arcs\n"
 		  "     label length\n"
 		  "0 1  0     1\n"
 		  "1 2  1     1\n"
 		  "2 3  2     1\n"
 		  "0 3  4     5\n"
 		  "0 3  5     10\n"
 		  "0 3  6     7\n"
 		  "4 2  7     1\n"
 		  "@attributes\n"
 		  "source 0\n"
 		  "target 3\n";
 		void checkDijkstraCompile()
+		{
 		  typedef int VType;
 		  typedef concepts::Digraph Digraph;
 		  typedef concepts::ReadMap<Digraph::Arc,VType> LengthMap;
 		  typedef Dijkstra<Digraph, LengthMap> DType;
 		  typedef Digraph::Node Node;
 		  typedef Digraph::Arc Arc;
 		  Digraph G;
 		  Node s, t;
+		  Node s, t, n;
 		  Arc e;
 		  VType l;
 		  int i;
 		  bool b;
 		  DType::DistMap d(G);
 		  DType::PredMap p(G);
 		  LengthMap length;
 		  Path<Digraph> pp;
 		  concepts::ReadMap<Node,bool> nm;
+		  {
 		    DType dijkstra_test(G,length);
 		    const DType& const_dijkstra_test = dijkstra_test;
 		    dijkstra_test.run(s);
 		    dijkstra_test.run(s,t);
 		    dijkstra_test.init();
 		    dijkstra_test.addSource(s);
 		    dijkstra_test.addSource(s, 1);
 		    n = dijkstra_test.processNextNode();
 		    n = const_dijkstra_test.nextNode();
 		    b = const_dijkstra_test.emptyQueue();
 		    i = const_dijkstra_test.queueSize();
 		    dijkstra_test.start();
 		    dijkstra_test.start(t);
 		    dijkstra_test.start(nm);
 		    l  = const_dijkstra_test.dist(t);
 		    e  = const_dijkstra_test.predArc(t);
 		    s  = const_dijkstra_test.predNode(t);
 		    b  = const_dijkstra_test.reached(t);
 		    b  = const_dijkstra_test.processed(t);
 		    d  = const_dijkstra_test.distMap();
 		    p  = const_dijkstra_test.predMap();
 		    pp = const_dijkstra_test.path(t);
 		    l  = const_dijkstra_test.currentDist(t);
+		  }
+		  {
 		    DType
 		      ::SetPredMap<concepts::ReadWriteMap<Node,Arc> >
 		      ::SetDistMap<concepts::ReadWriteMap<Node,VType> >
 		      ::SetStandardProcessedMap
 		      ::SetProcessedMap<concepts::WriteMap<Node,bool> >
 		      ::SetOperationTraits<DijkstraDefaultOperationTraits<VType> >
 		      ::SetHeap<BinHeap<VType, concepts::ReadWriteMap<Node,int> > >
 		      ::SetStandardHeap<BinHeap<VType, concepts::ReadWriteMap<Node,int> > >
 		      ::SetHeap<BinHeap<VType, concepts::ReadWriteMap<Node,int> >,
 		                concepts::ReadWriteMap<Node,int> >
 		      ::Create dijkstra_test(G,length);
 		    LengthMap length_map;
 		    concepts::ReadWriteMap<Node,Arc> pred_map;
 		    concepts::ReadWriteMap<Node,VType> dist_map;
 		    concepts::WriteMap<Node,bool> processed_map;
 		    concepts::ReadWriteMap<Node,int> heap_cross_ref;
 		    BinHeap<VType, concepts::ReadWriteMap<Node,int> > heap(heap_cross_ref);
 		    dijkstra_test
 		      .lengthMap(length_map)
 		      .predMap(pred_map)
 		      .distMap(dist_map)
 		      .processedMap(processed_map)
 		      .heap(heap, heap_cross_ref);
 		    dijkstra_test.run(s);
 		    dijkstra_test.run(s,t);
 		    dijkstra_test.addSource(s);
 		    dijkstra_test.addSource(s, 1);
 		    n = dijkstra_test.processNextNode();
 		    n = dijkstra_test.nextNode();
 		    b = dijkstra_test.emptyQueue();
 		    i = dijkstra_test.queueSize();
 		    dijkstra_test.start();
 		    dijkstra_test.start(t);
 		    dijkstra_test.start(nm);
 		    l  = dijkstra_test.dist(t);
 		    e  = dijkstra_test.predArc(t);
 		    s  = dijkstra_test.predNode(t);
 		    b  = dijkstra_test.reached(t);
 		    d  = dijkstra_test.distMap();
 		    p  = dijkstra_test.predMap();
 		    b  = dijkstra_test.processed(t);
 		    pp = dijkstra_test.path(t);
+		  }
+		  {
 		    DType
 		      ::SetPredMap<concepts::ReadWriteMap<Node,Arc> >
 		      ::SetDistMap<concepts::ReadWriteMap<Node,VType> >
 		      ::SetProcessedMap<concepts::WriteMap<Node,bool> >
 		      ::SetStandardProcessedMap
 		      ::SetOperationTraits<DijkstraDefaultOperationTraits<VType> >
 		      ::SetHeap<BinHeap<VType, concepts::ReadWriteMap<Node,int> > >
 		      ::SetStandardHeap<BinHeap<VType, concepts::ReadWriteMap<Node,int> > >
 		      ::Create dijkstra_test(G,length);
 		    dijkstra_test.run(s);
 		    dijkstra_test.run(s,t);
 		    l  = dijkstra_test.dist(t);
 		    e  = dijkstra_test.predArc(t);
 		    s  = dijkstra_test.predNode(t);
 		    b  = dijkstra_test.reached(t);
 		    pp = dijkstra_test.path(t);
 		    l  = dijkstra_test.currentDist(t);
+		  }
+		}
 		void checkDijkstraFunctionCompile()
+		{
 		  typedef int VType;
 		  typedef concepts::Digraph Digraph;
 		  typedef Digraph::Arc Arc;
 		  typedef Digraph::Node Node;
 		  typedef concepts::ReadMap<Digraph::Arc,VType> LengthMap;
 		  Digraph g;
 		  bool b;
 		  dijkstra(g,LengthMap()).run(Node());
 		  b=dijkstra(g,LengthMap()).run(Node(),Node());
 		  dijkstra(g,LengthMap())
 		    .predMap(concepts::ReadWriteMap<Node,Arc>())
 		    .distMap(concepts::ReadWriteMap<Node,VType>())
 		    .processedMap(concepts::WriteMap<Node,bool>())
 		    .run(Node());
 		  b=dijkstra(g,LengthMap())
 		    .predMap(concepts::ReadWriteMap<Node,Arc>())
 		    .distMap(concepts::ReadWriteMap<Node,VType>())
 		    .processedMap(concepts::WriteMap<Node,bool>())
 		    .path(concepts::Path<Digraph>())
 		    .dist(VType())
 		    .run(Node(),Node());
+		}
 		template <class Digraph>
 		void checkDijkstra() {

test/preflow_test.cc

Show inline comments

@@ -55,89 +55,95 @@
 		  "4 3 9     3\n"
 		  "5 7 10    3\n"
 		  "5 6 11    10\n"
 		  "5 8 12    10\n"
 		  "6 8 13    8\n"
 		  "8 9 14    20\n"
 		  "8 1 15    5\n"
 		  "9 5 16    5\n"
 		  "@attributes\n"
 		  "source 1\n"
 		  "target 8\n";
 		void checkPreflowCompile()
+		{
 		  typedef int VType;
 		  typedef concepts::Digraph Digraph;
 		  typedef Digraph::Node Node;
 		  typedef Digraph::Arc Arc;
 		  typedef concepts::ReadMap<Arc,VType> CapMap;
 		  typedef concepts::ReadWriteMap<Arc,VType> FlowMap;
 		  typedef concepts::WriteMap<Node,bool> CutMap;
 		  typedef Elevator<Digraph, Digraph::Node> Elev;
 		  typedef LinkedElevator<Digraph, Digraph::Node> LinkedElev;
 		  Digraph g;
 		  Node n;
 		  Arc e;
 		  CapMap cap;
 		  FlowMap flow;
 		  CutMap cut;
 		  VType v;
 		  bool b;
 		  Preflow<Digraph, CapMap>
+		  typedef Preflow<Digraph, CapMap>
 		    ::SetFlowMap<FlowMap>
 		    ::SetElevator<Elev>
 		    ::SetStandardElevator<LinkedElev>
-		    ::Create preflow_test(g,cap,n,n);
+		            ::Create PreflowType;
 		  PreflowType preflow_test(g, cap, n, n);
 		  const PreflowType& const_preflow_test = preflow_test;
 		  preflow_test.capacityMap(cap);
 		  flow = preflow_test.flowMap();
 		  preflow_test.flowMap(flow);
 		  preflow_test.source(n);
-		  preflow_test.target(n);
 		  preflow_test
 		    .capacityMap(cap)
 		    .flowMap(flow)
 		    .source(n)
 		    .target(n);
 		  preflow_test.init();
 		  preflow_test.init(cap);
 		  preflow_test.startFirstPhase();
 		  preflow_test.startSecondPhase();
 		  preflow_test.run();
 		  preflow_test.runMinCut();
 		  preflow_test.flowValue();
 		  preflow_test.minCut(n);
 		  preflow_test.minCutMap(cut);
 		  preflow_test.flow(e);
 		  v = const_preflow_test.flowValue();
 		  v = const_preflow_test.flow(e);
 		  const FlowMap& fm = const_preflow_test.flowMap();
 		  b = const_preflow_test.minCut(n);
 		  const_preflow_test.minCutMap(cut);
 		  ignore_unused_variable_warning(fm);
+		}
 		int cutValue (const SmartDigraph& g,
 		              const SmartDigraph::NodeMap<bool>& cut,
 		              const SmartDigraph::ArcMap<int>& cap) {
 		  int c=0;
 		  for(SmartDigraph::ArcIt e(g); e!=INVALID; ++e) {
 		    if (cut[g.source(e)] && !cut[g.target(e)]) c+=cap[e];
+		  }
 		  return c;
+		}
 		bool checkFlow(const SmartDigraph& g,
 		               const SmartDigraph::ArcMap<int>& flow,
 		               const SmartDigraph::ArcMap<int>& cap,
 		               SmartDigraph::Node s, SmartDigraph::Node t) {
 		  for (SmartDigraph::ArcIt e(g); e != INVALID; ++e) {
 		    if (flow[e] < 0 || flow[e] > cap[e]) return false;
+		  }
 		  for (SmartDigraph::NodeIt n(g); n != INVALID; ++n) {
 		    if (n == s || n == t) continue;
 		    int sum = 0;
 		    for (SmartDigraph::OutArcIt e(g, n); e != INVALID; ++e) {
 		      sum += flow[e];
+		    }
 		    for (SmartDigraph::InArcIt e(g, n); e != INVALID; ++e) {
 		      sum -= flow[e];
+		    }
 		    if (sum != 0) return false;

0 comments (0 inline)

RhodeCode

Login to your account