// -*- mode:C++ -*-

 #ifndef LEMON_BENCH_TEST_H

 #define LEMON_BENCH_TEST_H

 #include<vector>

 #include<iostream>

 #include<lemon/time_measure.h>

 ///An experimental typedef factory

 #define GRAPH_TYPEDEF_FACTORY(Graph) \

    typedef typename Graph::   Node      Node;\

    typedef typename Graph::   NodeIt    NodeIt;\

    typedef typename Graph::   Edge      Edge;\

    typedef typename Graph::   EdgeIt    EdgeIt;\

    typedef typename Graph:: InEdgeIt  InEdgeIt;\

    typedef typename Graph::OutEdgeIt OutEdgeIt;

 #define GRAPH_TYPEDEF_FACTORY_NOTYPENAME(Graph) \

    typedef Graph::   Node      Node;\

    typedef Graph::   NodeIt    NodeIt;\

    typedef Graph::   Edge      Edge;\

    typedef Graph::   EdgeIt    EdgeIt;\

    typedef Graph:: InEdgeIt  InEdgeIt;\

    typedef Graph::OutEdgeIt OutEdgeIt;

 ///A primitive primtest

 ///\bug 2 is not a prime according to this function!

 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.

 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(char *ID,lemon::Timer &T) 

 {

   lemon::TimeStamp S(T);

   std::cout << ID << ' ' << S.getUserTime() << ' '

 	    << S.getSystemTime() << ' ' << S.getRealTime() << std::endl;

 }

 ///

 template<class Graph>

 void addHiperCube(Graph &G,int dim,std::vector<typename Graph::Node> &nodes)

 {

   GRAPH_TYPEDEF_FACTORY(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 addBiDirHiperCube(Graph &G,int dim,std::vector<typename Graph::Node>&nodes)

 {

   GRAPH_TYPEDEF_FACTORY(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