RhodeCode

/* -*- mode: C++; indent-tabs-mode: nil; -*-
 *
 * This file is a part of LEMON, a generic C++ optimization library.
 *
 * Copyright (C) 2003-2009
 * 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.h>
#include <lemon/hartmann_orlin.h>
#include <lemon/howard.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 Value>
struct MmcClassConcept
{
  template <typename MMC>
  struct Constraints {
    void constraints() {
      const Constraints& me = *this;

      typedef typename MMC
        ::template SetPath<ListPath<GR> >
        ::template SetLargeValue<Value>
        ::Create MmcAlg;
      MmcAlg mmc(me.g, me.length);
      const MmcAlg& const_mmc = mmc;
      
      typename MmcAlg::Tolerance tol = const_mmc.tolerance();
      mmc.tolerance(tol);
      
      b = mmc.cycle(p).run();
      b = mmc.findMinMean();
      b = mmc.findCycle();

      v = const_mmc.cycleLength();
      i = const_mmc.cycleArcNum();
      d = const_mmc.cycleMean();
      p = const_mmc.cycle();
    }

    typedef concepts::ReadMap<typename GR::Arc, Value> LM;
  
    GR g;
    LM length;
    ListPath<GR> p;
    Value 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 length, int size) {
  MMC alg(gr, lm);
  alg.findMinMean();
  check(alg.cycleMean() == static_cast<double>(length) / size,
        "Wrong cycle mean");
  alg.findCycle();
  check(alg.cycleLength() == length && alg.cycleArcNum() == 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;

    // Karp
    checkConcept< MmcClassConcept<GR, int>,
                  Karp<GR, concepts::ReadMap<GR::Arc, int> > >();
    checkConcept< MmcClassConcept<GR, float>,
                  Karp<GR, concepts::ReadMap<GR::Arc, float> > >();
    
    // HartmannOrlin
    checkConcept< MmcClassConcept<GR, int>,
                  HartmannOrlin<GR, concepts::ReadMap<GR::Arc, int> > >();
    checkConcept< MmcClassConcept<GR, float>,
                  HartmannOrlin<GR, concepts::ReadMap<GR::Arc, float> > >();
    
    // Howard
    checkConcept< MmcClassConcept<GR, int>,
                  Howard<GR, concepts::ReadMap<GR::Arc, int> > >();
    checkConcept< MmcClassConcept<GR, float>,
                  Howard<GR, concepts::ReadMap<GR::Arc, float> > >();

    if (IsSameType<Howard<GR, concepts::ReadMap<GR::Arc, int> >::LargeValue,
          long_int>::result == 0) check(false, "Wrong LargeValue type");
    if (IsSameType<Howard<GR, concepts::ReadMap<GR::Arc, float> >::LargeValue,
          double>::result == 0) check(false, "Wrong LargeValue 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<Karp<GR, IntArcMap> >(gr, l1, c1,  6, 3);
    checkMmcAlg<Karp<GR, IntArcMap> >(gr, l2, c2,  5, 2);
    checkMmcAlg<Karp<GR, IntArcMap> >(gr, l3, c3,  0, 1);
    checkMmcAlg<Karp<GR, IntArcMap> >(gr, l4, c4, -1, 1);

    // HartmannOrlin
    checkMmcAlg<HartmannOrlin<GR, IntArcMap> >(gr, l1, c1,  6, 3);
    checkMmcAlg<HartmannOrlin<GR, IntArcMap> >(gr, l2, c2,  5, 2);
    checkMmcAlg<HartmannOrlin<GR, IntArcMap> >(gr, l3, c3,  0, 1);
    checkMmcAlg<HartmannOrlin<GR, IntArcMap> >(gr, l4, c4, -1, 1);

    // Howard
    checkMmcAlg<Howard<GR, IntArcMap> >(gr, l1, c1,  6, 3);
    checkMmcAlg<Howard<GR, IntArcMap> >(gr, l2, c2,  5, 2);
    checkMmcAlg<Howard<GR, IntArcMap> >(gr, l3, c3,  0, 1);
    checkMmcAlg<Howard<GR, IntArcMap> >(gr, l4, c4, -1, 1);
  }

  return 0;
}