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

#include <sstream>

#include <lemon/smart_graph.h>

#include <lemon/lgf_reader.h>

#include <lemon/path.h>

#include <lemon/concepts/digraph.h>

#include <lemon/concept_check.h>

#include <lemon/karp_mmc.h>

#include <lemon/hartmann_orlin_mmc.h>

#include <lemon/howard_mmc.h>

#include "test_tools.h"

using namespace lemon;

char test_lgf[] =

  "@nodes\n"

  "label\n"

  "1\n"

  "2\n"

  "3\n"

  "4\n"

  "5\n"

  "6\n"

  "7\n"

  "@arcs\n"

  "    len1 len2 len3 len4  c1 c2 c3 c4\n"

  "1 2    1    1    1    1   0  0  0  0\n"

  "2 4    5    5    5    5   1  0  0  0\n"

  "2 3    8    8    8    8   0  0  0  0\n"

  "3 2   -2    0    0    0   1  0  0  0\n"

  "3 4    4    4    4    4   0  0  0  0\n"

  "3 7   -4   -4   -4   -4   0  0  0  0\n"

  "4 1    2    2    2    2   0  0  0  0\n"

  "4 3    3    3    3    3   1  0  0  0\n"

  "4 4    3    3    0    0   0  0  1  0\n"

  "5 2    4    4    4    4   0  0  0  0\n"

  "5 6    3    3    3    3   0  1  0  0\n"

  "6 5    2    2    2    2   0  1  0  0\n"

  "6 4   -1   -1   -1   -1   0  0  0  0\n"

  "6 7    1    1    1    1   0  0  0  0\n"

  "7 7    4    4    4   -1   0  0  0  1\n";

// Check the interface of an MMC algorithm

template <typename GR, typename Cost>

struct MmcClassConcept

{

  template <typename MMC>

  struct Constraints {

    void constraints() {

      const Constraints& me = *this;

      typedef typename MMC

        ::template SetPath<ListPath<GR> >

        ::template SetLargeCost<Cost>

        ::Create MmcAlg;

      MmcAlg mmc(me.g, me.cost);

      const MmcAlg& const_mmc = mmc;

      typename MmcAlg::Tolerance tol = const_mmc.tolerance();

      mmc.tolerance(tol);

      b = mmc.cycle(p).run();

      b = mmc.findCycleMean();

      b = mmc.findCycle();

      v = const_mmc.cycleCost();

      i = const_mmc.cycleSize();

      d = const_mmc.cycleMean();

      p = const_mmc.cycle();

    }

    typedef concepts::ReadMap<typename GR::Arc, Cost> CM;

    GR g;

    CM cost;

    ListPath<GR> p;

    Cost v;

    int i;

    double d;

    bool b;

  };

};

// Perform a test with the given parameters

template <typename MMC>

void checkMmcAlg(const SmartDigraph& gr,

                 const SmartDigraph::ArcMap<int>& lm,

                 const SmartDigraph::ArcMap<int>& cm,

                 int cost, int size) {

  MMC alg(gr, lm);

  check(alg.findCycleMean(), "Wrong result");

  check(alg.cycleMean() == static_cast<double>(cost) / size,

        "Wrong cycle mean");

  alg.findCycle();

  check(alg.cycleCost() == cost && alg.cycleSize() == size,

        "Wrong path");

  SmartDigraph::ArcMap<int> cycle(gr, 0);

  for (typename MMC::Path::ArcIt a(alg.cycle()); a != INVALID; ++a) {

    ++cycle[a];

  }

  for (SmartDigraph::ArcIt a(gr); a != INVALID; ++a) {

    check(cm[a] == cycle[a], "Wrong path");

  }

}

// Class for comparing types

template <typename T1, typename T2>

struct IsSameType {

  static const int result = 0;

};

template <typename T>

struct IsSameType<T,T> {

  static const int result = 1;

};

