lemon: comparison test/maps

equal deleted inserted replaced

-:3eb5ca24e997
+:f5866f57ae2a
 /* -*- mode: C++; indent-tabs-mode: nil; -*-
 *
 * This file is a part of LEMON, a generic C++ optimization library.
 *
-* Copyright (C) 2003-2009
+* 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
 FunctorToMap<F> map1;
 FunctorToMap<F> map2 = FunctorToMap<F>(F());
 B b = functorToMap(F())[A()];
 checkConcept<ReadMap<A,B>, MapToFunctor<ReadMap<A,B> > >();
-MapToFunctor<ReadMap<A,B> > map = MapToFunctor<ReadMap<A,B> >(ReadMap<A,B>());
+MapToFunctor<ReadMap<A,B> > map =
+MapToFunctor<ReadMap<A,B> >(ReadMap<A,B>());
 check(functorToMap(&func)[A()] == 3,
 "Something is wrong with FunctorToMap");
 check(mapToFunctor(constMap<A,int>(2))(A()) == 2,
 "Something is wrong with MapToFunctor");
 int i = 0;
 for ( LoggerBoolMap<vec::iterator>::Iterator it = map2.begin();
 it != map2.end(); ++it )
 check(v1[i++] == *it, "Something is wrong with LoggerBoolMap");
 typedef ListDigraph Graph;
 DIGRAPH_TYPEDEFS(Graph);
 Graph gr;
 Node n0 = gr.addNode();
 Node n1 = gr.addNode();
 Node n2 = gr.addNode();
 Node n3 = gr.addNode();
 gr.addArc(n3, n0);
 gr.addArc(n3, n2);
 gr.addArc(n0, n2);
 gr.addArc(n2, n1);
 gr.addArc(n0, n1);
 {
 std::vector<Node> v;
 dfs(gr).processedMap(loggerBoolMap(std::back_inserter(v))).run();
 check(v.size()==4 && v[0]==n1 && v[1]==n2 && v[2]==n0 && v[3]==n3,
 "Something is wrong with LoggerBoolMap");
 }
 {
 std::vector<Node> v(countNodes(gr));
 dfs(gr).processedMap(loggerBoolMap(v.begin())).run();
 check(v.size()==4 && v[0]==n1 && v[1]==n2 && v[2]==n0 && v[3]==n3,
 "Something is wrong with LoggerBoolMap");
 }
 }
 // IdMap, RangeIdMap
 {
 typedef ListDigraph Graph;
 DIGRAPH_TYPEDEFS(Graph);
 checkConcept<ReadMap<Node, int>, IdMap<Graph, Node> >();
 checkConcept<ReadMap<Arc, int>, IdMap<Graph, Arc> >();
 checkConcept<ReadMap<Node, int>, RangeIdMap<Graph, Node> >();
 checkConcept<ReadMap<Arc, int>, RangeIdMap<Graph, Arc> >();
 Graph gr;
 IdMap<Graph, Node> nmap(gr);
 IdMap<Graph, Arc> amap(gr);
 RangeIdMap<Graph, Node> nrmap(gr);
 RangeIdMap<Graph, Arc> armap(gr);
 Node n0 = gr.addNode();
 Node n1 = gr.addNode();
 Node n2 = gr.addNode();
 Arc a0 = gr.addArc(n0, n1);
 Arc a1 = gr.addArc(n0, n2);
 Arc a2 = gr.addArc(n2, n1);
 Arc a3 = gr.addArc(n2, n0);
 check(nmap[n0] == gr.id(n0) && nmap(gr.id(n0)) == n0, "Wrong IdMap");
 check(nmap[n1] == gr.id(n1) && nmap(gr.id(n1)) == n1, "Wrong IdMap");
 check(nmap[n2] == gr.id(n2) && nmap(gr.id(n2)) == n2, "Wrong IdMap");
 check(amap[a0] == gr.id(a0) && amap(gr.id(a0)) == a0, "Wrong IdMap");
 check(amap[a2] == gr.id(a2) && amap(gr.id(a2)) == a2, "Wrong IdMap");
 check(amap[a3] == gr.id(a3) && amap(gr.id(a3)) == a3, "Wrong IdMap");
 check(nmap.inverse()[gr.id(n0)] == n0, "Wrong IdMap::InverseMap");
 check(amap.inverse()[gr.id(a0)] == a0, "Wrong IdMap::InverseMap");
 check(nrmap.size() == 3 && armap.size() == 4,
 "Wrong RangeIdMap::size()");
 check(nrmap[n0] == 0 && nrmap(0) == n0, "Wrong RangeIdMap");
 check(nrmap[n1] == 1 && nrmap(1) == n1, "Wrong RangeIdMap");
 check(nrmap[n2] == 2 && nrmap(2) == n2, "Wrong RangeIdMap");
 check(armap[a0] == 0 && armap(0) == a0, "Wrong RangeIdMap");
 check(armap[a1] == 1 && armap(1) == a1, "Wrong RangeIdMap");
 check(armap[a2] == 2 && armap(2) == a2, "Wrong RangeIdMap");
 check(armap[a3] == 3 && armap(3) == a3, "Wrong RangeIdMap");
 check(nrmap.inverse()[0] == n0, "Wrong RangeIdMap::InverseMap");
 check(armap.inverse()[0] == a0, "Wrong RangeIdMap::InverseMap");
 gr.erase(n1);
 if (nrmap[n0] == 1) nrmap.swap(n0, n2);
 nrmap.swap(n2, n0);
 if (armap[a1] == 1) armap.swap(a1, a3);
 armap.swap(a3, a1);
 check(nrmap.size() == 2 && armap.size() == 2,
 "Wrong RangeIdMap::size()");
 check(nrmap[n0] == 1 && nrmap(1) == n0, "Wrong RangeIdMap");
 check(nrmap[n2] == 0 && nrmap(0) == n2, "Wrong RangeIdMap");
 check(armap[a1] == 1 && armap(1) == a1, "Wrong RangeIdMap");
 check(armap[a3] == 0 && armap(0) == a3, "Wrong RangeIdMap");
 check(nrmap.inverse()[0] == n2, "Wrong RangeIdMap::InverseMap");
 check(armap.inverse()[0] == a3, "Wrong RangeIdMap::InverseMap");
 }
 // SourceMap, TargetMap, ForwardMap, BackwardMap, InDegMap, OutDegMap
 {
 typedef ListGraph Graph;
 GRAPH_TYPEDEFS(Graph);
 checkConcept<ReadMap<Arc, Node>, SourceMap<Graph> >();
 checkConcept<ReadMap<Arc, Node>, TargetMap<Graph> >();
 checkConcept<ReadMap<Edge, Arc>, ForwardMap<Graph> >();
 checkConcept<ReadMap<Edge, Arc>, BackwardMap<Graph> >();
 checkConcept<ReadMap<Node, int>, InDegMap<Graph> >();
 Graph gr;
 Node n0 = gr.addNode();
 Node n1 = gr.addNode();
 Node n2 = gr.addNode();
 gr.addEdge(n0,n1);
 gr.addEdge(n1,n2);
 gr.addEdge(n0,n2);
 gr.addEdge(n2,n1);
 gr.addEdge(n1,n2);
 gr.addEdge(n0,n1);
 for (EdgeIt e(gr); e != INVALID; ++e) {
 check(forwardMap(gr)[e] == gr.direct(e, true), "Wrong ForwardMap");
 check(backwardMap(gr)[e] == gr.direct(e, false), "Wrong BackwardMap");
 }
 check(mapCompare(gr,
 sourceMap(orienter(gr, constMap<Edge, bool>(true))),
 targetMap(orienter(gr, constMap<Edge, bool>(false)))),
 "Wrong SourceMap or TargetMap");
 typedef Orienter<Graph, const ConstMap<Edge, bool> > Digraph;
 Digraph dgr(gr, constMap<Edge, bool>(true));
 OutDegMap<Digraph> odm(dgr);
 InDegMap<Digraph> idm(dgr);
 check(odm[n0] == 3 && odm[n1] == 2 && odm[n2] == 1, "Wrong OutDegMap");
 check(idm[n0] == 0 && idm[n1] == 3 && idm[n2] == 3, "Wrong InDegMap");
 gr.addEdge(n2, n0);
 check(odm[n0] == 3 && odm[n1] == 2 && odm[n2] == 2, "Wrong OutDegMap");
 check(idm[n0] == 1 && idm[n1] == 3 && idm[n2] == 3, "Wrong InDegMap");
 }
 // CrossRefMap
 {
 typedef ListDigraph Graph;
 DIGRAPH_TYPEDEFS(Graph);
 CrossRefMap<Graph, Node, int> >();
 checkConcept<ReadWriteMap<Node, bool>,
 CrossRefMap<Graph, Node, bool> >();
 checkConcept<ReadWriteMap<Node, double>,
 CrossRefMap<Graph, Node, double> >();
 Graph gr;
 typedef CrossRefMap<Graph, Node, char> CRMap;
 CRMap map(gr);
 Node n0 = gr.addNode();
 Node n1 = gr.addNode();
 Node n2 = gr.addNode();
 map.set(n0, 'A');
 map.set(n1, 'B');
 map.set(n2, 'C');
 check(map[n0] == 'A' && map('A') == n0 && map.inverse()['A'] == n0,
 "Wrong CrossRefMap");
 check(map[n1] == 'B' && map('B') == n1 && map.inverse()['B'] == n1,
 "Wrong CrossRefMap");
 check(map[n2] == 'C' && map('C') == n2 && map.inverse()['C'] == n2,
 "Wrong CrossRefMap");
 check(map.count('A') == 1 && map.count('B') == 1 && map.count('C') == 1,
 "Wrong CrossRefMap::count()");
 CRMap::ValueIt it = map.beginValue();
 check(*it++ == 'A' && *it++ == 'B' && *it++ == 'C' &&
 it == map.endValue(), "Wrong value iterator");
 map.set(n2, 'A');
 check(map[n0] == 'A' && map[n1] == 'B' && map[n2] == 'A',
 "Wrong CrossRefMap");
 check(map('A') == n0 && map.inverse()['A'] == n0, "Wrong CrossRefMap");
 typedef SmartDigraph Graph;
 DIGRAPH_TYPEDEFS(Graph);
 checkConcept<ReadWriteMap<Node, int>,
 CrossRefMap<Graph, Node, int> >();
 Graph gr;
 typedef CrossRefMap<Graph, Node, char> CRMap;
 typedef CRMap::ValueIterator ValueIt;
 CRMap map(gr);
 Node n0 = gr.addNode();
 Node n1 = gr.addNode();
 Node n2 = gr.addNode();
 map.set(n0, 'A');
 map.set(n1, 'B');
 map.set(n2, 'C');
 map.set(n2, 'A');
 map.set(n0, 'C');
 ValueIt it = map.beginValue();
 check(*it++ == 'A' && *it++ == 'B' && *it++ == 'C' &&
 it == map.endValue(), "Wrong value iterator");
 }
 // Iterable bool map
 {
 typedef SmartGraph Graph;
 typedef SmartGraph::Node Item;
 ++n;
 }
 check(n == num, "Wrong number");
 }
 // Graph map utilities:
 // mapMin(), mapMax(), mapMinValue(), mapMaxValue()
 // mapFind(), mapFindIf(), mapCount(), mapCountIf()
 // mapCopy(), mapCompare(), mapFill()
 {
 SmartDigraph g;
 Node n1 = g.addNode();
 Node n2 = g.addNode();
 Node n3 = g.addNode();
 SmartDigraph::NodeMap<int> map1(g);
 SmartDigraph::ArcMap<char> map2(g);
 ConstMap<Node, A> cmap1 = A();
 ConstMap<Arc, C> cmap2 = C(0);
 map1[n1] = 10;
 map1[n2] = 5;
 map1[n3] = 12;
 // mapMin(), mapMax(), mapMinValue(), mapMaxValue()
 check(mapMin(g, map1) == n2, "Wrong mapMin()");
 check(mapMax(g, map1) == n3, "Wrong mapMax()");
 check(mapMin(g, map1, std::greater<int>()) == n3, "Wrong mapMin()");
 check(mapMax(g, map1, std::greater<int>()) == n2, "Wrong mapMax()");
 Arc a1 = g.addArc(n1, n2);
 Arc a2 = g.addArc(n1, n3);
 Arc a3 = g.addArc(n2, n3);
 Arc a4 = g.addArc(n3, n1);
 map2[a1] = 'b';
 map2[a2] = 'a';
 map2[a3] = 'b';
 map2[a4] = 'c';
 "Wrong mapCountIf()");
 check(mapCountIf(g, map2, Less<char>('c')) == 3,
 "Wrong mapCountIf()");
 check(mapCountIf(g, map2, Less<char>('a')) == 0,
 "Wrong mapCountIf()");
 // MapIt, ConstMapIt
 /*
 These tests can be used after applying bugfix #330
 typedef SmartDigraph::NodeMap<int>::MapIt MapIt;
 typedef SmartDigraph::NodeMap<int>::ConstMapIt ConstMapIt;
 check(*std::min_element(MapIt(map1), MapIt(INVALID)) == 5,
 "Wrong NodeMap<>::MapIt");
 check(*std::max_element(ConstMapIt(map1), ConstMapIt(INVALID)) == 12,
 "Wrong NodeMap<>::MapIt");
 int sum = 0;
 std::for_each(MapIt(map1), MapIt(INVALID), Sum<int>(sum));
 check(sum == 27, "Wrong NodeMap<>::MapIt");
 std::for_each(ConstMapIt(map1), ConstMapIt(INVALID), Sum<int>(sum));
 check(sum == 54, "Wrong NodeMap<>::ConstMapIt");
 check(mapCompare(g, map2, scaleMap(map2, 1)), "Wrong mapCompare()");
 check(!mapCompare(g, map1, shiftMap(map1, 1)), "Wrong mapCompare()");
 SmartDigraph::NodeMap<int> map3(g, 0);
 SmartDigraph::ArcMap<char> map4(g, 'a');
 check(!mapCompare(g, map1, map3), "Wrong mapCompare()");
 check(!mapCompare(g, map2, map4), "Wrong mapCompare()");
 mapCopy(g, map1, map3);
 mapCopy(g, map2, map4);
 check(mapCompare(g, map1, map3), "Wrong mapCompare() or mapCopy()");
 check(mapCompare(g, map2, map4), "Wrong mapCompare() or mapCopy()");
 Undirector<SmartDigraph> ug(g);
 Undirector<SmartDigraph>::EdgeMap<char> umap1(ug, 'x');
 Undirector<SmartDigraph>::ArcMap<double> umap2(ug, 3.14);
 check(!mapCompare(g, map2, umap1), "Wrong mapCompare() or mapCopy()");
 check(!mapCompare(g, umap1, map2), "Wrong mapCompare() or mapCopy()");
 check(!mapCompare(ug, map2, umap1), "Wrong mapCompare() or mapCopy()");
 check(!mapCompare(ug, umap1, map2), "Wrong mapCompare() or mapCopy()");
 mapCopy(g, map2, umap1);
 check(mapCompare(g, map2, umap1), "Wrong mapCompare() or mapCopy()");
 check(mapCompare(g, umap1, map2), "Wrong mapCompare() or mapCopy()");
 check(mapCompare(ug, map2, umap1), "Wrong mapCompare() or mapCopy()");
 check(mapCompare(ug, umap1, map2), "Wrong mapCompare() or mapCopy()");
 mapCopy(g, map2, umap1);
 mapCopy(g, umap1, map2);
 mapCopy(ug, map2, umap1);
 mapCopy(ug, umap1, map2);
 check(!mapCompare(ug, umap1, umap2), "Wrong mapCompare() or mapCopy()");
 mapCopy(ug, umap1, umap2);
 check(mapCompare(ug, umap1, umap2), "Wrong mapCompare() or mapCopy()");
 check(!mapCompare(g, map1, constMap<Node>(2)), "Wrong mapCompare()");
 mapFill(g, map1, 2);
 check(mapCompare(g, constMap<Node>(2), map1), "Wrong mapFill()");
 check(!mapCompare(g, map2, constMap<Arc>('z')), "Wrong mapCompare()");
 mapCopy(g, constMap<Arc>('z'), map2);
 check(mapCompare(g, constMap<Arc>('z'), map2), "Wrong mapCopy()");
 }
 return 0;
 }

branch	1.2
changeset 1055	60f4aaedb20f
parent 836	8ddb7deabab9
child 1057	633956ca9421