graph_matching 0.1.0 → 0.1.1

data/profile/mcm_bipartite/compare.sh

@@ -1,15 +0,0 @@
-#!/usr/bin/env bash
-
-BENCHMARK_DIR='benchmark/mcm_bipartite/complete_bigraphs'
-
-if [ ! -d "$BENCHMARK_DIR" ]; then
-  echo "Directory not found: $BENCHMARK_DIR" 1>&2
-  exit 1
-fi
-
-echo "Benchmarking .."
-ruby -I lib "$BENCHMARK_DIR/benchmark.rb" > "$BENCHMARK_DIR/time2.data"
-
-echo "Plotting .."
-gnuplot "$BENCHMARK_DIR/compare.gnuplot"
-open "$BENCHMARK_DIR/plot_compare.png"

data/profile/mcm_bipartite/publish.sh

@@ -1,12 +0,0 @@
-#!/usr/bin/env bash
-
-BENCHMARK_DIR='benchmark/mcm_bipartite/complete_bigraphs'
-
-if [ ! -d "$BENCHMARK_DIR" ]; then
-  echo "Directory not found: $BENCHMARK_DIR" 1>&2
-  exit 1
-fi
-
-rm "$BENCHMARK_DIR/plot_compare.png"
-mv "$BENCHMARK_DIR/time2.data" "$BENCHMARK_DIR/time.data"
-gnuplot "$BENCHMARK_DIR/plot.gnuplot"

data/profile/mwm_general/compare.sh

@@ -1,15 +0,0 @@
-#!/usr/bin/env bash
-
-BENCHMARK_DIR='benchmark/mwm_general/complete_graphs'
-
-if [ ! -d "$BENCHMARK_DIR" ]; then
-  echo "Directory not found: $BENCHMARK_DIR" 1>&2
-  exit 1
-fi
-
-echo "Benchmarking .."
-ruby -I lib "$BENCHMARK_DIR/benchmark.rb" > "$BENCHMARK_DIR/time2.data"
-
-echo "Plotting .."
-gnuplot "$BENCHMARK_DIR/compare.gnuplot"
-open "$BENCHMARK_DIR/plot_compare.png"

data/profile/mwm_general/profile.rb

@@ -1,28 +0,0 @@
-# No shebang here.  Run with:
-#
-# ruby -I lib profile/mwm_general/profile.rb
-
-require 'graph_matching'
-require 'ruby-prof'
-
-def complete_graph(n)
-  g = GraphMatching::Graph::WeightedGraph.new
-  n_edges = (1..n - 1).reduce(:+)
-  0.upto(n - 2) do |i|
-    (i + 1).upto(n - 1) do |j|
-      g.add_edge(i, j)
-      g.set_w([i, j], rand(n_edges))
-    end
-  end
-  g
-end
-
-g = complete_graph(100)
-GC.disable
-RubyProf.start
-g.maximum_weighted_matching(true)
-result = RubyProf.stop
-GC.enable
-
-printer = RubyProf::FlatPrinter.new(result)
-printer.print(STDOUT)

data/profile/mwm_general/publish.sh

@@ -1,12 +0,0 @@
-#!/usr/bin/env bash
-
-BENCHMARK_DIR='benchmark/mwm_general/complete_graphs'
-
-if [ ! -d "$BENCHMARK_DIR" ]; then
-  echo "Directory not found: $BENCHMARK_DIR" 1>&2
-  exit 1
-fi
-
-rm "$BENCHMARK_DIR/plot_compare.png"
-mv "$BENCHMARK_DIR/time2.data" "$BENCHMARK_DIR/time.data"
-gnuplot "$BENCHMARK_DIR/plot.gnuplot"

data/research/examples/unweighted_general/1.txt

@@ -1,86 +0,0 @@
-Stage 1
-
-          5 -- 7
-        / ||   ||
-   1 = 3  ||   o
-  /     \ ||
-r        6
-  \     /
-   2 = 4
-  /
-a
-
-S = [ 1 by r, 2 by r, 5 by 3, 6 by 3 ]
-T = [ 3 by 1, 4 by 1 ]
-
-Stage 2
-
-   1 = B -- 7
-  /    |    ||
-r      |    o
-  \    |
-   2 = 4
-  /
-a
-
-S = [ 1 by r, 2 by r, 5 by 3, 6 by 3 ]
-T = [ 3 by 1, 4 by 1 ]
-
-Stage 3
-
-  B -- 7
- /     ||
-a      o
-
-Find augmenting path from r, *through B* to a
-
-1. AP = (a,B)
-1. expand B
-
-   1 = B -- 7
-  /    |    ||
-r      |    o
-  \    |
-   2 = 4
-  /
-a
-
-1. Kusner says: "propagating the augmenting path through the expansion steps"
-1. AP = (a,2), etc.. but how to find "etc"?  We know we want an
-   alternating path, so starting at 2, find a matched edge.
-1. AP = a2, 24
-1. AP = a2, 24, 4B
-1. B is a blossom.  Expand it.
-
-          5 -- 7
-        / ||   ||
-   1 = 3  ||   o
-  /     \ ||
-r        6
-  \     /
-   2 = 4
-  /
-a
-
-1. AP = a2, 24, 46
-1. AP = a2, 24, 46, 65
-1. Should we follow (5,3) or (5,7), or both?
-1. Following (5,7) doesn't reach r, and if we follow it,
-   either depth-first or breadth-first, we'll learn that.
-1. AP = a2, 24, 46, 65, 53
-1. AP = a2, 24, 46, 65, 53, 31
-1. AP = a2, 24, 46, 65, 53, 31, 1r
-1. Augmenting path: a, 2, 4, 6, 5, 3, 1, r
-
-          5 -- 7
-        //|   ||
-   1 - 3  |   o
-  //     \|
-r        6
-  \     //
-   2 - 4
-  //
-a
-
-1. size of matching = 5.  Decide is maximum cardinality
-   matching.  (How?)

data/research/van_rantwijk/mwm_example.py

