public void NoPath()
{
ImmutableHashSet <TestVertex> set1 = new HashSet <TestVertex>()
{
A, B, C, D
}.ToImmutableHashSet();
ImmutableHashSet <TestEdge> set2 = new HashSet <TestEdge>()
{
new TestEdge(A, B, W1),
new TestEdge(B, A, W1),
new TestEdge(C, D, W1),
new TestEdge(D, C, W1),
}.ToImmutableHashSet();
Graph = new TestAdjacencyListsGraph(set1, set2);
TestAbstractGraphPathSearch gs = GraphSearch;
ISet <IPath <TestVertex, TestEdge> > paths = gs.Search(Graph, A, B, Weigher, 1).Paths;
PrintPaths(paths);
Assert.Equal(1, paths.Count);
Assert.Equal(new TestDoubleWeight(1.0), paths.First().Cost);
paths = gs.Search(Graph, A, D, Weigher, 1).Paths;
PrintPaths(paths);
Assert.Equal(0, paths.Count);
paths = gs.Search(Graph, A, null, Weigher, 1).Paths;
PrintPaths(paths);
Assert.Equal(1, paths.Count);
Assert.Equal(new TestDoubleWeight(1.0), paths.First().Cost);
}
public void NegativeWeights()
{
ImmutableHashSet <TestVertex> set1 = new HashSet <TestVertex>()
{
A, B, C, D, E, F, G
}.ToImmutableHashSet();
ImmutableHashSet <TestEdge> set2 = new HashSet <TestEdge>()
{
new TestEdge(A, B, W1),
new TestEdge(A, C, NW1),
new TestEdge(B, D, W1),
new TestEdge(D, A, NW2),
new TestEdge(C, D, W1),
new TestEdge(D, E, W1),
new TestEdge(D, F, W1),
new TestEdge(E, G, W1),
new TestEdge(F, G, W1),
new TestEdge(G, A, NW5),
new TestEdge(A, G, W4),
}.ToImmutableHashSet();
Graph = new TestAdjacencyListsGraph(set1, set2);
ExecuteSearch(GraphSearch, Graph, A, G, Weigher, 3, new TestDoubleWeight(4.0));
ExecuteSinglePathSearch(GraphSearch, Graph, A, G, Weigher, 1, new TestDoubleWeight(4.0));
}
public void ComplexGraph()
{
SetDefaultWeights();
var aB = new TestEdge(A, B);
var bC = new TestEdge(B, C);
var aD = new TestEdge(A, D);
var dC = new TestEdge(D, C);
var cE = new TestEdge(C, E);
var bE = new TestEdge(B, E);
var vertices = new HashSet <TestVertex>()
{
A, B, C, D, E
}.ToImmutableHashSet();
var edges = new HashSet <TestEdge>()
{
aB, bC, aD, dC, cE, bE
}.ToImmutableHashSet();
var graph = new TestAdjacencyListsGraph(vertices, edges);
var riskProfile = new Dictionary <TestEdge, int>()
{
{ aB, 0 }, { bC, 0 }, { aD, 1 }, { dC, 1 }, { cE, 2 }, { bE, 3 },
}.ToImmutableDictionary();
var search = new TestSrlgGraphSearch(4, riskProfile);
var paths = search.Search(graph, A, E, Weigher).Paths;
}
public void MultiplePathGraph()
{
SetDefaultWeights();
var aB = new TestEdge(A, B);
var bE = new TestEdge(B, E);
var aD = new TestEdge(A, D);
var dE = new TestEdge(D, E);
var aC = new TestEdge(A, C);
var cE = new TestEdge(C, E);
var vertices = new HashSet <TestVertex>()
{
A, B, C, D, E,
}.ToImmutableHashSet();
var edges = new HashSet <TestEdge>()
{
aB, bE, aD, dE, aC, cE
}.ToImmutableHashSet();
var graph = new TestAdjacencyListsGraph(vertices, edges);
var riskProfile = new Dictionary <TestEdge, int>()
{
{ aB, 0 }, { bE, 1 }, { aD, 2 }, { dE, 3 }, { aC, 4 }, { cE, 5 }
}.ToImmutableDictionary();
var search = new TestSrlgGraphSearch(6, riskProfile);
var paths = search.Search(graph, A, E, Weigher).Paths;
Assert.True(paths.Count >= 1);
CheckIsDisjoint(paths.First(), riskProfile);
}
public void MultiplePathMultiplePairs()
{
var vertices = new HashSet <TestVertex>()
{
A, B, C, D, E
}.ToImmutableHashSet();
var edges = new HashSet <TestEdge>()
{
new TestEdge(A, B, W1),
new TestEdge(B, E, W1),
new TestEdge(A, C, W1),
new TestEdge(C, E, W1),
new TestEdge(A, D, W1),
new TestEdge(D, E, W1),
new TestEdge(A, E, W2),
}.ToImmutableHashSet();
var graph = new TestAdjacencyListsGraph(vertices, edges);
var result = GraphSearch.Search(graph, A, E, Weigher);
var paths = result.Paths;
Console.WriteLine($"\n\n{paths}\n\n\ndone\n");
Assert.Equal(3, paths.Count);
var dpp = (TestDisjointPathPair)paths.First();
Assert.Equal(2, dpp.Size);
}
public void OnePathPair()
{
SetDefaultWeights();
var aB = new TestEdge(A, B);
var bC = new TestEdge(B, C);
var aD = new TestEdge(A, D);
var dC = new TestEdge(D, C);
var vertices = new HashSet <TestVertex>()
{
A, B, C, D
}.ToImmutableHashSet();
var edges = new HashSet <TestEdge>()
{
aB, bC, aD, dC
}.ToImmutableHashSet();
var graph = new TestAdjacencyListsGraph(vertices, edges);
var riskProfile = new Dictionary <TestEdge, int>()
{
{ aB, 0 }, { bC, 0 }, { aD, 1 }, { dC, 1 },
}.ToImmutableDictionary();
var search = new TestSrlgGraphSearch(2, riskProfile);
var paths = search.Search(graph, A, C, Weigher).Paths;
Console.WriteLine($"\n\n\n{paths}\n\n\n");
Assert.Single(paths);
CheckIsDisjoint(paths.First(), riskProfile);
}
public void NoPath()
{
SetDefaultWeights();
var aB = new TestEdge(A, B);
var bC = new TestEdge(B, C);
var aD = new TestEdge(A, D);
var dC = new TestEdge(D, C);
var vertices = new HashSet <TestVertex>()
{
A, B, C, D, E
}.ToImmutableHashSet();
var edges = new HashSet <TestEdge>()
{
aB, bC, aD, dC
}.ToImmutableHashSet();
var graph = new TestAdjacencyListsGraph(vertices, edges);
var riskProfile = new Dictionary <TestEdge, int>()
{
{ aB, 0 }, { bC, 0 }, { aD, 1 }, { dC, 0 },
}.ToImmutableDictionary();
var search = new TestSrlgGraphSearch(2, riskProfile);
var paths = search.Search(graph, A, E, Weigher).Paths;
Console.WriteLine(paths);
Assert.Empty(paths);
}
public void DualEdgeMultiplePath()
{
ImmutableHashSet <TestVertex> set1 = new HashSet <TestVertex>()
{
A, B, C, D, E, F, G, H
}.ToImmutableHashSet();
ImmutableHashSet <TestEdge> set2 = new HashSet <TestEdge>()
{
new TestEdge(A, B, W1),
new TestEdge(A, C, W3),
new TestEdge(B, D, W2),
new TestEdge(B, C, W1),
new TestEdge(B, E, W4),
new TestEdge(C, E, W1),
new TestEdge(D, H, W5),
new TestEdge(D, E, W1),
new TestEdge(E, F, W1),
new TestEdge(F, D, W1),
new TestEdge(F, G, W1),
new TestEdge(F, H, W1),
new TestEdge(A, E, W3),
new TestEdge(B, D, W1),
}.ToImmutableHashSet();
Graph = new TestAdjacencyListsGraph(set1, set2);
ExecuteSearch(GraphSearch, Graph, A, E, Weigher, 3, W3);
ExecuteSinglePathSearch(GraphSearch, Graph, A, E, Weigher, 1, W3);
TestAbstractGraphPathSearch gs = GraphSearch;
ISet <IPath <TestVertex, TestEdge> > pathF = gs.Search(Graph, A, F, Weigher, TestAbstractGraphPathSearch.AllPaths).Paths;
ISet <IPath <TestVertex, TestEdge> > pathE = gs.Search(Graph, A, E, Weigher, TestAbstractGraphPathSearch.AllPaths).Paths;
Assert.Equal(0, pathF.Count - pathE.Count);
Assert.Equal(new TestDoubleWeight(1.0), pathF.First().Cost.Subtract(pathE.First().Cost));
}
public void Exceptions()
{
ImmutableHashSet <TestVertex> set1 = new HashSet <TestVertex>()
{
A, B, C, D
}.ToImmutableHashSet();
ImmutableHashSet <TestEdge> set2 = new HashSet <TestEdge>()
{
new TestEdge(A, B, W2),
new TestEdge(B, A, W1),
new TestEdge(A, A, W3),
new TestEdge(A, C, NW1),
new TestEdge(C, D, W3),
}.ToImmutableHashSet();
Graph = new TestAdjacencyListsGraph(set1, set2);
TestAbstractGraphPathSearch gs = GraphSearch;
ISet <IPath <TestVertex, TestEdge> > paths = gs.Search(Graph, A, D, Weigher, TestAbstractGraphPathSearch.AllPaths).Paths;
PrintPaths(paths);
Assert.Equal(0, paths.Count);
paths = gs.Search(Graph, A, A, Weigher, 5).Paths;
// Should find no paths between the same vertices.
Assert.Equal(0, paths.Count);
// Invalid operation since there should be no paths.
Assert.Throws <InvalidOperationException>(() => paths.First().Cost);
}
public void NoEdges()
{
Graph = new TestAdjacencyListsGraph(Vertices, new HashSet <TestEdge>());
foreach (TestVertex v in Vertices)
{
ExecuteSearch(GraphSearch, Graph, v, null, Weigher, 0, new TestDoubleWeight(0));
}
}
public void Basic()
{
var graph = new TestAdjacencyListsGraph(Vertices, Edges);
var gs = new TestTarjanGraphSearch();
var result = (TestTarjanGraphSearch.SccResult)gs.Search(graph, null);
Validate(result, 6);
}
public void NullSourceArgument()
{
Assert.Throws <ArgumentNullException>(() => Do());
void Do()
{
var graph = new TestAdjacencyListsGraph(Set1, Set2);
GraphSearch.Search(graph, null, H, Weigher, 1);
}
}
public void Disconnected()
{
var vertices = new HashSet <TestVertex>()
{
A, B, C, D
}.ToImmutableHashSet();
var edges = new HashSet <TestEdge>();
var graph = new TestAdjacencyListsGraph(vertices, edges);
var result = GraphSearch.Search(graph, A, D, Weigher);
var paths = result.Paths;
Assert.Empty(paths);
}
public void FourPath()
{
var graph = new TestAdjacencyListsGraph(Vertices, Edges);
IEnumerable <IPath <TestVertex, TestEdge> > result = NewSearch.LazyPathSearch(graph, A, E, Weigher);
List <IPath <TestVertex, TestEdge> > rList = result.Take(42).ToList();
Assert.Equal(4, rList.Count);
var expectedEdges = new List <TestEdge>()
{
new TestEdge(A, B, W1),
new TestEdge(B, C, W1),
new TestEdge(C, E, W1),
};
Assert.Equal(expectedEdges, rList[0].Edges);
Assert.Equal(W3, rList[0].Cost);
expectedEdges = new List <TestEdge>()
{
new TestEdge(A, C, W3),
new TestEdge(C, E, W1),
};
var alternateEdges = new List <TestEdge>()
{
new TestEdge(A, B, W1),
new TestEdge(B, D, W2),
new TestEdge(D, E, W1),
};
ImmutableHashSet <TestEdge> actual = new HashSet <TestEdge>(rList[1].Edges.Concat(rList[2].Edges)).ToImmutableHashSet();
ImmutableHashSet <TestEdge> expected = new HashSet <TestEdge>(expectedEdges.Concat(alternateEdges)).ToImmutableHashSet();
Assert.Subset(expected, actual);
Assert.Equal(W4, rList[1].Cost);
Assert.Equal(W4, rList[2].Cost);
expectedEdges = new List <TestEdge>()
{
new TestEdge(A, B, W1),
new TestEdge(B, E, W4),
};
Assert.Equal(expectedEdges, rList[3].Edges);
Assert.Equal(W5, rList[3].Cost);
}
public void NoPath()
{
ImmutableHashSet <TestVertex> vertices = new HashSet <TestVertex>()
{
A, B, C, D
}.ToImmutableHashSet();
ImmutableHashSet <TestEdge> edges = new HashSet <TestEdge>()
{
new TestEdge(A, B), new TestEdge(B, A),
new TestEdge(C, D), new TestEdge(D, C),
}.ToImmutableHashSet();
var graph = new TestAdjacencyListsGraph(vertices, edges);
IEnumerable <IPath <TestVertex, TestEdge> > result = NewSearch.LazyPathSearch(graph, A, D, Weigher);
Assert.Empty(result);
}
public void BasicGraph()
{
var vertices = new HashSet <TestVertex>()
{
A, B, C, D
}.ToImmutableHashSet();
var edges = new HashSet <TestEdge>()
{
new TestEdge(A, B),
new TestEdge(B, C),
new TestEdge(A, D),
new TestEdge(D, C),
}.ToImmutableHashSet();
var graph = new TestAdjacencyListsGraph(vertices, edges);
ExecuteSearch(GraphSearch, graph, A, C, null, 1, new ScalarWeight(4.0));
}
public void ExecuteBroadSearch()
{
Graph = new TestAdjacencyListsGraph(Vertices, Edges);
TestAbstractGraphPathSearch search = GraphSearch;
SpanningTreeResult result = (SpanningTreeResult)search.Search(Graph, A, null, Weigher, TestAbstractGraphPathSearch.AllPaths);
Assert.Equal(7, result.Paths.Count);
int[] types = new int[] { 0, 0, 0, 0 };
foreach (EdgeType type in result.Edges.Values)
{
types[(int)type] += 1;
}
Assert.Equal(7, types[(int)EdgeType.TreeEdge]);
Assert.Equal(1, types[(int)EdgeType.BackEdge]);
Assert.Equal(4, types[(int)EdgeType.ForwardEdge] + types[(int)EdgeType.CrossEdge]);
}
public void Basics()
{
ImmutableHashSet <TestVertex> vertices = new HashSet <TestVertex>()
{
A, B, C, D, E, F
}.ToImmutableHashSet();
var graph = new TestAdjacencyListsGraph(vertices, edges);
Assert.Equal(6, graph.Vertices.Count);
Assert.Equal(5, graph.Edges.Count);
Assert.Equal(1, graph.GetEdgesFrom(A).Count);
Assert.Equal(1, graph.GetEdgesTo(A).Count);
Assert.Equal(1, graph.GetEdgesTo(C).Count);
Assert.Equal(2, graph.GetEdgesFrom(B).Count);
Assert.Equal(2, graph.GetEdgesTo(D).Count);
}
protected void ExecuteDefaultTest(int pathCount, int pathLength, IWeight pathCost)
{
Graph = new TestAdjacencyListsGraph(Vertices, Edges);
IGraphPathSearch <TestVertex, TestEdge> search = GraphSearch;
ISet <IPath <TestVertex, TestEdge> > paths = search.Search(Graph, A, H, Weigher).Paths;
Assert.Equal(1, paths.Count);
IPath <TestVertex, TestEdge> p = paths.First();
Assert.Equal(A, p.Src);
Assert.Equal(H, p.Dst);
Assert.Equal(pathLength, p.Edges.Count);
Assert.Equal(pathCost, p.Cost);
paths = search.Search(Graph, A, null, Weigher).Paths;
PrintPaths(paths);
Assert.Equal(pathCount, paths.Count);
}
public void Equality()
{
ImmutableHashSet <TestVertex> vertices = new HashSet <TestVertex>()
{
A, B, C, D, E, F
}.ToImmutableHashSet();
ImmutableHashSet <TestVertex> vertices2 = new HashSet <TestVertex>()
{
A, B, C, D, E, F, G
}.ToImmutableHashSet();
var graph = new TestAdjacencyListsGraph(vertices, edges);
var same = new TestAdjacencyListsGraph(vertices, edges);
var different = new TestAdjacencyListsGraph(vertices2, edges);
Assert.Equal(graph, same);
Assert.NotEqual(graph, different);
}
public void DifferentPrimaryAndBackupPathLengths()
{
var vertices = new HashSet <TestVertex>()
{
A, B, C, D, E
}.ToImmutableHashSet();
var edges = new HashSet <TestEdge>()
{
new TestEdge(A, B),
new TestEdge(B, C),
new TestEdge(A, D),
new TestEdge(D, C),
new TestEdge(B, E),
new TestEdge(C, E),
}.ToImmutableHashSet();
var graph = new TestAdjacencyListsGraph(vertices, edges);
ExecuteSearch(GraphSearch, graph, A, E, Weigher, 1, new TestDoubleWeight(5.0));
}
public void MultiplePathOnePairGraph()
{
var vertices = new HashSet <TestVertex>()
{
A, B, C, D, E
}.ToImmutableHashSet();
var edges = new HashSet <TestEdge>()
{
new TestEdge(A, B, W1),
new TestEdge(B, C, W1),
new TestEdge(A, D, W1),
new TestEdge(D, C, W1),
new TestEdge(B, E, W2),
new TestEdge(C, E, W1),
}.ToImmutableHashSet();
var graph = new TestAdjacencyListsGraph(vertices, edges);
ExecuteSearch(GraphSearch, graph, A, E, Weigher, 1, new TestDoubleWeight(6.0));
}
public void VariableLenPathsWithConstantLinkWeight()
{
ImmutableHashSet <TestVertex> vertices = new HashSet <TestVertex>()
{
A, B, C, D, E, F, G, H
}.ToImmutableHashSet();
ImmutableHashSet <TestEdge> edges = new HashSet <TestEdge>()
{
new TestEdge(A, B),
new TestEdge(B, A), new TestEdge(B, C),
new TestEdge(C, B), new TestEdge(C, D),
new TestEdge(D, C), new TestEdge(D, E),
new TestEdge(E, D), new TestEdge(E, H),
new TestEdge(H, E), new TestEdge(H, G),
new TestEdge(G, H), new TestEdge(G, F),
new TestEdge(F, G), new TestEdge(F, B),
new TestEdge(B, F),
}.ToImmutableHashSet();
var graph = new TestAdjacencyListsGraph(vertices, edges);
IResult <TestVertex, TestEdge> result = NewSearch.Search(graph, A, G, Weigher, 8);
Assert.Equal(2, result.Paths.Count);
List <IPath <TestVertex, TestEdge> > paths = result.Paths.ToList();
var correctEdgeList = new List <TestEdge>()
{
new TestEdge(A, B),
new TestEdge(B, F),
new TestEdge(F, G),
};
Assert.True(paths[0].Edges.SequenceEqual(correctEdgeList));
correctEdgeList.Clear();
correctEdgeList = new List <TestEdge>()
{
new TestEdge(A, B),
new TestEdge(B, C),
new TestEdge(C, D),
new TestEdge(D, E),
new TestEdge(E, H),
new TestEdge(H, G),
};
Assert.True(paths[1].Edges.SequenceEqual(correctEdgeList));
}
public void Disconnected()
{
var vertices = new HashSet <TestVertex>();
for (int i = 0; i < 200; ++i)
{
vertices.Add(new TestVertex($"v{i}"));
}
Graph = new TestAdjacencyListsGraph(vertices, new HashSet <TestEdge>().ToImmutableHashSet());
Stopwatch sw = Stopwatch.StartNew();
foreach (TestVertex src in vertices)
{
ExecuteSearch(GraphSearch, Graph, src, null, null, 0, new TestDoubleWeight(0));
}
long elapsed = sw.ElapsedTicks;
Console.WriteLine($"Compute cost is {elapsed}");
}
public void NoPath()
{
ImmutableHashSet <TestVertex> vertices = new HashSet <TestVertex>()
{
A, B, C, D
}.ToImmutableHashSet();
ImmutableHashSet <TestEdge> edges = new HashSet <TestEdge>()
{
new TestEdge(A, B),
new TestEdge(B, A),
new TestEdge(C, D),
new TestEdge(D, C),
}.ToImmutableHashSet();
var graph = new TestAdjacencyListsGraph(vertices, edges);
IResult <TestVertex, TestEdge> result = NewSearch.Search(graph, A, D, Weigher, 1);
ISet <IPath <TestVertex, TestEdge> > resultPathSet = result.Paths;
Assert.True(resultPathSet.Count == 0);
}
public void ManualDoubleWeights()
{
ImmutableHashSet <TestVertex> set1 = new HashSet <TestVertex>()
{
A, B, C, D, E
}.ToImmutableHashSet();
ImmutableHashSet <TestEdge> set2 = new HashSet <TestEdge>()
{
new TestEdge(A, B, new TestDoubleWeight(1.5)),
new TestEdge(B, D, new TestDoubleWeight(3.5)),
new TestEdge(A, C, new TestDoubleWeight(2.2)),
new TestEdge(C, E, new TestDoubleWeight(1.1)),
new TestEdge(E, D, new TestDoubleWeight(1.7)),
new TestEdge(A, D, new TestDoubleWeight(5.0)),
}.ToImmutableHashSet();
Graph = new TestAdjacencyListsGraph(set1, set2);
ExecuteSearch(GraphSearch, Graph, A, D, Weigher, 3, new TestDoubleWeight(5.0));
ExecuteSinglePathSearch(GraphSearch, Graph, A, D, Weigher, 1, W5);
}
public void SingleCluster()
{
var edges = new HashSet <TestEdge>()
{
new TestEdge(A, B),
new TestEdge(B, C),
new TestEdge(C, D),
new TestEdge(D, E),
new TestEdge(E, F),
new TestEdge(F, G),
new TestEdge(G, H),
new TestEdge(H, A),
}.ToImmutableHashSet();
var graph = new TestAdjacencyListsGraph(Vertices, edges);
var gs = new TestTarjanGraphSearch();
var result = (TestTarjanGraphSearch.SccResult)gs.Search(graph, null);
Validate(result, 1);
Validate(result, 0, 8, 8);
}
public void TwoWeaklyConnectedClusters()
{
var edges = new HashSet <TestEdge>()
{
new TestEdge(A, B),
new TestEdge(B, C),
new TestEdge(C, D),
new TestEdge(D, A),
new TestEdge(E, F),
new TestEdge(F, G),
new TestEdge(G, H),
new TestEdge(H, E),
new TestEdge(B, E),
}.ToImmutableHashSet();
var graph = new TestAdjacencyListsGraph(Vertices, edges);
var gs = new TestTarjanGraphSearch();
var result = (TestTarjanGraphSearch.SccResult)gs.Search(graph, null);
Validate(result, 2);
Validate(result, 0, 4, 4);
Validate(result, 1, 4, 4);
}
public void OnePath()
{
var vertices = new HashSet <TestVertex>()
{
A, B, C, D
}.ToImmutableHashSet();
var edges = new HashSet <TestEdge>()
{
new TestEdge(A, B, W1),
new TestEdge(B, C, W1),
new TestEdge(A, C, W4),
new TestEdge(C, D, W1),
}.ToImmutableHashSet();
var graph = new TestAdjacencyListsGraph(vertices, edges);
var result = GraphSearch.Search(graph, A, D, Weigher);
var paths = result.Paths;
Assert.Single(paths);
var dpp = (TestDisjointPathPair)paths.First();
Assert.Equal(1, dpp.Size);
}
public void TwoClustersConnectedWithIgnoredEdges()
{
var edges = new HashSet <TestEdge>()
{
new TestEdge(A, B),
new TestEdge(B, C),
new TestEdge(C, D),
new TestEdge(D, A),
new TestEdge(E, F),
new TestEdge(F, G),
new TestEdge(G, H),
new TestEdge(H, E),
new TestEdge(B, E, Weigher.NonViableWeight),
new TestEdge(E, B, Weigher.NonViableWeight),
}.ToImmutableHashSet();
var graph = new TestAdjacencyListsGraph(Vertices, edges);
var gs = new TestTarjanGraphSearch();
var result = (TestTarjanGraphSearch.SccResult)gs.Search(graph, Weigher);
Validate(result, 2);
Validate(result, 0, 4, 4);
Validate(result, 1, 4, 4);
}
