/* -*- mode: C++; indent-tabs-mode: nil; -*-

  *

  * This file is a part of LEMON, a generic C++ optimization library.

  *

  * Copyright (C) 2003-2013

  * 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/core.h>

 #include <lemon/time_measure.h>

 #include <lemon/smart_graph.h>

 #include <lemon/maps.h>

 #include <lemon/radix_sort.h>

 #include <lemon/math.h>

 #include "test_tools.h"

 #include <vector>

 #include <list>

 #include <algorithm>

 using namespace lemon;

 static const int n = 10000;

 struct Negate {

   typedef int argument_type;

   typedef int result_type;

   int operator()(int a) { return - a; }

 };

 int negate(int a) { return - a; }

 template<class T>

 bool isTheSame(T &a, T&b)

 {

   typename T::iterator ai=a.begin();

   typename T::iterator bi=b.begin();

   for(;ai!=a.end()||bi!=b.end();++ai,++bi)

     if(*ai!=*bi) return false;

   return ai==a.end()&&bi==b.end();

 }

 template<class T>

 T listsort(typename T::iterator b, typename T::iterator e)

 {

   if(b==e) return T();

   typename T::iterator bn=b;

   if(++bn==e) {

     T l;

     l.push_back(*b);

     return l;

   }

   typename T::iterator m=b;

   bool x=false;

   for(typename T::iterator i=b;i!=e;++i,x=!x)

     if(x) ++m;

   T l1(listsort<T>(b,m));

   T l2(listsort<T>(m,e));

   T l;

   while((!l1.empty())&&(!l2.empty()))

     if(l1.front()<=l2.front())

       {

         l.push_back(l1.front());

         l1.pop_front();

       }

     else {

       l.push_back(l2.front());

       l2.pop_front();

     }

   while(!l1.empty())

     {

       l.push_back(l1.front());

       l1.pop_front();

     }

   while(!l2.empty())

     {

       l.push_back(l2.front());

       l2.pop_front();

     }

   return l;

 }

 template<class T>

 void generateIntSequence(int n, T & data) {

   int prime = 9973;

   int root = 136, value = 1;

   for (int i = 0; i < n; ++i) {

     data.push_back(value - prime / 2);

     value = (value * root) % prime;

   }

 }

 template<class T>

 void generateCharSequence(int n, T & data) {

   int prime = 251;

   int root = 3, value = root;

   for (int i = 0; i < n; ++i) {

     data.push_back(static_cast<unsigned char>(value));

     value = (value * root) % prime;

   }

 }

 void checkRadixSort() {

   {

     std::vector<int> data1;

     generateIntSequence(n, data1);

     std::vector<int> data2(data1);

     std::sort(data1.begin(), data1.end());

     radixSort(data2.begin(), data2.end());

     for (int i = 0; i < n; ++i) {

       check(data1[i] == data2[i], "Test failed");

     }

     // radixSort(data2.begin(), data2.end(), Negate());

     // for (int i = 0; i < n; ++i) {

     //   check(data1[i] == data2[n - 1 - i], "Test failed");

     // }

     // radixSort(data2.begin(), data2.end(), negate);

     // for (int i = 0; i < n; ++i) {

     //   check(data1[i] == data2[n - 1 - i], "Test failed");

     // }

   }

   {

     std::vector<unsigned char> data1(n);

     generateCharSequence(n, data1);

     std::vector<unsigned char> data2(data1);

     std::sort(data1.begin(), data1.end());

     radixSort(data2.begin(), data2.end());

     for (int i = 0; i < n; ++i) {

       check(data1[i] == data2[i], "Test failed");

     }

   }

   {

     std::list<int> data1;

     generateIntSequence(n, data1);

     std::list<int> data2(listsort<std::list<int> >(data1.begin(), data1.end()));

     radixSort(data1.begin(), data1.end());

     check(isTheSame(data1,data2), "Test failed");

     // radixSort(data2.begin(), data2.end(), Negate());

     // check(isTheSame(data1,data2), "Test failed");

     // for (int i = 0; i < n; ++i) {

     //   check(data1[i] == data2[n - 1 - i], "Test failed");

     // }

     // radixSort(data2.begin(), data2.end(), negate);

     // for (int i = 0; i < n; ++i) {

     //   check(data1[i] == data2[n - 1 - i], "Test failed");

     // }

   }

   {

     std::list<unsigned char> data1(n);

     generateCharSequence(n, data1);

     std::list<unsigned char> data2(listsort<std::list<unsigned char> >

                                    (data1.begin(),

                                     data1.end()));

     radixSort(data1.begin(), data1.end());

     check(isTheSame(data1,data2), "Test failed");

   }

 }

 void checkStableRadixSort() {

   {

     std::vector<int> data1;

     generateIntSequence(n, data1);

     std::vector<int> data2(data1);

     std::sort(data1.begin(), data1.end());

     stableRadixSort(data2.begin(), data2.end());

     for (int i = 0; i < n; ++i) {

       check(data1[i] == data2[i], "Test failed");

     }

     stableRadixSort(data2.begin(), data2.end(), Negate());

     for (int i = 0; i < n; ++i) {

       check(data1[i] == data2[n - 1 - i], "Test failed");

     }

     stableRadixSort(data2.begin(), data2.end(), negate);

     for (int i = 0; i < n; ++i) {

       check(data1[i] == data2[n - 1 - i], "Test failed");

     }

   }

   {

     std::vector<unsigned char> data1(n);

     generateCharSequence(n, data1);

     std::vector<unsigned char> data2(data1);

     std::sort(data1.begin(), data1.end());

     radixSort(data2.begin(), data2.end());

     for (int i = 0; i < n; ++i) {

       check(data1[i] == data2[i], "Test failed");

     }

   }

   {

     std::list<int> data1;

     generateIntSequence(n, data1);

     std::list<int> data2(listsort<std::list<int> >(data1.begin(),

                                                    data1.end()));

     stableRadixSort(data1.begin(), data1.end());

     check(isTheSame(data1,data2), "Test failed");

     // stableRadixSort(data2.begin(), data2.end(), Negate());

     // for (int i = 0; i < n; ++i) {

     //   check(data1[i] == data2[n - 1 - i], "Test failed");

     // }

     // stableRadixSort(data2.begin(), data2.end(), negate);

     // for (int i = 0; i < n; ++i) {

     //   check(data1[i] == data2[n - 1 - i], "Test failed");

     // }

   }

   {

     std::list<unsigned char> data1(n);

     generateCharSequence(n, data1);

     std::list<unsigned char> data2(listsort<std::list<unsigned char> >

                                    (data1.begin(),

                                     data1.end()));

     radixSort(data1.begin(), data1.end());

     check(isTheSame(data1,data2), "Test failed");

   }

 }

 int main() {

   checkRadixSort();

   checkStableRadixSort();

   return 0;

 }