public void TryGetDistance_Throws()
{
var graph = new AdjacencyGraph <TestVertex, Edge <TestVertex> >();
var algorithm = new FloydWarshallAllShortestPathAlgorithm <TestVertex, Edge <TestVertex> >(graph, edge => 1.0);
var vertex = new TestVertex();
// ReSharper disable AssignNullToNotNullAttribute
Assert.Throws <ArgumentNullException>(() => algorithm.TryGetDistance(vertex, null, out _));
Assert.Throws <ArgumentNullException>(() => algorithm.TryGetDistance(null, vertex, out _));
Assert.Throws <ArgumentNullException>(() => algorithm.TryGetDistance(null, null, out _));
// ReSharper restore AssignNullToNotNullAttribute
}
public void Evaluate(int SpreadMax)
{
if (FComp[0])
{
alg = new FloydWarshallAllShortestPathAlgorithm <Message, MessageEdge>(FGraph[0], edge => 1);
//alg.SetRootVertex(FRef[0]);
alg.Finished += (sender, args) =>
{
FDist.SliceCount = FVerts.SliceCount;
FSucc.SliceCount = FVerts.SliceCount;
for (int i = 0; i < FVerts.SliceCount; i++)
{
double result = -1;
FSucc[i] = alg.TryGetDistance(FRef[0], FVerts[i], out result);
FDist[i] = result;
}
};
if (FAsync[0])
{
Task.Run(() => alg.Compute());
}
else
{
alg.Compute();
}
}
FState[0] = alg?.State.ToString();
}
public void Compute()
{
var distances = new Dictionary <Edge <char>, double>();
var g = CreateGraph(distances);
var fw = new FloydWarshallAllShortestPathAlgorithm <char, Edge <char> >(g, e => distances[e]);
fw.Compute();
fw.Dump(Console.Out);
foreach (var i in g.Vertices)
{
foreach (var j in g.Vertices)
{
Console.Write("{0} -> {1}:", i, j);
IEnumerable <Edge <char> > path;
if (fw.TryGetPath(i, j, out path))
{
double cost = 0;
foreach (var edge in path)
{
Console.Write("{0}, ", edge.Source);
cost += distances[edge];
}
Console.Write("{0} --- {1}", j, cost);
}
Console.WriteLine();
}
}
{
double distance;
Assert.IsTrue(fw.TryGetDistance('A', 'A', out distance));
Assert.AreEqual(0, distance);
Assert.IsTrue(fw.TryGetDistance('A', 'B', out distance));
Assert.AreEqual(6, distance);
Assert.IsTrue(fw.TryGetDistance('A', 'C', out distance));
Assert.AreEqual(1, distance);
Assert.IsTrue(fw.TryGetDistance('A', 'D', out distance));
Assert.AreEqual(4, distance);
Assert.IsTrue(fw.TryGetDistance('A', 'E', out distance));
Assert.AreEqual(5, distance);
}
}
public void TryGetDistance()
{
const int vertex1 = 1;
const int vertex2 = 2;
const int vertex3 = 3;
var graph = new AdjacencyGraph <int, Edge <int> >();
graph.AddVerticesAndEdge(new Edge <int>(vertex1, vertex2));
graph.AddVertex(vertex3);
var algorithm = new FloydWarshallAllShortestPathAlgorithm <int, Edge <int> >(graph, edge => 1.0);
Assert.IsFalse(algorithm.TryGetDistance(vertex1, vertex2, out _));
Assert.IsFalse(algorithm.TryGetDistance(vertex1, vertex3, out _));
algorithm.Compute();
Assert.IsTrue(algorithm.TryGetDistance(vertex1, vertex2, out double distance));
Assert.AreEqual(1, distance);
Assert.IsFalse(algorithm.TryGetDistance(vertex1, vertex3, out _));
}
public void FloydWarshallSimpleGraph()
{
var distances = new Dictionary <Edge <char>, double>();
AdjacencyGraph <char, Edge <char> > graph = CreateGraph(distances);
var algorithm = new FloydWarshallAllShortestPathAlgorithm <char, Edge <char> >(graph, e => distances[e]);
algorithm.Compute();
Assert.IsTrue(algorithm.TryGetDistance('A', 'A', out double distance));
Assert.AreEqual(0, distance);
Assert.IsTrue(algorithm.TryGetDistance('A', 'B', out distance));
Assert.AreEqual(6, distance);
Assert.IsTrue(algorithm.TryGetDistance('A', 'C', out distance));
Assert.AreEqual(1, distance);
Assert.IsTrue(algorithm.TryGetDistance('A', 'D', out distance));
Assert.AreEqual(4, distance);
Assert.IsTrue(algorithm.TryGetDistance('A', 'E', out distance));
Assert.AreEqual(5, distance);
}
public static List <KeyValuePair <(string, 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 FloydWarshallAllShortestPathAlgorithm <string, TaggedEdge <string, string> >(graph, Weights);
algorithm.Compute();
var results = new List <KeyValuePair <(string, string), double> >();
foreach (var v in graph.Vertices)
{
double distance = double.PositiveInfinity;
algorithm.TryGetDistance(root, v, out distance);
results.Add(new KeyValuePair <(string, string), double>((root, v), distance));
}
return(results);
}
public static List <KeyValuePair <(int, int), double> > Get(AdjacencyGraph <int, Edge <int> > graph, int root)
{
Func <Edge <int>, double> Weights = e => 1.0;
var algorithm = new FloydWarshallAllShortestPathAlgorithm <int, Edge <int> >(graph, Weights);
algorithm.Compute();
var results = new List <KeyValuePair <(int, int), double> >();
foreach (var v in graph.Vertices)
{
double distance = double.PositiveInfinity;
algorithm.TryGetDistance(root, v, out distance);
results.Add(new KeyValuePair <(int, int), double>((root, v), distance));
}
return(results);
}
