Ticket #168: bp_benchmark_ea93dc149092.patch

lemon/dimacs.h

@@ -2 +2 @@
  *
  * This file is a part of LEMON, a generic C++ optimization library.
  *
- * Copyright (C) 2003-2010
+ * Copyright (C) 2003-2012
  * Egervary Jeno Kombinatorikus Optimalizalasi Kutatocsoport
  * (Egervary Research Group on Combinatorial Optimization, EGRES).
  *
@@ -45 +45 @@
       MIN,   ///< DIMACS file type for minimum cost flow problems.
       MAX,   ///< DIMACS file type for maximum flow problems.
       SP,    ///< DIMACS file type for shostest path problems.
-      MAT    ///< DIMACS file type for plain graphs and matching problems.
+      MAT,   ///< DIMACS file type for plain graphs and matching problems.
+      ASN,   ///< DIMACS file type for assignment problems.
+      UBM,   ///< DIMACS file type for unweighted bipartite matching problems.
+      WBM    ///< DIMACS file type for weighted bipartite matching problems.
     };
     ///The file type
     Type type;
@@ -82 +85 @@
               else if(problem=="max") r.type=DimacsDescriptor::MAX;
               else if(problem=="sp") r.type=DimacsDescriptor::SP;
               else if(problem=="mat") r.type=DimacsDescriptor::MAT;
+              else if(problem=="asn") r.type=DimacsDescriptor::ASN;
+              else if(problem=="ubm") r.type=DimacsDescriptor::UBM;
+              else if(problem=="wbm") r.type=DimacsDescriptor::WBM;
               else throw FormatError("Unknown problem type");
               return r;
             }
@@ -101 +107 @@
   }
 
 