@@ -1,19 +0,0 @@
-from mwmatching import maxWeightMatching
-from random import randrange
-from time import clock
-from math import pow
-
-for n in list(range(2, 151)):
-  n_edges = (pow(n, 2) + n) / 2
-  edges = []
-  for i in list(range(n - 1)):
-    for j in list(range(i + 1, n)):
-      edges.append([i, j, randrange(0, n_edges)])
-
-  # Return a list "mate", such that mate[i] == j if vertex i is matched to
-  # vertex j, and mate[i] == -1 if vertex i is not matched.
-  before = clock()
-  match = maxWeightMatching(edges, maxcardinality=True)
-  after = clock()
-
-  print str(n) + "\t" + str(after - before)

data/research/van_rantwijk/mwmatching.py

@@ -1,945 +0,0 @@
-"""Weighted maximum matching in general graphs.
-
-The algorithm is taken from "Efficient Algorithms for Finding Maximum
-Matching in Graphs" by Zvi Galil, ACM Computing Surveys, 1986.
-It is based on the "blossom" method for finding augmenting paths and
-the "primal-dual" method for finding a matching of maximum weight, both
-due to Jack Edmonds.
-Some ideas came from "Implementation of algorithms for maximum matching
-on non-bipartite graphs" by H.J. Gabow, Standford Ph.D. thesis, 1973.
-
-A C program for maximum weight matching by Ed Rothberg was used extensively
-to validate this new code.
-"""
-
-#
-# Changes:
-#
-# 2013-04-07
-#   * Added Python 3 compatibility with contributions from Daniel Saunders.
-#
-# 2008-06-08
-#   * First release.
-#
-
-from __future__ import print_function
-
-# If assigned, DEBUG(str) is called with lots of debug messages.
-DEBUG = None
-"""def DEBUG(s):
-    from sys import stderr
-    print('DEBUG:', s, file=stderr)
-"""
-
-# Check delta2/delta3 computation after every substage;
-# only works on integer weights, slows down the algorithm to O(n^4).
-CHECK_DELTA = False
-
-# Check optimality of solution before returning; only works on integer weights.
-CHECK_OPTIMUM = True
-
-
-def maxWeightMatching(edges, maxcardinality=False):
-    """Compute a maximum-weighted matching in the general undirected
-    weighted graph given by "edges".  If "maxcardinality" is true,
-    only maximum-cardinality matchings are considered as solutions.
-
-    Edges is a sequence of tuples (i, j, wt) describing an undirected
-    edge between vertex i and vertex j with weight wt.  There is at most
-    one edge between any two vertices; no vertex has an edge to itself.
-    Vertices are identified by consecutive, non-negative integers.
-
-    Return a list "mate", such that mate[i] == j if vertex i is
-    matched to vertex j, and mate[i] == -1 if vertex i is not matched.
-
-    This function takes time O(n ** 3)."""
-
-    #
-    # Vertices are numbered 0 .. (nvertex-1).
-    # Non-trivial blossoms are numbered nvertex .. (2*nvertex-1)
-    #
-    # Edges are numbered 0 .. (nedge-1).
-    # Edge endpoints are numbered 0 .. (2*nedge-1), such that endpoints
-    # (2*k) and (2*k+1) both belong to edge k.
-    #
-    # Many terms used in the comments (sub-blossom, T-vertex) come from
-    # the paper by Galil; read the paper before reading this code.
-    #
-
-    # Python 2/3 compatibility.
-    from sys import version as sys_version
-    if sys_version < '3':
-        integer_types = (int, long)
-    else:
-        integer_types = (int,)
-
-    # Deal swiftly with empty graphs.
-    if not edges:
-        return [ ]
-
-    # Count vertices.
-    nedge = len(edges)
-    nvertex = 0
-    for (i, j, w) in edges:
-        assert i >= 0 and j >= 0 and i != j
-        if i >= nvertex:
-            nvertex = i + 1
-        if j >= nvertex:
-            nvertex = j + 1
-
-    # Find the maximum edge weight.
-    maxweight = max(0, max([ wt for (i, j, wt) in edges ]))
-
-    # If p is an edge endpoint,
-    # endpoint[p] is the vertex to which endpoint p is attached.
-    # Not modified by the algorithm.
-    endpoint = [ edges[p//2][p%2] for p in range(2*nedge) ]
-
-    # If v is a vertex,
-    # neighbend[v] is the list of remote endpoints of the edges attached to v.
-    # Not modified by the algorithm.
-    neighbend = [ [ ] for i in range(nvertex) ]
-    for k in range(len(edges)):
-        (i, j, w) = edges[k]
-        neighbend[i].append(2*k+1)
-        neighbend[j].append(2*k)
-
-    # If v is a vertex,
-    # mate[v] is the remote endpoint of its matched edge, or -1 if it is single
-    # (i.e. endpoint[mate[v]] is v's partner vertex).
-    # Initially all vertices are single; updated during augmentation.
-    mate = nvertex * [ -1 ]
-
-    # If b is a top-level blossom,
-    # label[b] is 0 if b is unlabeled (free);
-    #             1 if b is an S-vertex/blossom;
-    #             2 if b is a T-vertex/blossom.
-    # The label of a vertex is found by looking at the label of its
-    # top-level containing blossom.
-    # If v is a vertex inside a T-blossom,
-    # label[v] is 2 iff v is reachable from an S-vertex outside the blossom.
-    # Labels are assigned during a stage and reset after each augmentation.
-    label = (2 * nvertex) * [ 0 ]
-
-    # If b is a labeled top-level blossom,
-    # labelend[b] is the remote endpoint of the edge through which b obtained
-    # its label, or -1 if b's base vertex is single.
-    # If v is a vertex inside a T-blossom and label[v] == 2,
-    # labelend[v] is the remote endpoint of the edge through which v is
-    # reachable from outside the blossom.
-    labelend = (2 * nvertex) * [ -1 ]
-
-    # If v is a vertex,
-    # inblossom[v] is the top-level blossom to which v belongs.
-    # If v is a top-level vertex, v is itself a blossom (a trivial blossom)
-    # and inblossom[v] == v.
-    # Initially all vertices are top-level trivial blossoms.
-    inblossom = list(range(nvertex))
-
-    # If b is a sub-blossom,
-    # blossomparent[b] is its immediate parent (sub-)blossom.
-    # If b is a top-level blossom, blossomparent[b] is -1.
-    blossomparent = (2 * nvertex) * [ -1 ]
-
-    # If b is a non-trivial (sub-)blossom,
-    # blossomchilds[b] is an ordered list of its sub-blossoms, starting with
-    # the base and going round the blossom.
-    blossomchilds = (2 * nvertex) * [ None ]
-
-    # If b is a (sub-)blossom,
-    # blossombase[b] is its base VERTEX (i.e. recursive sub-blossom).
-    blossombase = list(range(nvertex)) + nvertex * [ -1 ]
-
-    # If b is a non-trivial (sub-)blossom,
-    # blossomendps[b] is a list of endpoints on its connecting edges,
-    # such that blossomendps[b][i] is the local endpoint of blossomchilds[b][i]
-    # on the edge that connects it to blossomchilds[b][wrap(i+1)].
-    blossomendps = (2 * nvertex) * [ None ]
-
-    # If v is a free vertex (or an unreached vertex inside a T-blossom),
-    # bestedge[v] is the edge to an S-vertex with least slack,
-    # or -1 if there is no such edge.
-    # If b is a (possibly trivial) top-level S-blossom,
-    # bestedge[b] is the least-slack edge to a different S-blossom,
-    # or -1 if there is no such edge.
-    # This is used for efficient computation of delta2 and delta3.
-    bestedge = (2 * nvertex) * [ -1 ]
-
-    # If b is a non-trivial top-level S-blossom,
-    # blossombestedges[b] is a list of least-slack edges to neighbouring
-    # S-blossoms, or None if no such list has been computed yet.
-    # This is used for efficient computation of delta3.
-    blossombestedges = (2 * nvertex) * [ None ]
-
-    # List of currently unused blossom numbers.
-    unusedblossoms = list(range(nvertex, 2*nvertex))
-
-    # If v is a vertex,
-    # dualvar[v] = 2 * u(v) where u(v) is the v's variable in the dual
-    # optimization problem (multiplication by two ensures integer values
-    # throughout the algorithm if all edge weights are integers).
-    # If b is a non-trivial blossom,
-    # dualvar[b] = z(b) where z(b) is b's variable in the dual optimization
-    # problem.
-    dualvar = nvertex * [ maxweight ] + nvertex * [ 0 ]
-
-    # If allowedge[k] is true, edge k has zero slack in the optimization
-    # problem; if allowedge[k] is false, the edge's slack may or may not
-    # be zero.
-    allowedge = nedge * [ False ]
-
-    # Queue of newly discovered S-vertices.
-    queue = [ ]
-
-    # Return 2 * slack of edge k (does not work inside blossoms).
-    def slack(k):
-        (i, j, wt) = edges[k]
-        return dualvar[i] + dualvar[j] - 2 * wt
-
-    # Generate the leaf vertices of a blossom.
-    def blossomLeaves(b):
-        if b < nvertex:
-            yield b
-        else:
-            for t in blossomchilds[b]:
-                if t < nvertex:
-                    yield t
-                else:
-                    for v in blossomLeaves(t):
-                        yield v
-
-    # Assign label t to the top-level blossom containing vertex w
-    # and record the fact that w was reached through the edge with
-    # remote endpoint p.
-    def assignLabel(w, t, p):
-        if DEBUG: DEBUG('assignLabel(%d,%d,%d)' % (w, t, p))
-        b = inblossom[w]
-        assert label[w] == 0 and label[b] == 0
-        label[w] = label[b] = t
-        labelend[w] = labelend[b] = p
-        bestedge[w] = bestedge[b] = -1
-        if t == 1:
-            # b became an S-vertex/blossom; add it(s vertices) to the queue.
-            queue.extend(blossomLeaves(b))
-            if DEBUG: DEBUG('PUSH ' + str(list(blossomLeaves(b))))
-        elif t == 2:
-            # b became a T-vertex/blossom; assign label S to its mate.
-            # (If b is a non-trivial blossom, its base is the only vertex
-            # with an external mate.)
-            base = blossombase[b]
-            assert mate[base] >= 0
-            assignLabel(endpoint[mate[base]], 1, mate[base] ^ 1)
-
-    # Trace back from vertices v and w to discover either a new blossom
-    # or an augmenting path. Return the base vertex of the new blossom or -1.
-    def scanBlossom(v, w):
-        if DEBUG: DEBUG('scanBlossom(%d,%d)' % (v, w))
-        # Trace back from v and w, placing breadcrumbs as we go.
-        path = [ ]
-        base = -1
-        while v != -1 or w != -1:
-            # Look for a breadcrumb in v's blossom or put a new breadcrumb.
-            b = inblossom[v]
-            if label[b] & 4:
-                base = blossombase[b]
-                break
-            assert label[b] == 1
-            path.append(b)
-            label[b] = 5
-            # Trace one step back.
-            assert labelend[b] == mate[blossombase[b]]
-            if labelend[b] == -1:
-                # The base of blossom b is single; stop tracing this path.
-                v = -1
-            else:
-                v = endpoint[labelend[b]]
-                b = inblossom[v]
-                assert label[b] == 2
-                # b is a T-blossom; trace one more step back.
-                assert labelend[b] >= 0
-                v = endpoint[labelend[b]]
-            # Swap v and w so that we alternate between both paths.
-            if w != -1:
-                v, w = w, v
-       # Remove breadcrumbs.
-        for b in path:
-            label[b] = 1
-        # Return base vertex, if we found one.
-        return base
-
-    # Construct a new blossom with given base, containing edge k which
-    # connects a pair of S vertices. Label the new blossom as S; set its dual
-    # variable to zero; relabel its T-vertices to S and add them to the queue.
-    def addBlossom(base, k):
-        (v, w, wt) = edges[k]
-        bb = inblossom[base]
-        bv = inblossom[v]
-        bw = inblossom[w]
-        # Create blossom.
-        b = unusedblossoms.pop()
-        if DEBUG: DEBUG('addBlossom(%d,%d) (v=%d w=%d) -> %d' % (base, k, v, w, b))
-        blossombase[b] = base
-        blossomparent[b] = -1
-        blossomparent[bb] = b
-        # Make list of sub-blossoms and their interconnecting edge endpoints.
-        blossomchilds[b] = path = [ ]
-        blossomendps[b] = endps = [ ]
-        # Trace back from v to base.
-        while bv != bb:
-            # Add bv to the new blossom.
-            blossomparent[bv] = b
-            path.append(bv)
-            endps.append(labelend[bv])
-            assert (label[bv] == 2 or
-                    (label[bv] == 1 and labelend[bv] == mate[blossombase[bv]]))
-            # Trace one step back.
-            assert labelend[bv] >= 0
-            v = endpoint[labelend[bv]]
-            bv = inblossom[v]
-        # Reverse lists, add endpoint that connects the pair of S vertices.
-        path.append(bb)
-        path.reverse()
-        endps.reverse()
-        endps.append(2*k)
-        # Trace back from w to base.
-        while bw != bb:
-            # Add bw to the new blossom.
-            blossomparent[bw] = b
-            path.append(bw)
-            endps.append(labelend[bw] ^ 1)
-            assert (label[bw] == 2 or
-                    (label[bw] == 1 and labelend[bw] == mate[blossombase[bw]]))
-            # Trace one step back.
-            assert labelend[bw] >= 0
-            w = endpoint[labelend[bw]]
-            bw = inblossom[w]
-        # Set label to S.
-        assert label[bb] == 1
-        label[b] = 1
-        labelend[b] = labelend[bb]
-        # Set dual variable to zero.
-        dualvar[b] = 0
-        # Relabel vertices.
-        for v in blossomLeaves(b):
-            if label[inblossom[v]] == 2:
-                # This T-vertex now turns into an S-vertex because it becomes
-                # part of an S-blossom; add it to the queue.
-                queue.append(v)
-            inblossom[v] = b
-        # Compute blossombestedges[b].
-        bestedgeto = (2 * nvertex) * [ -1 ]
-        for bv in path:
-            if blossombestedges[bv] is None:
-                # This subblossom does not have a list of least-slack edges;
-                # get the information from the vertices.
-                nblists = [ [ p // 2 for p in neighbend[v] ]
-                            for v in blossomLeaves(bv) ]
-            else:
-                # Walk this subblossom's least-slack edges.
-                nblists = [ blossombestedges[bv] ]
-            for nblist in nblists:
-                for k in nblist:
-                    (i, j, wt) = edges[k]
-                    if inblossom[j] == b:
-                        i, j = j, i
-                    bj = inblossom[j]
-                    if (bj != b and label[bj] == 1 and
-                        (bestedgeto[bj] == -1 or
-                         slack(k) < slack(bestedgeto[bj]))):
-                        bestedgeto[bj] = k
-            # Forget about least-slack edges of the subblossom.
-            blossombestedges[bv] = None
-            bestedge[bv] = -1
-        blossombestedges[b] = [ k for k in bestedgeto if k != -1 ]
-        # Select bestedge[b].
-        bestedge[b] = -1
-        for k in blossombestedges[b]:
-            if bestedge[b] == -1 or slack(k) < slack(bestedge[b]):
-                bestedge[b] = k
-        if DEBUG: DEBUG('blossomchilds[%d]=' % b + repr(blossomchilds[b]))
-
-    # Expand the given top-level blossom.
-    def expandBlossom(b, endstage):
-        if DEBUG: DEBUG('expandBlossom(%d,%d) %s' % (b, endstage, repr(blossomchilds[b])))
-        # Convert sub-blossoms into top-level blossoms.
-        for s in blossomchilds[b]:
-            blossomparent[s] = -1
-            if s < nvertex:
-                inblossom[s] = s
-            elif endstage and dualvar[s] == 0:
-                # Recursively expand this sub-blossom.
-                expandBlossom(s, endstage)
-            else:
-                for v in blossomLeaves(s):
-                    inblossom[v] = s
-        # If we expand a T-blossom during a stage, its sub-blossoms must be
-        # relabeled.
-        if (not endstage) and label[b] == 2:
-            # Start at the sub-blossom through which the expanding
-            # blossom obtained its label, and relabel sub-blossoms untili
-            # we reach the base.
-            # Figure out through which sub-blossom the expanding blossom
-            # obtained its label initially.
-            assert labelend[b] >= 0
-            entrychild = inblossom[endpoint[labelend[b] ^ 1]]
-            # Decide in which direction we will go round the blossom.
-            j = blossomchilds[b].index(entrychild)
-            if j & 1:
-                # Start index is odd; go forward and wrap.
-                j -= len(blossomchilds[b])
-                jstep = 1
-                endptrick = 0
-            else:
-                # Start index is even; go backward.
-                jstep = -1
-                endptrick = 1
-            # Move along the blossom until we get to the base.
-            p = labelend[b]
-            while j != 0:
-                # Relabel the T-sub-blossom.
-                label[endpoint[p ^ 1]] = 0
-                label[endpoint[blossomendps[b][j-endptrick]^endptrick^1]] = 0
-                assignLabel(endpoint[p ^ 1], 2, p)
-                # Step to the next S-sub-blossom and note its forward endpoint.
-                allowedge[blossomendps[b][j-endptrick]//2] = True
-                j += jstep
-                p = blossomendps[b][j-endptrick] ^ endptrick
-                # Step to the next T-sub-blossom.
-                allowedge[p//2] = True
-                j += jstep
-            # Relabel the base T-sub-blossom WITHOUT stepping through to
-            # its mate (so don't call assignLabel).
-            bv = blossomchilds[b][j]
-            label[endpoint[p ^ 1]] = label[bv] = 2
-            labelend[endpoint[p ^ 1]] = labelend[bv] = p
-            bestedge[bv] = -1
-            # Continue along the blossom until we get back to entrychild.
-            j += jstep
-            while blossomchilds[b][j] != entrychild:
-                # Examine the vertices of the sub-blossom to see whether
-                # it is reachable from a neighbouring S-vertex outside the
-                # expanding blossom.
-                bv = blossomchilds[b][j]
-                if label[bv] == 1:
-                    # This sub-blossom just got label S through one of its
-                    # neighbours; leave it.
-                    j += jstep
-                    continue
-                for v in blossomLeaves(bv):
-                    if label[v] != 0:
-                        break
-                # If the sub-blossom contains a reachable vertex, assign
-                # label T to the sub-blossom.
-                if label[v] != 0:
-                    assert label[v] == 2
-                    assert inblossom[v] == bv
-                    label[v] = 0
-                    label[endpoint[mate[blossombase[bv]]]] = 0
-                    assignLabel(v, 2, labelend[v])
-                j += jstep
-        # Recycle the blossom number.
-        label[b] = labelend[b] = -1
-        blossomchilds[b] = blossomendps[b] = None
-        blossombase[b] = -1
-        blossombestedges[b] = None
-        bestedge[b] = -1
-        unusedblossoms.append(b)
-
-    # Swap matched/unmatched edges over an alternating path through blossom b
-    # between vertex v and the base vertex. Keep blossom bookkeeping consistent.
-    def augmentBlossom(b, v):
-        if DEBUG: DEBUG('augmentBlossom(%d,%d)' % (b, v))
-        # Bubble up through the blossom tree from vertex v to an immediate
-        # sub-blossom of b.
-        t = v
-        while blossomparent[t] != b:
-            t = blossomparent[t]
-        # Recursively deal with the first sub-blossom.
-        if t >= nvertex:
-            augmentBlossom(t, v)
-        # Decide in which direction we will go round the blossom.
-        i = j = blossomchilds[b].index(t)
-        if i & 1:
-            # Start index is odd; go forward and wrap.
-            j -= len(blossomchilds[b])
-            jstep = 1
-            endptrick = 0
-        else:
-            # Start index is even; go backward.
-            jstep = -1
-            endptrick = 1
-        # Move along the blossom until we get to the base.
-        while j != 0:
-            # Step to the next sub-blossom and augment it recursively.
-            j += jstep
-            t = blossomchilds[b][j]
-            p = blossomendps[b][j-endptrick] ^ endptrick
-            if t >= nvertex:
-                augmentBlossom(t, endpoint[p])
-            # Step to the next sub-blossom and augment it recursively.
-            j += jstep
-            t = blossomchilds[b][j]
-            if t >= nvertex:
-                augmentBlossom(t, endpoint[p ^ 1])
-            # Match the edge connecting those sub-blossoms.
-            mate[endpoint[p]] = p ^ 1
-            mate[endpoint[p ^ 1]] = p
-            if DEBUG: DEBUG('PAIR %d %d (k=%d)' % (endpoint[p], endpoint[p^1], p//2))
-        # Rotate the list of sub-blossoms to put the new base at the front.
-        blossomchilds[b] = blossomchilds[b][i:] + blossomchilds[b][:i]
-        blossomendps[b]  = blossomendps[b][i:]  + blossomendps[b][:i]
-        blossombase[b] = blossombase[blossomchilds[b][0]]
-        assert blossombase[b] == v
-
-    # Swap matched/unmatched edges over an alternating path between two
-    # single vertices. The augmenting path runs through edge k, which
-    # connects a pair of S vertices.
-    def augmentMatching(k):
-        (v, w, wt) = edges[k]
-        if DEBUG: DEBUG('augmentMatching(%d) (v=%d w=%d)' % (k, v, w))
-        if DEBUG: DEBUG('PAIR %d %d (k=%d)' % (v, w, k))
-        for (s, p) in ((v, 2*k+1), (w, 2*k)):
-            # Match vertex s to remote endpoint p. Then trace back from s
-            # until we find a single vertex, swapping matched and unmatched
-            # edges as we go.
-            while 1:
-                bs = inblossom[s]
-                assert label[bs] == 1
-                assert labelend[bs] == mate[blossombase[bs]]
-                # Augment through the S-blossom from s to base.
-                if bs >= nvertex:
-                    augmentBlossom(bs, s)
-                # Update mate[s]
-                mate[s] = p
-                # Trace one step back.
-                if labelend[bs] == -1:
-                    # Reached single vertex; stop.
-                    break
-                t = endpoint[labelend[bs]]
-                bt = inblossom[t]
-                assert label[bt] == 2
-                # Trace one step back.
-                assert labelend[bt] >= 0
-                s = endpoint[labelend[bt]]
-                j = endpoint[labelend[bt] ^ 1]
-                # Augment through the T-blossom from j to base.
-                assert blossombase[bt] == t
-                if bt >= nvertex:
-                    augmentBlossom(bt, j)
-                # Update mate[j]
-                mate[j] = labelend[bt]
-                # Keep the opposite endpoint;
-                # it will be assigned to mate[s] in the next step.
-                p = labelend[bt] ^ 1
-                if DEBUG: DEBUG('PAIR %d %d (k=%d)' % (s, t, p//2))
-
-    # Verify that the optimum solution has been reached.
-    def verifyOptimum():
-        if maxcardinality:
-            # Vertices may have negative dual;
-            # find a constant non-negative number to add to all vertex duals.
-            vdualoffset = max(0, -min(dualvar[:nvertex]))
-        else:
-            vdualoffset = 0
-        # 0. all dual variables are non-negative
-        assert min(dualvar[:nvertex]) + vdualoffset >= 0
-        assert min(dualvar[nvertex:]) >= 0
-        # 0. all edges have non-negative slack and
-        # 1. all matched edges have zero slack;
-        for k in range(nedge):
-            (i, j, wt) = edges[k]
-            s = dualvar[i] + dualvar[j] - 2 * wt
-            iblossoms = [ i ]
-            jblossoms = [ j ]
-            while blossomparent[iblossoms[-1]] != -1:
-                iblossoms.append(blossomparent[iblossoms[-1]])
-            while blossomparent[jblossoms[-1]] != -1:
-                jblossoms.append(blossomparent[jblossoms[-1]])
-            iblossoms.reverse()
-            jblossoms.reverse()
-            for (bi, bj) in zip(iblossoms, jblossoms):
-                if bi != bj:
-                    break
-                s += 2 * dualvar[bi]
-            assert s >= 0
-            if mate[i] // 2 == k or mate[j] // 2 == k:
-                assert mate[i] // 2 == k and mate[j] // 2 == k
-                assert s == 0
-        # 2. all single vertices have zero dual value;
-        for v in range(nvertex):
-            assert mate[v] >= 0 or dualvar[v] + vdualoffset == 0
-        # 3. all blossoms with positive dual value are full.
-        for b in range(nvertex, 2*nvertex):
-            if blossombase[b] >= 0 and dualvar[b] > 0:
-                assert len(blossomendps[b]) % 2 == 1
-                for p in blossomendps[b][1::2]:
-                    assert mate[endpoint[p]] == p ^ 1
-                    assert mate[endpoint[p ^ 1]] == p
-        # Ok.
-
-    # Check optimized delta2 against a trivial computation.
-    def checkDelta2():
-        for v in range(nvertex):
-            if label[inblossom[v]] == 0:
-                bd = None
-                bk = -1
-                for p in neighbend[v]:
-                    k = p // 2
-                    w = endpoint[p]
-                    if label[inblossom[w]] == 1:
-                        d = slack(k)
-                        if bk == -1 or d < bd:
-                            bk = k
-                            bd = d
-                if DEBUG and (bestedge[v] != -1 or bk != -1) and (bestedge[v] == -1 or bd != slack(bestedge[v])):
-                    DEBUG('v=' + str(v) + ' bk=' + str(bk) + ' bd=' + str(bd) + ' bestedge=' + str(bestedge[v]) + ' slack=' + str(slack(bestedge[v])))
-                assert (bk == -1 and bestedge[v] == -1) or (bestedge[v] != -1 and bd == slack(bestedge[v]))
-
-    # Check optimized delta3 against a trivial computation.
-    def checkDelta3():
-        bk = -1
-        bd = None
-        tbk = -1
-        tbd = None
-        for b in range(2 * nvertex):
-            if blossomparent[b] == -1 and label[b] == 1:
-                for v in blossomLeaves(b):
-                    for p in neighbend[v]:
-                        k = p // 2
-                        w = endpoint[p]
-                        if inblossom[w] != b and label[inblossom[w]] == 1:
-                            d = slack(k)
-                            if bk == -1 or d < bd:
-                                bk = k
-                                bd = d
-                if bestedge[b] != -1:
-                    (i, j, wt) = edges[bestedge[b]]
-                    assert inblossom[i] == b or inblossom[j] == b
-                    assert inblossom[i] != b or inblossom[j] != b
-                    assert label[inblossom[i]] == 1 and label[inblossom[j]] == 1
-                    if tbk == -1 or slack(bestedge[b]) < tbd:
-                        tbk = bestedge[b]
-                        tbd = slack(bestedge[b])
-        if DEBUG and bd != tbd:
-            DEBUG('bk=%d tbk=%d bd=%s tbd=%s' % (bk, tbk, repr(bd), repr(tbd)))
-        assert bd == tbd
-
-    # Main loop: continue until no further improvement is possible.
-    for t in range(nvertex):
-
-        # Each iteration of this loop is a "stage".
-        # A stage finds an augmenting path and uses that to improve
-        # the matching.
-        if DEBUG: DEBUG('STAGE %d' % t)
-
-        # Remove labels from top-level blossoms/vertices.
-        label[:] = (2 * nvertex) * [ 0 ]
-
-        # Forget all about least-slack edges.
-        bestedge[:] = (2 * nvertex) * [ -1 ]
-        blossombestedges[nvertex:] = nvertex * [ None ]
-
-        # Loss of labeling means that we can not be sure that currently
-        # allowable edges remain allowable througout this stage.
-        allowedge[:] = nedge * [ False ]
-
-        # Make queue empty.
-        queue[:] = [ ]
- 
-        # Label single blossoms/vertices with S and put them in the queue.
-        for v in range(nvertex):
-            if mate[v] == -1 and label[inblossom[v]] == 0:
-                assignLabel(v, 1, -1)
-
-        # Loop until we succeed in augmenting the matching.
-        augmented = 0
-        while 1:
-
-            # Each iteration of this loop is a "substage".
-            # A substage tries to find an augmenting path;
-            # if found, the path is used to improve the matching and
-            # the stage ends. If there is no augmenting path, the
-            # primal-dual method is used to pump some slack out of
-            # the dual variables.
-            if DEBUG: DEBUG('SUBSTAGE')
-
-            # Continue labeling until all vertices which are reachable
-            # through an alternating path have got a label.
-            while queue and not augmented:
-
-                # Take an S vertex from the queue.
-                v = queue.pop()
-                if DEBUG: DEBUG('POP v=%d' % v)
-                assert label[inblossom[v]] == 1
-
-                # Scan its neighbours:
-                for p in neighbend[v]:
-                    k = p // 2
-                    w = endpoint[p]
-                    # w is a neighbour to v
-                    if inblossom[v] == inblossom[w]:
-                        # this edge is internal to a blossom; ignore it
-                        continue
-                    if not allowedge[k]:
-                        kslack = slack(k)
-                        if kslack <= 0:
-                            # edge k has zero slack => it is allowable
-                            allowedge[k] = True
-                    if allowedge[k]:
-                        if label[inblossom[w]] == 0:
-                            # (C1) w is a free vertex;
-                            # label w with T and label its mate with S (R12).
-                            assignLabel(w, 2, p ^ 1)
-                        elif label[inblossom[w]] == 1:
-                            # (C2) w is an S-vertex (not in the same blossom);
-                            # follow back-links to discover either an
-                            # augmenting path or a new blossom.
-                            base = scanBlossom(v, w)
-                            if base >= 0:
-                                # Found a new blossom; add it to the blossom
-                                # bookkeeping and turn it into an S-blossom.
-                                addBlossom(base, k)
-                            else:
-                                # Found an augmenting path; augment the
-                                # matching and end this stage.
-                                augmentMatching(k)
-                                augmented = 1
-                                break
-                        elif label[w] == 0:
-                            # w is inside a T-blossom, but w itself has not
-                            # yet been reached from outside the blossom;
-                            # mark it as reached (we need this to relabel
-                            # during T-blossom expansion).
-                            assert label[inblossom[w]] == 2
-                            label[w] = 2
-                            labelend[w] = p ^ 1
-                    elif label[inblossom[w]] == 1:
-                        # keep track of the least-slack non-allowable edge to
-                        # a different S-blossom.
-                        b = inblossom[v]
-                        if bestedge[b] == -1 or kslack < slack(bestedge[b]):
-                            bestedge[b] = k
-                    elif label[w] == 0:
-                        # w is a free vertex (or an unreached vertex inside
-                        # a T-blossom) but we can not reach it yet;
-                        # keep track of the least-slack edge that reaches w.
-                        if bestedge[w] == -1 or kslack < slack(bestedge[w]):
-                            bestedge[w] = k
-
-            if augmented:
-                break
-
-            # There is no augmenting path under these constraints;
-            # compute delta and reduce slack in the optimization problem.
-            # (Note that our vertex dual variables, edge slacks and delta's
-            # are pre-multiplied by two.)
-            deltatype = -1
-            delta = deltaedge = deltablossom = None
-
-            # Verify data structures for delta2/delta3 computation.
-            if CHECK_DELTA:
-                checkDelta2()
-                checkDelta3()
-
-            # Compute delta1: the minumum value of any vertex dual.
-            if not maxcardinality:
-                deltatype = 1
-                delta = min(dualvar[:nvertex])
-
-            # Compute delta2: the minimum slack on any edge between
-            # an S-vertex and a free vertex.
-            for v in range(nvertex):
-                if label[inblossom[v]] == 0 and bestedge[v] != -1:
-                    d = slack(bestedge[v])
-                    if deltatype == -1 or d < delta:
-                        delta = d
-                        deltatype = 2
-                        deltaedge = bestedge[v]
-
-            # Compute delta3: half the minimum slack on any edge between
-            # a pair of S-blossoms.
-            for b in range(2 * nvertex):
-                if ( blossomparent[b] == -1 and label[b] == 1 and
-                     bestedge[b] != -1 ):
-                    kslack = slack(bestedge[b])
-                    if isinstance(kslack, integer_types):
-                        assert (kslack % 2) == 0
-                        d = kslack // 2
-                    else:
-                        d = kslack / 2
-                    if deltatype == -1 or d < delta:
-                        delta = d
-                        deltatype = 3
-                        deltaedge = bestedge[b]
-
-            # Compute delta4: minimum z variable of any T-blossom.
-            for b in range(nvertex, 2*nvertex):
-                if ( blossombase[b] >= 0 and blossomparent[b] == -1 and
-                     label[b] == 2 and
-                     (deltatype == -1 or dualvar[b] < delta) ):
-                    delta = dualvar[b]
-                    deltatype = 4
-                    deltablossom = b
-
-            if deltatype == -1:
-                # No further improvement possible; max-cardinality optimum
-                # reached. Do a final delta update to make the optimum
-                # verifyable.
-                assert maxcardinality
-                deltatype = 1
-                delta = max(0, min(dualvar[:nvertex]))
-
-            # Update dual variables according to delta.
-            for v in range(nvertex):
-                if label[inblossom[v]] == 1:
-                    # S-vertex: 2*u = 2*u - 2*delta
-                    dualvar[v] -= delta
-                elif label[inblossom[v]] == 2:
-                    # T-vertex: 2*u = 2*u + 2*delta
-                    dualvar[v] += delta
-            for b in range(nvertex, 2*nvertex):
-                if blossombase[b] >= 0 and blossomparent[b] == -1:
-                    if label[b] == 1:
-                        # top-level S-blossom: z = z + 2*delta
-                        dualvar[b] += delta
-                    elif label[b] == 2:
-                        # top-level T-blossom: z = z - 2*delta
-                        dualvar[b] -= delta
-
-            # Take action at the point where minimum delta occurred.
-            if DEBUG: DEBUG('delta%d=%f' % (deltatype, delta))
-            if deltatype == 1: 
-                # No further improvement possible; optimum reached.
-                break
-            elif deltatype == 2:
-                # Use the least-slack edge to continue the search.
-                allowedge[deltaedge] = True
-                (i, j, wt) = edges[deltaedge]
-                if label[inblossom[i]] == 0:
-                    i, j = j, i
-                assert label[inblossom[i]] == 1
-                queue.append(i)
-            elif deltatype == 3:
-                # Use the least-slack edge to continue the search.
-                allowedge[deltaedge] = True
-                (i, j, wt) = edges[deltaedge]
-                assert label[inblossom[i]] == 1
-                queue.append(i)
-            elif deltatype == 4:
-                # Expand the least-z blossom.
-                expandBlossom(deltablossom, False)
-
-            # End of a this substage.
-
-        # Stop when no more augmenting path can be found.
-        if not augmented:
-            break
-
-        # End of a stage; expand all S-blossoms which have dualvar = 0.
-        for b in range(nvertex, 2*nvertex):
-            if ( blossomparent[b] == -1 and blossombase[b] >= 0 and
-                 label[b] == 1 and dualvar[b] == 0 ):
-                expandBlossom(b, True)
-
-    # Verify that we reached the optimum solution.
-    if CHECK_OPTIMUM:
-        verifyOptimum()
-
-    # Transform mate[] such that mate[v] is the vertex to which v is paired.
-    for v in range(nvertex):
-        if mate[v] >= 0:
-            mate[v] = endpoint[mate[v]]
-    for v in range(nvertex):
-        assert mate[v] == -1 or mate[mate[v]] == v
-
-    return mate
-
-
-# Unit tests
-if __name__ == '__main__':
-    import unittest, math
-
-    class MaxWeightMatchingTests(unittest.TestCase):
-
-        def test10_empty(self):
-            # empty input graph
-            self.assertEqual(maxWeightMatching([]), [])
-
-        def test11_singleedge(self):
-            # single edge
-            self.assertEqual(maxWeightMatching([ (0,1,1) ]), [1, 0])
-
-        def test12(self):
-            self.assertEqual(maxWeightMatching([ (1,2,10), (2,3,11) ]), [ -1, -1, 3, 2 ])
-
-        def test13(self):
-            self.assertEqual(maxWeightMatching([ (1,2,5), (2,3,11), (3,4,5) ]), [ -1, -1, 3, 2, -1 ])
-
-        def test14_maxcard(self):
-            # maximum cardinality
-            self.assertEqual(maxWeightMatching([ (1,2,5), (2,3,11), (3,4,5) ], True), [ -1, 2, 1, 4, 3 ])
-
-        def test15_float(self):
-            # floating point weigths
-            self.assertEqual(maxWeightMatching([ (1,2,math.pi), (2,3,math.exp(1)), (1,3,3.0), (1,4,math.sqrt(2.0)) ]), [ -1, 4, 3, 2, 1 ])
-
-        def test16_negative(self):
-            # negative weights
-            self.assertEqual(maxWeightMatching([ (1,2,2), (1,3,-2), (2,3,1), (2,4,-1), (3,4,-6) ], False), [ -1, 2, 1, -1, -1 ])
-            self.assertEqual(maxWeightMatching([ (1,2,2), (1,3,-2), (2,3,1), (2,4,-1), (3,4,-6) ], True), [ -1, 3, 4, 1, 2 ])
-
-        def test20_sblossom(self):
-            # create S-blossom and use it for augmentation
-            self.assertEqual(maxWeightMatching([ (1,2,8), (1,3,9), (2,3,10), (3,4,7) ]), [ -1, 2, 1, 4, 3 ])
-            self.assertEqual(maxWeightMatching([ (1,2,8), (1,3,9), (2,3,10), (3,4,7), (1,6,5), (4,5,6) ]), [ -1, 6, 3, 2, 5, 4, 1 ])
-
-        def test21_tblossom(self):
-            # create S-blossom, relabel as T-blossom, use for augmentation
-            self.assertEqual(maxWeightMatching([ (1,2,9), (1,3,8), (2,3,10), (1,4,5), (4,5,4), (1,6,3) ]), [ -1, 6, 3, 2, 5, 4, 1 ])
-            self.assertEqual(maxWeightMatching([ (1,2,9), (1,3,8), (2,3,10), (1,4,5), (4,5,3), (1,6,4) ]), [ -1, 6, 3, 2, 5, 4, 1 ])
-            self.assertEqual(maxWeightMatching([ (1,2,9), (1,3,8), (2,3,10), (1,4,5), (4,5,3), (3,6,4) ]), [ -1, 2, 1, 6, 5, 4, 3 ])
-
-        def test22_s_nest(self):
-            # create nested S-blossom, use for augmentation
-            self.assertEqual(maxWeightMatching([ (1,2,9), (1,3,9), (2,3,10), (2,4,8), (3,5,8), (4,5,10), (5,6,6) ]), [ -1, 3, 4, 1, 2, 6, 5 ])
-
-        def test23_s_relabel_nest(self):
-            # create S-blossom, relabel as S, include in nested S-blossom
-            self.assertEqual(maxWeightMatching([ (1,2,10), (1,7,10), (2,3,12), (3,4,20), (3,5,20), (4,5,25), (5,6,10), (6,7,10), (7,8,8) ]), [ -1, 2, 1, 4, 3, 6, 5, 8, 7 ])
-
-        def test24_s_nest_expand(self):
-            # create nested S-blossom, augment, expand recursively
-            self.assertEqual(maxWeightMatching([ (1,2,8), (1,3,8), (2,3,10), (2,4,12), (3,5,12), (4,5,14), (4,6,12), (5,7,12), (6,7,14), (7,8,12) ]), [ -1, 2, 1, 5, 6, 3, 4, 8, 7 ])
-
-        def test25_s_t_expand(self):
-            # create S-blossom, relabel as T, expand
-            self.assertEqual(maxWeightMatching([ (1,2,23), (1,5,22), (1,6,15), (2,3,25), (3,4,22), (4,5,25), (4,8,14), (5,7,13) ]), [ -1, 6, 3, 2, 8, 7, 1, 5, 4 ])
-
-        def test26_s_nest_t_expand(self):
-            # create nested S-blossom, relabel as T, expand
-            self.assertEqual(maxWeightMatching([ (1,2,19), (1,3,20), (1,8,8), (2,3,25), (2,4,18), (3,5,18), (4,5,13), (4,7,7), (5,6,7) ]), [ -1, 8, 3, 2, 7, 6, 5, 4, 1 ])
-
-        def test30_tnasty_expand(self):
-            # create blossom, relabel as T in more than one way, expand, augment
-            self.assertEqual(maxWeightMatching([ (1,2,45), (1,5,45), (2,3,50), (3,4,45), (4,5,50), (1,6,30), (3,9,35), (4,8,35), (5,7,26), (9,10,5) ]), [ -1, 6, 3, 2, 8, 7, 1, 5, 4, 10, 9 ])
-
-        def test31_tnasty2_expand(self):
-            # again but slightly different
-            self.assertEqual(maxWeightMatching([ (1,2,45), (1,5,45), (2,3,50), (3,4,45), (4,5,50), (1,6,30), (3,9,35), (4,8,26), (5,7,40), (9,10,5) ]), [ -1, 6, 3, 2, 8, 7, 1, 5, 4, 10, 9 ])
-
-        def test32_t_expand_leastslack(self):
-            # create blossom, relabel as T, expand such that a new least-slack S-to-free edge is produced, augment
-            self.assertEqual(maxWeightMatching([ (1,2,45), (1,5,45), (2,3,50), (3,4,45), (4,5,50), (1,6,30), (3,9,35), (4,8,28), (5,7,26), (9,10,5) ]), [ -1, 6, 3, 2, 8, 7, 1, 5, 4, 10, 9 ])
-
-        def test33_nest_tnasty_expand(self):
-            # create nested blossom, relabel as T in more than one way, expand outer blossom such that inner blossom ends up on an augmenting path
-            self.assertEqual(maxWeightMatching([ (1,2,45), (1,7,45), (2,3,50), (3,4,45), (4,5,95), (4,6,94), (5,6,94), (6,7,50), (1,8,30), (3,11,35), (5,9,36), (7,10,26), (11,12,5) ]), [ -1, 8, 3, 2, 6, 9, 4, 10, 1, 5, 7, 12, 11 ])
-
-        def test34_nest_relabel_expand(self):
-            # create nested S-blossom, relabel as S, expand recursively
-            self.assertEqual(maxWeightMatching([ (1,2,40), (1,3,40), (2,3,60), (2,4,55), (3,5,55), (4,5,50), (1,8,15), (5,7,30), (7,6,10), (8,10,10), (4,9,30) ]), [ -1, 2, 1, 5, 9, 3, 7, 6, 10, 4, 8 ])
-
-    CHECK_DELTA = True
-    unittest.main()
-
-# end