RhodeCode

/* -*- mode: C++; indent-tabs-mode: nil; -*-
 *
 * This file is a part of LEMON, a generic C++ optimization library.
 *
 * Copyright (C) 2003-2010
 * 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 "test_tools.h"
#include <lemon/smart_graph.h>
#include <lemon/max_cardinality_search.h>
#include <lemon/concepts/digraph.h>
#include <lemon/concepts/maps.h>
#include <lemon/concepts/heap.h>
#include <lemon/lgf_reader.h>

using namespace lemon;
using namespace std;

char test_lgf[] =
  "@nodes\n"
  "label\n"
  "0\n"
  "1\n"
  "2\n"
  "3\n"
  "@arcs\n"
  "    label capacity\n"
  "0 1 0     2\n"
  "1 0 1     2\n"
  "2 1 2     1\n"
  "2 3 3     3\n"
  "3 2 4     3\n"
  "3 1 5     5\n"
  "@attributes\n"
  "s 0\n"
  "x 1\n"
  "y 2\n"
  "z 3\n";

void checkMaxCardSearchCompile() {

  typedef concepts::Digraph Digraph;
  typedef int Value;
  typedef Digraph::Node Node;
  typedef Digraph::Arc Arc;
  typedef concepts::ReadMap<Arc,Value> CapMap;
  typedef concepts::ReadWriteMap<Node,Value> CardMap;
  typedef concepts::ReadWriteMap<Node,bool> ProcMap;
  typedef Digraph::NodeMap<int> HeapCrossRef;

  Digraph g;
  Node n,s;
  CapMap cap;
  CardMap card;
  ProcMap proc;
  HeapCrossRef crossref(g);
  
  typedef MaxCardinalitySearch<Digraph,CapMap>
    ::SetCapacityMap<CapMap>
    ::SetCardinalityMap<CardMap>
    ::SetProcessedMap<ProcMap>
    ::SetStandardHeap<BinHeap<Value,HeapCrossRef> >
    ::Create MaxCardType;

  MaxCardType maxcard(g,cap);
  const MaxCardType& const_maxcard = maxcard;

  const MaxCardType::Heap& heap_const = const_maxcard.heap();
  MaxCardType::Heap& heap = const_cast<MaxCardType::Heap&>(heap_const);
  maxcard.heap(heap,crossref);
  
  maxcard.capacityMap(cap).cardinalityMap(card).processedMap(proc);

  maxcard.init();
  maxcard.addSource(s);
  n = maxcard.nextNode();
   maxcard.processNextNode();
   maxcard.start();
   maxcard.run(s);
   maxcard.run();
 }

 void checkWithIntMap( std::istringstream& input)
 {
   typedef SmartDigraph Digraph;
   typedef Digraph::Node Node;
   typedef Digraph::ArcMap<int> CapMap;

   Digraph g;
   Node s,x,y,z,a;
   CapMap cap(g);

   DigraphReader<Digraph>(g,input).
     arcMap("capacity", cap).
     node("s",s).
     node("x",x).
     node("y",y).
     node("z",z).
     run();

   MaxCardinalitySearch<Digraph,CapMap> maxcard(g,cap);

   maxcard.init();
   maxcard.addSource(s);
   maxcard.start(x);

   check(maxcard.processed(s) and !maxcard.processed(x) and
         !maxcard.processed(y), "Wrong processed()!");

   a=maxcard.nextNode();
   check(maxcard.processNextNode()==a,
         "Wrong nextNode() or processNextNode() return value!");

   check(maxcard.processed(a), "Wrong processNextNode()!");

   maxcard.start();
   check(maxcard.cardinality(x)==2 and maxcard.cardinality(y)>=4,
         "Wrong cardinalities!");
 }

 void checkWithConst1Map(std::istringstream &input) {
   typedef SmartDigraph Digraph;
   typedef Digraph::Node Node;

   Digraph g;
   Node s,x,y,z;

  DigraphReader<Digraph>(g,input).
    node("s",s).
    node("x",x).
    node("y",y).
    node("z",z).
    run();

  MaxCardinalitySearch<Digraph> maxcard(g);
  maxcard.run(s);
  check(maxcard.cardinality(x)==1 &&
        maxcard.cardinality(y)+maxcard.cardinality(z)==3,
        "Wrong cardinalities!");
}

int main() {

  std::istringstream input1(test_lgf);
  checkWithIntMap(input1);

  std::istringstream input2(test_lgf);
  checkWithConst1Map(input2);
}