Index: benchmark/Makefile.am
===================================================================
--- benchmark/Makefile.am	(revision 2341)
+++ benchmark/Makefile.am	(revision 2647)
@@ -1,36 +1,23 @@
-EXTRA_DIST += \
-	benchmark/Makefile
-	benchmark/edge_lookup_test
-
-noinst_HEADERS += benchmark/bench_tools.h
+#noinst_HEADERS += benchmark/bench_tools.h
 
 if WANT_BENCHMARK
 
-noinst_PROGRAMS += \
-	benchmark/graph-bench \
-	benchmark/hcube \
-	benchmark/swap_bipartite_bench \
-	benchmark/bfs-bench \
-	benchmark/radix_sort-bench \
-	benchmark/swap_bipartite_bench \
-	benchmark/random_bench \
-	benchmark/edge_lookup \
-	benchmark/min_cut
+#noinst_PROGRAMS += \
+#	benchmark/graph-bench \
+#	benchmark/hcube \
+#	benchmark/swap_bipartite_bench \
+#	benchmark/bfs-bench \
+#	benchmark/radix_sort-bench \
+#	benchmark/swap_bipartite_bench
 
 endif WANT_BENCHMARK
 
-benchmark_graph_bench_SOURCES = benchmark/graph-bench.cc
+#benchmark_graph_bench_SOURCES = benchmark/graph-bench.cc
 
-benchmark_hcube_SOURCES = benchmark/hcube.cc
+#benchmark_hcube_SOURCES = benchmark/hcube.cc
 
-benchmark_bfs_bench_SOURCES = benchmark/bfs-bench.cc
+#benchmark_bfs_bench_SOURCES = benchmark/bfs-bench.cc
 
-benchmark_radix_sort_bench_SOURCES = benchmark/radix_sort-bench.cc
+#benchmark_radix_sort_bench_SOURCES = benchmark/radix_sort-bench.cc
 