+
+  /// \brief DIMACS unweighted bipartite matching problem reader function.
+  ///
+  /// This function reads an unweighted bipartite matching problem instance
+  /// from DIMACS format, i.e. from a DIMACS file having a line starting with
+  /// \code
+  ///   p ubm
+  /// \endcode
+  /// and creates the corresponding bipartite graph.
+  ///
+  /// At the beginning, \c g is cleared by \c g.clear().
+  ///
+  /// If the file type was previously evaluated by dimacsType(), then
+  /// the descriptor struct should be given by the \c dest parameter.
+  template <typename BpGraph>
+  void readDimacsUbm(std::istream& is,
+                     BpGraph &g,
+                     DimacsDescriptor desc=DimacsDescriptor())
+  {
+    g.clear();
+
+    if(desc.type==DimacsDescriptor::NONE) desc=dimacsType(is);
+    if(desc.type!=DimacsDescriptor::UBM)
+      throw FormatError("Problem type mismatch");
+
+    std::vector<typename BpGraph::Node> nodes(desc.nodeNum + 1, INVALID);
+    typename BpGraph::Edge e;
+    std::string problem, str;
+    char c;
+    int i, j;
+
+    // eat up comment lines and problem line
+    while (is >> c && (c=='c' || c=='p')) {
+      getline(is, str);
+    }
+    is.unget();
+
+    // reading red nodes
+    while (is >> c && c == 'n') {
+      is >> i;
+      getline(is, str);
+      nodes[i] = g.addRedNode();
+    }
+    is.unget();
+
+    // remaining nodes are blue:
+    for (int k = 1; k <= desc.nodeNum; ++k) {
+      if (nodes[k] == INVALID) nodes[k] = g.addBlueNode();
+    }
+
+    // reading edges
+    while (is >> c && c == 'a') {
+      is >> i >> j;
+      getline(is, str);
+      e = g.addEdge(g.asRedNode(nodes[i]), g.asBlueNode(nodes[j]));
+    }
+  }
+
+
+  /// \brief DIMACS weighted bipartite matching problem reader function.
+  ///
+  /// This function reads a weighted bipartite matching problem instance from
+  /// DIMACS format, i.e. from a DIMACS file having a line starting with
+  /// \code
+  ///   p wbm
+  /// \endcode
+  /// and creates the corresponding bipartite graph and weight map.
+  ///
+  /// At the beginning, \c g is cleared by \c g.clear().
+  ///
+  /// If the file type was previously evaluated by dimacsType(), then
+  /// the descriptor struct should be given by the \c dest parameter.
+  template <typename BpGraph, typename WeightMap>
+  void readDimacsWbm(std::istream& is,
+                     BpGraph &g,
+                     WeightMap &m,
+                     DimacsDescriptor desc=DimacsDescriptor())
+  {
+    g.clear();
+
+    if(desc.type==DimacsDescriptor::NONE) desc=dimacsType(is);
+    if(desc.type!=DimacsDescriptor::WBM)
+      throw FormatError("Problem type mismatch");
+
+    std::vector<typename BpGraph::Node> nodes(desc.nodeNum + 1, INVALID);
+    typename BpGraph::Edge e;
+    std::string problem, str;
+    char c;
+    int i, j;
+    typename WeightMap::Value w;
+
+    // eat up comment lines and problem line
+    while (is >> c && (c=='c' || c=='p')) {
+      getline(is, str);
+    }
+    is.unget();
+
+    // reading red nodes
+    while (is >> c && c == 'n') {
+      is >> i;
+      getline(is, str);
+      nodes[i] = g.addRedNode();
+    }
+    is.unget();
+
+    // remaining nodes are blue:
+    for (int k = 1; k <= desc.nodeNum; ++k) {
+      if (nodes[k] == INVALID) nodes[k] = g.addBlueNode();
+    }
+
+    // reading edges and weights
+    while (is >> c && c == 'a') {
+      is >> i >> j >> w;
+      getline(is, str);
+      e = g.addEdge(g.asRedNode(nodes[i]), g.asBlueNode(nodes[j]));
+      m.set(e, w);
+    }
+  }
+
+
+  /// \brief DIMACS assignment problem reader function.
+  ///
+  /// This function reads an assignment problem instance from DIMACS format,
+  /// i.e. from a DIMACS file having a line starting with
+  /// \code
+  ///   p asn
+  /// \endcode
+  /// and creates the corresponding digraph, arc cost- and supply map.
+  ///
+  /// At the beginning, \c g is cleared by \c g.clear().
+  /// Cost of the arcs are written to the cost map,
+  /// and the supply map contains the supply of the nodes, which is
+  /// 1 for sources and -1 for sink nodes.
+  ///
+  /// If the file type was previously evaluated by dimacsType(), then
+  /// the descriptor struct should be given by the \c dest parameter.
+  template <typename Digraph, typename CostMap>
+  void readDimacsAsn(std::istream& is,
+                     Digraph &g,
+                     CostMap &cost,
+                     typename Digraph::template NodeMap<int> &supply,
+                     DimacsDescriptor desc=DimacsDescriptor())
+  {
+    g.clear();
+
+    if(desc.type==DimacsDescriptor::NONE) desc=dimacsType(is);
+    if(desc.type!=DimacsDescriptor::ASN)
+      throw FormatError("Problem type mismatch");
+
+    std::vector<typename Digraph::Node> nodes(desc.nodeNum + 1, INVALID);
+    typename Digraph::Arc e;
+    std::string problem, str;
+    char c;
+    int i, j;
+    typename CostMap::Value co;
+
+    for (int k = 1; k <= desc.nodeNum; ++k) {
+      nodes[k] = g.addNode();
+      supply.set(nodes[k], -1);
+    }
+
+    // eat up comment lines and problem line
+    while (is >> c && (c=='c' || c=='p')) {
+      getline(is, str);
+    }
+    is.unget();
+
+    // reading source nodes
+    while (is >> c && c == 'n') {
+      is >> i;
+      getline(is, str);
+      supply.set(nodes[i], 1);
+    }
+    is.unget();
+
+    // reading arcs
+    while (is >> c && c == 'a') {
+      is >> i >> j >> co;
+      getline(is, str);
+      e = g.addArc(nodes[i], nodes[j]);
+      cost.set(e, co);
+    }
+  }
+
   /// \brief DIMACS minimum cost flow reader function.
   ///
   /// This function reads a minimum cost flow instance from DIMACS format,

tools/CMakeLists.txt

@@ -16 +16 @@
 ADD_EXECUTABLE(dimacs-solver dimacs-solver.cc)
 TARGET_LINK_LIBRARIES(dimacs-solver lemon)
 
