/// <summary>
/// Transposes the actual graph. The direction of all edges is inverted.
/// </summary>
public void Transpose()
{
foreach (DirectedGraphEdge edge in this.EdgesList)
{
string key = edge.From + "," + edge.To;
string keyReverse = edge.To + "," + edge.From;
bool occursTwice = this._edges.ContainsKey(keyReverse);
if (occursTwice && key.CompareTo(keyReverse) < 0)
{
double tempCost = this._edges[keyReverse].Cost;
this._edges[keyReverse].Cost = this._edges[key].Cost;
this._edges[key].Cost = tempCost;
}
else if (!occursTwice)
{
this._edges.Remove(edge.From + "," + edge.To);
DirectedGraphEdge tempEdge = (DirectedGraphEdge)edge.Clone();
tempEdge.Transpose();
this._edges.Add(edge.To + "," + edge.From, tempEdge);
}
//Console.WriteLine("Reverted edge (" + edge.From + ","
// + edge.To + ") to edge (" + key + ").");
}
}
public bool AdditionalEdgeInducesDirectedCycle(DirectedGraphEdge additionalEdge)
{
DirectedGraph tempGraph = (DirectedGraph)this.Clone();
tempGraph.AddEdge(additionalEdge);
tempGraph.ComputeStronglyConnectedComponents(null);
List <GraphNode> query = (from node1 in tempGraph.Nodes
from node2 in tempGraph.Nodes
where ((!node1.Name.Equals(node2.Name)) &&
node1.ComponentNumber == node2.ComponentNumber)
select node1).ToList();
return(query != null && query.Count() > 0);
}
/// <summary>
/// Adds an edge to the graph. If an edge (u,v) already exists,
/// nothing is done. Use UpdateEdgeWeights to change the weights of existing
/// edges. The return value of this function signalizes, whether the edge was added
/// or not.
/// </summary>
/// <param name="edge"></param>
/// <returns>true if edge was added, false otherwise</returns>
public bool AddEdge(DirectedGraphEdge edge)
{
string tempKey = edge.From + "," + edge.To;
if (!this._edges.ContainsKey(tempKey))
{
this._edges.Add(tempKey, edge);
return(true);
}
else
{
return(false);
}
}
public bool EdgeReversalInducesDirectedCycle(DirectedGraphEdge edge)
{
DirectedGraph tempGraph = (DirectedGraph)this.Clone();
tempGraph.RemoveEdge(edge.From, edge.To);
tempGraph.AddEdge(new DirectedGraphEdge(edge.To, edge.From, edge.Cost));
tempGraph.ComputeStronglyConnectedComponents(null);
List <GraphNode> query = (from node1 in tempGraph.Nodes
from node2 in tempGraph.Nodes
where ((!node1.Name.Equals(node2.Name)) &&
node1.ComponentNumber == node2.ComponentNumber)
select node1).ToList();
return(query != null && query.Count() > 0);
}
public void UpdateEdgeName(string key, string newFrom, string newTo)
{
if (this._edges.ContainsKey(key))
{
DirectedGraphEdge tempEdge = new DirectedGraphEdge(newFrom, newTo, 0);
if (!this._edges.ContainsKey(tempEdge.Key))
{
tempEdge = this._edges[key];
this._edges.Remove(key);
tempEdge.ChangeEdgeFrom(newFrom);
tempEdge.ChangeEdgeTo(newTo);
this._edges.Add(tempEdge.Key, tempEdge);
}
}
}
/// <summary>
/// Helper function, which is used by ComputeCompelledAndReversibleEdges()
/// </summary>
/// <param name="edge"></param>
/// <param name="reversibleEdges"></param>
private void _addReversibleEdge(DirectedGraphEdge edge,
ref Dictionary <string, List <DirectedGraphEdge> > reversibleEdges)
{
if (edge.Label == GraphEdgeLabel.UNLABELLED)
{
edge.Label = GraphEdgeLabel.REVERSIBLE;
if (reversibleEdges.ContainsKey(edge.To))
{
reversibleEdges[edge.To].Add(edge);
}
else
{
List <DirectedGraphEdge> tempReversibleEdges = new List <DirectedGraphEdge>();
tempReversibleEdges.Add(edge);
reversibleEdges.Add(edge.To, tempReversibleEdges);
}
}
}
/// <summary>
/// Helper function, which is used by ComputeCompelledAndReversibleEdges()
/// </summary>
/// <param name="edge"></param>
/// <param name="compelledEdges"></param>
private void _addCompelledEdge(DirectedGraphEdge edge,
ref Dictionary <string, List <DirectedGraphEdge> > compelledEdges)
{
if (edge.Label == GraphEdgeLabel.UNLABELLED)
{
edge.Label = GraphEdgeLabel.COMPLELLED;
if (compelledEdges.ContainsKey(edge.To))
{
compelledEdges[edge.To].Add(edge);
}
else
{
List <DirectedGraphEdge> tempCompelledEdges = new List <DirectedGraphEdge>();
tempCompelledEdges.Add(edge);
compelledEdges.Add(edge.To, tempCompelledEdges);
}
}
}
public void ComputeCompelledAndReversibleEdges()
{
List <DirectedGraphEdge> orderedEdges = this._getOrderedEdges();
Dictionary <string, List <DirectedGraphEdge> > reversibleEdges = new Dictionary <string, List <DirectedGraphEdge> >();
Dictionary <string, List <DirectedGraphEdge> > compelledEdges = new Dictionary <string, List <DirectedGraphEdge> >();
Dictionary <string, List <DirectedGraphEdge> > unlabelledEdges = new Dictionary <string, List <DirectedGraphEdge> >();
bool doneForThisCycle = false;
foreach (var edge in orderedEdges)
{
edge.Label = GraphEdgeLabel.UNLABELLED;
if (unlabelledEdges.ContainsKey(edge.To))
{
unlabelledEdges[edge.To].Add(edge);
}
else
{
List <DirectedGraphEdge> tempEdges = new List <DirectedGraphEdge>();
tempEdges.Add(edge);
unlabelledEdges.Add(edge.To, tempEdges);
}
}
foreach (DirectedGraphEdge edge in orderedEdges)
{
if (edge.Label == GraphEdgeLabel.UNLABELLED)
{
doneForThisCycle = false;
if (compelledEdges.ContainsKey(edge.From))
{
List <DirectedGraphEdge> tempCompelledEdges = compelledEdges[edge.From];
foreach (DirectedGraphEdge compelledEdge in tempCompelledEdges)
{
string tempKey = compelledEdge.From + "," + edge.To;
if (!this._edges.ContainsKey(tempKey))
{
if (edge.Label != GraphEdgeLabel.COMPLELLED)
{
this._addCompelledEdge(edge, ref compelledEdges);
unlabelledEdges[edge.To].Remove(edge);
}
if (unlabelledEdges.ContainsKey(edge.To))
{
foreach (DirectedGraphEdge tempEdge in unlabelledEdges[edge.To])
{
this._addCompelledEdge(tempEdge, ref compelledEdges);
}
unlabelledEdges.Remove(edge.To);
}
doneForThisCycle = true;
}
else
{
DirectedGraphEdge tempEdge = this._edges[tempKey];
if (tempEdge.Label == GraphEdgeLabel.UNLABELLED)
{
this._addCompelledEdge(tempEdge, ref compelledEdges);
unlabelledEdges[tempEdge.To].Remove(tempEdge);
}
}
}
}
if (!doneForThisCycle)
{
IEnumerable <DirectedGraphEdge> query =
from queryEdge in Edges
where queryEdge.To == edge.To && queryEdge.From != edge.From
select queryEdge;
bool containsSpecialEdge = false;
foreach (DirectedGraphEdge testEdge in query)
{
string tempKey = testEdge.From + "," + edge.From;
if (!this._edges.ContainsKey(tempKey))
{
containsSpecialEdge = true;
break;
}
}
if (containsSpecialEdge)
{
this._addCompelledEdge(edge, ref compelledEdges);
unlabelledEdges[edge.To].Remove(edge);
if (unlabelledEdges.ContainsKey(edge.To))
{
foreach (DirectedGraphEdge tempEdge in unlabelledEdges[edge.To])
{
this._addCompelledEdge(tempEdge, ref compelledEdges);
}
unlabelledEdges.Remove(edge.To);
}
}
else
{
this._addReversibleEdge(edge, ref reversibleEdges);
unlabelledEdges[edge.To].Remove(edge);
if (unlabelledEdges.ContainsKey(edge.To))
{
foreach (DirectedGraphEdge tempEdge in unlabelledEdges[edge.To])
{
this._addReversibleEdge(tempEdge, ref reversibleEdges);
}
unlabelledEdges.Remove(edge.To);
}
}
}
}
}
}
public List <string> SampleOrder()
{
DirectedGraph tempGraph = (DirectedGraph)this._restrictionGraph.Clone();
List <string> orderedNodes = new List <string>();
int[][] tempRestrictionMatrix = (int[][])this._standardRestrictionMatrix.Clone();
double sum = 0;
double randomNumber = 0;
double tempSum = 0;
int index = 0;
List <Tuple <double, Tuple <uint, uint> > > choices = _getPossibleChoices(tempRestrictionMatrix, ref sum);
while (choices.Count > 0)
{
index = 0;
// if all allowed choices in M are zero, we draw the index from a uniform distribution
// otherwise, the entry M[i,j] is proportional to its probability to be chosen
if (sum - 0.0001 < 0 && sum + 0.0001 > 0)
{
index = _randomNumbers.Next(choices.Count);
}
else
{
randomNumber = ((double)this._randomNumbers.Next()) / Int32.MaxValue * sum;
//find choice that corresponds to random number
tempSum = 0;
do
{
tempSum += choices[index++].Item1;
}while (index < choices.Count && tempSum < randomNumber - 0.0001);
// this should not happen
if (index == choices.Count)
{
--index;
}
}
//add edge to restriction graph
DirectedGraphEdge chosenEdge = new DirectedGraphEdge(this._indexToName[choices[index].Item2.Item1],
this._indexToName[choices[index].Item2.Item2],
0);
tempGraph.AddEdge(chosenEdge);
//update restrictions
HashSet <string> newChildren = tempGraph.GetReachableNodes(chosenEdge.To);
newChildren.Add(chosenEdge.To);
tempRestrictionMatrix[this._nameToIndex[chosenEdge.From]][this._nameToIndex[chosenEdge.To]] = 1;
HashSet <string> ancestors = tempGraph.GetAncestors(chosenEdge.From);
foreach (string newChild in newChildren)
{
tempRestrictionMatrix[this._nameToIndex[newChild]][this._nameToIndex[chosenEdge.From]] = 1;
foreach (string ancestor in ancestors)
{
tempRestrictionMatrix[this._nameToIndex[newChild]][this._nameToIndex[ancestor]] = 1;
}
}
// prepare next round
sum = 0;
choices = _getPossibleChoices(tempRestrictionMatrix, ref sum);
}
// if there are no free choices, tempGraph contains all choices and has therefore a unique topological order
return(tempGraph.GetTopologicalOrder());
}