-benchmark_swap_bipartite_bench_SOURCES = benchmark/swap_bipartite_bench.cc
-
-benchmark_random_bench_SOURCES = benchmark/random_bench.cc
-
-benchmark_edge_lookup_SOURCES = benchmark/edge_lookup.cc
-
-benchmark_min_cut_SOURCES = benchmark/min_cut.cc
+#benchmark_swap_bipartite_bench_SOURCES = benchmark/swap_bipartite_bench.cc
Index: benchmark/bench_tools.h
===================================================================
--- benchmark/bench_tools.h	(revision 2553)
+++ 	(revision )
@@ -1,128 +1,0 @@
-/* -*- C++ -*-
- *
- * 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.
- *
- */
-
-#ifndef LEMON_BENCH_TEST_H
-#define LEMON_BENCH_TEST_H
-
-#include<vector>
-#include<iostream>
-
-#include<lemon/graph_utils.h>
-#include<lemon/time_measure.h>
-
-///A primitive primtest
-
-///\bug 2 is not a prime according to this function!
-///
-///\bug This function should go out of header file. I'm making it
-/// inline for now.
-inline bool isPrim(int n)
-{
-  if(n%2) {
-    for(int k=3;n/k>=k;k+=2)
-      if(!(n%k)) return false;
-    return true;
-  }
-  return false;
-}
-
-///Finds the smallest prime not less then \c n.
-
-///\bug This function should go out of header file. I'm making it
-/// inline for now.
-inline int nextPrim(int n)
-{
-  for(n+=!(n%2);!isPrim(n);n+=2) ;
-  return n;
-}
-
-
-/// Class to generate consecutive primes
-class Primes 
-{
-  std::vector<int> primes;
-  int n;
-  
-  bool isPrime(int m) 
-  {
-    for(int i=0;m<primes[i]*primes[i];i++) if(!(m%primes[i])) return false;
-    return true;
-  }
-public:
-  Primes() : n(1) {}
-  
-  int operator() ()
-    {
-      if(primes.size()==0) {
-	primes.push_back(2);
-	return 2;
-      }
-      else {
-	do n+=2; while(!isPrime(n));
-	primes.push_back(n);
-	return n;
-      }
-    }
-};
-
-inline void PrintTime(const char *ID, lemon::Timer &T) 
-{
-  lemon::TimeStamp S(T);
-  std::cout << ID << ' ' << S.userTime() << ' '
-	    << S.systemTime() << ' ' << S.realTime() << std::endl;
-}
-
-
-
-///
-template<class Graph>
-void addHyperCube(Graph &G,int dim,std::vector<typename Graph::Node> &nodes)
-{
-  GRAPH_TYPEDEFS(typename Graph);
-  
-  std::vector<int> bits(dim+1);
-  bits[0]=1;
-  for(int i=1;i<=dim;i++) bits[i]=2*bits[i-1];
-  
-  for(int i=0;i<bits[dim];i++) {
-    nodes.push_back(G.addNode());
-    for(int j=0;j<dim;j++) if(i&bits[j]) G.addEdge(nodes[i-bits[j]],nodes[i]);
-  }
-}
-
-///
-template<class Graph>
-void addBiDirHyperCube(Graph &G,int dim,std::vector<typename Graph::Node>&nodes)
-{
-  GRAPH_TYPEDEFS(typename Graph);
-  
-  std::vector<int> bits(dim+1);
-  bits[0]=1;
-  for(int i=1;i<=dim;i++) bits[i]=2*bits[i-1];
-  
-  for(int i=0;i<bits[dim];i++) {
-    nodes.push_back(G.addNode());
-    for(int j=0;j<dim;j++) if(i&bits[j]) {
-      G.addEdge(nodes[i-bits[j]],nodes[i]);
-      G.addEdge(nodes[i],nodes[i-bits[j]]);
-    }
-    
-  }
-}  
-
-#endif
Index: benchmark/benchmark
===================================================================
--- benchmark/benchmark	(revision 1435)
+++ 	(revision )
@@ -1,41 +1,0 @@
-#!/bin/bash
-
-function runtest () # prefix, prog, args
-{
-    echo $1 1>&2
-    $2 $3 $4 $5 $6 $7 $8 $9 >/dev/null;
-    for ((i=1;i<=3;i++))
-      do
-      $2 $3 $4 $5 $6 $7 $8 $9;
-    done |
-    awk '{print "'$1'",$0}'
-}
-
-function runalltest() #postfix, CXX, CXXFLAGS
-{
-    echo $1 1>&2
-    make clean >/dev/null
-    make CXX="$2" CXXFLAGS="$3"  >/dev/null
-    {
-	runtest HCUBE19 hcube 19
-	runtest BFS13-5000 hcube 13 5000
-	runtest BFS10-50000 hcube 10 50000
-	runtest GRBENCH graph-bench
-    } | awk "{print \$0, \"$1\"}"
-}
-
-runalltest "gcc-3.3 -O2"                 g++ "-O2"
-runalltest "gcc-3.3 -O2-march=pentium-m" g++ "-O2 -march=pentium-m"
-runalltest "gcc-3.3 -O3"                 g++ "-O3"
-runalltest "gcc-3.3 -O3-march=pentium-m" g++ "-O3 -march=pentium-m"
-
-runalltest "gcc-3.4 -O2"                 g++-3.4 "-O2"
-runalltest "gcc-3.4 -O2-march=pentium-m" g++-3.4 "-O2 -march=pentium-m"
-runalltest "gcc-3.4 -O3"                 g++-3.4 "-O3"
-runalltest "gcc-3.4 -O3-march=pentium-m" g++-3.4 "-O3 -march=pentium-m"
-         
-runalltest "icc -O2"                 icc "-O2"
-runalltest "icc -O2-march=pentium-m" icc "-O2 -march=pentium-m"
-runalltest "icc -O3"                 icc "-O3"
-runalltest "icc -O3-march=pentium-m" icc "-O3 -march=pentium-m"
-
Index: benchmark/bfs-bench.cc
===================================================================
--- benchmark/bfs-bench.cc	(revision 2569)
+++ 	(revision )
@@ -1,159 +1,0 @@
-/* -*- C++ -*-
- *
- * 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<queue>
-#include<lemon/math.h>
-#include<lemon/smart_graph.h>
-#include"bench_tools.h"
-
-using namespace std;
-using namespace lemon;
-
-inline int numOfOnes(int n,int dim)
-{
-  int s=0;
-  for(int i=0;i<dim;i++) {
-    s+=n%2;
-    n>>=1;
-  }
-  return s;
-}
-
-inline int numOfZeros(int n,int dim)
-{
-  int s=dim;
-  for(int i=0;i<dim;i++) {
-    s-=n&1;
-    n>>=1;
-  }
-  return s;
-}
-
-template<class Graph>
-void bfsStlQueue(Graph &G,typename Graph::Node source)
-{
-  GRAPH_TYPEDEFS(typename Graph);
-
-  using namespace std;
-  
-  typename Graph::template NodeMap<bool> visited(G,false);
-    
-  queue<typename Graph::Node> Q;
-    
-  Q.push(source);
-  visited[source]=true;
-  do {
-    Node n(Q.front());
-    Node m;
-    Q.pop();
-    for(OutEdgeIt e(G,n);e!=INVALID;++e)
-      if(!visited[m=G.target(e)]) {
-	Q.push(m);
-	visited.set(m,true);
-      }
-  } while(!Q.empty());
-}
-
-template<class Graph>
-void bfsOwnQueue(Graph &G,typename Graph::Node source)
-{
-  GRAPH_TYPEDEFS(typename Graph);
-
-  using namespace std;
-  
-  typename Graph::template NodeMap<bool> visited(G,false);
-  
-  int N=G.nodeNum();
-  vector<typename Graph::Node> Q(N);
-  int Qh=0;
-  int Qt=0;
-  
-
-  Q[Qh++]=source;
-  visited.set(source,true);
-  do {
-    Node m;
-    Node n=Q[Qt++];
-    for(OutEdgeIt e(G,n);e!=INVALID;++e)
-      if(!visited[m=G.target(e)]) {
-	Q[Qh++]=m;
-	visited.set(m,true);
-      }
-  } while(Qt!=Qh);
-}
-
-template<class Graph>
-void iteratorBench(Graph &G)
-{
-  GRAPH_TYPEDEFS(typename Graph);
-
-  int i=0;
-  
-  for(NodeIt n(G);n!=INVALID;++n)
-    for(OutEdgeIt e(G,n);e!=INVALID;++e)
-      i++;
-}
-
-int main(int argc, char *argv[])
-{
-  typedef SmartGraph Graph;
-
-  GRAPH_TYPEDEFS(Graph);
-
-  Graph G;
-  
-  Timer T;
-  
-  if(argc!=3) {
-    cout << "Usage: " << argv[0] << " dim mul\n";
-    return 1;
-  }
-  
-  int dim=atoi(argv[1]);
-  int mul=atoi(argv[2]);
-  
-//   cout << "Creating Hipercube ("<< (1<<dim) << " nodes, "
-//        << dim*(1<<dim) << " edges):";
-
-  T.restart();
-  vector<Node> nodes;
-  addBiDirHyperCube(G,dim,nodes);
-
-  PrintTime("GENGRAPH",T);
-
-  T.restart();
-  {
-    for(int i=0;i<mul;i++)
-      bfsStlQueue(G,nodes[0]);
-  }
-  PrintTime("BFS-STL",T);
-  T.restart();
-  {
-    for(int i=0;i<mul;i++)
-      bfsOwnQueue(G,nodes[0]);
-  }
-  PrintTime("BFS-OWN",T);
-  T.restart();
-  {
-    for(int i=0;i<mul;i++)
-      iteratorBench(G);
-  }
-  PrintTime("ITERATE",T);
-
-
-}
Index: benchmark/edge_lookup.cc
===================================================================
--- benchmark/edge_lookup.cc	(revision 2553)
+++ 	(revision )
@@ -1,556 +1,0 @@
-/* -*- C++ -*-
- *
- * 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/smart_graph.h>
-#include<vector>
-#include<lemon/time_measure.h>
-#include<lemon/random.h>
-#include<lemon/graph_utils.h>
-#include<algorithm>
-
-using namespace lemon;
-
-  template<class G>
-  class EdgeLookUp2
-  {
-  public:
-    GRAPH_TYPEDEFS(typename G);
-    typedef G Graph;
-
-  private:
-    const Graph &_g;
-    typename Graph::template NodeMap<int> _start;
-    typename Graph::template NodeMap<int> _end;
-    std::vector<Edge> _edges;
-    
-    class EdgeLess {
-      const Graph &g;
-    public:
-      EdgeLess(const Graph &_g) : g(_g) {}
-      bool operator()(Edge a,Edge b) const 
-      {
-	return g.target(a)<g.target(b);
-      }
-    };
-    
-  public:
-    
-    ///Constructor
-    EdgeLookUp2(const Graph &g) :_g(g),_start(g),_end(g) {refresh();}
-    
-  public:
-    ///Refresh the data structure at a node.
-    void refresh(Node n) 
-    {
-      const int bi = _start[n] = _edges.size();
-      for(OutEdgeIt e(_g,n);e!=INVALID;++e) _edges.push_back(e);
-      const typename std::vector<Edge>::iterator ei=_edges.end();
-      _end[n]=_edges.size();
-      std::sort(_edges.begin()+bi,ei,EdgeLess(_g));
-    }
-    ///Refresh the full data structure.
-    void refresh() 
-    {
-      _edges.clear();
-      for(NodeIt n(_g);n!=INVALID;++n) refresh(n);
-    }
-    
-    ///Find an edge between two nodes.
-    
-    ///Find an edge between two nodes.
-    ///\param s The source node
-    ///\param t The target node
-    ///\return An edge from \c s to \c t if there exists,
-    ///\ref INVALID otherwise.
-
-    Edge operator()(Node s, Node t) 
-    {
-      int a=_start[s];
-      int b=_end[s];
-      while(a<b) 
-	{
-	  int n=(a+b)/2;
-	  Node tt = _g.target(_edges[n]);
-	  if(tt==t) return _edges[n];
-	  else if(tt<t) a=n+1;
-	  else b=n;
-	}
-      return INVALID;
-    }
-
-    ///Find the next edge
-      
-      ///\warning This function is unimplemented.
-    Edge operator()(Node s, Node t, Edge prev) 
-    {
-      return prev==INVALID?(*this)(s,t):INVALID;
-    }
-      
-  };
-
-  template<class G>
-  class EdgeLookUp3
-  {
-  public:
-    GRAPH_TYPEDEFS(typename G);
-    typedef G Graph;
-
-  private:
-    const Graph &_g;
-    typename Graph::template NodeMap<Edge*> _start;
-    typename Graph::template NodeMap<Edge*> _end;
-    std::vector<Edge> _edges;
-    
-    class EdgeLess {
-      const Graph &g;
-    public:
-      EdgeLess(const Graph &_g) : g(_g) {}
-      bool operator()(Edge a,Edge b) const 
-      {
-	return g.target(a)<g.target(b);
-      }
-    };
-    
-  public:
-    
-    ///Constructor
-    EdgeLookUp3(const Graph &g) :_g(g),_start(g),_end(g) {refresh();}
-    
-  public:
-    ///Refresh the data structure at a node.
-    void refresh(Node n) 
-    {
-      const int bi = _start[n] = _edges.size();
-      for(OutEdgeIt e(_g,n);e!=INVALID;++e) _edges.push_back(e);
-      const typename std::vector<Edge>::iterator ei=_edges.end();
-      _end[n]=_edges.size();
-      std::sort(_edges.begin()+bi,ei,EdgeLess(_g));
-    }
-    ///Refresh the full data structure.
-    void refresh() 
-    {
-      _edges.resize(countEdges(_g));
-      int l=0;
-      for(NodeIt n(_g);n!=INVALID;++n)
-	{
-	  int ls = l;
-	  _start[n]=&(_edges[l]);	
-	  for(OutEdgeIt e(_g,n);e!=INVALID;++e) _edges[l++]=e;
-	  _end[n]=&(_edges[l]);
-	  std::sort(_edges.begin()+ls,_edges.begin()+l,EdgeLess(_g));
-	}
-      
-    }
-    
-    ///Find an edge between two nodes.
-    
-    ///Find an edge between two nodes.
-    ///\param s The source node
-    ///\param t The target node
-    ///\return An edge from \c s to \c t if there exists,
-    ///\ref INVALID otherwise.
-
-    Edge operator()(Node s, Node t) 
-    {
-      Edge *a=_start[s];
-      Edge *b=_end[s];
-      while(a!=b) 
-	{
- 	  Edge *m=a+((b-a)/2);
-	  Node tt = _g.target(*m);
-	  if(tt==t) return *m;
-	  else if(tt<t) a=m+1;
-	  else b=m;
-	}
-      return INVALID;
-    }
-
-    ///Find the next edge
-      
-      ///\warning This function is unimplemented.
-    Edge operator()(Node s, Node t, Edge prev) 
-    {
-      return prev==INVALID?(*this)(s,t):INVALID;
-    }
-      
-  };
-
-//   template<class G>
-//   class EdgeLookUp4
-//   {
-//   public:
-//     GRAPH_TYPEDEFS(typename G);
-//     typedef G Graph;
-    
-//   private:
-//     const Graph &_g;
-//     typename Graph::template NodeMap<Edge*> _start;
-//     typename Graph::template NodeMap<Edge*> _end;
-//     std::vector<Edge> _edges;
-    
-//     class EdgeLess {
-//       const Graph &g;
-//     public:
-//       EdgeLess(const Graph &_g) : g(_g) {}
-//       bool operator()(Edge a,Edge b) const 
-//       {
-// 	return g.target(a)<g.target(b);
-//       }
-//     };
-    
-//   public:
-    
-//     ///Constructor
-//     EdgeLookUp4(const Graph &g) :_g(g),_start(g),_end(g) {refresh();}
-    
-//   public:
-//     ///Refresh the data structure at a node.
-//     void refresh(Node n) 
-//     {
-//       const int bi = _start[n] = _edges.size();
-//       for(OutEdgeIt e(_g,n);e!=INVALID;++e) _edges.push_back(e);
-//       const typename std::vector<Edge>::iterator ei=_edges.end();
-//       _end[n]=_edges.size();
-//       std::sort(_edges.begin()+bi,ei,EdgeLess(_g));
-//     }
-//     ///Refresh the full data structure.
-//     void refresh() 
-//     {
-//       _edges.resize(countEdges(_g));
-//       int l=0;
-//       for(NodeIt n(_g);n!=INVALID;++n)
-// 	{
-// 	  int ls = l;
-// 	  _start[n]=&(_edges[l]);	
-// 	  for(OutEdgeIt e(_g,n);e!=INVALID;++e) _edges[l++]=e;
-// 	  _end[n]=&(_edges[l]);
-// 	  std::sort(_edges.begin()+ls,_edges.begin()+l,EdgeLess(_g));
-// 	}
-      
-//     }
-    
-//     ///Find an edge between two nodes.
-    
-//     ///Find an edge between two nodes.
-//     ///\param s The source node
-//     ///\param t The target node
-//     ///\return An edge from \c s to \c t if there exists,
-//     ///\ref INVALID otherwise.
-
-//     Edge operator()(Node s, Node t) 
-//     {
-//       Edge *a=_start[s];
-//       Edge *b=_end[s];
-//       while(a!=b) 
-// 	{
-// // #ifdef X86
-//  	  Edge *m=(Edge*)(((unsigned int)a+(unsigned int)b)/2 & 0xfffffffc);
-// // #elif X86_64
-// // 	  Edge *m=(Edge*)(((unsigned long)a+(undigned long)b)/2 & 0xfffffffc);
-// // #else
-// //  	  Edge *m=a+((b-a)/2);
-// // #endif
-// 	  Node tt = _g.target(*m);
-// 	  if(tt==t) return *m;
-// 	  else if(tt<t) a=m+1;
-// 	  else b=m;
-// 	}
-//       return INVALID;
-//     }
-
-//     ///Find the next edge
-      
-//       ///\warning This function is unimplemented.
-//     Edge operator()(Node s, Node t, Edge prev) 
-//     {
-//       return prev==INVALID?(*this)(s,t):INVALID;
-//     }
-      
-//   };
-
-//   template<class G>
-//   class EdgeLookUp5
-//   {
-//   public:
-//     GRAPH_TYPEDEFS(typename G);
-//     typedef G Graph;
-    
-//   private:
-//     const Graph &_g;
-//     typename Graph::template NodeMap<Edge*> _start;
-//     typename Graph::template NodeMap<Edge*> _end;
-//     std::vector<Edge> _edges;
-    
-//     class EdgeLess {
-//       const Graph &g;
-//     public:
-//       EdgeLess(const Graph &_g) : g(_g) {}
-//       bool operator()(Edge a,Edge b) const 
-//       {
-// 	return g.target(a)<g.target(b);
-//       }
-//     };
-    
-//   public:
-    
-//     ///Constructor
-//     EdgeLookUp5(const Graph &g) :_g(g),_start(g),_end(g) {refresh();}
-    
-//   public:
-//     ///Refresh the data structure at a node.
-//     void refresh(Node n) 
-//     {
-//       const int bi = _start[n] = _edges.size();
-//       for(OutEdgeIt e(_g,n);e!=INVALID;++e) _edges.push_back(e);
-//       const typename std::vector<Edge>::iterator ei=_edges.end();
-//       _end[n]=_edges.size();
-//       std::sort(_edges.begin()+bi,ei,EdgeLess(_g));
-//     }
-//     ///Refresh the full data structure.
-//     void refresh() 
-//     {
-//       _edges.resize(countEdges(_g));
-//       int l=0;
-//       for(NodeIt n(_g);n!=INVALID;++n)
-// 	{
-// 	  int ls = l;
-// 	  _start[n]=&(_edges[l]);	
-// 	  for(OutEdgeIt e(_g,n);e!=INVALID;++e) _edges[l++]=e;
-// 	  _end[n]=&(_edges[l]);
-// 	  std::sort(_edges.begin()+ls,_edges.begin()+l,EdgeLess(_g));
-// 	}
-      
-//     }
-    
-//     ///Find an edge between two nodes.
-    
-//     ///Find an edge between two nodes.
-//     ///\param s The source node
-//     ///\param t The target node
-//     ///\return An edge from \c s to \c t if there exists,
-//     ///\ref INVALID otherwise.
-
-//     Edge operator()(Node s, Node t) 
-//     {
-//       Edge *a=_start[s];
-//       Edge *b=_end[s];
-//       while(a!=b) 
-// 	{
-// // #ifdef X86
-//  	  Edge *m=(Edge*)((((unsigned int)a>>1)+((unsigned int)b)>>1)
-// 			  & 0xfffffffc);
-// // #elif X86_64
-// // 	  Edge *m=(Edge*)(((unsigned long)a>>1+(undigned long)b)>>1)&0xfffffffc);
-// // #else
-// //  	  Edge *m=a+((b-a)/2);
-// // #endif
-// 	  Node tt = _g.target(*m);
-// 	  if(tt==t) return *m;
-// 	  else if(tt<t) a=m+1;
-// 	  else b=m;
-// 	}
-//       return INVALID;
-//     }
-
-//     ///Find the next edge
-      
-//       ///\warning This function is unimplemented.
-//     Edge operator()(Node s, Node t, Edge prev) 
-//     {
-//       return prev==INVALID?(*this)(s,t):INVALID;
-//     }
-      
-//   };
-
-GRAPH_TYPEDEFS(SmartGraph);
-typedef SmartGraph Graph;
-
-class FE 
-{
-public:
-  Graph &_g;
-  FE(Graph &g) :_g(g) {}
-  void operator()() 
-  {
-    Edge e;
-    
-    for(NodeIt v(_g);v!=INVALID;++v)
-      for(NodeIt u(_g);u!=INVALID;++u)
-	e=findEdge(_g,u,v);
-  }
-  
-};
-
-class EL 
-{
-public:
-  Graph &_g;
-  EdgeLookUp<Graph> _el;
-  EL(Graph &g) :_g(g), _el(g) {}
-  void operator()() 
-  {
-    Edge e;
-    
-    for(NodeIt v(_g);v!=INVALID;++v)
-      for(NodeIt u(_g);u!=INVALID;++u)
-	e=_el(u,v);
-  }
-  
-};
-
-class DEL 
-{
-public:
-  Graph &_g;
-  DynEdgeLookUp<Graph> _el;
-  DEL(Graph &g) :_g(g), _el(g) {}
-  void operator()() 
-  {
-    Edge e;
-    
-    for(NodeIt v(_g);v!=INVALID;++v)
-      for(NodeIt u(_g);u!=INVALID;++u)
-	e=_el(u,v);
-  }
-  
-};
-
-class EL2
-{
-public:
-  Graph &_g;
-  EdgeLookUp2<Graph> _el;
-  EL2(Graph &g) :_g(g), _el(g) {}
-  void operator()() 
-  {
-    Edge e;
-    
-    for(NodeIt v(_g);v!=INVALID;++v)
-      for(NodeIt u(_g);u!=INVALID;++u)
-	e=_el(u,v);
-  }
-  
-};
-
-class EL3
-{
-public:
-  Graph &_g;
-  EdgeLookUp3<Graph> _el;
-  EL3(Graph &g) :_g(g), _el(g) {}
-  void operator()() 
-  {
-    Edge e;
-    
-    for(NodeIt v(_g);v!=INVALID;++v)
-      for(NodeIt u(_g);u!=INVALID;++u)
-	e=_el(u,v);
-  }
-  
-};
-
-// class EL4
-// {
-// public:
-//   Graph &_g;
-//   EdgeLookUp4<Graph> _el;
-//   EL4(Graph &g) :_g(g), _el(g) {}
-//   void operator()() 
-//   {
-//     Edge e;
-    
-//     for(NodeIt v(_g);v!=INVALID;++v)
-//       for(NodeIt u(_g);u!=INVALID;++u)
-// 	e=_el(u,v);
-//   }
-  
-// };
-
-// class EL5
-// {
-// public:
-//   Graph &_g;
-//   EdgeLookUp5<Graph> _el;
-//   EL5(Graph &g) :_g(g), _el(g) {}
-//   void operator()() 
-//   {
-//     Edge e;
-    
-//     for(NodeIt v(_g);v!=INVALID;++v)
-//       for(NodeIt u(_g);u!=INVALID;++u)
-// 	e=_el(u,v);
-//   }
-  
-// };
-
-int main(int, char**argv)
-{
-  int N=atoi(argv[1]);
-  int M=int(N*atof(argv[2]));
-  
-  Graph g;
-  
-  std::vector<Node> v;
-  for(int i=0;i<N;i++) v.push_back(g.addNode());
-  for(int i=0;i<M;i++) g.addEdge(v[rnd[N]],v[rnd[N]]);
-
-//   {
-//     Edge e;
-    
-//     TimeReport t("findEdge: ");
-//     for(NodeIt u(g);u!=INVALID;++u)
-//       for(NodeIt v(g);v!=INVALID;++v)
-// 	e=findEdge(g,u,v);
-//   }
-//   {
-//     Edge e;
-//     EdgeLookUp<Graph> el(g);
-    
-//     TimeReport t("EdgeLookUp: ");
-//     for(NodeIt u(g);u!=INVALID;++u)
-//       for(NodeIt v(g);v!=INVALID;++v)
-// 	e=el(u,v);
-//   }
-
-
-  TimeStamp t1 = runningTimeTest(FE(g),1);
-  TimeStamp t2 = runningTimeTest(EL(g),1);
-  TimeStamp t3 = runningTimeTest(DEL(g),1);
-  TimeStamp t4 = runningTimeTest(EL2(g),1);
-  TimeStamp t5 = runningTimeTest(EL3(g),1);
-//   TimeStamp t5 = runningTimeTest(EL4(g),1);
-//   TimeStamp t6 = runningTimeTest(EL5(g),1);
-
-  std::cout << t1.userTime() << ' ' 
-	    << t2.userTime() << ' '
-	    << t3.userTime() << ' '
-	    << t4.userTime() << ' '
-	    << t5.userTime() << ' '
-// 	    << t5.userTime() << ' '
-//  	    << t6.userTime()
-	    << std::endl;
-  std::cout << t1.userTime()/N/N << ' ' 
-	    << t2.userTime()/N/N << ' '
-	    << t3.userTime()/N/N << ' '
-	    << t4.userTime()/N/N << ' '
-	    << t5.userTime()/N/N << ' '
-// 	    << t5.userTime()/N/N << ' '
-//  	    << t6.userTime()/N/N
-	    << std::endl;
-}
-
Index: benchmark/edge_lookup_test
===================================================================
--- benchmark/edge_lookup_test	(revision 2235)
+++ 	(revision )
@@ -1,7 +1,0 @@
-#!/bin/bash
-
-for((i=1;i<50;i++))
-do
-    echo -n $i ''
-    edge_lookup 100 $i
-done
Index: benchmark/graph-bench.cc
===================================================================
--- benchmark/graph-bench.cc	(revision 2592)
+++ 	(revision )
@@ -1,76 +1,0 @@
-/* -*- C++ -*-
- *
- * 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/list_graph.h>
-
-#include"bench_tools.h"
-
-using namespace lemon;
-
-///Makes a full graph by adding and deleting a lot of edges;
-
-///\param n Number of nodes.
-///\param rat The funcion will make \f$rat\timesn^2\f$ edge addition and
-///\f$(rat-1)\timesn^2\f$ deletion.
-///\param p Tuning parameters.
-///\warning \c rat, \c p, and \c n must be pairwise relative primes. 
-template <class Graph>
-void makeFullGraph(int n, int rat, int p)
-{
-  GRAPH_TYPEDEFS(typename Graph);
-
-  Graph G;
-  
-  //  Node nodes[n];
-  std::vector<Node> nodes(n);
-  for(int i=0;i<n;i++) nodes[i]=G.addNode();
-  
-  //Edge equ[rat];
-  std::vector<Edge> equ(rat);
-  
-  /// \bug There is no long long int type in C++98.
-  long long int count;
-  
-  for(count=0;count<rat;count++) {
-    equ[int(count%rat)]=G.addEdge(nodes[int((count*p)%n)],
-				  nodes[int((count*p/n)%n)]);
-  }
-  for(;(count%rat)||((count*p)%n)||((count*p/n)%n);count++) {
-    //    if(!(count%1000000)) fprintf(stderr,"%d\r",count);
-    if(count%rat) G.erase(equ[count%rat]);
-    equ[int(count%rat)]=G.addEdge(nodes[int((count*p)%n)],
-				  nodes[int((count*p/n)%n)]);
-  }
-//   std::cout << "Added " << count
-// 	    << " ( " << n << "^2 * " << rat << " ) edges\n";
-
-
-  //  for(int i=0;1;i++) ;
-}
-
-int main()
-{
-  lemon::Timer T;
-  makeFullGraph<ListGraph>(nextPrim(1000),nextPrim(300),nextPrim(100));
-  
-  PrintTime("BIG",T);
-  T.restart();
-  makeFullGraph<ListGraph>(nextPrim(100),nextPrim(30000),nextPrim(150));
-
-  PrintTime("SMALL",T);
-}
Index: benchmark/hcube.cc
===================================================================
--- benchmark/hcube.cc	(revision 2569)
+++ 	(revision )
@@ -1,121 +1,0 @@
-/* -*- C++ -*-
- *
- * 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/math.h>
-#include<lemon/list_graph.h>
-#include<lemon/smart_graph.h>
-#include<lemon/dijkstra.h>
-#include<lemon/preflow.h>
-
-#include"bench_tools.h"
-
-using namespace std;
-using namespace lemon;
-
-inline int numOfOnes(int n,int dim)
-{
-  int s=0;
-  for(int i=0;i<dim;i++) {
-    s+=n%2;
-    n>>=1;
-  }
-  return s;
-}
-
-inline int numOfZeros(int n,int dim)
-{
-  int s=dim;
-  for(int i=0;i<dim;i++) {
-    s-=n&1;
-    n>>=1;
-  }
-  return s;
-}
-
-int main(int argc, char *argv[])
-{
-  //  typedef ListGraph Graph;
-  typedef SmartGraph Graph;
-
-  GRAPH_TYPEDEFS(Graph);
-
-  Graph G;
-  
-  Timer T;
-  
-  if(argc!=2) {
-    cout << "Usage: " << argv[0] << " dim\n";
-    return 1;
-  }
-  
-  int dim=atoi(argv[1]);
-  
-//   cout << "Creating Hipercube ("<< (1<<dim) << " nodes, "
-//        << dim*(1<<dim) << " edges):";
-
-  T.restart();
-  vector<Node> nodes;
-  addBiDirHyperCube(G,dim,nodes);
-
-  PrintTime("GENGRAPH",T);
-
-  T.restart();
-  Graph::EdgeMap<int> map(G);
-  for(int i=0;i<5;i++) {
-    Primes P;
-    for(int j=0;j<dim*(1<<dim);j++) P();
-    
-    //  for(EdgeIt e(G);G.valid(e);G.next(e)) map[e]=P();
-
-    ///\todo It must have been commented out because of
-    ///setToId
-//     Edge te;
-//     for(int i=0;i<dim*(1<<dim);i++) {
-//       te.setToId(((long long int)(i)*93505)%(dim*(1<<dim)));
-//       //    map[Edge(((long long int)(i)*2987)%(dim*(1<<dim)))]=P();
-//       map[te]=P();
-//     }
-    
-//     for(int i=0;i<(1<<dim);i++) {
-//       int mul= (1<<(numOfZeros(i,dim)/4));
-//       for(OutEdgeIt e(G,nodes[i]);G.valid(e);G.next(e))
-// 	map[e]*=mul;
-//     }
-  }
-  
-  PrintTime("GENLENGTHS",T);
-
-  T.restart();
-  {
-    Dijkstra<Graph> Dij(G,map);
-    for(int i=0;i<10;i++)
-      Dij.run(nodes[0]);
-  }
-  PrintTime("DIJKSTRA",T);
-
-  T.restart();
-  {
-   Graph::EdgeMap<int> flow(G);
-   
-    Preflow<Graph> MF(G,map,nodes[0],nodes[1<<dim-1]);
-    for(int i=0;i<10;i++)
-      MF.run();
-  }
-  PrintTime("PREFLOW",T);
-
-}
Index: benchmark/min_cut.cc
===================================================================
--- benchmark/min_cut.cc	(revision 2553)
+++ 	(revision )
@@ -1,187 +1,0 @@
-/* -*- C++ -*-
- *
- * 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/list_graph.h>
-
-#include <lemon/hao_orlin.h>
-#include <lemon/nagamochi_ibaraki.h>
-#include <lemon/time_measure.h>
-
-using namespace lemon;
-
-#include "min_cut_graphs.h"
-
-
-void testRegUGraph();
-void testNoiUGraph();
-void testBikeWheelUGraph();
-
-int main() {
-  testRegUGraph();
-  testNoiUGraph();
-  testBikeWheelUGraph();
-  return 0;
-}
-
-//#define int long long
-
-
-int cutValue(const ListUGraph& g, const ListUGraph::UEdgeMap<int>& c,
-           const ListUGraph::NodeMap<bool>& n) {
-  int v = 0;
-  for (ListUGraph::UEdgeIt e(g); e != INVALID; ++e) {
-    if (n[g.source(e)] != n[g.target(e)]) {
-      v += c[e];
-    }
-  }
-  return v;
-}
-
-int cutSize(const ListUGraph& g, const ListUGraph::NodeMap<bool>& nm) {
-  int m = 0;
-  for (ListUGraph::NodeIt n(g); n != INVALID; ++n) {
-    if (nm[n]) {
-      ++m;
-    }
-  }
-  return m;
-}
-
-int testNI(const ListUGraph& g, const ListUGraph::UEdgeMap<int>& c) {
-  TimeReport tr("Nagamochi-Ibaraki : ");
-  NagamochiIbaraki<ListUGraph, ListUGraph::UEdgeMap<int> > alg(g, c);
-  alg.run();
-  ListUGraph::NodeMap<bool> n(g);
-  alg.minCut(n);
-  std::cout << "Check : " << cutValue(g, c, n) << ' '
-            << cutSize(g, n) << std::endl;
-  return alg.minCut();
-}
-
-int testHO(const ListUGraph& g, const ListUGraph::UEdgeMap<int>& c) {
-  TimeReport tr("Hao-Orlin : ");
-  HaoOrlin<ListUGraph, ListUGraph::UEdgeMap<int> > alg(g, c);
-  alg.init();
-  alg.calculateOut();
-  ListUGraph::NodeMap<bool> n(g);
-  alg.minCut(n);
-  std::cout << "Check : " << cutValue(g, c, n) << ' '
-            << cutSize(g, n) << std::endl;
-  return alg.minCut();
-}
-
-void testBikeWheelUGraph(int n) {
-  ListUGraph g;
-  ListUGraph::UEdgeMap<int> c(g);
-  genBikeWheelUGraph(g, c, n);
-  std::cout << "Node number : " << n << std::endl;
-  std::cout << "Hao-Orlin : " << testHO(g, c) << std::endl;
-  std::cout << "Nagamochi-Ibaraki : " << testNI(g, c) << std::endl;
-}
-
-void testBikeWheelUGraph() {
-  std::cout << "BikeWheelUGraph : " << std::endl;
-  for (int k = 10; k <= 13; ++k) {
-    int n = 1 << k;
-    testBikeWheelUGraph(n);
-  }
-}
-
-void testNoiUGraph(int n, int d, int k, int p) {
-  ListUGraph g;
-  ListUGraph::UEdgeMap<int> c(g);
-  genNoiUGraph(g, c, n, d, k, p);
-  std::cout << "Node number : " << n << std::endl;
-  std::cout << "Density : " << d << std::endl;
-  std::cout << "Tight components : " << k << std::endl;
-  std::cout << "Scale : " << p << std::endl;
-  std::cout << "Hao-Orlin : " << testHO(g, c) << std::endl;
-  std::cout << "Nagamochi-Ibaraki : " << testNI(g, c) << std::endl;
-}
-
-
-void testNoiUGraph() {
-  std::cout << "NoiUGraph : " << std::endl; 
-  std::cout << "Serial 1 : " << std::endl;
-  for (int n = 300; n <= 1000; n += 100) {
-    testNoiUGraph(n, 50, 1, n);
-  }
-  std::cout << "Serial 2 : " << std::endl;
-  for (int n = 300; n <= 1000; n += 100) {
-    testNoiUGraph(n, 50, 2, n);
-  }
-  std::cout << "Serial 3 : " << std::endl;
-  int da3[] = { 5, 10, 25, 50, 75, 100 };
-  int dn3 = sizeof(da3) / sizeof(da3[0]);
-  for (int d = 0; d < dn3; ++d) {
-    testNoiUGraph(1000, da3[d], 1, 1000);
-  }
-  std::cout << "Serial 4 : " << std::endl;
-  for (int d = 0; d < dn3; ++d) {
-    testNoiUGraph(1000, da3[d], 2, 1000);
-  }
-  std::cout << "Serial 5 : " << std::endl;
-  int ka5[] = {1, 2, 3, 5, 7, 10, 20, 30, 33, 35, 
-               40, 50, 100, 200, 300, 400, 500};
-  int kn5 = sizeof(ka5) / sizeof(ka5[0]);
-  for (int k = 0; k < kn5; ++k) {
-    testNoiUGraph(1000, 50, ka5[k], 1000);
-  }
-  std::cout << "Serial 6 : " << std::endl;
-  int pa6[] = { 5000, 2000, 1000, 500, 250, 100, 50, 10, 1};
-  int pn6 = sizeof(pa6) / sizeof(pa6[0]);
-  for (int p = 0; p < pn6; ++p) {
-    testNoiUGraph(1000, 50, 2, pa6[p]);
-  }  
-  
-}
-
-void testRegUGraph(int n, int d) {
-  ListUGraph g;
-  ListUGraph::UEdgeMap<int> c(g);
-  genRegUGraph(g, c, n, d);
-  std::cout << "Node number : " << n << std::endl;
-  std::cout << "Number of cycles : " << d << std::endl;
-  std::cout << "Hao-Orlin : " << testHO(g, c) << std::endl;
-  std::cout << "Nagamochi-Ibaraki : " << testNI(g, c) << std::endl;
-}
-
-void testRegUGraph() {
-  std::cout << "RegUGraph : " << std::endl; 
-  std::cout << "Serial 1 : " << std::endl;
-  int da1[] = { 1, 3, 10, 33, 100, 333, 1000};
-  int dn1 = sizeof(da1) / sizeof(da1[0]);
-  for (int d = 0; d < dn1; ++d) {
-    testRegUGraph(1001, da1[d]);
-  }
-  std::cout << "Serial 2 : " << std::endl;
-  int na2[] = { 50, 100, 200, 400, 800};
-  int nn2 = sizeof(na2) / sizeof(na2[0]);
-  for (int n = 0; n < nn2; ++n) {
-    testRegUGraph(na2[n], 50);
-  }
-  std::cout << "Serial 3 : " << std::endl;
-  for (int n = 8; n <= 14; ++n) {
-    testRegUGraph(1 << n, 2);
-  }
-  std::cout << "Serial 4 : " << std::endl;
-  for (int n = 7; n <= 11; ++n) {
-    testRegUGraph(1 << n, 1 << (n - 4));
-  }  
-}
-
Index: benchmark/min_cut_graphs.h
===================================================================
--- benchmark/min_cut_graphs.h	(revision 2553)
+++ 	(revision )
@@ -1,99 +1,0 @@
-/* -*- C++ -*-
- *
- * 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/random.h>
-
-
-template <typename UGraph, typename CapacityMap>
-void genNoiUGraph(UGraph& g, CapacityMap& c, 
-                  int n, int d, int k, int p) {
-  std::vector<typename UGraph::Node> nodes(n);
-  for (int i = 0; i < n; ++i) {
-    nodes[i] = g.addNode();
-  }
-  typename UGraph::template NodeMap<int> comp(g);
-  for (int i = 0; i < n; ++i) {
-    comp[nodes[i]] = rnd[k];
-  }
-  int m = (n * (n - 1) * d) / 200;
-  for (int i = 0; i < m; ++i) {
-    int s = rnd[n], t = rnd[n];
-    c[g.addEdge(nodes[s], nodes[t])] =
-      rnd[(comp[nodes[s]] == comp[nodes[t]] ? p : 1) * 100]; 
-  }
-}
-
-template <typename UGraph, typename CapacityMap>
-void genBikeWheelUGraph(UGraph& g, CapacityMap& c, int n) {
-  std::vector<typename UGraph::Node> nodes(n);
-  for (int i = 0; i < n; ++i) {
-    nodes[i] = g.addNode();
-  }
-  for (int i = 0; i < n - 2; ++i) {
-    c[g.addEdge(nodes[i], nodes[n - 1 - (i % 2)])] = 2;
-  }
-  for (int i = 1; i < n - 2; ++i) {
-    c[g.addEdge(nodes[i - 1], nodes[i])] = n - 1;
-  }
-  c[g.addEdge(nodes[n - 3], nodes[0])] = n - 1;
-  c[g.addEdge(nodes[n - 2], nodes[n - 1])] = 2;
-}
-
-template <typename UGraph, typename CapacityMap>
-void genRegUGraph(UGraph& g, CapacityMap& c, int n, int d) {
-  std::vector<typename UGraph::Node> nodes(n);
-  for (int i = 0; i < n; ++i) {
-    nodes[i] = g.addNode();
-  }
-  for (int k = 0; k < d; ++k) {
-    for (int i = 0; i < n; ++i) {
-      int r = rnd[n];
-      typename UGraph::Node t = nodes[r];
-      nodes[r] = nodes[i];
-      nodes[i] = t;
-    }
-    for (int i = 1; i < n; ++i) {
-      c[g.addEdge(nodes[i - 1], nodes[i])] = 1;
-    }
-    c[g.addEdge(nodes[n - 1], nodes[0])] = 1;
-  }
-}
-
-template <typename UGraph, typename CapacityMap>
-void genCdgUGraph(UGraph& g, CapacityMap& c, int n, int d) {
-  std::vector<typename UGraph::Node> nodes(n);
-  for (int i = 0; i < n; ++i) {
-    nodes[i] = g.addNode();
-  }
-  std::vector<typename UGraph::Node> mix(n * d);
-  for (int i = 0; i < n; ++i) {
-    for (int j = 0; j < d; ++j) {
-      mix[i * d + j] = nodes[i];
-    }
-  }
-  while (mix.size() >= 2) {
-    int r;
-    r = rnd[mix.size()];
-    typename UGraph::Node s = mix[r];
-    mix[r] = mix.back(); mix.pop_back();
-    r = rnd[mix.size()];
-    typename UGraph::Node t = mix[r];
-    mix[r] = mix.back(); mix.pop_back();
-    c[g.addEdge(s, t)] = 1;
-  }
-}
Index: benchmark/radix_sort-bench.cc
===================================================================
--- benchmark/radix_sort-bench.cc	(revision 2569)
+++ 	(revision )
@@ -1,90 +1,0 @@
-/* -*- C++ -*-
- *
- * 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.
- *
- */
-
-#define NDEBUG
-
-#include <lemon/time_measure.h>
-#include <lemon/smart_graph.h>
-#include <lemon/graph_utils.h>
-#include <lemon/maps.h>
-#include <lemon/error.h>
-
-#include <lemon/radix_sort.h>
-
-#include <lemon/random.h>
-
-#include <vector>
-#include <algorithm>
-#include <lemon/math.h>
-
-using namespace std;
-using namespace lemon;
-
-void testRadixSort() {
-  int n = 10000000;
-  vector<int> data(n);
-  for (int i = 0; i < n; ++i) {
-    data[i] = rnd[1000] - 500;
-  }
-  radixSort(data.begin(), data.end());
-}
-
-
-void testCounterSort() {
-  int n = 10000000;
-  vector<int> data(n);
-  for (int i = 0; i < n; ++i) {
-    data[i] = rnd[1000] - 500;
-  }
-  counterSort(data.begin(), data.end());
-}
-
-void testSort() {
-  int n = 10000000;
-  vector<int> data(n);
-  for (int i = 0; i < n; ++i) {
-    data[i] = rnd[1000] - 500;
-  }
-  sort(data.begin(), data.end());
-}
-
-void testStableSort() {
-  int n = 10000000;
-  vector<int> data(n);
-  for (int i = 0; i < n; ++i) {
-    data[i] = rnd[1000] - 500;
-  }
-  stable_sort(data.begin(), data.end());
-}
-
-void testSorts() {
-  {
-    int n = 10000000;
-    vector<int> data(n);
-  }
-  cout << "Radix sort: " << runningTimeTest(testRadixSort, 60) << endl;
-  cout << "Counter sort: " << runningTimeTest(testCounterSort, 60) << endl;
-  cout << "Standard sort: " << runningTimeTest(testSort, 60) << endl;
-  cout << "Stable sort: " << runningTimeTest(testStableSort, 60) << endl;
-}
-
-
-int main() {
-  testSorts();
-  return 0;
-}
Index: benchmark/random_bench.cc
===================================================================
--- benchmark/random_bench.cc	(revision 2553)
+++ 	(revision )
@@ -1,151 +1,0 @@
-/* -*- C++ -*-
- *
- * 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<stdlib.h>
-#include<lemon/random.h>
-#include<lemon/time_measure.h>
-
-using namespace lemon;
-
-void f_no() 
-{
-}
-
-inline void f_noi() 
-{
-}
-
-inline void f_i() 
-{
-  static int r;  
-  r=5;
-}
-
-inline void f_l() 
-{
-  static long int r;
-  r=5;
-}
-
-inline void f_d() 
-{
-  static double r;
-  r=5;
-}
-
-inline void f_rand() 
-{
-  static int r;  
-  r=rand();
-}
-
-inline void f_random() 
-{
-  static long int r;
-  r=random();
-}
-
-inline void f_drand48() 
-{
-  static double r;
-  r=drand48();
-}
-
-inline void f_rnd_d() 
-{
-  static double r;
-  r=rnd();
-}
-inline void f_rnd_int1000() 
-{
-  static int r;
-  r=rnd[1000];
-}
-inline void f_rnd_bool() 
-{
-  static bool r;
-  r=rnd.boolean();
-}
-
-// inline void f_() 
-// {
-//   static double r;
-//   r=;
-// }
-
-int main()
-{
-  TimeStamp full;
-  TimeStamp t;
-  unsigned int n;
-  
-  const double TEST_DURATION=10;
-
-  t=runningTimeTest(f_no,2,&n,&full);
-
-  t=runningTimeTest(f_no,TEST_DURATION,&n,&full); 
-  std::cout << "EMPTY:         ";
-  std::cout << t.userTime() << " (" << n << " tests)\n";
-  
-  t=runningTimeTest(f_noi,TEST_DURATION,&n,&full);
-  std::cout << "INLINED EMPTY: ";
-  std::cout << t.userTime() << " (" << n << " tests)\n";
-  
-  TimeStamp ti=t=runningTimeTest(f_i,TEST_DURATION,&n,&full);
-  std::cout << "INT COPY:      ";
-  std::cout << t.userTime() << " (" << n << " tests)\n";
-  
-  TimeStamp tl=t=runningTimeTest(f_l,TEST_DURATION,&n,&full);
-  std::cout << "LONG COPY:     ";
-  std::cout << t.userTime() << " (" << n << " tests)\n";
-  
-  TimeStamp td=t=runningTimeTest(f_d,TEST_DURATION,&n,&full);
-  std::cout << "DOUBLE COPY:   ";
-  std::cout << t.userTime() << " (" << n << " tests)\n";
-  
-  t=runningTimeTest(f_rand,TEST_DURATION,&n,&full);
-  std::cout << "rand():        ";
-  std::cout << (t-ti).userTime() << " (" << n << " tests)\n";
-  
-  t=runningTimeTest(f_random,TEST_DURATION,&n,&full);
-  std::cout << "random():      ";
-  std::cout << (t-tl).userTime() << " (" << n << " tests)\n";
-  
-  t=runningTimeTest(f_drand48,TEST_DURATION,&n,&full);
-  std::cout << "drand48():     ";
-  std::cout << (t-td).userTime() << " (" << n << " tests)\n";
-  
-  t=runningTimeTest(f_rnd_d,TEST_DURATION,&n,&full);
-  std::cout << "rnd():         ";
-  std::cout << (t-td).userTime() << " (" << n << " tests)\n";
-  
-  t=runningTimeTest(f_rnd_int1000,TEST_DURATION,&n,&full);
-  std::cout << "rnd[1000]:     ";
-  std::cout << (t-ti).userTime() << " (" << n << " tests)\n";
-  
-  t=runningTimeTest(f_rnd_bool,TEST_DURATION,&n,&full);
-  std::cout << "rnd.boolean(): ";
-  std::cout << (t-ti).userTime() << " (" << n << " tests)\n";
-  
-//   t=runningTimeTest(f_,TEST_DURATION,&n,&full);
-//   std::cout << "\n";
-//   std::cout << t << " (" << n << " tests)\n";
-//   std::cout << "Total: " << full << "\n\n";
-  
-  return 0;
-}
Index: benchmark/swap_bipartite_bench.cc
===================================================================
--- benchmark/swap_bipartite_bench.cc	(revision 2553)
+++ 	(revision )
@@ -1,135 +1,0 @@
-/* -*- C++ -*-
- *
- * 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 <cstdlib>
-#include <iostream>
-#include <sstream>
-
-#include <lemon/smart_graph.h>
-#include <lemon/list_graph.h>
-
-#include <lemon/bpugraph_adaptor.h>
-#include <lemon/bipartite_matching.h>
-
-#include <lemon/graph_utils.h>
-#include <lemon/graph_to_eps.h>
-
-#include <lemon/time_measure.h>
-#include <lemon/random.h>
-
-using namespace std;
-using namespace lemon;
-
-typedef SmartBpUGraph Graph;
-typedef ListBpUGraph LGraph;
-BPUGRAPH_TYPEDEFS(Graph);
-
-
-int main() {
-
-  for (int k = 1; k < 100; ++k) {
-    
-    int n = k * 100;
-    int m = (100 - k) * 100;
-    int e = 20000;
-    int s = 100;
-    
-    Timer nt(false), st(false);
-    Timer lnt(false), lst(false);
-    
-    for (int i = 0; i < s; ++i) {
-      Graph graph;
-      LGraph lgraph;
-      vector<Node> aNodes;
-      vector<Node> bNodes;  
-      vector<LGraph::Node> laNodes;
-      vector<LGraph::Node> lbNodes;  
-      
-      for (int j = 0; j < n; ++j) {
-        Node node = graph.addANode();
-        aNodes.push_back(node);
-        LGraph::Node lnode = lgraph.addANode();
-        laNodes.push_back(lnode);
-      }
-      for (int j = 0; j < m; ++j) {
-        Node node = graph.addBNode();
-        bNodes.push_back(node);
-        LGraph::Node lnode = lgraph.addBNode();
-        lbNodes.push_back(lnode);
-      }
-      for (int j = 0; j < e; ++j) {
-        int a,b;
-	Node aNode = aNodes[a=rnd[n]];
-        Node bNode = bNodes[b=rnd[m]];
-        graph.addEdge(aNode, bNode);
-	LGraph::Node laNode = laNodes[a];
-        LGraph::Node lbNode = lbNodes[b];
-        lgraph.addEdge(laNode, lbNode);
-      }
-
-      {
-        MaxBipartiteMatching<Graph> bpmatch(graph);
-        
-        nt.start();
-        bpmatch.init();
-        bpmatch.start();
-        nt.stop();
-        
-      }
-
-      {
-        typedef SwapBpUGraphAdaptor<Graph> SGraph;
-        SGraph sgraph(graph);
-        MaxBipartiteMatching<SGraph> bpmatch(sgraph);
-
-        st.start();
-        bpmatch.init();
-        bpmatch.start();
-        st.stop();
-        
-      }                 
-      {
-        MaxBipartiteMatching<LGraph> bpmatch(lgraph);
-        
-        lnt.start();
-        bpmatch.init();
-        bpmatch.start();
-        lnt.stop();
-        
-      }
-
-      {
-        typedef SwapBpUGraphAdaptor<LGraph> SGraph;
-        SGraph sgraph(lgraph);
-        MaxBipartiteMatching<SGraph> bpmatch(sgraph);
-
-        lst.start();
-        bpmatch.init();
-        bpmatch.start();
-        lst.stop();
-        
-      }
-     }
-
-    cout << k * 100 << ' ' << nt.realTime() << ' ' << st.realTime()
-	 << ' ' << lnt.realTime() << ' ' << lst.realTime()<< endl;
-
-  }
-
-  return 0;
-}
