/* -*- C++ -*-

 * src/test/dijkstra_heap_test.cc - Part of LEMON, a generic C++ optimization library

 *

 * Copyright (C) 2004 Egervary Jeno Kombinatorikus Optimalizalasi Kutatocsoport

 * (Egervary Combinatorial Optimization Research Group, 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.

 *

 */

//Tests dijsktra.h with two heap implementations:

//the default binary heap of bin_heap.h, and the 

//Fibonacci heap of fib_heap.h.

//The input is a graph in standard dimacs format from the standard input (like

//in /lemon_loc/testfiles/dimacs). It runs dijkstra.h on this graph with both

//heaps, checking two postconditions:

//- if the edges e=uv of the shortest path tree reported by dijkstra.h have

//dist(v)-dist(u)=length(e)

// - if all edges e=uv with u reachable from the root have

//dist(v)-dist(u)>=length(e)

#include <iostream>

#include <math.h>

#include <lemon/smart_graph.h>

#include <lemon/dimacs.h>

#include <lemon/dijkstra.h>

#include <lemon/time_measure.h>

#include <lemon/bin_heap.h>

#include <lemon/fib_heap.h>

using namespace lemon;

int main(int, char **) {

  typedef SmartGraph Graph;

  typedef Graph::Edge Edge;

  typedef Graph::Node Node;

  typedef Graph::EdgeIt EdgeIt;

  typedef Graph::NodeIt NodeIt;

  typedef Graph::template EdgeMap<int> LengthMap;

  Graph G;

  Node s, t;

  LengthMap cap(G);

  readDimacsMaxFlow(std::cin, G, s, t, cap);

  Timer ts;

  std::cout <<

    "\n  Testing dijkstra.h with binary heap implementation bin_heap.h,"

	    <<std::endl;

  std::cout<<"  on a graph with " << 

    G.nodeNum() << " nodes and " << G.edgeNum() << " edges..."

	   << std::endl<<std::endl;

  Dijkstra<Graph, LengthMap> 

    dijkstra_test(G, cap);

  ts.reset();

  dijkstra_test.run(s);

  std::cout << "elapsed time: " << ts << std::endl;

  int error1=0;

  int error2=0;

  EdgeIt e;

  for(G.first(e); e!=INVALID; ++e) {

    Node u=G.source(e);

    Node v=G.target(e);

    if ( dijkstra_test.dist(v) - dijkstra_test.dist(u) > cap[e] )

      if ( dijkstra_test.reached(u) ) {

	std::cout<<"Error! dist(target)-dist(source)- edge_length= " 

		 <<dijkstra_test.dist(v) - dijkstra_test.dist(u) 

	  - cap[e]<<std::endl;

	++error1;

      }

  }

  NodeIt v;

  for(G.first(v); v!=INVALID; ++v) {

    if ( dijkstra_test.reached(v) ) {

      Edge e=dijkstra_test.pred(v);

      Node u=G.source(e);

      if ( dijkstra_test.dist(v) - dijkstra_test.dist(u) != cap[e] ) {

	std::cout<<"Error in a shortest path tree edge! Difference: " 

		 <<std::abs(dijkstra_test.dist(v) - dijkstra_test.dist(u) 

			    - cap[e])<<std::endl;

	++error2;

      }

    }

  }

  std::cout << error1 << " non-tree and " << error2 

	    << " shortest path tree edge is erroneous."<<std::endl;

  std::cout <<

    "\n\n  Testing dijkstra.h with Fibonacci heap implementation fib_heap.h,"

	    <<std::endl;

  std::cout<<"  on a graph with " << 

    G.nodeNum() << " nodes and " << G.edgeNum() << " edges..."

	   << std::endl<<std::endl;

  Dijkstra<Graph, LengthMap, FibHeap> 

    dijkstra_test2(G, cap);

  ts.reset();

  dijkstra_test2.run(s);

  std::cout << "elapsed time: " << ts << std::endl;

  error1=0;

  error2=0;

  for(G.first(e); e!=INVALID; ++e) {

    Node u=G.source(e);

    Node v=G.target(e);

    if ( dijkstra_test2.dist(v) - dijkstra_test2.dist(u) > cap[e] )

      if ( dijkstra_test2.reached(u) ) {

	std::cout<<"Error! dist(target)-dist(source)- edge_length= " 

		 <<dijkstra_test2.dist(v) - dijkstra_test2.dist(u) 

	  - cap[e]<<std::endl;

	++error1;

      }

  }

  for(G.first(v); v!=INVALID; ++v) {

    if ( dijkstra_test2.reached(v) ) {

      Edge e=dijkstra_test2.pred(v);

      Node u=G.source(e);

      if ( dijkstra_test2.dist(v) - dijkstra_test2.dist(u) != cap[e] ) {

	std::cout<<"Error in a shortest path tree edge! Difference: " 

		 <<std::abs(dijkstra_test2.dist(v) - dijkstra_test2.dist(u) 

			    - cap[e])<<std::endl;

	++error2;

      }

    }

  }

  std::cout << error1 << " non-tree and " << error2 

	    << " shortest path tree edge is erroneous."<<std::endl;

  return 0;

}