internal static Dictionary <string, double> Ancestor(Graph weightedDirectedGraph)
{
var tempGraph = new Graph();
var resultDictionary = new Dictionary <string, double>();
//Create negative weighted directed graph
tempGraph.AddVertexRange(weightedDirectedGraph.Vertices);
tempGraph.AddEdgeRange(weightedDirectedGraph.Edges.Select(x => new Edge(x.Name, x.Source, x.Target, -x.Weight)));
//Solve shortest path of Top -> vertex
var algorithm = new BellmanFordShortestPathAlgorithm <string, Edge>(tempGraph, e => e.Weight);
var pred = new VertexPredecessorRecorderObserver <string, Edge>();
pred.Attach(algorithm);
foreach (var vertex in tempGraph.Vertices)
{
algorithm.Compute("Top");
IEnumerable <Edge> path;
pred.TryGetPath(vertex, out path);
if (path != null)
{
resultDictionary[vertex] = -path.Sum(a => a.Weight);
}
}
return(resultDictionary);
}
public static TryFunc <TVertex, IEnumerable <TEdge> > ShortestPathsBellmanFord <TVertex, TEdge>(
#if !NET20
this
#endif
IVertexAndEdgeListGraph <TVertex, TEdge> visitedGraph,
Func <TEdge, double> edgeWeights,
TVertex source
)
where TEdge : IEdge <TVertex>
{
Contract.Requires(visitedGraph != null);
Contract.Requires(edgeWeights != null);
Contract.Requires(source != null);
var algorithm = new BellmanFordShortestPathAlgorithm <TVertex, TEdge>(visitedGraph, edgeWeights);
var predecessorRecorder = new VertexPredecessorRecorderObserver <TVertex, TEdge>();
using (predecessorRecorder.Attach(algorithm))
algorithm.Compute(source);
var predecessors = predecessorRecorder.VertexPredecessors;
return(delegate(TVertex v, out IEnumerable <TEdge> edges)
{
return EdgeExtensions.TryGetPath(predecessors, v, out edges);
});
}
public static IDictionary <int, double> Get(AdjacencyGraph <int, Edge <int> > graph, int root)
{
Func <Edge <int>, double> Weights = e => 1.0;
var algorithm = new BellmanFordShortestPathAlgorithm <int, Edge <int> >(graph, Weights);
algorithm.Compute(root);
return(algorithm.Distances);
}
public static IDictionary <string, double> Get(AdjacencyGraph <string, TaggedEdge <string, string> > graph, string root)
{
Func <TaggedEdge <string, string>, double> Weights = e => double.Parse(e.Tag);
var algorithm = new BellmanFordShortestPathAlgorithm <string, TaggedEdge <string, string> >(graph, Weights);
algorithm.Compute(root);
return(algorithm.Distances);
}
public void GetVertexColor_Throws()
{
var graph = new AdjacencyGraph <int, Edge <int> >();
graph.AddVertex(0);
var algorithm = new BellmanFordShortestPathAlgorithm <int, Edge <int> >(graph, edge => 1.0);
algorithm.Compute(0);
// ReSharper disable once ReturnValueOfPureMethodIsNotUsed
Assert.Throws <VertexNotFoundException>(() => algorithm.GetVertexColor(1));
}
public void GetVertexColor()
{
var graph = new AdjacencyGraph <int, Edge <int> >();
graph.AddVerticesAndEdge(new Edge <int>(1, 2));
var algorithm = new BellmanFordShortestPathAlgorithm <int, Edge <int> >(graph, _ => 1.0);
algorithm.Compute(1);
Assert.AreEqual(GraphColor.Black, algorithm.GetVertexColor(1));
Assert.AreEqual(GraphColor.Black, algorithm.GetVertexColor(2));
}
public static BellmanFordShortestPathAlgorithm <T, Edge <T> > CreateAlgorithmAndMaybeDoComputation <T>(
[NotNull] ContractScenario <T> scenario)
{
var graph = new AdjacencyGraph <T, Edge <T> >();
graph.AddVerticesAndEdgeRange(scenario.EdgesInGraph.Select(e => new Edge <T>(e.Source, e.Target)));
graph.AddVertexRange(scenario.SingleVerticesInGraph);
double Weights(Edge <T> e) => 1.0;
var algorithm = new BellmanFordShortestPathAlgorithm <T, Edge <T> >(graph, Weights);
if (scenario.DoComputation)
{
algorithm.Compute(scenario.Root);
}
return(algorithm);
}
//public void FindPath(string @from = "START", string @to = "END")
//{
// Func<Edge<string>, double> edgeCost = AlgorithmExtensions.GetIndexer(EdgeCost);
// // Positive or negative weights
// TryFunc<string, System.Collections.Generic.IEnumerable<Edge<string>>> tryGetPath = Graph.ShortestPathsBellmanFord(edgeCost, @from);
// IEnumerable<Edge<string>> path;
// if (tryGetPath(@to, out path))
// {
// Console.Write("Path found from {0} to {1}: {0}", @from, @to);
// foreach (var e in path) { Console.Write(" > {0}", e.Target); }
// Console.WriteLine();
// }
// else { Console.WriteLine("No path found from {0} to {1}."); }
//}
public double GetETA(string start = "A")
{
Func <Edge <Vertex>, double> edgeCost = e => this.edgeCostList[e];
// Bellman algorithm works with either positive or negative weights
BellmanFordShortestPathAlgorithm <Vertex, Edge <Vertex> > pathCalc = new BellmanFordShortestPathAlgorithm <Vertex, Edge <Vertex> >(this.graph, edgeCost);
Vertex source = nodeMap[start];
Vertex target = nodeMap["Z"];
pathCalc.Compute(source);
var distances = pathCalc.Distances;
var distanceToTarget = 0 - distances[target];
return(distanceToTarget);
}
private static void RunBellmanFordAndCheck <TVertex, TEdge>(
[NotNull] IVertexAndEdgeListGraph <TVertex, TEdge> graph,
[NotNull] TVertex root)
where TEdge : IEdge <TVertex>
{
var distances = new Dictionary <TEdge, double>();
foreach (TEdge edge in graph.Edges)
{
distances[edge] = graph.OutDegree(edge.Source) + 1;
}
var algorithm = new BellmanFordShortestPathAlgorithm <TVertex, TEdge>(
graph,
e => distances[e]);
algorithm.InitializeVertex += vertex =>
{
Assert.AreEqual(GraphColor.White, algorithm.VerticesColors[vertex]);
};
var predecessors = new VertexPredecessorRecorderObserver <TVertex, TEdge>();
using (predecessors.Attach(algorithm))
algorithm.Compute(root);
Assert.AreEqual(graph.VertexCount, algorithm.VerticesColors.Count);
foreach (TVertex vertex in graph.Vertices)
{
Assert.AreEqual(GraphColor.Black, algorithm.VerticesColors[vertex]);
}
Assert.IsFalse(algorithm.FoundNegativeCycle);
CollectionAssert.IsNotEmpty(algorithm.GetDistances());
Assert.AreEqual(graph.VertexCount, algorithm.GetDistances().Count());
Verify(algorithm, predecessors);
}
public void BellmanFord_NegativeCycle()
{
// Without negative cycle
var edge12 = new Edge <int>(1, 2);
var edge23 = new Edge <int>(2, 3);
var edge34 = new Edge <int>(3, 4);
var negativeWeightGraph = new AdjacencyGraph <int, Edge <int> >();
negativeWeightGraph.AddVerticesAndEdgeRange(new[]
{
edge12, edge23, edge34
});
var algorithm = new BellmanFordShortestPathAlgorithm <int, Edge <int> >(
negativeWeightGraph,
e =>
{
if (e == edge12)
{
return(12.0);
}
if (e == edge23)
{
return(-23.0);
}
if (e == edge34)
{
return(-34.0);
}
return(1.0);
});
Assert.DoesNotThrow(() => algorithm.Compute(1));
Assert.IsFalse(algorithm.FoundNegativeCycle);
// With negative cycle
var edge41 = new Edge <int>(4, 1);
var negativeCycleGraph = new AdjacencyGraph <int, Edge <int> >();
negativeCycleGraph.AddVerticesAndEdgeRange(new[]
{
edge12, edge23, edge34, edge41
});
algorithm = new BellmanFordShortestPathAlgorithm <int, Edge <int> >(
negativeCycleGraph,
e =>
{
if (e == edge12)
{
return(12.0);
}
if (e == edge23)
{
return(-23.0);
}
if (e == edge34)
{
return(-34.0);
}
if (e == edge41)
{
return(41.0);
}
return(1.0);
});
Assert.DoesNotThrow(() => algorithm.Compute(1));
Assert.IsTrue(algorithm.FoundNegativeCycle);
}