int main() {

  #ifdef LEMON_HAVE_LONG_LONG

    typedef long long long_int;

  #else

    typedef long long_int;

  #endif

  // Check the interface

  {

    typedef concepts::Digraph GR;

    // KarpMmc

    checkConcept< MmcClassConcept<GR, int>,

                  KarpMmc<GR, concepts::ReadMap<GR::Arc, int> > >();

    checkConcept< MmcClassConcept<GR, float>,

                  KarpMmc<GR, concepts::ReadMap<GR::Arc, float> > >();

    // HartmannOrlinMmc

    checkConcept< MmcClassConcept<GR, int>,

                  HartmannOrlinMmc<GR, concepts::ReadMap<GR::Arc, int> > >();

    checkConcept< MmcClassConcept<GR, float>,

                  HartmannOrlinMmc<GR, concepts::ReadMap<GR::Arc, float> > >();

    // HowardMmc

    checkConcept< MmcClassConcept<GR, int>,

                  HowardMmc<GR, concepts::ReadMap<GR::Arc, int> > >();

    checkConcept< MmcClassConcept<GR, float>,

                  HowardMmc<GR, concepts::ReadMap<GR::Arc, float> > >();

    check((IsSameType<HowardMmc<GR, concepts::ReadMap<GR::Arc, int> >

           ::LargeCost, long_int>::result == 1), "Wrong LargeCost type");

    check((IsSameType<HowardMmc<GR, concepts::ReadMap<GR::Arc, float> >

           ::LargeCost, double>::result == 1), "Wrong LargeCost type");

  }

  // Run various tests

  {

    typedef SmartDigraph GR;

    DIGRAPH_TYPEDEFS(GR);

    GR gr;

    IntArcMap l1(gr), l2(gr), l3(gr), l4(gr);

    IntArcMap c1(gr), c2(gr), c3(gr), c4(gr);

    std::istringstream input(test_lgf);

    digraphReader(gr, input).

      arcMap("len1", l1).

      arcMap("len2", l2).

      arcMap("len3", l3).

      arcMap("len4", l4).

      arcMap("c1", c1).

      arcMap("c2", c2).

      arcMap("c3", c3).

      arcMap("c4", c4).

      run();

    // Karp

    checkMmcAlg<KarpMmc<GR, IntArcMap> >(gr, l1, c1,  6, 3);

    checkMmcAlg<KarpMmc<GR, IntArcMap> >(gr, l2, c2,  5, 2);

    checkMmcAlg<KarpMmc<GR, IntArcMap> >(gr, l3, c3,  0, 1);

    checkMmcAlg<KarpMmc<GR, IntArcMap> >(gr, l4, c4, -1, 1);

    // HartmannOrlin

    checkMmcAlg<HartmannOrlinMmc<GR, IntArcMap> >(gr, l1, c1,  6, 3);

    checkMmcAlg<HartmannOrlinMmc<GR, IntArcMap> >(gr, l2, c2,  5, 2);

    checkMmcAlg<HartmannOrlinMmc<GR, IntArcMap> >(gr, l3, c3,  0, 1);

    checkMmcAlg<HartmannOrlinMmc<GR, IntArcMap> >(gr, l4, c4, -1, 1);

    // Howard

    checkMmcAlg<HowardMmc<GR, IntArcMap> >(gr, l1, c1,  6, 3);

    checkMmcAlg<HowardMmc<GR, IntArcMap> >(gr, l2, c2,  5, 2);

    checkMmcAlg<HowardMmc<GR, IntArcMap> >(gr, l3, c3,  0, 1);

    checkMmcAlg<HowardMmc<GR, IntArcMap> >(gr, l4, c4, -1, 1);

    // Howard with iteration limit

    HowardMmc<GR, IntArcMap> mmc(gr, l1);

    check((mmc.findCycleMean(2) == HowardMmc<GR, IntArcMap>::ITERATION_LIMIT),

      "Wrong termination cause");

    check((mmc.findCycleMean(4) == HowardMmc<GR, IntArcMap>::OPTIMAL),

      "Wrong termination cause");

  }

  return 0;

}