/* -*- 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 <iostream>

 #include <vector>

 #include <lemon/concept_check.h>

 #include <lemon/concept/matrix_maps.h>

 #include <lemon/concept/maps.h>

 #include <lemon/concept/graph.h>

 #include <lemon/matrix_maps.h>

 #include <lemon/smart_graph.h>

 #include "test_tools.h"

 #include "graph_test.h"

 #include "map_test.h"

 using namespace lemon;

 using namespace lemon::concept;

 int main() {

   typedef SmartGraph Graph;

   typedef Graph::Node Node;

   { // checking MatrixMap for int

     typedef DynamicMatrixMap<Graph, Node, int> IntMatrixMap;

     checkConcept<ReferenceMatrixMap<Node, Node, int, 

       IntMatrixMap::Reference, IntMatrixMap::ConstReference>,

       IntMatrixMap>();

   }

   { // checking MatrixMap for bool

     typedef DynamicMatrixMap<Graph, Node, bool> BoolMatrixMap;

     checkConcept<ReferenceMatrixMap<Node, Node, bool, 

       BoolMatrixMap::Reference, BoolMatrixMap::ConstReference>,

       BoolMatrixMap>();

   }

   {

     Graph graph;

     typedef DynamicMatrixMap<Graph, Node, int> IntMatrixMap;

     IntMatrixMap matrix(graph);

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

       graph.addNode();

     }

     for (Graph::NodeIt it(graph); it != INVALID; ++it) {

       for (Graph::NodeIt jt(graph); jt != INVALID; ++jt) {

 	int val = urandom(100);

 	matrix.set(it, jt, val);

 	check(matrix(it, jt) == val, "Wrong assign");

 	check(matrix(it, jt) == matrixRowMap(matrix, it)[jt], "Wrong rowMap");

 	check(matrix(it, jt) == matrixColMap(matrix, jt)[it], "Wrong colMap");

       }

     }

     const IntMatrixMap& cm = matrix;

     for (Graph::NodeIt it(graph); it != INVALID; ++it) {

       for (Graph::NodeIt jt(graph); jt != INVALID; ++jt) {

 	check(cm(it, jt) == matrixRowMap(cm, it)[jt], "Wrong rowMap");

 	check(cm(it, jt) == matrixColMap(cm, jt)[it], "Wrong colMap");

       }

     }

   }

   { // checking MatrixMap for int

     typedef DynamicSymMatrixMap<Graph, Node, int> IntMatrixMap;

     checkConcept<ReferenceMatrixMap<Node, Node, int, 

       IntMatrixMap::Reference, IntMatrixMap::ConstReference>,

       IntMatrixMap>();

   }

   { // checking MatrixMap for bool

     typedef DynamicSymMatrixMap<Graph, Node, bool> BoolMatrixMap;

     checkConcept<ReferenceMatrixMap<Node, Node, bool, 

       BoolMatrixMap::Reference, BoolMatrixMap::ConstReference>,

       BoolMatrixMap>();

   }

   {

     Graph graph;

     typedef DynamicSymMatrixMap<Graph, Node, int> IntMatrixMap;

     IntMatrixMap matrix(graph);

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

       graph.addNode();

     }

     for (Graph::NodeIt it(graph); it != INVALID; ++it) {

       for (Graph::NodeIt jt(graph); jt != INVALID; ++jt) {

 	int val = urandom(100);

 	matrix.set(it, jt, val);

 	check(matrix(it, jt) == val, "Wrong assign");

 	check(matrix(jt, it) == val, "Wrong assign");

 	check(matrix(it, jt) == matrixRowMap(matrix, it)[jt], "Wrong rowMap");

 	check(matrix(it, jt) == matrixColMap(matrix, jt)[it], "Wrong colMap");

       }

     }

     const IntMatrixMap& cm = matrix;

     for (Graph::NodeIt it(graph); it != INVALID; ++it) {

       for (Graph::NodeIt jt(graph); jt != INVALID; ++jt) {

 	check(cm(it, jt) == matrixRowMap(cm, it)[jt], "Wrong rowMap");

 	check(cm(it, jt) == matrixColMap(cm, jt)[it], "Wrong colMap");

       }

     }

   }

   std::cout << __FILE__ ": All tests passed.\n";

   return 0;

 }