/**
* Scale weights in the graph
*
* @param g {@link BipartiteGraph}
* @param c2 first {@link EdgeArray}
* @param c1 second {@link EdgeArray}
* @param f value
* @return <code>true</code> is none of the edges properties in the two array are equal
*/
private boolean scaleWeights(final BipartiteGraph g, final EdgeArray c2, EdgeArray c1, double f) {
Edge e;
double C = 0;
Iterator<Edge> edgesIterator = g.getEdgesIterator();
while (edgesIterator.hasNext()) {
e = (Edge) edgesIterator.next();
C = Math.max(C, fabs((((Double) c2.getEdgeProperty(e)).doubleValue())));
}
double S = computeS(f, C);
boolean noScaling = true;
edgesIterator = g.getEdgesIterator();
while (edgesIterator.hasNext()) {
e = (Edge) edgesIterator.next();
c1.setEdgeProperty(
e, new Double(scaleWeight(((Double) c2.getEdgeProperty(e)).doubleValue(), S)));
if (((Double) c2.getEdgeProperty(e)).doubleValue()
!= ((Double) c1.getEdgeProperty(e)).doubleValue()) noScaling = false;
}
return noScaling;
}
/**
* Run the algorithm
*
* @return an {@link EdgesSet}
*/
public EdgesSet runAlgorithm() {
EdgesSet result = new EdgesSet(g.getEdgesSet().getVc());
// for all nodes(v,G) pot[v] = 0;
// this will be done by giving pot:= VertexArray(g,new Double(0))
if (g.getEdgesSet().isEmpty()) return new EdgesSet(g.getEdgesSet().getVc());
// check that all edges are directed from A to B
// this should be a precondition also
VertexArray free = new VertexArray(g, new Boolean(true));
VertexArray pred = new VertexArray(g, null);
VertexArray dist = new VertexArray(g, new Double(0));
VertexPQ PQ = new VertexPQ(g);
switch (heuristic) {
case NAIVE_HEURISTIC:
Double C = new Double(0);
Iterator<Edge> edgesIterator = g.getEdgesIterator();
while (edgesIterator.hasNext()) {
Edge e = edgesIterator.next();
Double edgeC = (Double) c.getEdgeProperty(e);
if (edgeC.compareTo(C) == 1) // bigger than...
C = edgeC;
}
Iterator<Vertex> leftVertexesIterator = g.getLeftVertexSetIterator();
while (leftVertexesIterator.hasNext()) {
pot.setVertexProperty(leftVertexesIterator.next(), C);
}
break;
case SIMPLE_HEURISTIC:
Iterator<Vertex> leftVertexesIterator1 = g.getLeftVertexSetIterator();
while (leftVertexesIterator1.hasNext()) {
Vertex a = leftVertexesIterator1.next();
Edge eMax = null;
double C_max = 0;
Iterator<Edge> vertexAdjEdgesIterator =
GraphUtilities.getVertexAdjEdges(g, a).getMembers().iterator();
while (vertexAdjEdgesIterator.hasNext()) {
Edge e = vertexAdjEdgesIterator.next();
if (((Double) c.getEdgeProperty(e)).doubleValue() > C_max) {
eMax = e;
C_max = ((Double) c.getEdgeProperty(e)).doubleValue();
}
}
pot.setVertexProperty(a, new Double(C_max));
Vertex b;
if (eMax != null
&& ((Boolean)
free.getVertexProperty((b = GraphUtilities.getEdgeTargetVertex(g, eMax))))
.booleanValue()) {
eMax.turnOverEdgeDirection();
free.setVertexProperty(a, new Boolean(false));
free.setVertexProperty(b, new Boolean(false));
}
}
break;
default:
// REFINED_HEURISTIC
mwbmHeuristic(g, c, pot, free);
break;
}
Iterator<Vertex> leftVertexesIterator = g.getLeftVertexSetIterator();
while (leftVertexesIterator.hasNext()) {
Vertex a = leftVertexesIterator.next();
if (((Boolean) free.getVertexProperty(a)).booleanValue())
augment(g, a, c, pot, free, pred, dist, PQ);
}
Iterator<Vertex> rightVertexesIterator = g.getRightVertexSetIterator();
while (rightVertexesIterator.hasNext()) {
Vertex b = rightVertexesIterator.next();
Iterator<Edge> outEdgesIterator =
GraphUtilities.getVertexOutEdges(g, b).getMembers().iterator();
while (outEdgesIterator.hasNext()) {
result.addMember(outEdgesIterator.next());
}
}
result.turnOverEdges(false);
return result;
}
/**
* The maximum weight bipartite matching heuristis
*
* @param g {@link BipartiteGraph}
* @param c an {@link EdgeArray}
* @param pot a {@link VertexArray}
* @param free free {@link VertexArray}
*/
private void mwbmHeuristic(BipartiteGraph g, EdgeArray c, VertexArray pot, VertexArray free) {
Vertex a, b;
Edge e, e2, eb;
VertexArray secEdge = new VertexArray(g, null);
Iterator<Vertex> leftVertexSetIterator = g.getLeftVertexSetIterator();
while (leftVertexSetIterator.hasNext()) {
a = (Vertex) leftVertexSetIterator.next();
double max2 = 0, max = 0;
eb = null;
e2 = null;
// compute edges with largest and second largest slack
Iterator<Edge> aAdjEdgesIterator =
GraphUtilities.getVertexAdjEdges(g, a).getMembers().iterator();
while (aAdjEdgesIterator.hasNext()) {
e = (Edge) aAdjEdgesIterator.next();
double we =
((Double) c.getEdgeProperty(e)).doubleValue()
- ((Double) pot.getVertexProperty(GraphUtilities.getEdgeTargetVertex(g, e)))
.doubleValue();
if (we >= max2) {
if (we >= max) {
max2 = max;
e2 = eb;
max = we;
eb = e;
} else {
max2 = we;
e2 = e;
}
}
}
if (eb != null) {
b = GraphUtilities.getEdgeTargetVertex(g, eb);
if (((Boolean) free.getVertexProperty(b)).booleanValue()) {
// match eb and change pot[] to make slack of e2 zero
secEdge.setVertexProperty(a, e2);
pot.setVertexProperty(a, new Double(max2));
pot.setVertexProperty(b, new Double(max - max2));
eb.turnOverEdgeDirection();
free.setVertexProperty(a, new Boolean(false));
free.setVertexProperty(b, new Boolean(false));
} else {
// try to augment matching along
// path of length 3 given by sec_edge[]
pot.setVertexProperty(a, new Double(max));
e2 = GraphUtilities.getVertexFirstAdjEdge(g, b);
e = (Edge) secEdge.getVertexProperty(GraphUtilities.getEdgeTargetVertex(g, e2));
if (e != null
&& GraphUtilities.getVertexOutDeg(g, GraphUtilities.getEdgeTargetVertex(g, e)) == 0) {
free.setVertexProperty(a, new Boolean(false));
free.setVertexProperty(GraphUtilities.getEdgeTargetVertex(g, e), new Boolean(false));
e.turnOverEdgeDirection();
e2.turnOverEdgeDirection();
eb.turnOverEdgeDirection();
}
}
} else {
pot.setVertexProperty(a, new Double(0));
}
}
}