RhodeCode

 * 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 <fstream>

#include <limits>

#include <lemon/list_graph.h>

#include <lemon/lgf_reader.h>

#include <lemon/network_simplex.h>

#include <lemon/concepts/digraph.h>

#include <lemon/concept_check.h>

#include "test_tools.h"

using namespace lemon;

// Test networks

char test_lgf[] =

  "@nodes\n"

  "label  sup1 sup2 sup3 sup4 sup5 sup6\n"

  "    1    20   27    0   30   20   30\n"

  "    2    -4    0    0    0   -8   -3\n"

  "    3     0    0    0    0    0    0\n"

  "    4     0    0    0    0    0    0\n"

  "    5     9    0    0    0    6   11\n"

  "    6    -6    0    0    0   -5   -6\n"

  "    7     0    0    0    0    0    0\n"

  "    8     0    0    0    0    0    3\n"

  "    9     3    0    0    0    0    0\n"

  "   10    -2    0    0    0   -7   -2\n"

  "   11     0    0    0    0  -10    0\n"

  "   12   -20  -27    0  -30  -30  -20\n"

  "\n"                

  "@arcs\n"

  DigraphReader<Digraph>(neg1_gr, neg_inp1)

    .arcMap("cost", neg1_c)

    .arcMap("low1", neg1_l1)

    .arcMap("low2", neg1_l2)

    .nodeMap("sup", neg1_s)

    .run();

  std::istringstream neg_inp2(test_neg2_lgf);

  DigraphReader<Digraph>(neg2_gr, neg_inp2)

    .arcMap("cost", neg2_c)

    .nodeMap("sup", neg2_s)

    .run();

  // Check the interface of NetworkSimplex

  {

    typedef concepts::Digraph GR;

    checkConcept< McfClassConcept<GR, int, int>,

                  NetworkSimplex<GR> >();

    checkConcept< McfClassConcept<GR, double, double>,

                  NetworkSimplex<GR, double> >();

    checkConcept< McfClassConcept<GR, int, double>,

                  NetworkSimplex<GR, int, double> >();

  }

  // Test NetworkSimplex

  { 

    typedef NetworkSimplex<Digraph> MCF;

    runMcfGeqTests<MCF>(MCF::FIRST_ELIGIBLE, "NS-FE", true);

    runMcfLeqTests<MCF>(MCF::FIRST_ELIGIBLE, "NS-FE");

    runMcfGeqTests<MCF>(MCF::BEST_ELIGIBLE,  "NS-BE", true);

    runMcfLeqTests<MCF>(MCF::BEST_ELIGIBLE,  "NS-BE");

    runMcfGeqTests<MCF>(MCF::BLOCK_SEARCH,   "NS-BS", true);

    runMcfLeqTests<MCF>(MCF::BLOCK_SEARCH,   "NS-BS");

    runMcfGeqTests<MCF>(MCF::CANDIDATE_LIST, "NS-CL", true);

    runMcfLeqTests<MCF>(MCF::CANDIDATE_LIST, "NS-CL");

    runMcfGeqTests<MCF>(MCF::ALTERING_LIST,  "NS-AL", true);

    runMcfLeqTests<MCF>(MCF::ALTERING_LIST,  "NS-AL");

  }

  return 0;

}