+ADD_EXECUTABLE(weighted-bp-gen weighted-bp-gen.cc)
+TARGET_LINK_LIBRARIES(weighted-bp-gen lemon)
+
+ADD_EXECUTABLE(unweighted-bp-gen unweighted-bp-gen.cc)
+TARGET_LINK_LIBRARIES(unweighted-bp-gen lemon)
+
+ADD_EXECUTABLE(bp-matching-benchmark bp-matching-benchmark.cc)
+TARGET_LINK_LIBRARIES(bp-matching-benchmark lemon)
+
 INSTALL(
   TARGETS lgf-gen dimacs-to-lgf dimacs-solver
   RUNTIME DESTINATION bin

tools/Makefile.am

@@ -4 +4 @@
 if WANT_TOOLS
 
 bin_PROGRAMS += \
+        tools/bp-matching-benchmark \
         tools/dimacs-solver \
         tools/dimacs-to-lgf \
-        tools/lgf-gen
+        tools/lgf-gen \
+        tools/unweighted-bp-gen \
+        tools/weighted-bp-gen
 
 dist_bin_SCRIPTS += tools/lemon-0.x-to-1.x.sh
 
 endif WANT_TOOLS
 
+tools_bp_matching_benchmark_SOURCES = tools/bp-matching-benchmark.cc
 tools_dimacs_solver_SOURCES = tools/dimacs-solver.cc
 tools_dimacs_to_lgf_SOURCES = tools/dimacs-to-lgf.cc
 tools_lgf_gen_SOURCES = tools/lgf-gen.cc
+tools_unweighted_bp_gen_SOURCES = tools/unweighted-bp-gen.cc
+tools_weighted_bp_gen_SOURCES = tools/weighted-bp-gen.cc
+ No newline at end of file

new file tools/bp-matching-benchmark.cc

@@ +1 @@
+/* -*- mode: C++; indent-tabs-mode: nil; -*-
+ *
+ * This file is a part of LEMON, a generic C++ optimization library.
+ *
+ * Copyright (C) 2003-2012
+ * 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/dimacs.h>
+#include <lemon/maps.h>
+#include <lemon/smart_graph.h>
+#include <lemon/time_measure.h>
+#include <lemon/hopcroft_karp.h>
+#include <lemon/matching.h>
+#include <lemon/preflow.h>
+#include <lemon/bp_matching.h>
+#include <iostream>
+
+using namespace std;
+using namespace lemon;
+
+
+template <typename BpGraph, typename Digraph>
+void create_network(const BpGraph &bpg,
+                    Digraph &network,
+                    typename Digraph::Node &source,
+                    typename Digraph::Node &sink)
+{
+  network.clear();
+  source = network.addNode();
+  sink = network.addNode();
+
+  typename BpGraph::template NodeMap<typename Digraph::Node> xref(bpg);
+  for (typename BpGraph::RedNodeIt r(bpg); r!=INVALID; ++r) {
+    xref.set(r, network.addNode());
+    network.addArc(source, xref[r]);
+  }
+  for (typename BpGraph::BlueNodeIt b(bpg); b!=INVALID; ++b) {
+    xref.set(b, network.addNode());
+    network.addArc(xref[b], sink);
+  }
+
+  for (typename BpGraph::EdgeIt e(bpg); e!=INVALID; ++e) {
+    network.addArc(xref[bpg.redNode(e)], xref[bpg.blueNode(e)]);
+  }
+}
+
+typedef SmartDigraph Digraph;
+typedef SmartBpGraph BpGraph;
+
+///\ingroup tools
+///\file
+///\brief Benchmark program for weighted and unweighted bipartite matching.
+///
+/// The program input is a Dimacs file with a problem line starting
+/// \code
+///   p ubm
+/// \endcode
+/// or
+/// \code
+///   p wbm
+/// \endcode
+///
+/// Depending on the input, it runs the \ref lemon::HopcroftKarp
+/// "Hopcroft-Karp", the \ref lemon::MaxMatching "general matching"
+/// and the \ref lemon::Preflow "Preflow" algorithms for finding
+/// a maximum cardinality bipartite matching, or the
+/// \ref lemon::MaxWeightedBpMatching "max. weighted matching
+/// for sparse bipartite graphs" and the \ref lemon::MaxWeightedMatching
+/// "max. weighted matching for general graph" to find the maximum
+/// weighted matching.
+int main() {
+  DimacsDescriptor desc = dimacsType(cin);
+  if (desc.type == DimacsDescriptor::UBM) {
+    // unweighted bipartite matching
+    Timer hk_t(false), mm_t(false), pf_t(false);
+
+    BpGraph bpg;
+    readDimacsUbm(cin, bpg, desc);
+
+    Digraph network;
+    Digraph::Node source, target;
+    create_network(bpg, network, source, target);
+
+    hk_t.start();
+    HopcroftKarp<BpGraph> hk(bpg);
+    hk.run();
+    hk_t.stop();
+
+    mm_t.start();
+    MaxMatching<BpGraph> mm(bpg);
+    mm.run();
+    mm_t.stop();
+
+    pf_t.start();
+    Preflow<Digraph, ConstMap<Digraph::Arc, int> >
+      pf(network, constMap<Digraph::Arc, int>(1), source, target);
+    pf.run();
+    pf_t.stop();
+
+    cout << "Benchmarking in unweighted case, using a bipartite graph\n"
+         << "with " << countRedNodes(bpg) << " red, "
+         << countBlueNodes(bpg) << " blue nodes, and "
+         << desc.edgeNum << " edges.\n"
+         << "--------------------------------------------------------\n"
+         << "Algorithm used       Matching size       Time\n"
+         << "Hopcroft-Karp            " << hk.matchingSize()
+         << "         " << hk_t.realTime() << "\n"
+         << "General matching         " << mm.matchingSize()
+         << "         " << mm_t.realTime() << "\n"
+         << "Preflow                  " << pf.flowValue()
+         << "         " << pf_t.realTime() << endl;
+
+  } else if (desc.type == DimacsDescriptor::WBM) {
+    // weighted bipartite matching
+    Timer bm_t(false), gm_t(false);
+
+    BpGraph bpg;
+    BpGraph::EdgeMap<int> weight(bpg);
+    readDimacsWbm(cin, bpg, weight, desc);
+
+    bm_t.start();
+    MaxWeightedBpMatching<BpGraph> bm(bpg, weight);
+    bm.run();
+    bm_t.stop();
+
+    gm_t.start();
+    MaxWeightedMatching<BpGraph> gm(bpg, weight);
+    gm.run();
+    gm_t.stop();
+
+    cout << "Benchmarking on weighted bipartite matching problem on a "
+         << "graph\nwith " << countRedNodes(bpg) << " red, "
+         << countBlueNodes(bpg) << " blue nodes and "
+         << desc.edgeNum << " edges\n"
+         << "--------------------------------------------------------\n"
+         << "Algorithm used       Maximum weight       Time\n"
+         << "Bipartite matching       " << bm.matchingWeight()
+         << "         " << bm_t.realTime() << "\n"
+         << "General matching         " << gm.matchingWeight()
+         << "         " << gm_t.realTime() << endl;
+
+  } else {
+    cerr << "Wrong problem type." << endl;
+    return 1;
+  }
+
+  return 0;
+}

new file tools/unweighted-bp-gen.cc

@@ +1 @@
+/* -*- mode: C++; indent-tabs-mode: nil; -*-
+ *
+ * This file is a part of LEMON, a generic C++ optimization library.
+ *
+ * Copyright (C) 2003-2012
+ * 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/arg_parser.h>
+#include <lemon/random.h>
+
+using namespace lemon;
+using namespace std;
+
+///\ingroup tools
+///\file
+///\brief Random bipartite graph generator.
+///
+/// This program generates an unweighted bipartite matching problem.
+/// The output is in Dimacs format, with problem type of 'ubm'. The
+/// enumerated nodes form one set of the bipartite graph, and
+/// the edges do not have any label.
+int main(int argc, char** argv) {
+  int seed = 1,
+    red = 5,
+    blue = 5,
+    density = 10;
+
+  ArgParser arg_p(argc, argv);
+
+  arg_p.refOption("seed",
+                  "Seed of the random number generator (default: 1)",
+                  seed)
+    .refOption("red",
+               "Number of red nodes (default: 5)",
+               red)
+    .refOption("blue",
+               "Number of blue nodes (default: 5)",
+               blue)
+    .refOption("density",
+               "Number of edges (default: 10)",
+               density);
+
+  arg_p.synonym("s", "seed")
+    .synonym("r", "red")
+    .synonym("b", "blue")
+    .synonym("d", "density");
+
+  arg_p.parse();
+
+  rnd.seed(seed);
+
+
+  long max_edge = red*blue;
+  long edge_left = density;
+
+  if (max_edge < density) {
+    cerr << "Too many edges!\n"
+         << "At most " << max_edge << " edges can be placed in the graph.\n";
+    return 1;
+  }
+
+  cout << "c Random bipartite graph for bipartite matching\n"
+       << "c----------------------------------------------\n"
+       << "c Input parameters:\n"
+       << "c   Random seed: " << seed << "\n"
+       << "c   Number of nodes: " << red + blue << "\n"
+       << "c     Number of red nodes:  " << red << "\n"
+       << "c     Number of blue nodes: " << blue << "\n"
+       << "c   Number of edges: " << density << "\n"
+       << "c----------------------------------------------\n";
+  cout << "p ubm " << red + blue << " " << density << "\n";
+
+  // red nodes:
+  for (int r=1; r <= red; ++r) {
+    cout << "n " << r << "\n";
+  }
+
+  // edges:
+  for (int r = 1; r <= red; ++r) {
+    for (int b = red+1; b <= red + blue; ++b) {
+      if (rnd.boolean(static_cast<long double>(edge_left) / max_edge)) {
+        --edge_left;
+        cout << "a " << r << " " << b << "\n";
+      }
+      --max_edge;
+    }
+  }
+
+  return 0;
+}
+

new file tools/weighted-bp-gen.cc

@@ +1 @@
+/* -*- mode: C++; indent-tabs-mode: nil; -*-
+ *
+ * This file is a part of LEMON, a generic C++ optimization library.
+ *
+ * Copyright (C) 2003-2012
+ * 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/arg_parser.h>
+#include <lemon/random.h>
+
+using namespace lemon;
+using namespace std;
+
+///\ingroup tools
+///\file
+///\brief Random weighted bipartite graph generator.
+///
+/// This program generates a weighted bipartite matching problem.
+/// The output is in Dimacs format, with problem type of 'wbm'. The
+/// enumerated nodes form one set of the bipartite graph, and
+/// the edge labels denote weights.
+int main(int argc, char** argv) {
+  int seed = 1,
+    red = 5,
+    blue = 5,
+    density = 10,
+    minweight = 10,
+    maxweight = 100;
+
+  ArgParser arg_p(argc, argv);
+
+  arg_p.refOption("seed",
+                  "Seed of the random number generator (default: 1)",
+                  seed)
+    .refOption("red",
+               "Number of red nodes (default: 5)",
+               red)
+    .refOption("blue",
+               "Number of blue nodes (default: 5)",
+               blue)
+    .refOption("density",
+               "Number of edges (default: 10)",
+               density)
+    .refOption("minweight",
+               "Minimal weight of edges (default: 10)",
+               minweight)
+    .refOption("maxweight",
+               "Maximal weight of edges (default: 100",
+               maxweight);
+
+  arg_p.synonym("s", "seed")
+    .synonym("r", "red")
+    .synonym("b", "blue")
+    .synonym("d", "density")
+    .synonym("min", "minweight")
+    .synonym("max", "maxweight");
+
+  arg_p.parse();
+
+  rnd.seed(seed);
+
+
+  long max_edge = red*blue;
+  long edge_left = density;
+
+  if (max_edge < density) {
+    cerr << "Too many edges!\n"
+         << "At most " << max_edge << " edges can be placed in the graph.\n";
+    return 1;
+  }
+
+  cout << "c Random bipartite graph for weighted bipartite matching\n"
+       << "c----------------------------------------------\n"
+       << "c Input parameters:\n"
+       << "c   Random seed: " << seed << "\n"
+       << "c   Number of nodes: " << red + blue << "\n"
+       << "c     Number of red nodes:  " << red << "\n"
+       << "c     Number of blue nodes: " << blue << "\n"
+       << "c   Number of edges: " << density << "\n"
+       << "c   Minimal weight of edges: " << minweight << "\n"
+       << "c   Maximal weight of edges: " << maxweight << "\n"
+       << "c----------------------------------------------\n";
+  cout << "p wbm " << red + blue << " " << density << "\n";
+
+  // red nodes:
+  for (int r=1; r <= red; ++r) {
+    cout << "n " << r << "\n";
+  }
+
+  // edges:
+  for (int r = 1; r <= red; ++r) {
+    for (int b = red+1; b <= red + blue; ++b) {
+      if (rnd.boolean(static_cast<long double>(edge_left) / max_edge)) {
+        --edge_left;
+        cout << "a " << r << " " << b << " "
+             << rnd.integer(minweight, maxweight+1) << "\n";
+      }
+      --max_edge;
+    }
+  }
+
+  return 0;
+}
+