[Lemon-commits] Alpar Juttner: Merge
Lemon HG
hg at lemon.cs.elte.hu
Wed Apr 15 08:26:54 CEST 2009
details: http://lemon.cs.elte.hu/hg/lemon/rev/630c4898c548
changeset: 621:630c4898c548
user: Alpar Juttner <alpar [at] cs.elte.hu>
date: Wed Apr 15 07:13:30 2009 +0100
description:
Merge
diffstat:
test/bfs_test.cc | 59 ++++++++++++++++++++++++-----
test/circulation_test.cc | 35 ++++++++++-------
test/dfs_test.cc | 53 ++++++++++++++++++++++----
test/dijkstra_test.cc | 92 ++++++++++++++++++++++++++++++++++-----------
test/preflow_test.cc | 36 ++++++++++-------
5 files changed, 204 insertions(+), 71 deletions(-)
diffs (truncated from 409 to 300 lines):
diff --git a/test/bfs_test.cc b/test/bfs_test.cc
--- a/test/bfs_test.cc
+++ b/test/bfs_test.cc
@@ -58,41 +58,80 @@
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);
diff --git a/test/circulation_test.cc b/test/circulation_test.cc
--- a/test/circulation_test.cc
+++ b/test/circulation_test.cc
@@ -71,27 +71,34 @@
DeltaMap delta;
FlowMap flow;
BarrierMap bar;
+ VType v;
+ bool b;
- Circulation<Digraph, CapMap, CapMap, DeltaMap>
- ::SetFlowMap<FlowMap>
- ::SetElevator<Elev>
- ::SetStandardElevator<LinkedElev>
- ::Create circ_test(g,lcap,ucap,delta);
-
- circ_test.lowerCapMap(lcap);
- circ_test.upperCapMap(ucap);
- circ_test.deltaMap(delta);
- flow = circ_test.flowMap();
- circ_test.flowMap(flow);
+ typedef Circulation<Digraph, CapMap, CapMap, DeltaMap>
+ ::SetFlowMap<FlowMap>
+ ::SetElevator<Elev>
+ ::SetStandardElevator<LinkedElev>
+ ::Create CirculationType;
+ CirculationType circ_test(g, lcap, ucap, delta);
+ const CirculationType& const_circ_test = circ_test;
+
+ 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>
diff --git a/test/dfs_test.cc b/test/dfs_test.cc
--- a/test/dfs_test.cc
+++ b/test/dfs_test.cc
@@ -62,39 +62,74 @@
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);
diff --git a/test/dijkstra_test.cc b/test/dijkstra_test.cc
--- a/test/dijkstra_test.cc
+++ b/test/dijkstra_test.cc
@@ -60,48 +60,94 @@
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);
More information about the Lemon-commits
mailing list