COIN-OR::LEMON - Graph Library

About

Downloads

Documentation

Development

Issue Tracker

Browse Tickets

Custom Query

Roadmap

Browse Source

Local Info

Mailing Lists

Search

Changes in / [589:630c4898c548:588:58f70400e139] in lemon-1.2


Ignore:
Location:
test
Files:
5 edited

Legend:

Unmodified
Added
Removed

  • test/bfs_test.cc

    r585 r440  
    5959
    6060  Digraph G;
    61   Node s, t, n;
     61  Node s, t;
    6262  Arc e;
    63   int l, i;
     63  int l;
    6464  bool b;
    6565  BType::DistMap d(G);
    6666  BType::PredMap p(G);
    6767  Path<Digraph> pp;
    68   concepts::ReadMap<Node,bool> nm;
    6968
    7069  {
    7170    BType bfs_test(G);
    72     const BType& const_bfs_test = bfs_test;
    7371
    7472    bfs_test.run(s);
    … …  
    7674    bfs_test.run();
    7775
    78     bfs_test.init();
    79     bfs_test.addSource(s);
    80     n = bfs_test.processNextNode();
    81     n = bfs_test.processNextNode(t, b);
    82     n = bfs_test.processNextNode(nm, n);
    83     n = const_bfs_test.nextNode();
    84     b = const_bfs_test.emptyQueue();
    85     i = const_bfs_test.queueSize();
    86    
    87     bfs_test.start();
    88     bfs_test.start(t);
    89     bfs_test.start(nm);
    90 
    91     l  = const_bfs_test.dist(t);
    92     e  = const_bfs_test.predArc(t);
    93     s  = const_bfs_test.predNode(t);
    94     b  = const_bfs_test.reached(t);
    95     d  = const_bfs_test.distMap();
    96     p  = const_bfs_test.predMap();
    97     pp = const_bfs_test.path(t);
     76    l  = bfs_test.dist(t);
     77    e  = bfs_test.predArc(t);
     78    s  = bfs_test.predNode(t);
     79    b  = bfs_test.reached(t);
     80    d  = bfs_test.distMap();
     81    p  = bfs_test.predMap();
     82    pp = bfs_test.path(t);
    9883  }
    9984  {
    … …  
    10287      ::SetDistMap<concepts::ReadWriteMap<Node,int> >
    10388      ::SetReachedMap<concepts::ReadWriteMap<Node,bool> >
     89      ::SetProcessedMap<concepts::WriteMap<Node,bool> >
    10490      ::SetStandardProcessedMap
    105       ::SetProcessedMap<concepts::WriteMap<Node,bool> >
    10691      ::Create bfs_test(G);
    107      
    108     concepts::ReadWriteMap<Node,Arc> pred_map;
    109     concepts::ReadWriteMap<Node,int> dist_map;
    110     concepts::ReadWriteMap<Node,bool> reached_map;
    111     concepts::WriteMap<Node,bool> processed_map;
    112    
    113     bfs_test
    114       .predMap(pred_map)
    115       .distMap(dist_map)
    116       .reachedMap(reached_map)
    117       .processedMap(processed_map);
    11892
    11993    bfs_test.run(s);
    12094    bfs_test.run(s,t);
    12195    bfs_test.run();
    122    
    123     bfs_test.init();
    124     bfs_test.addSource(s);
    125     n = bfs_test.processNextNode();
    126     n = bfs_test.processNextNode(t, b);
    127     n = bfs_test.processNextNode(nm, n);
    128     n = bfs_test.nextNode();
    129     b = bfs_test.emptyQueue();
    130     i = bfs_test.queueSize();
    131    
    132     bfs_test.start();
    133     bfs_test.start(t);
    134     bfs_test.start(nm);
    13596
    13697    l  = bfs_test.dist(t);

  • test/circulation_test.cc

    r585 r440  
    7272  FlowMap flow;
    7373  BarrierMap bar;
    74   VType v;
    75   bool b;
    7674
    77   typedef Circulation<Digraph, CapMap, CapMap, DeltaMap>
    78             ::SetFlowMap<FlowMap>
    79             ::SetElevator<Elev>
    80             ::SetStandardElevator<LinkedElev>
    81             ::Create CirculationType;
    82   CirculationType circ_test(g, lcap, ucap, delta);
    83   const CirculationType& const_circ_test = circ_test;
    84    
    85   circ_test
    86     .lowerCapMap(lcap)
    87     .upperCapMap(ucap)
    88     .deltaMap(delta)
    89     .flowMap(flow);
     75  Circulation<Digraph, CapMap, CapMap, DeltaMap>
     76    ::SetFlowMap<FlowMap>
     77    ::SetElevator<Elev>
     78    ::SetStandardElevator<LinkedElev>
     79    ::Create circ_test(g,lcap,ucap,delta);
     80
     81  circ_test.lowerCapMap(lcap);
     82  circ_test.upperCapMap(ucap);
     83  circ_test.deltaMap(delta);
     84  flow = circ_test.flowMap();
     85  circ_test.flowMap(flow);
    9086
    9187  circ_test.init();
    … …  
    9490  circ_test.run();
    9591
    96   v = const_circ_test.flow(a);
    97   const FlowMap& fm = const_circ_test.flowMap();
    98   b = const_circ_test.barrier(n);
    99   const_circ_test.barrierMap(bar);
    100  
    101   ignore_unused_variable_warning(fm);
     92  circ_test.barrier(n);
     93  circ_test.barrierMap(bar);
     94  circ_test.flow(a);
    10295}
    10396

  • test/dfs_test.cc

    r585 r440  
    6363  Node s, t;
    6464  Arc e;
    65   int l, i;
     65  int l;
    6666  bool b;
    6767  DType::DistMap d(G);
    6868  DType::PredMap p(G);
    6969  Path<Digraph> pp;
    70   concepts::ReadMap<Arc,bool> am;
    7170
    7271  {
    7372    DType dfs_test(G);
    74     const DType& const_dfs_test = dfs_test;
    7573
    7674    dfs_test.run(s);
    … …  
    7876    dfs_test.run();
    7977
    80     dfs_test.init();
    81     dfs_test.addSource(s);
    82     e = dfs_test.processNextArc();
    83     e = const_dfs_test.nextArc();
    84     b = const_dfs_test.emptyQueue();
    85     i = const_dfs_test.queueSize();
    86    
    87     dfs_test.start();
    88     dfs_test.start(t);
    89     dfs_test.start(am);
    90 
    91     l  = const_dfs_test.dist(t);
    92     e  = const_dfs_test.predArc(t);
    93     s  = const_dfs_test.predNode(t);
    94     b  = const_dfs_test.reached(t);
    95     d  = const_dfs_test.distMap();
    96     p  = const_dfs_test.predMap();
    97     pp = const_dfs_test.path(t);
     78    l  = dfs_test.dist(t);
     79    e  = dfs_test.predArc(t);
     80    s  = dfs_test.predNode(t);
     81    b  = dfs_test.reached(t);
     82    d  = dfs_test.distMap();
     83    p  = dfs_test.predMap();
     84    pp = dfs_test.path(t);
    9885  }
    9986  {
    … …  
    10289      ::SetDistMap<concepts::ReadWriteMap<Node,int> >
    10390      ::SetReachedMap<concepts::ReadWriteMap<Node,bool> >
     91      ::SetProcessedMap<concepts::WriteMap<Node,bool> >
    10492      ::SetStandardProcessedMap
    105       ::SetProcessedMap<concepts::WriteMap<Node,bool> >
    10693      ::Create dfs_test(G);
    107 
    108     concepts::ReadWriteMap<Node,Arc> pred_map;
    109     concepts::ReadWriteMap<Node,int> dist_map;
    110     concepts::ReadWriteMap<Node,bool> reached_map;
    111     concepts::WriteMap<Node,bool> processed_map;
    112    
    113     dfs_test
    114       .predMap(pred_map)
    115       .distMap(dist_map)
    116       .reachedMap(reached_map)
    117       .processedMap(processed_map);
    11894
    11995    dfs_test.run(s);
    12096    dfs_test.run(s,t);
    12197    dfs_test.run();
    122     dfs_test.init();
    123 
    124     dfs_test.addSource(s);
    125     e = dfs_test.processNextArc();
    126     e = dfs_test.nextArc();
    127     b = dfs_test.emptyQueue();
    128     i = dfs_test.queueSize();
    129    
    130     dfs_test.start();
    131     dfs_test.start(t);
    132     dfs_test.start(am);
    13398
    13499    l  = dfs_test.dist(t);

  • test/dijkstra_test.cc

    r585 r440  
    6161
    6262  Digraph G;
    63   Node s, t, n;
     63  Node s, t;
    6464  Arc e;
    6565  VType l;
    66   int i;
    6766  bool b;
    6867  DType::DistMap d(G);
    … …  
    7069  LengthMap length;
    7170  Path<Digraph> pp;
    72   concepts::ReadMap<Node,bool> nm;
    7371
    7472  {
    7573    DType dijkstra_test(G,length);
    76     const DType& const_dijkstra_test = dijkstra_test;
    7774
    7875    dijkstra_test.run(s);
    7976    dijkstra_test.run(s,t);
    8077
    81     dijkstra_test.init();
    82     dijkstra_test.addSource(s);
    83     dijkstra_test.addSource(s, 1);
    84     n = dijkstra_test.processNextNode();
    85     n = const_dijkstra_test.nextNode();
    86     b = const_dijkstra_test.emptyQueue();
    87     i = const_dijkstra_test.queueSize();
    88    
    89     dijkstra_test.start();
    90     dijkstra_test.start(t);
    91     dijkstra_test.start(nm);
    92 
    93     l  = const_dijkstra_test.dist(t);
    94     e  = const_dijkstra_test.predArc(t);
    95     s  = const_dijkstra_test.predNode(t);
    96     b  = const_dijkstra_test.reached(t);
    97     b  = const_dijkstra_test.processed(t);
    98     d  = const_dijkstra_test.distMap();
    99     p  = const_dijkstra_test.predMap();
    100     pp = const_dijkstra_test.path(t);
    101     l  = const_dijkstra_test.currentDist(t);
     78    l  = dijkstra_test.dist(t);
     79    e  = dijkstra_test.predArc(t);
     80    s  = dijkstra_test.predNode(t);
     81    b  = dijkstra_test.reached(t);
     82    d  = dijkstra_test.distMap();
     83    p  = dijkstra_test.predMap();
     84    pp = dijkstra_test.path(t);
    10285  }
    10386  {
    … …  
    10588      ::SetPredMap<concepts::ReadWriteMap<Node,Arc> >
    10689      ::SetDistMap<concepts::ReadWriteMap<Node,VType> >
     90      ::SetProcessedMap<concepts::WriteMap<Node,bool> >
    10791      ::SetStandardProcessedMap
    108       ::SetProcessedMap<concepts::WriteMap<Node,bool> >
    10992      ::SetOperationTraits<DijkstraDefaultOperationTraits<VType> >
    11093      ::SetHeap<BinHeap<VType, concepts::ReadWriteMap<Node,int> > >
    11194      ::SetStandardHeap<BinHeap<VType, concepts::ReadWriteMap<Node,int> > >
    112       ::SetHeap<BinHeap<VType, concepts::ReadWriteMap<Node,int> >,
    113                 concepts::ReadWriteMap<Node,int> >
    11495      ::Create dijkstra_test(G,length);
    115 
    116     LengthMap length_map;
    117     concepts::ReadWriteMap<Node,Arc> pred_map;
    118     concepts::ReadWriteMap<Node,VType> dist_map;
    119     concepts::WriteMap<Node,bool> processed_map;
    120     concepts::ReadWriteMap<Node,int> heap_cross_ref;
    121     BinHeap<VType, concepts::ReadWriteMap<Node,int> > heap(heap_cross_ref);
    122    
    123     dijkstra_test
    124       .lengthMap(length_map)
    125       .predMap(pred_map)
    126       .distMap(dist_map)
    127       .processedMap(processed_map)
    128       .heap(heap, heap_cross_ref);
    12996
    13097    dijkstra_test.run(s);
    13198    dijkstra_test.run(s,t);
    132 
    133     dijkstra_test.addSource(s);
    134     dijkstra_test.addSource(s, 1);
    135     n = dijkstra_test.processNextNode();
    136     n = dijkstra_test.nextNode();
    137     b = dijkstra_test.emptyQueue();
    138     i = dijkstra_test.queueSize();
    139    
    140     dijkstra_test.start();
    141     dijkstra_test.start(t);
    142     dijkstra_test.start(nm);
    14399
    144100    l  = dijkstra_test.dist(t);
    … …  
    146102    s  = dijkstra_test.predNode(t);
    147103    b  = dijkstra_test.reached(t);
    148     b  = dijkstra_test.processed(t);
    149104    pp = dijkstra_test.path(t);
    150     l  = dijkstra_test.currentDist(t);
    151105  }
    152106

  • test/preflow_test.cc

    r585 r440  
    8585  FlowMap flow;
    8686  CutMap cut;
    87   VType v;
    88   bool b;
    89 
    90   typedef Preflow<Digraph, CapMap>
    91             ::SetFlowMap<FlowMap>
    92             ::SetElevator<Elev>
    93             ::SetStandardElevator<LinkedElev>
    94             ::Create PreflowType;
    95   PreflowType preflow_test(g, cap, n, n);
    96   const PreflowType& const_preflow_test = preflow_test;
    97 
    98   preflow_test
    99     .capacityMap(cap)
    100     .flowMap(flow)
    101     .source(n)
    102     .target(n);
     87
     88  Preflow<Digraph, CapMap>
     89    ::SetFlowMap<FlowMap>
     90    ::SetElevator<Elev>
     91    ::SetStandardElevator<LinkedElev>
     92    ::Create preflow_test(g,cap,n,n);
     93
     94  preflow_test.capacityMap(cap);
     95  flow = preflow_test.flowMap();
     96  preflow_test.flowMap(flow);
     97  preflow_test.source(n);
     98  preflow_test.target(n);
    10399
    104100  preflow_test.init();
    … …  
    109105  preflow_test.runMinCut();
    110106
    111   v = const_preflow_test.flowValue();
    112   v = const_preflow_test.flow(e);
    113   const FlowMap& fm = const_preflow_test.flowMap();
    114   b = const_preflow_test.minCut(n);
    115   const_preflow_test.minCutMap(cut);
    116  
    117   ignore_unused_variable_warning(fm);
     107  preflow_test.flowValue();
     108  preflow_test.minCut(n);
     109  preflow_test.minCutMap(cut);
     110  preflow_test.flow(e);
     111
    118112}
    119113
Note: See TracChangeset for help on using the changeset viewer.