Changes in / [953:d8ea85825e02:952:23da1b807280] in lemon

Files:

• doc/groups.dox (modified) (2 diffs)
• lemon/Makefile.am (modified) (1 diff)
• lemon/fractional_matching.h (deleted)
• lemon/matching.h (modified) (61 diffs)
• test/CMakeLists.txt (modified) (1 diff)
• test/Makefile.am (modified) (2 diffs)
• test/fractional_matching_test.cc (deleted)
• test/matching_test.cc (modified) (1 diff)

doc/groups.dox

@@ -387 +387 @@
 problem of maximum flow.
 
-\ref Circulation is a preflow push-relabel algorithm implemented directly
+\ref Circulation is a preflow push-relabel algorithm implemented directly 
 for finding feasible circulations, which is a somewhat different problem,
 but it is strongly related to maximum flow.
@@ -523 +523 @@
   Edmond's blossom shrinking algorithm for calculating maximum weighted
   perfect matching in general graphs.
-- \ref MaxFractionalMatching Push-relabel algorithm for calculating
-  maximum cardinality fractional matching in general graphs.
-- \ref MaxWeightedFractionalMatching Augmenting path algorithm for calculating
-  maximum weighted fractional matching in general graphs.
-- \ref MaxWeightedPerfectFractionalMatching
-  Augmenting path algorithm for calculating maximum weighted
-  perfect fractional matching in general graphs.
 
 \image html matching.png

lemon/Makefile.am

@@ -85 +85 @@
         lemon/euler.h \
         lemon/fib_heap.h \
-        lemon/fractional_matching.h \
         lemon/full_graph.h \
         lemon/glpk.h \

lemon/matching.h

@@ -17 +17 @@
  */
 
-#ifndef LEMON_MATCHING_H
-#define LEMON_MATCHING_H
+#ifndef LEMON_MAX_MATCHING_H
+#define LEMON_MAX_MATCHING_H
 
 #include <vector>
@@ -29 +29 @@
 #include <lemon/bin_heap.h>
 #include <lemon/maps.h>
-#include <lemon/fractional_matching.h>
 
 ///\ingroup matching
@@ -43 +42 @@
   /// This class implements Edmonds' alternating forest matching algorithm
   /// for finding a maximum cardinality matching in a general undirected graph.
-  /// It can be started from an arbitrary initial matching
+  /// It can be started from an arbitrary initial matching 
   /// (the default is the empty one).
   ///
@@ -71 +70 @@
     ///\brief Status constants for Gallai-Edmonds decomposition.
     ///
-    ///These constants are used for indicating the Gallai-Edmonds
+    ///These constants are used for indicating the Gallai-Edmonds 
     ///decomposition of a graph. The nodes with status \c EVEN (or \c D)
     ///induce a subgraph with factor-critical components, the nodes with
     ///status \c ODD (or \c A) form the canonical barrier, and the nodes
-    ///with status \c MATCHED (or \c C) induce a subgraph having a
+    ///with status \c MATCHED (or \c C) induce a subgraph having a 
     ///perfect matching.
     enum Status {
@@ -514 +513 @@
     }
 
-    /// \brief Start Edmonds' algorithm with a heuristic improvement
+    /// \brief Start Edmonds' algorithm with a heuristic improvement 
     /// for dense graphs
     ///
@@ -536 +535 @@
     /// \brief Run Edmonds' algorithm
     ///
