/* -*- C++ -*-

 *

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

 *

 * Copyright (C) 2003-2006

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

#include <lemon/smart_graph.h>

#include <lemon/graph_utils.h>

#include <lemon/maps.h>

#include <lemon/radix_sort.h>

#include "test_tools.h"

#include <vector>

#include <algorithm>

#include <cmath>

using namespace std;

using namespace lemon;

void checkRadixSort() {

  {

    int n = 10000;

    vector<int> data1(n), data2(n);

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

      data1[i] = data2[i] = rnd[1000] - 500;

    }

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

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

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

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

    }

  } {

    int n = 10000;

    vector<unsigned char> data1(n), data2(n);

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

      data1[i] = data2[i] = rnd[(unsigned char)200];

    }

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

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

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

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

    }

  }

}

void checkCounterSort() {

  {

    int n = 10000;

    vector<int> data1(n), data2(n);

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

      data1[i] = data2[i] = rnd[1000] - 500;

    }

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

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

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

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

    } 

  } {

    int n = 10000;

    vector<unsigned char> data1(n), data2(n);

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

      data1[i] = data2[i] = rnd[(unsigned char)200];

    }

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

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

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

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

    } 

  }

}

void checkSorts() {

  checkRadixSort();

  checkCounterSort();

}

void checkGraphRadixSort() {

  typedef SmartGraph Graph;

  typedef Graph::Node Node;

  typedef Graph::Edge Edge;

  const int n = 100;

  const int e = (int)(n * log((double)n));

  Graph graph;

  vector<Node> nodes;

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

    nodes.push_back(graph.addNode());

  }

  vector<Edge> edges;

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

    int s = rnd[n];

    int t = rnd[n];

    edges.push_back(graph.addEdge(nodes[s], nodes[t]));

  }

  radixSort(edges.begin(), edges.end(), 

	    mapFunctor(composeMap(IdMap<Graph, Node>(graph), 

				  sourceMap(graph))));

  Graph::EdgeMap<bool> was(graph, false);

  for (int i = 0; i < (int)edges.size(); ++i) {

    check(!was[edges[i]], "Test failed");

    was[edges[i]] = true;

  }

  for (int i = 1; i < (int)edges.size(); ++i) {

    check(graph.id(graph.source(edges[i - 1])) <= 

	  graph.id(graph.source(edges[i])), "Test failed");

  }

}

void checkGraphCounterSort() {

  typedef SmartGraph Graph;

  typedef Graph::Node Node;

  typedef Graph::Edge Edge;

  const int n = 100;

  const int e = (int)(n * log((double)n));

  Graph graph;

  vector<Node> nodes;

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

    nodes.push_back(graph.addNode());

  }

  vector<Edge> edges;

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

    int s = rnd[n];

    int t = rnd[n];

    edges.push_back(graph.addEdge(nodes[s], nodes[t]));

  }

  counterSort(edges.begin(), edges.end(), 

	      mapFunctor(composeMap(IdMap<Graph, Node>(graph), 

				    sourceMap(graph))));

  counterSort(edges.begin(), edges.end(), 

	      mapFunctor(composeMap(IdMap<Graph, Node>(graph), 

				    targetMap(graph))));

  Graph::EdgeMap<bool> was(graph, false);

  for (int i = 0; i < (int)edges.size(); ++i) {

    check(!was[edges[i]], "Test failed");

    was[edges[i]] = true;

  }

  for (int i = 1; i < (int)edges.size(); ++i) {

    check(graph.id(graph.target(edges[i - 1])) < 

	  graph.id(graph.target(edges[i])) || 

	  (graph.id(graph.target(edges[i - 1])) ==

	   graph.id(graph.target(edges[i])) &&

	   graph.id(graph.source(edges[i - 1])) <= 

	   graph.id(graph.source(edges[i]))), "Test failed");

  }

}

void checkGraphSorts() {

  checkGraphRadixSort();

  checkGraphCounterSort();

}

int main() {

  checkSorts();

  checkGraphSorts();

  return 0;

}