Ticket #168: bp_matching_test_751a90ada614.patch

new file test/bp_matching_test.cc

@@ +1 @@
+/* -*- 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 <lemon/concepts/bpgraph.h>
+#include <lemon/list_graph.h>
+#include <lemon/smart_graph.h>
+#include <lemon/full_graph.h>
+#include <lemon/bp_matching.h>
+
+#include "test_tools.h"
+
+using namespace lemon;
+
+static const unsigned int seed = 123456;
+
+bool prob(double p)
+{
+  return rand() / static_cast<double>(RAND_MAX) < p;
+}
+
+template<typename G>
+int generateBpGraph(G& g, 
+                    typename G::template EdgeMap<int>& edgeWeight,
+                    int nX, int nY, double p)
+{
+  int nEdges = 0;
+  
+  g.reserveNode(nX + nY);
+  g.reserveEdge(static_cast<int>(nX * nY * p));
+
+  for (int x = 0; x < nX; x++)
+    g.addRedNode();
+
+  for (int y = 0; y < nY; y++)
+    g.addBlueNode();
+
+  for (typename G::RedIt x(g); x != INVALID; ++x) 
+  {
+    for (typename G::BlueIt y(g); y != INVALID; ++y)
+    {
+      if (prob(p))
+      {
+        const typename G::Edge e = g.addEdge(x, y);
+        edgeWeight[e] = (rand() % 100) + 1;
+        nEdges++;
+      }
+    }
+  }
+
+  return nEdges;
+}
+
+template<>
+int generateBpGraph<FullBpGraph>(FullBpGraph& g,
+                                 FullBpGraph::EdgeMap<int>& edgeWeight,
+                                 int nX, int nY, double)
+{
+  for (FullBpGraph::RedIt x(g); x != INVALID; ++x) 
+  {
+    for (FullBpGraph::BlueIt y(g); y != INVALID; ++y)
+    {
+      const FullBpGraph::Edge e = g.edge(x, y);
+      edgeWeight[e] = (rand() % 100) + 1;
+    }
+  }
+
+  return nX * nY;
+}
+
+template<typename G>
+int runMWBM(G& graph, int nX, int nY, double p)
+{
+  srand(seed);
+
+  typename G::template EdgeMap<int> weight(graph);
+  generateBpGraph(graph, weight, nX, nY, p);
+
+  MaxWeightedBipartiteMatching<G> mwbm(graph, weight);
+  mwbm.run();
+
+  MaxWeightedDenseBipartiteMatching<G> mwbm_d(graph, weight);
+  mwbm_d.run();
+
+  check(mwbm.checkOptimality(), 
+        "MaxWeightedBipartiteMatching returned a sub-optimal matching");
+
+  check(mwbm.checkOptimality(), 
+        "MaxWeightedDenseBipartiteMatching returned a sub-optimal matching");
+
+  check(mwbm.matchingWeight() == mwbm_d.matchingWeight(),
+      "The two methods returned different matchings");
+
+  return mwbm.matchingWeight();
+}
+
+int main()
+{
+  static const int card_count = 3;
+  static const int prob_count = 3;
+
+  const double prob[prob_count] = {0.01, 1};
+  const int card[card_count] = {100, 500, 1000};
+
+  for (int i = 0; i < card_count; i++)
+  {
+    for (int j = 0; j < card_count; j++)
+    {
+      for (int k = 0; k < prob_count; k++)
+      {
+        int nX = card[i];
+        int nY = card[j];
+        double p = prob[k];
+
+        if (nY < nX) 
+          std::swap(nX, nY);
+
+        ListBpGraph list_G;
+        SmartBpGraph smart_G;
+        // FullBpGraph does not compile
+
+        int list_matching = runMWBM(list_G, nX, nY, p);
+        int smart_matching = runMWBM(smart_G, nX, nY, p);
+
+        check(list_matching == smart_matching, 
+          "Different solutions for identical graphs (MWBM)");
+      }
+    }
+  }
+
+  return 0;
+}