COIN-OR::LEMON - Graph Library

Ticket #100: fddd4d1ac621.patch

File fddd4d1ac621.patch, 12.1 KB (added by Balazs Dezso, 11 years ago)
  • lemon/concepts/heap.h

    # HG changeset patch
    # User Balazs Dezso <deba@inf.elte.hu>
    # Date 1215781309 -7200
    # Node ID fddd4d1ac62161651f9abd6922a46969488187d7
    # Parent  a5ee729dc1e10eb45f0925d2956766671f1c3d63
    Cleaning of heap test and bug fix in heap concept check
    
    diff -r a5ee729dc1e1 -r fddd4d1ac621 lemon/concepts/heap.h
    a b  
    181181
    182182          Item item;
    183183          Prio prio;
    184           State state;
    185184          item=Item();
    186185          prio=Prio();
    187186          ignore_unused_variable_warning(item);
    188187          ignore_unused_variable_warning(prio);
    189           ignore_unused_variable_warning(state);
    190188
    191189          OwnItem own_item;
    192190          OwnPrio own_prio;
     
    203201          ignore_unused_variable_warning(heap2);
    204202         
    205203          int s = heap.size();
     204          ignore_unused_variable_warning(s);
    206205          bool e = heap.empty();
     206          ignore_unused_variable_warning(e);
    207207
    208208          prio = heap.prio();
    209209          item = heap.top();
     
    227227          heap.erase(own_item);
    228228          heap.clear();
    229229
    230           state = heap.state(item);
    231           heap.state(item, state);
    232           state = heap.state(own_item);
     230          own_state = heap.state(own_item);
    233231          heap.state(own_item, own_state);
    234232
    235           state = _Heap::PRE_HEAP;
    236           state = _Heap::IN_HEAP;
    237           state = _Heap::POST_HEAP;
    238233          own_state = _Heap::PRE_HEAP;
    239234          own_state = _Heap::IN_HEAP;
    240235          own_state = _Heap::POST_HEAP;
  • test/CMakeLists.txt

    diff -r a5ee729dc1e1 -r fddd4d1ac621 test/CMakeLists.txt
    a b  
    1313  graph_copy_test
    1414  graph_test
    1515  graph_utils_test
     16  heap_test
    1617  kruskal_test
    1718  maps_test
    1819  path_test
  • test/Makefile.am

    diff -r a5ee729dc1e1 -r fddd4d1ac621 test/Makefile.am
    a b  
    33
    44noinst_HEADERS += \
    55        test/graph_test.h \
    6         test/heap_test.h \
    76        test/graph_maps_test.h \
    87        test/test_tools.h
    98
     
    1817        test/graph_copy_test \
    1918        test/graph_test \
    2019        test/graph_utils_test \
     20        test/heap_test \
    2121        test/kruskal_test \
    2222        test/maps_test \
    2323        test/random_test \
     
    4040test_graph_copy_test_SOURCES = test/graph_copy_test.cc
    4141test_graph_test_SOURCES = test/graph_test.cc
    4242test_graph_utils_test_SOURCES = test/graph_utils_test.cc
    43 # test_heap_test_SOURCES = test/heap_test.cc
     43test_heap_test_SOURCES = test/heap_test.cc
    4444test_kruskal_test_SOURCES = test/kruskal_test.cc
    4545test_maps_test_SOURCES = test/maps_test.cc
    4646test_path_test_SOURCES = test/path_test.cc
  • test/heap_test.cc

    diff -r a5ee729dc1e1 -r fddd4d1ac621 test/heap_test.cc
    a b  
    2424#include <lemon/concept_check.h>
    2525#include <lemon/concepts/heap.h>
    2626
    27 #include <lemon/list_graph.h>
     27#include <lemon/smart_graph.h>
    2828
    29 #include <lemon/digraph_reader.h>
     29#include <lemon/lgf_reader.h>
     30#include <lemon/dijkstra.h>
     31#include <lemon/maps.h>
    3032
    3133#include <lemon/bin_heap.h>
    32 #include <lemon/fib_heap.h>
    33 #include <lemon/radix_heap.h>
    34 #include <lemon/bucket_heap.h>
    3534
    3635#include "test_tools.h"
    3736
    38 #include "heap_test.h"
    39 
    40 #include <lemon/time_measure.h>
    41 
    4237using namespace lemon;
    4338using namespace lemon::concepts;
     39
     40typedef ListDigraph Digraph;
     41DIGRAPH_TYPEDEFS(Digraph);
     42
     43char test_lgf[] =
     44  "@nodes\n"
     45  "label\n"     
     46  "0\n"
     47  "1\n"
     48  "2\n"
     49  "3\n"
     50  "4\n"
     51  "5\n"
     52  "6\n"
     53  "7\n"
     54  "8\n"
     55  "9\n"
     56  "@arcs\n"
     57  "             label   capacity\n"     
     58  "0    5       0       94\n"   
     59  "3    9       1       11\n"   
     60  "8    7       2       83\n"   
     61  "1    2       3       94\n"   
     62  "5    7       4       35\n"   
     63  "7    4       5       84\n"   
     64  "9    5       6       38\n"   
     65  "0    4       7       96\n"   
     66  "6    7       8       6\n"   
     67  "3    1       9       27\n"   
     68  "5    2       10      77\n"   
     69  "5    6       11      69\n"   
     70  "6    5       12      41\n"   
     71  "4    6       13      70\n"   
     72  "3    2       14      45\n"   
     73  "7    9       15      93\n"   
     74  "5    9       16      50\n"   
     75  "9    0       17      94\n"   
     76  "9    6       18      67\n"   
     77  "0    9       19      86\n"   
     78  "@attributes\n"
     79  "source 3\n";
     80
     81int test_seq[] = { 2, 28, 19, 27, 33, 25, 13, 41, 10, 26,  1,  9,  4, 34};
     82int test_inc[] = {20, 28, 34, 16,  0, 46, 44,  0, 42, 32, 14,  8,  6, 37};
     83
     84int test_len = sizeof(test_seq) / sizeof(test_seq[0]);
     85
     86template <typename Heap>
     87void heapSortTest() {
     88  RangeMap<int> map(test_len, -1);
     89
     90  Heap heap(map);
     91 
     92  std::vector<int> v(test_len);
     93
     94  for (int i = 0; i < test_len; ++i) {
     95    v[i] = test_seq[i];
     96    heap.push(i, v[i]);
     97  }
     98  std::sort(v.begin(), v.end());
     99  for (int i = 0; i < test_len; ++i) {
     100    check(v[i] == heap.prio() ,"Wrong order in heap sort.");
     101    heap.pop();
     102  }
     103}
     104
     105template <typename Heap>
     106void heapIncreaseTest() {
     107  RangeMap<int> map(test_len, -1);
     108
     109  Heap heap(map);
     110 
     111  std::vector<int> v(test_len);
     112
     113  for (int i = 0; i < test_len; ++i) {
     114    v[i] = test_seq[i];
     115    heap.push(i, v[i]);
     116  }
     117  for (int i = 0; i < test_len; ++i) {
     118    v[i] += test_inc[i];
     119    heap.increase(i, v[i]);
     120  }
     121  std::sort(v.begin(), v.end());
     122  for (int i = 0; i < test_len; ++i) {
     123    check(v[i] == heap.prio() ,"Wrong order in heap increase test.");
     124    heap.pop();
     125  }
     126}
     127
     128
     129
     130template <typename Heap>
     131void dijkstraHeapTest(const Digraph& digraph, const IntArcMap& length,
     132                      Node source) {
     133 
     134  typename Dijkstra<Digraph, IntArcMap>::template DefStandardHeap<Heap>::
     135    Create dijkstra(digraph, length);
     136
     137  dijkstra.run(source);
     138
     139  for(ArcIt a(digraph); a != INVALID; ++a) {
     140    Node s = digraph.source(a);
     141    Node t = digraph.target(a);
     142    if (dijkstra.reached(s)) {
     143      check( dijkstra.dist(t) - dijkstra.dist(s) <= length[a],
     144             "Error in a shortest path tree!");
     145    }
     146  }
     147
     148  for(NodeIt n(digraph); n != INVALID; ++n) {
     149    if ( dijkstra.reached(n) && dijkstra.predArc(n) != INVALID ) {
     150      Arc a = dijkstra.predArc(n);
     151      Node s = digraph.source(a);
     152      check( dijkstra.dist(n) - dijkstra.dist(s) == length[a],
     153             "Error in a shortest path tree!");
     154    }
     155  }
     156
     157}
    44158
    45159int main() {
    46160
    47161  typedef int Item;
    48162  typedef int Prio;
    49   typedef IntIntMap ItemIntMap;
     163  typedef RangeMap<int> ItemIntMap;
     164 
     165  Digraph digraph;
     166  IntArcMap length(digraph);
     167  Node source;
    50168
    51   typedef ListDigraph Digraph;
    52 
    53   typedef Digraph::Arc Arc;
    54   typedef Digraph::Node Node;
    55   typedef Digraph::ArcIt ArcIt;
    56   typedef Digraph::NodeIt NodeIt;
    57   typedef Digraph::ArcMap<int> LengthMap;
    58 
    59   Digraph digraph;
    60   LengthMap length(digraph);
    61   Node start;
    62 
    63   /// \todo create own test digraph
    64 
    65   std::string f_name;
    66   if( getenv("srcdir") )
    67     f_name = std::string(getenv("srcdir"));
    68   else f_name = ".";
    69   f_name += "/test/dijkstra_test.lgf";
    70  
    71   std::ifstream input(f_name.c_str());
    72   check(input, "Input file '" << f_name << "' not found.");
    73   DigraphReader<Digraph>(input, digraph).
    74     readArcMap("capacity", length).
    75     readNode("source", start).
     169  std::istringstream input(test_lgf);
     170  digraphReader(input, digraph).
     171    arcMap("capacity", length).
     172    node("source", source).
    76173    run(); 
    77174 
    78175  {
    79     std::cout << "Checking Bin Heap" << std::endl;
    80 
    81176    typedef BinHeap<Prio, ItemIntMap> IntHeap;
    82177    checkConcept<Heap<Prio, ItemIntMap>, IntHeap>();
    83     heapSortTest<IntHeap>(100);
    84     heapIncreaseTest<IntHeap>(100);
     178    heapSortTest<IntHeap>();
     179    heapIncreaseTest<IntHeap>();
    85180   
    86     typedef FibHeap<Prio, Digraph::NodeMap<int> > NodeHeap;
    87     checkConcept<Heap<Prio, Digraph::NodeMap<int> >, NodeHeap>();
    88     Timer timer;
    89     dijkstraHeapTest<Digraph, LengthMap, NodeHeap>(digraph, length, start);
    90     std::cout << timer << std::endl;
    91   }
    92   {
    93     std::cout << "Checking Fib Heap" << std::endl;
    94 
    95     typedef FibHeap<Prio, ItemIntMap> IntHeap;
    96     checkConcept<Heap<Prio, ItemIntMap>, IntHeap>();
    97     heapSortTest<IntHeap>(100);
    98     heapIncreaseTest<IntHeap>(100);
    99 
    100     typedef FibHeap<Prio, Digraph::NodeMap<int> > NodeHeap;
    101     checkConcept<Heap<Prio, Digraph::NodeMap<int> >, NodeHeap>();
    102     Timer timer;
    103     dijkstraHeapTest<Digraph, LengthMap, NodeHeap>(digraph, length, start);
    104     std::cout << timer << std::endl;
    105   }
    106   {
    107     std::cout << "Checking Radix Heap" << std::endl;
    108 
    109     typedef RadixHeap<ItemIntMap> IntHeap;
    110     checkConcept<Heap<Prio, ItemIntMap>, IntHeap>();
    111     heapSortTest<IntHeap>(100);
    112     heapIncreaseTest<IntHeap>(100);
    113 
    114     typedef RadixHeap<Digraph::NodeMap<int> > NodeHeap;
    115     checkConcept<Heap<Prio, Digraph::NodeMap<int> >, NodeHeap>();
    116     Timer timer;
    117     dijkstraHeapTest<Digraph, LengthMap, NodeHeap>(digraph, length, start);
    118     std::cout << timer << std::endl;
    119   }
    120 
    121   {
    122     std::cout << "Checking Bucket Heap" << std::endl;
    123 
    124     typedef BucketHeap<ItemIntMap> IntHeap;
    125     checkConcept<Heap<Prio, ItemIntMap>, IntHeap>();
    126     heapSortTest<IntHeap>(100);
    127     heapIncreaseTest<IntHeap>(100);
    128 
    129     typedef BucketHeap<Digraph::NodeMap<int> > NodeHeap;
    130     checkConcept<Heap<Prio, Digraph::NodeMap<int> >, NodeHeap>();
    131     Timer timer;
    132     dijkstraHeapTest<Digraph, LengthMap, NodeHeap>(digraph, length, start);
    133     std::cout << timer << std::endl;
     181    typedef BinHeap<Prio, IntNodeMap > NodeHeap;
     182    checkConcept<Heap<Prio, IntNodeMap >, NodeHeap>();
     183    dijkstraHeapTest<NodeHeap>(digraph, length, source);
    134184  }
    135185
    136186  return 0;
  • deleted file test/heap_test.h

    diff -r a5ee729dc1e1 -r fddd4d1ac621 test/heap_test.h
    + -  
    1 /* -*- C++ -*-
    2  *
    3  * This file is a part of LEMON, a generic C++ optimization library
    4  *
    5  * Copyright (C) 2003-2008
    6  * Egervary Jeno Kombinatorikus Optimalizalasi Kutatocsoport
    7  * (Egervary Research Group on Combinatorial Optimization, EGRES).
    8  *
    9  * Permission to use, modify and distribute this software is granted
    10  * provided that this copyright notice appears in all copies. For
    11  * precise terms see the accompanying LICENSE file.
    12  *
    13  * This software is provided "AS IS" with no warranty of any kind,
    14  * express or implied, and with no claim as to its suitability for any
    15  * purpose.
    16  *
    17  */
    18 
    19 #include <vector>
    20 #include <algorithm>
    21 
    22 #include <lemon/dijkstra.h>
    23 
    24 class IntIntMap : public std::vector<int> {
    25 public:
    26   typedef std::vector<int> Parent;
    27 
    28   typedef int Key;
    29   typedef int Value;
    30 
    31   IntIntMap() : Parent() {}
    32   IntIntMap(int n) : Parent(n) {}
    33   IntIntMap(int n, int v) : Parent(n, v) {}
    34 
    35   void set(int key, int value) {
    36     Parent::operator[](key) = value;
    37   }
    38 };
    39 
    40 
    41 template <typename _Heap>
    42 void heapSortTest(int n) {
    43   typedef _Heap Heap;
    44   IntIntMap map(n, -1);
    45 
    46   Heap heap(map);
    47  
    48   std::vector<int> v(n);
    49 
    50   for (int i = 0; i < n; ++i) {
    51     v[i] = rnd[1000];
    52     heap.push(i, v[i]);
    53   }
    54   std::sort(v.begin(), v.end());
    55   for (int i = 0; i < n; ++i) {
    56     check(v[i] == heap.prio() ,"Wrong order in heap sort.");
    57     heap.pop();
    58   }
    59 }
    60 
    61 template <typename _Heap>
    62 void heapIncreaseTest(int n) {
    63   typedef _Heap Heap;
    64   IntIntMap map(n, -1);
    65 
    66   Heap heap(map);
    67  
    68   std::vector<int> v(n);
    69 
    70   for (int i = 0; i < n; ++i) {
    71     v[i] = rnd[1000];
    72     heap.push(i, v[i]);
    73   }
    74   for (int i = 0; i < n; ++i) {
    75     v[i] += rnd[1000];
    76     heap.increase(i, v[i]);
    77   }
    78   std::sort(v.begin(), v.end());
    79   for (int i = 0; i < n; ++i) {
    80     check(v[i] == heap.prio() ,"Wrong order in heap increase test.");
    81     heap.pop();
    82   }
    83 }
    84 
    85 
    86 
    87 template <typename _Digraph, typename _LengthMap, typename _Heap>
    88 void dijkstraHeapTest(_Digraph& digraph, _LengthMap& length,
    89                       typename _Digraph::Node& start) {
    90 
    91   typedef _Heap Heap;
    92   typedef _Digraph Digraph;
    93   typedef _LengthMap LengthMap;
    94 
    95   typedef typename Digraph::Node Node;
    96   typedef typename Digraph::Arc Arc;
    97   typedef typename Digraph::NodeIt NodeIt;
    98   typedef typename Digraph::ArcIt ArcIt;
    99 
    100   typename Dijkstra<Digraph, LengthMap>::template DefStandardHeap<Heap>::
    101     Create dijkstra(digraph, length);
    102 
    103   dijkstra.run(start);
    104 
    105   for(ArcIt e(digraph); e!=INVALID; ++e) {
    106     Node u=digraph.source(e);
    107     Node v=digraph.target(e);
    108     if (dijkstra.reached(u)) {
    109       check( dijkstra.dist(v) - dijkstra.dist(u) <= length[e],
    110              "Error in a shortest path tree arc!");
    111     }
    112   }
    113 
    114   for(NodeIt v(digraph); v!=INVALID; ++v) {
    115     if ( dijkstra.reached(v) && dijkstra.predArc(v) != INVALID ) {
    116       Arc e=dijkstra.predArc(v);
    117       Node u=digraph.source(e);
    118       check( dijkstra.dist(v) - dijkstra .dist(u) == length[e],
    119              "Error in a shortest path tree arc!");
    120     }
    121   }
    122 
    123 }