-    /// This function runs Edmonds' algorithm. An additional heuristic of
-    /// postponing shrinks is used for relatively dense graphs
+    /// This function runs Edmonds' algorithm. An additional heuristic of 
+    /// postponing shrinks is used for relatively dense graphs 
     /// (for which <tt>m>=2*n</tt> holds).
     void run() {
@@ -558 +557 @@
     /// \brief Return the size (cardinality) of the matching.
     ///
-    /// This function returns the size (cardinality) of the current matching.
+    /// This function returns the size (cardinality) of the current matching. 
     /// After run() it returns the size of the maximum matching in the graph.
     int matchingSize() const {
@@ -572 +571 @@
     /// \brief Return \c true if the given edge is in the matching.
     ///
-    /// This function returns \c true if the given edge is in the current
+    /// This function returns \c true if the given edge is in the current 
     /// matching.
     bool matching(const Edge& edge) const {
@@ -581 +580 @@
     ///
     /// This function returns the matching arc (or edge) incident to the
-    /// given node in the current matching or \c INVALID if the node is
+    /// given node in the current matching or \c INVALID if the node is 
     /// not covered by the matching.
     Arc matching(const Node& n) const {
@@ -597 +596 @@
     /// \brief Return the mate of the given node.
     ///
-    /// This function returns the mate of the given node in the current
+    /// This function returns the mate of the given node in the current 
     /// matching or \c INVALID if the node is not covered by the matching.
     Node mate(const Node& n) const {
@@ -607 +606 @@
 
     /// \name Dual Solution
-    /// Functions to get the dual solution, i.e. the Gallai-Edmonds
+    /// Functions to get the dual solution, i.e. the Gallai-Edmonds 
     /// decomposition.
 
@@ -650 +649 @@
   /// \f$O(nm\log n)\f$ time complexity.
   ///
-  /// The maximum weighted matching problem is to find a subset of the
-  /// edges in an undirected graph with maximum overall weight for which
+  /// The maximum weighted matching problem is to find a subset of the 
+  /// edges in an undirected graph with maximum overall weight for which 
   /// each node has at most one incident edge.
   /// It can be formulated with the following linear program.
@@ -675 +674 @@
       \frac{\vert B \vert - 1}{2}z_B\f] */
   ///
-  /// The algorithm can be executed with the run() function.
+  /// The algorithm can be executed with the run() function. 
   /// After it the matching (the primal solution) and the dual solution
-  /// can be obtained using the query functions and the
-  /// \ref MaxWeightedMatching::BlossomIt "BlossomIt" nested class,
-  /// which is able to iterate on the nodes of a blossom.
+  /// can be obtained using the query functions and the 
+  /// \ref MaxWeightedMatching::BlossomIt "BlossomIt" nested class, 
+  /// which is able to iterate on the nodes of a blossom. 
   /// If the value type is integer, then the dual solution is multiplied
   /// by \ref MaxWeightedMatching::dualScale "4".
   ///
   /// \tparam GR The undirected graph type the algorithm runs on.
-  /// \tparam WM The type edge weight map. The default type is
+  /// \tparam WM The type edge weight map. The default type is 
   /// \ref concepts::Graph::EdgeMap "GR::EdgeMap<int>".
 #ifdef DOXYGEN
@@ -747 +746 @@
 
     enum Status {
-      EVEN = -1, MATCHED = 0, ODD = 1
+      EVEN = -1, MATCHED = 0, ODD = 1, UNMATCHED = -2
     };
 
@@ -799 +798 @@
 
     Value _delta_sum;
-    int _unmatched;
-
-    typedef MaxWeightedFractionalMatching<Graph, WeightMap> FractionalMatching;
-    FractionalMatching *_fractional;
 
     void createStructures() {
@@ -850 +845 @@
 
     void destroyStructures() {
+      _node_num = countNodes(_graph);
+      _blossom_num = _node_num * 3 / 2;
+
       if (_matching) {
         delete _matching;
@@ -925 +923 @@
               _delta3->push(e, rw / 2);
             }
+          } else if ((*_blossom_data)[vb].status == UNMATCHED) {
+            if (_delta3->state(e) != _delta3->IN_HEAP) {
+              _delta3->push(e, rw);
+            }
           } else {
+            typename std::map<int, Arc>::iterator it =
+              (*_node_data)[vi].heap_index.find(tree);
+
+            if (it != (*_node_data)[vi].heap_index.end()) {
+              if ((*_node_data)[vi].heap[it->second] > rw) {
+                (*_node_data)[vi].heap.replace(it->second, e);
+                (*_node_data)[vi].heap.decrease(e, rw);
+                it->second = e;
+              }
+            } else {
+              (*_node_data)[vi].heap.push(e, rw);
+              (*_node_data)[vi].heap_index.insert(std::make_pair(tree, e));
+            }
+
+            if ((*_blossom_set)[v] > (*_node_data)[vi].heap.prio()) {
+              _blossom_set->decrease(v, (*_node_data)[vi].heap.prio());
+
+              if ((*_blossom_data)[vb].status == MATCHED) {
+                if (_delta2->state(vb) != _delta2->IN_HEAP) {
+                  _delta2->push(vb, _blossom_set->classPrio(vb) -
+                               (*_blossom_data)[vb].offset);
+                } else if ((*_delta2)[vb] > _blossom_set->classPrio(vb) -
+                           (*_blossom_data)[vb].offset){
+                  _delta2->decrease(vb, _blossom_set->classPrio(vb) -
+                                   (*_blossom_data)[vb].offset);
+                }
+              }
+            }
+          }
+        }
+      }
+      (*_blossom_data)[blossom].offset = 0;
+    }
+
+    void matchedToOdd(int blossom) {
+      if (_delta2->state(blossom) == _delta2->IN_HEAP) {
+        _delta2->erase(blossom);
+      }
+      (*_blossom_data)[blossom].offset += _delta_sum;
+      if (!_blossom_set->trivial(blossom)) {
+        _delta4->push(blossom, (*_blossom_data)[blossom].pot / 2 +
+                     (*_blossom_data)[blossom].offset);
+      }
+    }
+
+    void evenToMatched(int blossom, int tree) {
+      if (!_blossom_set->trivial(blossom)) {
+        (*_blossom_data)[blossom].pot += 2 * _delta_sum;
+      }
+
+      for (typename BlossomSet::ItemIt n(*_blossom_set, blossom);
+           n != INVALID; ++n) {
+        int ni = (*_node_index)[n];
+        (*_node_data)[ni].pot -= _delta_sum;
+
+        _delta1->erase(n);
+
+        for (InArcIt e(_graph, n); e != INVALID; ++e) {
+          Node v = _graph.source(e);
+          int vb = _blossom_set->find(v);
+          int vi = (*_node_index)[v];
+
+          Value rw = (*_node_data)[ni].pot + (*_node_data)[vi].pot -
+            dualScale * _weight[e];
+
+          if (vb == blossom) {
+            if (_delta3->state(e) == _delta3->IN_HEAP) {
+              _delta3->erase(e);
+            }
+          } else if ((*_blossom_data)[vb].status == EVEN) {
+
+            if (_delta3->state(e) == _delta3->IN_HEAP) {
+              _delta3->erase(e);
+            }
+
+            int vt = _tree_set->find(vb);
+
+            if (vt != tree) {
+
+              Arc r = _graph.oppositeArc(e);
+
+              typename std::map<int, Arc>::iterator it =
+                (*_node_data)[ni].heap_index.find(vt);
+
+              if (it != (*_node_data)[ni].heap_index.end()) {
+                if ((*_node_data)[ni].heap[it->second] > rw) {
+                  (*_node_data)[ni].heap.replace(it->second, r);
+                  (*_node_data)[ni].heap.decrease(r, rw);
+                  it->second = r;
+                }
+              } else {
+                (*_node_data)[ni].heap.push(r, rw);
+                (*_node_data)[ni].heap_index.insert(std::make_pair(vt, r));
+              }
+
+              if ((*_blossom_set)[n] > (*_node_data)[ni].heap.prio()) {
+                _blossom_set->decrease(n, (*_node_data)[ni].heap.prio());
+
+                if (_delta2->state(blossom) != _delta2->IN_HEAP) {
+                  _delta2->push(blossom, _blossom_set->classPrio(blossom) -
+                               (*_blossom_data)[blossom].offset);
+                } else if ((*_delta2)[blossom] >
+                           _blossom_set->classPrio(blossom) -
+                           (*_blossom_data)[blossom].offset){
+                  _delta2->decrease(blossom, _blossom_set->classPrio(blossom) -
+                                   (*_blossom_data)[blossom].offset);
+                }
+              }
+            }
+
+          } else if ((*_blossom_data)[vb].status == UNMATCHED) {
+            if (_delta3->state(e) == _delta3->IN_HEAP) {
+              _delta3->erase(e);
+            }
+          } else {
+
+            typename std::map<int, Arc>::iterator it =
+              (*_node_data)[vi].heap_index.find(tree);
+
+            if (it != (*_node_data)[vi].heap_index.end()) {
+              (*_node_data)[vi].heap.erase(it->second);
+              (*_node_data)[vi].heap_index.erase(it);
+              if ((*_node_data)[vi].heap.empty()) {
+                _blossom_set->increase(v, std::numeric_limits<Value>::max());
+              } else if ((*_blossom_set)[v] < (*_node_data)[vi].heap.prio()) {
+                _blossom_set->increase(v, (*_node_data)[vi].heap.prio());
+              }
+
+              if ((*_blossom_data)[vb].status == MATCHED) {
+                if (_blossom_set->classPrio(vb) ==
+                    std::numeric_limits<Value>::max()) {
+                  _delta2->erase(vb);
+                } else if ((*_delta2)[vb] < _blossom_set->classPrio(vb) -
+                           (*_blossom_data)[vb].offset) {
+                  _delta2->increase(vb, _blossom_set->classPrio(vb) -
+                                   (*_blossom_data)[vb].offset);
+                }
+              }
+            }
+          }
+        }
+      }
+    }
+
+    void oddToMatched(int blossom) {
+      (*_blossom_data)[blossom].offset -= _delta_sum;
+
+      if (_blossom_set->classPrio(blossom) !=
+          std::numeric_limits<Value>::max()) {
+        _delta2->push(blossom, _blossom_set->classPrio(blossom) -
+                       (*_blossom_data)[blossom].offset);
+      }
+
+      if (!_blossom_set->trivial(blossom)) {
+        _delta4->erase(blossom);
+      }
+    }
+
+    void oddToEven(int blossom, int tree) {
+      if (!_blossom_set->trivial(blossom)) {
+        _delta4->erase(blossom);
+        (*_blossom_data)[blossom].pot -=
+          2 * (2 * _delta_sum - (*_blossom_data)[blossom].offset);
+      }
+
+      for (typename BlossomSet::ItemIt n(*_blossom_set, blossom);
+           n != INVALID; ++n) {
+        int ni = (*_node_index)[n];
+
+        _blossom_set->increase(n, std::numeric_limits<Value>::max());
+
+        (*_node_data)[ni].heap.clear();
+        (*_node_data)[ni].heap_index.clear();
+        (*_node_data)[ni].pot +=
+          2 * _delta_sum - (*_blossom_data)[blossom].offset;
+
+        _delta1->push(n, (*_node_data)[ni].pot);
+
+        for (InArcIt e(_graph, n); e != INVALID; ++e) {
+          Node v = _graph.source(e);
+          int vb = _blossom_set->find(v);
+          int vi = (*_node_index)[v];
+
+          Value rw = (*_node_data)[ni].pot + (*_node_data)[vi].pot -
+            dualScale * _weight[e];
+
+          if ((*_blossom_data)[vb].status == EVEN) {
+            if (_delta3->state(e) != _delta3->IN_HEAP && blossom != vb) {
+              _delta3->push(e, rw / 2);
+            }
+          } else if ((*_blossom_data)[vb].status == UNMATCHED) {
+            if (_delta3->state(e) != _delta3->IN_HEAP) {
+              _delta3->push(e, rw);
+            }
+          } else {
+
             typename std::map<int, Arc>::iterator it =
               (*_node_data)[vi].heap_index.find(tree);
@@ -960 +1158 @@
     }
 
-    void matchedToOdd(int blossom) {
+
+    void matchedToUnmatched(int blossom) {
       if (_delta2->state(blossom) == _delta2->IN_HEAP) {
         _delta2->erase(blossom);
-      }
-      (*_blossom_data)[blossom].offset += _delta_sum;
-      if (!_blossom_set->trivial(blossom)) {
-        _delta4->push(blossom, (*_blossom_data)[blossom].pot / 2 +
-                      (*_blossom_data)[blossom].offset);
-      }
-    }
-
-    void evenToMatched(int blossom, int tree) {
-      if (!_blossom_set->trivial(blossom)) {
-        (*_blossom_data)[blossom].pot += 2 * _delta_sum;
       }
 
@@ -979 +1167 @@
            n != INVALID; ++n) {
         int ni = (*_node_index)[n];
-        (*_node_data)[ni].pot -= _delta_sum;
-
-        _delta1->erase(n);
+
+        _blossom_set->increase(n, std::numeric_limits<Value>::max());
+
+        (*_node_data)[ni].heap.clear();
+        (*_node_data)[ni].heap_index.clear();
+
+        for (OutArcIt e(_graph, n); e != INVALID; ++e) {
+          Node v = _graph.target(e);
+          int vb = _blossom_set->find(v);
+          int vi = (*_node_index)[v];
+
+          Value rw = (*_node_data)[ni].pot + (*_node_data)[vi].pot -
+            dualScale * _weight[e];
+
+          if ((*_blossom_data)[vb].status == EVEN) {
+            if (_delta3->state(e) != _delta3->IN_HEAP) {
+              _delta3->push(e, rw);
+            }
+          }
+        }
+      }
+    }
+
+    void unmatchedToMatched(int blossom) {
+      for (typename BlossomSet::ItemIt n(*_blossom_set, blossom);
+           n != INVALID; ++n) {
+        int ni = (*_node_index)[n];
 
         for (InArcIt e(_graph, n); e != INVALID; ++e) {
@@ -1003 +1215 @@
             int vt = _tree_set->find(vb);
 
-            if (vt != tree) {
-
-              Arc r = _graph.oppositeArc(e);
-
-              typename std::map<int, Arc>::iterator it =
-                (*_node_data)[ni].heap_index.find(vt);
-
-              if (it != (*_node_data)[ni].heap_index.end()) {
-                if ((*_node_data)[ni].heap[it->second] > rw) {
-                  (*_node_data)[ni].heap.replace(it->second, r);
-                  (*_node_data)[ni].heap.decrease(r, rw);
-                  it->second = r;
-                }
-              } else {
-                (*_node_data)[ni].heap.push(r, rw);
-                (*_node_data)[ni].heap_index.insert(std::make_pair(vt, r));
-              }
-
-              if ((*_blossom_set)[n] > (*_node_data)[ni].heap.prio()) {
-                _blossom_set->decrease(n, (*_node_data)[ni].heap.prio());
-
-                if (_delta2->state(blossom) != _delta2->IN_HEAP) {
-                  _delta2->push(blossom, _blossom_set->classPrio(blossom) -
-                               (*_blossom_data)[blossom].offset);
-                } else if ((*_delta2)[blossom] >
-                           _blossom_set->classPrio(blossom) -
-                           (*_blossom_data)[blossom].offset){
-                  _delta2->decrease(blossom, _blossom_set->classPrio(blossom) -
-                                   (*_blossom_data)[blossom].offset);
-                }
-              }
-            }
-          } else {
+            Arc r = _graph.oppositeArc(e);
 
             typename std::map<int, Arc>::iterator it =
-              (*_node_data)[vi].heap_index.find(tree);
-
-            if (it != (*_node_data)[vi].heap_index.end()) {
-              (*_node_data)[vi].heap.erase(it->second);
-              (*_node_data)[vi].heap_index.erase(it);
-              if ((*_node_data)[vi].heap.empty()) {
-                _blossom_set->increase(v, std::numeric_limits<Value>::max());
-              } else if ((*_blossom_set)[v] < (*_node_data)[vi].heap.prio()) {
-                _blossom_set->increase(v, (*_node_data)[vi].heap.prio());
-              }
-
-              if ((*_blossom_data)[vb].status == MATCHED) {
-                if (_blossom_set->classPrio(vb) ==
-                    std::numeric_limits<Value>::max()) {
-                  _delta2->erase(vb);
-                } else if ((*_delta2)[vb] < _blossom_set->classPrio(vb) -
-                           (*_blossom_data)[vb].offset) {
-                  _delta2->increase(vb, _blossom_set->classPrio(vb) -
-                                   (*_blossom_data)[vb].offset);
-                }
-              }
-            }
-          }
-        }
-      }
-    }
-
-    void oddToMatched(int blossom) {
-      (*_blossom_data)[blossom].offset -= _delta_sum;
-
-      if (_blossom_set->classPrio(blossom) !=
-          std::numeric_limits<Value>::max()) {
-        _delta2->push(blossom, _blossom_set->classPrio(blossom) -
-                      (*_blossom_data)[blossom].offset);
-      }
-
-      if (!_blossom_set->trivial(blossom)) {
-        _delta4->erase(blossom);
-      }
-    }
-
-    void oddToEven(int blossom, int tree) {
-      if (!_blossom_set->trivial(blossom)) {
-        _delta4->erase(blossom);
-        (*_blossom_data)[blossom].pot -=
-          2 * (2 * _delta_sum - (*_blossom_data)[blossom].offset);
-      }
-
-      for (typename BlossomSet::ItemIt n(*_blossom_set, blossom);
-           n != INVALID; ++n) {
-        int ni = (*_node_index)[n];
-
-        _blossom_set->increase(n, std::numeric_limits<Value>::max());
-
-        (*_node_data)[ni].heap.clear();
-        (*_node_data)[ni].heap_index.clear();
-        (*_node_data)[ni].pot +=
-          2 * _delta_sum - (*_blossom_data)[blossom].offset;
-
-        _delta1->push(n, (*_node_data)[ni].pot);
-
-        for (InArcIt e(_graph, n); e != INVALID; ++e) {
-          Node v = _graph.source(e);
-          int vb = _blossom_set->find(v);
-          int vi = (*_node_index)[v];
-
-          Value rw = (*_node_data)[ni].pot + (*_node_data)[vi].pot -
-            dualScale * _weight[e];
-
-          if ((*_blossom_data)[vb].status == EVEN) {
-            if (_delta3->state(e) != _delta3->IN_HEAP && blossom != vb) {
-              _delta3->push(e, rw / 2);
-            }
-          } else {
-
-            typename std::map<int, Arc>::iterator it =
-              (*_node_data)[vi].heap_index.find(tree);
-
-            if (it != (*_node_data)[vi].heap_index.end()) {
-              if ((*_node_data)[vi].heap[it->second] > rw) {
-                (*_node_data)[vi].heap.replace(it->second, e);
-                (*_node_data)[vi].heap.decrease(e, rw);
-                it->second = e;
+              (*_node_data)[ni].heap_index.find(vt);
+
+            if (it != (*_node_data)[ni].heap_index.end()) {
+              if ((*_node_data)[ni].heap[it->second] > rw) {
+                (*_node_data)[ni].heap.replace(it->second, r);
+                (*_node_data)[ni].heap.decrease(r, rw);
+                it->second = r;
               }
             } else {
-              (*_node_data)[vi].heap.push(e, rw);
-              (*_node_data)[vi].heap_index.insert(std::make_pair(tree, e));
-            }
-
-            if ((*_blossom_set)[v] > (*_node_data)[vi].heap.prio()) {
-              _blossom_set->decrease(v, (*_node_data)[vi].heap.prio());
-
-              if ((*_blossom_data)[vb].status == MATCHED) {
-                if (_delta2->state(vb) != _delta2->IN_HEAP) {
-                  _delta2->push(vb, _blossom_set->classPrio(vb) -
-                               (*_blossom_data)[vb].offset);
-                } else if ((*_delta2)[vb] > _blossom_set->classPrio(vb) -
-                           (*_blossom_data)[vb].offset) {
-                  _delta2->decrease(vb, _blossom_set->classPrio(vb) -
-                                   (*_blossom_data)[vb].offset);
-                }
+              (*_node_data)[ni].heap.push(r, rw);
+              (*_node_data)[ni].heap_index.insert(std::make_pair(vt, r));
+            }
+
+            if ((*_blossom_set)[n] > (*_node_data)[ni].heap.prio()) {
+              _blossom_set->decrease(n, (*_node_data)[ni].heap.prio());
+
+              if (_delta2->state(blossom) != _delta2->IN_HEAP) {
+                _delta2->push(blossom, _blossom_set->classPrio(blossom) -
+                             (*_blossom_data)[blossom].offset);
+              } else if ((*_delta2)[blossom] > _blossom_set->classPrio(blossom)-
+                         (*_blossom_data)[blossom].offset){
+                _delta2->decrease(blossom, _blossom_set->classPrio(blossom) -
+                                 (*_blossom_data)[blossom].offset);
               }
             }
+
+          } else if ((*_blossom_data)[vb].status == UNMATCHED) {
+            if (_delta3->state(e) == _delta3->IN_HEAP) {
+              _delta3->erase(e);
+            }
           }
         }
       }
-      (*_blossom_data)[blossom].offset = 0;
     }
 
@@ -1189 +1295 @@
       destroyTree(tree);
 
+      (*_blossom_data)[blossom].status = UNMATCHED;
       (*_blossom_data)[blossom].base = node;
-      (*_blossom_data)[blossom].next = INVALID;
-    }
+      matchedToUnmatched(blossom);
+    }
+
 
     void augmentOnEdge(const Edge& edge) {
@@ -1198 +1306 @@
       int right = _blossom_set->find(_graph.v(edge));
 
-      int left_tree = _tree_set->find(left);
-      alternatePath(left, left_tree);
-      destroyTree(left_tree);
-
-      int right_tree = _tree_set->find(right);
-      alternatePath(right, right_tree);
-      destroyTree(right_tree);
+      if ((*_blossom_data)[left].status == EVEN) {
+        int left_tree = _tree_set->find(left);
+        alternatePath(left, left_tree);
+        destroyTree(left_tree);
+      } else {
+        (*_blossom_data)[left].status = MATCHED;
+        unmatchedToMatched(left);
+      }
+
+      if ((*_blossom_data)[right].status == EVEN) {
+        int right_tree = _tree_set->find(right);
+        alternatePath(right, right_tree);
+        destroyTree(right_tree);
+      } else {
+        (*_blossom_data)[right].status = MATCHED;
+        unmatchedToMatched(right);
+      }
 
       (*_blossom_data)[left].next = _graph.direct(edge, true);
       (*_blossom_data)[right].next = _graph.direct(edge, false);
-    }
-
-    void augmentOnArc(const Arc& arc) {
-
-      int left = _blossom_set->find(_graph.source(arc));
-      int right = _blossom_set->find(_graph.target(arc));
-
-      (*_blossom_data)[left].status = MATCHED;
-
-      int right_tree = _tree_set->find(right);
-      alternatePath(right, right_tree);
-      destroyTree(right_tree);
-
-      (*_blossom_data)[left].next = arc;
-      (*_blossom_data)[right].next = _graph.oppositeArc(arc);
     }
 
@@ -1427 +1530 @@
           (*_blossom_data)[sb].pred = pred;
           (*_blossom_data)[sb].next =
-            _graph.oppositeArc((*_blossom_data)[tb].next);
+                           _graph.oppositeArc((*_blossom_data)[tb].next);
 
           pred = (*_blossom_data)[ub].next;
@@ -1527 +1630 @@
 
       for (int i = 0; i < int(blossoms.size()); ++i) {
-        if ((*_blossom_data)[blossoms[i]].next != INVALID) {
+        if ((*_blossom_data)[blossoms[i]].status == MATCHED) {
 
           Value offset = (*_blossom_data)[blossoms[i]].offset;
@@ -1565 +1668 @@
         _delta4_index(0), _delta4(0),
 
-        _delta_sum(), _unmatched(0),
-
-        _fractional(0)
-    {}
+        _delta_sum() {}
 
     ~MaxWeightedMatching() {
       destroyStructures();
-      if (_fractional) {
-        delete _fractional;
-      }
     }
 
@@ -1602 +1699 @@
         (*_delta4_index)[i] = _delta4->PRE_HEAP;
       }
-
-      _unmatched = _node_num;
 
       int index = 0;
@@ -1639 +1734 @@
     }
 
-    /// \brief Initialize the algorithm with fractional matching
-    ///
-    /// This function initializes the algorithm with a fractional
-    /// matching. This initialization is also called jumpstart heuristic.
-    void fractionalInit() {
-      createStructures();
-      
-      if (_fractional == 0) {
-        _fractional = new FractionalMatching(_graph, _weight, false);
-      }
-      _fractional->run();
-
-      for (ArcIt e(_graph); e != INVALID; ++e) {
-        (*_node_heap_index)[e] = BinHeap<Value, IntArcMap>::PRE_HEAP;
-      }
-      for (NodeIt n(_graph); n != INVALID; ++n) {
-        (*_delta1_index)[n] = _delta1->PRE_HEAP;
-      }
-      for (EdgeIt e(_graph); e != INVALID; ++e) {
-        (*_delta3_index)[e] = _delta3->PRE_HEAP;
-      }
-      for (int i = 0; i < _blossom_num; ++i) {
-        (*_delta2_index)[i] = _delta2->PRE_HEAP;
-        (*_delta4_index)[i] = _delta4->PRE_HEAP;
-      }
-
-      _unmatched = 0;
-
-      int index = 0;
-      for (NodeIt n(_graph); n != INVALID; ++n) {
-        Value pot = _fractional->nodeValue(n);
-        (*_node_index)[n] = index;
-        (*_node_data)[index].pot = pot;
-        int blossom =
-          _blossom_set->insert(n, std::numeric_limits<Value>::max());
-
-        (*_blossom_data)[blossom].status = MATCHED;
-        (*_blossom_data)[blossom].pred = INVALID;
-        (*_blossom_data)[blossom].next = _fractional->matching(n);
-        if (_fractional->matching(n) == INVALID) {
-          (*_blossom_data)[blossom].base = n;
-        }
-        (*_blossom_data)[blossom].pot = 0;
-        (*_blossom_data)[blossom].offset = 0;
-        ++index;
-      }
-
-      typename Graph::template NodeMap<bool> processed(_graph, false);
-      for (NodeIt n(_graph); n != INVALID; ++n) {
-        if (processed[n]) continue;
-        processed[n] = true;
-        if (_fractional->matching(n) == INVALID) continue;
-        int num = 1;
-        Node v = _graph.target(_fractional->matching(n));
-        while (n != v) {
-          processed[v] = true;
-          v = _graph.target(_fractional->matching(v));
-          ++num;
-        }
-
-        if (num % 2 == 1) {
-          std::vector<int> subblossoms(num);
-
-          subblossoms[--num] = _blossom_set->find(n);
-          _delta1->push(n, _fractional->nodeValue(n));
-          v = _graph.target(_fractional->matching(n));
-          while (n != v) {
-            subblossoms[--num] = _blossom_set->find(v);
-            _delta1->push(v, _fractional->nodeValue(v));
-            v = _graph.target(_fractional->matching(v));            
-          }
-          
-          int surface = 
-            _blossom_set->join(subblossoms.begin(), subblossoms.end());
-          (*_blossom_data)[surface].status = EVEN;
-          (*_blossom_data)[surface].pred = INVALID;
-          (*_blossom_data)[surface].next = INVALID;
-          (*_blossom_data)[surface].pot = 0;
-          (*_blossom_data)[surface].offset = 0;
-          
-          _tree_set->insert(surface);
-          ++_unmatched;
-        }
-      }
-
-      for (EdgeIt e(_graph); e != INVALID; ++e) {
-        int si = (*_node_index)[_graph.u(e)];
-        int sb = _blossom_set->find(_graph.u(e));
-        int ti = (*_node_index)[_graph.v(e)];
-        int tb = _blossom_set->find(_graph.v(e));
-        if ((*_blossom_data)[sb].status == EVEN &&
-            (*_blossom_data)[tb].status == EVEN && sb != tb) {
-          _delta3->push(e, ((*_node_data)[si].pot + (*_node_data)[ti].pot -
-                            dualScale * _weight[e]) / 2);
-        }
-      }
-
-      for (NodeIt n(_graph); n != INVALID; ++n) {
-        int nb = _blossom_set->find(n);
-        if ((*_blossom_data)[nb].status != MATCHED) continue;
-        int ni = (*_node_index)[n];
-
-        for (OutArcIt e(_graph, n); e != INVALID; ++e) {
-          Node v = _graph.target(e);
-          int vb = _blossom_set->find(v);
-          int vi = (*_node_index)[v];
-
-          Value rw = (*_node_data)[ni].pot + (*_node_data)[vi].pot -
-            dualScale * _weight[e];
-
-          if ((*_blossom_data)[vb].status == EVEN) {
-
-            int vt = _tree_set->find(vb);
-
-            typename std::map<int, Arc>::iterator it =
-              (*_node_data)[ni].heap_index.find(vt);
-
-            if (it != (*_node_data)[ni].heap_index.end()) {
-              if ((*_node_data)[ni].heap[it->second] > rw) {
-                (*_node_data)[ni].heap.replace(it->second, e);
-                (*_node_data)[ni].heap.decrease(e, rw);
-                it->second = e;
-              }
-            } else {
-              (*_node_data)[ni].heap.push(e, rw);
-              (*_node_data)[ni].heap_index.insert(std::make_pair(vt, e));
-            }
-          }
-        }
-            
-        if (!(*_node_data)[ni].heap.empty()) {
-          _blossom_set->decrease(n, (*_node_data)[ni].heap.prio());
-          _delta2->push(nb, _blossom_set->classPrio(nb));
-        }
-      }
-    }
-
     /// \brief Start the algorithm
     ///
     /// This function starts the algorithm.
     ///
-    /// \pre \ref init() or \ref fractionalInit() must be called
-    /// before using this function.
+    /// \pre \ref init() must be called before using this function.
     void start() {
       enum OpType {
@@ -1787 +1744 @@
       };
 
-      while (_unmatched > 0) {
+      int unmatched = _node_num;
+      while (unmatched > 0) {
         Value d1 = !_delta1->empty() ?
           _delta1->prio() : std::numeric_limits<Value>::max();
@@ -1800 +1758 @@
           _delta4->prio() : std::numeric_limits<Value>::max();
 
-        _delta_sum = d3; OpType ot = D3;
-        if (d1 < _delta_sum) { _delta_sum = d1; ot = D1; }
+        _delta_sum = d1; OpType ot = D1;
         if (d2 < _delta_sum) { _delta_sum = d2; ot = D2; }
+        if (d3 < _delta_sum) { _delta_sum = d3; ot = D3; }
         if (d4 < _delta_sum) { _delta_sum = d4; ot = D4; }
+
 
         switch (ot) {
@@ -1810 +1769 @@
             Node n = _delta1->top();
             unmatchNode(n);
-            --_unmatched;
+            --unmatched;
           }
           break;
@@ -1817 +1776 @@
             int blossom = _delta2->top();
             Node n = _blossom_set->classTop(blossom);
-            Arc a = (*_node_data)[(*_node_index)[n]].heap.top();
-            if ((*_blossom_data)[blossom].next == INVALID) {
-              augmentOnArc(a);
-              --_unmatched;
-            } else {
-              extendOnArc(a);
-            }
+            Arc e = (*_node_data)[(*_node_index)[n]].heap.top();
+            extendOnArc(e);
           }
           break;
@@ -1836 +1790 @@
               _delta3->pop();
             } else {
-              int left_tree = _tree_set->find(left_blossom);
-              int right_tree = _tree_set->find(right_blossom);
+              int left_tree;
+              if ((*_blossom_data)[left_blossom].status == EVEN) {
+                left_tree = _tree_set->find(left_blossom);
+              } else {
+                left_tree = -1;
+                ++unmatched;
+              }
+              int right_tree;
+              if ((*_blossom_data)[right_blossom].status == EVEN) {
+                right_tree = _tree_set->find(right_blossom);
+              } else {
+                right_tree = -1;
+                ++unmatched;
+              }
 
               if (left_tree == right_tree) {
@@ -1843 +1809 @@
               } else {
                 augmentOnEdge(e);
-                _unmatched -= 2;
+                unmatched -= 2;
               }
             }
@@ -1861 +1827 @@
     /// \note mwm.run() is just a shortcut of the following code.
     /// \code
-    ///   mwm.fractionalInit();
+    ///   mwm.init();
     ///   mwm.start();
     /// \endcode
     void run() {
-      fractionalInit();
+      init();
       start();
     }
@@ -1872 +1838 @@
 
     /// \name Primal Solution
-    /// Functions to get the primal solution, i.e. the maximum weighted
+    /// Functions to get the primal solution, i.e. the maximum weighted 
     /// matching.\n
     /// Either \ref run() or \ref start() function should be called before
@@ -1891 +1857 @@
         }
       }
-      return sum / 2;
+      return sum /= 2;
     }
 
@@ -1911 +1877 @@
     /// \brief Return \c true if the given edge is in the matching.
     ///
-    /// This function returns \c true if the given edge is in the found
+    /// This function returns \c true if the given edge is in the found 
     /// matching.
     ///
@@ -1922 +1888 @@
     ///
     /// This function returns the matching arc (or edge) incident to the
-    /// given node in the found matching or \c INVALID if the node is
+    /// given node in the found matching or \c INVALID if the node is 
     /// not covered by the matching.
     ///
@@ -1940 +1906 @@
     /// \brief Return the mate of the given node.
     ///
-    /// This function returns the mate of the given node in the found
+    /// This function returns the mate of the given node in the found 
     /// matching or \c INVALID if the node is not covered by the matching.
     ///
@@ -1960 +1926 @@
     /// \brief Return the value of the dual solution.
     ///
-    /// This function returns the value of the dual solution.
-    /// It should be equal to the primal value scaled by \ref dualScale
+    /// This function returns the value of the dual solution. 
+    /// It should be equal to the primal value scaled by \ref dualScale 
     /// "dual scale".
     ///
@@ -2016 +1982 @@
     /// \brief Iterator for obtaining the nodes of a blossom.
     ///
-    /// This class provides an iterator for obtaining the nodes of the
+    /// This class provides an iterator for obtaining the nodes of the 
     /// given blossom. It lists a subset of the nodes.
-    /// Before using this iterator, you must allocate a
+    /// Before using this iterator, you must allocate a 
     /// MaxWeightedMatching class and execute it.
     class BlossomIt {
@@ -2027 +1993 @@
       /// Constructor to get the nodes of the given variable.
       ///
-      /// \pre Either \ref MaxWeightedMatching::run() "algorithm.run()" or
-      /// \ref MaxWeightedMatching::start() "algorithm.start()" must be
+      /// \pre Either \ref MaxWeightedMatching::run() "algorithm.run()" or 
+      /// \ref MaxWeightedMatching::start() "algorithm.start()" must be 
       /// called before initializing this iterator.
       BlossomIt(const MaxWeightedMatching& algorithm, int variable)
@@ -2081 +2047 @@
   /// \f$O(nm\log n)\f$ time complexity.
   ///
-  /// The maximum weighted perfect matching problem is to find a subset of
-  /// the edges in an undirected graph with maximum overall weight for which
+  /// The maximum weighted perfect matching problem is to find a subset of 
+  /// the edges in an undirected graph with maximum overall weight for which 
   /// each node has exactly one incident edge.
   /// It can be formulated with the following linear program.
@@ -2105 +2071 @@
       \frac{\vert B \vert - 1}{2}z_B\f] */
   ///
-  /// The algorithm can be executed with the run() function.
+  /// The algorithm can be executed with the run() function. 
   /// After it the matching (the primal solution) and the dual solution
-  /// can be obtained using the query functions and the
-  /// \ref MaxWeightedPerfectMatching::BlossomIt "BlossomIt" nested class,
-  /// which is able to iterate on the nodes of a blossom.
+  /// can be obtained using the query functions and the 
+  /// \ref MaxWeightedPerfectMatching::BlossomIt "BlossomIt" nested class, 
+  /// which is able to iterate on the nodes of a blossom. 
   /// If the value type is integer, then the dual solution is multiplied
   /// by \ref MaxWeightedMatching::dualScale "4".
   ///
   /// \tparam GR The undirected graph type the algorithm runs on.
-  /// \tparam WM The type edge weight map. The default type is
+  /// \tparam WM The type edge weight map. The default type is 
   /// \ref concepts::Graph::EdgeMap "GR::EdgeMap<int>".
 #ifdef DOXYGEN
@@ -2225 +2191 @@
 
     Value _delta_sum;
-    int _unmatched;
-
-    typedef MaxWeightedPerfectFractionalMatching<Graph, WeightMap> 
-    FractionalMatching;
-    FractionalMatching *_fractional;
 
     void createStructures() {
@@ -2273 +2234 @@
 
     void destroyStructures() {
+      _node_num = countNodes(_graph);
+      _blossom_num = _node_num * 3 / 2;
+
       if (_matching) {
         delete _matching;
@@ -2945 +2909 @@
         _delta4_index(0), _delta4(0),
 
-        _delta_sum(), _unmatched(0),
-
-        _fractional(0)
-    {}
+        _delta_sum() {}
 
     ~MaxWeightedPerfectMatching() {
       destroyStructures();
-      if (_fractional) {
-        delete _fractional;
-      }
     }
 
@@ -2979 +2937 @@
         (*_delta4_index)[i] = _delta4->PRE_HEAP;
       }
-
-      _unmatched = _node_num;
 
       int index = 0;
@@ -3015 +2971 @@
     }
 
-    /// \brief Initialize the algorithm with fractional matching
-    ///
-    /// This function initializes the algorithm with a fractional
-    /// matching. This initialization is also called jumpstart heuristic.
-    void fractionalInit() {
-      createStructures();
-      
-      if (_fractional == 0) {
-        _fractional = new FractionalMatching(_graph, _weight, false);
-      }
-      if (!_fractional->run()) {
-        _unmatched = -1;
-        return;
-      }
-
-      for (ArcIt e(_graph); e != INVALID; ++e) {
-        (*_node_heap_index)[e] = BinHeap<Value, IntArcMap>::PRE_HEAP;
-      }
-      for (EdgeIt e(_graph); e != INVALID; ++e) {
-        (*_delta3_index)[e] = _delta3->PRE_HEAP;
-      }
-      for (int i = 0; i < _blossom_num; ++i) {
-        (*_delta2_index)[i] = _delta2->PRE_HEAP;
-        (*_delta4_index)[i] = _delta4->PRE_HEAP;
-      }
-
-      _unmatched = 0;
-
-      int index = 0;
-      for (NodeIt n(_graph); n != INVALID; ++n) {
-        Value pot = _fractional->nodeValue(n);
-        (*_node_index)[n] = index;
-        (*_node_data)[index].pot = pot;
-        int blossom =
-          _blossom_set->insert(n, std::numeric_limits<Value>::max());
-
-        (*_blossom_data)[blossom].status = MATCHED;
-        (*_blossom_data)[blossom].pred = INVALID;
-        (*_blossom_data)[blossom].next = _fractional->matching(n);
-        (*_blossom_data)[blossom].pot = 0;
-        (*_blossom_data)[blossom].offset = 0;
-        ++index;
-      }
-
-      typename Graph::template NodeMap<bool> processed(_graph, false);
-      for (NodeIt n(_graph); n != INVALID; ++n) {
-        if (processed[n]) continue;
-        processed[n] = true;
-        if (_fractional->matching(n) == INVALID) continue;
-        int num = 1;
-        Node v = _graph.target(_fractional->matching(n));
-        while (n != v) {
-          processed[v] = true;
-          v = _graph.target(_fractional->matching(v));
-          ++num;
-        }
-
-        if (num % 2 == 1) {
-          std::vector<int> subblossoms(num);
-
-          subblossoms[--num] = _blossom_set->find(n);
-          v = _graph.target(_fractional->matching(n));
-          while (n != v) {
-            subblossoms[--num] = _blossom_set->find(v);
-            v = _graph.target(_fractional->matching(v));            
-          }
-          
-          int surface = 
-            _blossom_set->join(subblossoms.begin(), subblossoms.end());
-          (*_blossom_data)[surface].status = EVEN;
-          (*_blossom_data)[surface].pred = INVALID;
-          (*_blossom_data)[surface].next = INVALID;
-          (*_blossom_data)[surface].pot = 0;
-          (*_blossom_data)[surface].offset = 0;
-          
-          _tree_set->insert(surface);
-          ++_unmatched;
-        }
-      }
-
-      for (EdgeIt e(_graph); e != INVALID; ++e) {
-        int si = (*_node_index)[_graph.u(e)];
-        int sb = _blossom_set->find(_graph.u(e));
-        int ti = (*_node_index)[_graph.v(e)];
-        int tb = _blossom_set->find(_graph.v(e));
-        if ((*_blossom_data)[sb].status == EVEN &&
-            (*_blossom_data)[tb].status == EVEN && sb != tb) {
-          _delta3->push(e, ((*_node_data)[si].pot + (*_node_data)[ti].pot -
-                            dualScale * _weight[e]) / 2);
-        }
-      }
-
-      for (NodeIt n(_graph); n != INVALID; ++n) {
-        int nb = _blossom_set->find(n);
-        if ((*_blossom_data)[nb].status != MATCHED) continue;
-        int ni = (*_node_index)[n];
-
-        for (OutArcIt e(_graph, n); e != INVALID; ++e) {
-          Node v = _graph.target(e);
-          int vb = _blossom_set->find(v);
-          int vi = (*_node_index)[v];
-
-          Value rw = (*_node_data)[ni].pot + (*_node_data)[vi].pot -
-            dualScale * _weight[e];
-
-          if ((*_blossom_data)[vb].status == EVEN) {
-
-            int vt = _tree_set->find(vb);
-
-            typename std::map<int, Arc>::iterator it =
-              (*_node_data)[ni].heap_index.find(vt);
-
-            if (it != (*_node_data)[ni].heap_index.end()) {
-              if ((*_node_data)[ni].heap[it->second] > rw) {
-                (*_node_data)[ni].heap.replace(it->second, e);
-                (*_node_data)[ni].heap.decrease(e, rw);
-                it->second = e;
-              }
-            } else {
-              (*_node_data)[ni].heap.push(e, rw);
-              (*_node_data)[ni].heap_index.insert(std::make_pair(vt, e));
-            }
-          }
-        }
-            
-        if (!(*_node_data)[ni].heap.empty()) {
-          _blossom_set->decrease(n, (*_node_data)[ni].heap.prio());
-          _delta2->push(nb, _blossom_set->classPrio(nb));
-        }
-      }
-    }
-
     /// \brief Start the algorithm
     ///
     /// This function starts the algorithm.
     ///
-    /// \pre \ref init() or \ref fractionalInit() must be called before
-    /// using this function.
+    /// \pre \ref init() must be called before using this function.
     bool start() {
       enum OpType {
@@ -3158 +2981 @@
       };
 
-      if (_unmatched == -1) return false;
-
-      while (_unmatched > 0) {
+      int unmatched = _node_num;
+      while (unmatched > 0) {
         Value d2 = !_delta2->empty() ?
           _delta2->prio() : std::numeric_limits<Value>::max();
@@ -3170 +2992 @@
           _delta4->prio() : std::numeric_limits<Value>::max();
 
-        _delta_sum = d3; OpType ot = D3;
-        if (d2 < _delta_sum) { _delta_sum = d2; ot = D2; }
+        _delta_sum = d2; OpType ot = D2;
+        if (d3 < _delta_sum) { _delta_sum = d3; ot = D3; }
         if (d4 < _delta_sum) { _delta_sum = d4; ot = D4; }
 
@@ -3204 +3026 @@
               } else {
                 augmentOnEdge(e);
-                _unmatched -= 2;
+                unmatched -= 2;
               }
             }
@@ -3223 +3045 @@
     /// \note mwpm.run() is just a shortcut of the following code.
     /// \code
-    ///   mwpm.fractionalInit();
+    ///   mwpm.init();
     ///   mwpm.start();
     /// \endcode
     bool run() {
-      fractionalInit();
+      init();
       return start();
     }
@@ -3234 +3056 @@
 
     /// \name Primal Solution
-    /// Functions to get the primal solution, i.e. the maximum weighted
+    /// Functions to get the primal solution, i.e. the maximum weighted 
     /// perfect matching.\n
     /// Either \ref run() or \ref start() function should be called before
@@ -3253 +3075 @@
         }
       }
-      return sum / 2;
+      return sum /= 2;
     }
 
     /// \brief Return \c true if the given edge is in the matching.
     ///
-    /// This function returns \c true if the given edge is in the found
+    /// This function returns \c true if the given edge is in the found 
     /// matching.
     ///
@@ -3269 +3091 @@
     ///
     /// This function returns the matching arc (or edge) incident to the
-    /// given node in the found matching or \c INVALID if the node is
+    /// given node in the found matching or \c INVALID if the node is 
     /// not covered by the matching.
     ///
@@ -3287 +3109 @@
     /// \brief Return the mate of the given node.
     ///
-    /// This function returns the mate of the given node in the found
+    /// This function returns the mate of the given node in the found 
     /// matching or \c INVALID if the node is not covered by the matching.
     ///
@@ -3306 +3128 @@
     /// \brief Return the value of the dual solution.
     ///
-    /// This function returns the value of the dual solution.
-    /// It should be equal to the primal value scaled by \ref dualScale
+    /// This function returns the value of the dual solution. 
+    /// It should be equal to the primal value scaled by \ref dualScale 
     /// "dual scale".
     ///
@@ -3362 +3184 @@
     /// \brief Iterator for obtaining the nodes of a blossom.
     ///
-    /// This class provides an iterator for obtaining the nodes of the
+    /// This class provides an iterator for obtaining the nodes of the 
     /// given blossom. It lists a subset of the nodes.
-    /// Before using this iterator, you must allocate a
+    /// Before using this iterator, you must allocate a 
     /// MaxWeightedPerfectMatching class and execute it.
     class BlossomIt {
@@ -3373 +3195 @@
       /// Constructor to get the nodes of the given variable.
       ///
-      /// \pre Either \ref MaxWeightedPerfectMatching::run() "algorithm.run()"
-      /// or \ref MaxWeightedPerfectMatching::start() "algorithm.start()"
+      /// \pre Either \ref MaxWeightedPerfectMatching::run() "algorithm.run()" 
+      /// or \ref MaxWeightedPerfectMatching::start() "algorithm.start()" 
       /// must be called before initializing this iterator.
       BlossomIt(const MaxWeightedPerfectMatching& algorithm, int variable)
@@ -3420 +3242 @@
 } //END OF NAMESPACE LEMON
 
-#endif //LEMON_MATCHING_H
+#endif //LEMON_MAX_MATCHING_H

test/CMakeLists.txt

@@ -22 +22 @@
   error_test
   euler_test
-  fractional_matching_test
   gomory_hu_test
   graph_copy_test

test/Makefile.am

@@ -24 +24 @@
         test/error_test \
         test/euler_test \
-        test/fractional_matching_test \
         test/gomory_hu_test \
         test/graph_copy_test \
@@ -73 +72 @@
 test_error_test_SOURCES = test/error_test.cc
 test_euler_test_SOURCES = test/euler_test.cc
-test_fractional_matching_test_SOURCES = test/fractional_matching_test.cc
 test_gomory_hu_test_SOURCES = test/gomory_hu_test.cc
 test_graph_copy_test_SOURCES = test/graph_copy_test.cc

test/matching_test.cc

@@ -402 +402 @@
       edgeMap("weight", weight).run();
 
-    bool perfect;
-    {
-      MaxMatching<SmartGraph> mm(graph);
-      mm.run();
-      checkMatching(graph, mm);
-      perfect = 2 * mm.matchingSize() == countNodes(graph);
-    }
-
-    {
-      MaxWeightedMatching<SmartGraph> mwm(graph, weight);
-      mwm.run();
-      checkWeightedMatching(graph, weight, mwm);
-    }
-
-    {
-      MaxWeightedMatching<SmartGraph> mwm(graph, weight);
-      mwm.init();
-      mwm.start();
-      checkWeightedMatching(graph, weight, mwm);
-    }
-
-    {
-      MaxWeightedPerfectMatching<SmartGraph> mwpm(graph, weight);
-      bool result = mwpm.run();
-      
-      check(result == perfect, "Perfect matching found");
-      if (perfect) {
-        checkWeightedPerfectMatching(graph, weight, mwpm);
-      }
-    }
-
-    {
-      MaxWeightedPerfectMatching<SmartGraph> mwpm(graph, weight);
-      mwpm.init();
-      bool result = mwpm.start();
-      
-      check(result == perfect, "Perfect matching found");
-      if (perfect) {
-        checkWeightedPerfectMatching(graph, weight, mwpm);
-      }
+    MaxMatching<SmartGraph> mm(graph);
+    mm.run();
+    checkMatching(graph, mm);
+
+    MaxWeightedMatching<SmartGraph> mwm(graph, weight);
+    mwm.run();
+    checkWeightedMatching(graph, weight, mwm);
+
+    MaxWeightedPerfectMatching<SmartGraph> mwpm(graph, weight);
+    bool perfect = mwpm.run();
+
+    check(perfect == (mm.matchingSize() * 2 == countNodes(graph)),
+          "Perfect matching found");
+
+    if (perfect) {
+      checkWeightedPerfectMatching(graph, weight, mwpm);
     }
   }