public void ClearRootVertex()
{
var graph = new AdjacencyGraph <int, Edge <int> >();
var algorithm = new EulerianTrailAlgorithm <int, Edge <int> >(graph);
ClearRootVertex_Test(algorithm);
}
public void SetRootVertex_Throws()
{
var graph = new AdjacencyGraph <TestVertex, Edge <TestVertex> >();
var algorithm = new EulerianTrailAlgorithm <TestVertex, Edge <TestVertex> >(graph);
SetRootVertex_Throws_Test(algorithm);
}
/// <summary>
/// Tests all actions for adjacencygraph and filtered graph.
/// </summary>
public void Test()
{
// The all action algorithms
AdjacencyGraph g = GraphProvider.Fsm();
Console.WriteLine("Graph: {0} vertices, {1} edges, {2} eulerian trails",
g.VerticesCount,
g.EdgesCount,
EulerianTrailAlgorithm.ComputeEulerianPathCount(g)
);
// do layout
EulerianTrailAlgorithm euler = CreateEulerianTrail(g);
EdgeCollection temps = euler.AddTemporaryEdges(g);
Console.WriteLine("Added {0} temporary edges", temps.Count);
foreach (NamedEdge ne in temps)
{
ne.Name = "temporary";
}
euler.Compute();
euler.RemoveTemporaryEdges(g);
Console.WriteLine("Circuit: {0} edges",
euler.Circuit.Count);
foreach (NamedEdge e in euler.Circuit)
{
Console.WriteLine("{0}->{1} ({2})",
(NamedVertex)e.Source,
(NamedVertex)e.Target,
e.Name
);
}
Console.WriteLine("Trails:");
foreach (EdgeCollection ec in euler.Trails(
Traversal.FirstVertexIf(g.Vertices, new NameEqualPredicate("S0")))
)
{
foreach (IEdge edge in ec)
{
Console.WriteLine("{0}->{1}, {2}",
((NamedVertex)edge.Source).Name,
((NamedVertex)edge.Target).Name,
((NamedEdge)edge).Name
);
}
Console.WriteLine();
}
Console.WriteLine("Testing AdjacencyGraph");
TestAllActions(GraphProvider.Fsm(), @"../EdgeDfs");
// testing on filtered graph
Console.WriteLine("Testing FilteredVertexAndEdgeListGraph");
TestAllActions(GraphProvider.FilteredFsm(), @"../FilteredEdgeDfs");
}
public void AddTemporaryEdges_Throws()
{
var graph = new AdjacencyGraph <int, Edge <int> >();
var algorithm = new EulerianTrailAlgorithm <int, Edge <int> >(graph);
// ReSharper disable once AssignNullToNotNullAttribute
Assert.Throws <ArgumentNullException>(() => algorithm.AddTemporaryEdges(null));
}
public void ComputeWithRoot()
{
var graph = new AdjacencyGraph <int, Edge <int> >();
graph.AddVertex(0);
var algorithm = new EulerianTrailAlgorithm <int, Edge <int> >(graph);
ComputeWithRoot_Test(algorithm);
}
public void RemoveTemporaryEdges(AdjacencyGraph <int, EquatableEdge <int> > graph)
{
var algorithm = new EulerianTrailAlgorithm <int, EquatableEdge <int> >(graph);
int edgeCount = graph.EdgeCount;
EquatableEdge <int>[] tmpEdges = algorithm.AddTemporaryEdges(
(source, target) => new EquatableEdge <int>(source, target));
Assert.AreEqual(edgeCount + tmpEdges.Length, graph.EdgeCount);
algorithm.RemoveTemporaryEdges();
Assert.AreEqual(edgeCount, graph.EdgeCount);
}
private static void ComputeTrails <TVertex, TEdge>(
IMutableVertexAndEdgeListGraph <TVertex, TEdge> graph,
TVertex root,
Func <TVertex, TVertex, TEdge> edgeFactory,
out ICollection <TEdge>[] trails,
out TEdge[] circuit)
where TEdge : IEdge <TVertex>
{
trails = new ICollection <TEdge> [0];
circuit = new TEdge[0];
int circuitCount = EulerianTrailAlgorithm <TVertex, TEdge> .ComputeEulerianPathCount(graph);
if (circuitCount == 0)
{
return;
}
TEdge[] graphEdges = graph.Edges.ToArray();
var algorithm = new EulerianTrailAlgorithm <TVertex, TEdge>(graph);
algorithm.AddTemporaryEdges((s, t) => edgeFactory(s, t));
TEdge[] augmentedGraphEdges = graph.Edges.ToArray();
Assert.GreaterOrEqual(augmentedGraphEdges.Length, graphEdges.Length);
TEdge[] temporaryEdges = augmentedGraphEdges.Except(graphEdges).ToArray();
Assert.AreEqual(augmentedGraphEdges.Length - graphEdges.Length, temporaryEdges.Length);
algorithm.Compute();
trails = algorithm.Trails(root).ToArray();
algorithm.RemoveTemporaryEdges();
Assert.IsNotNull(algorithm.Circuit);
circuit = algorithm.Circuit;
// Lets make sure all the edges are in the trail
var edges = new HashSet <TEdge>();
foreach (TEdge edge in graph.Edges)
{
Assert.IsTrue(edges.Add(edge));
}
foreach (ICollection <TEdge> trail in trails)
{
Assert.AreEqual(graph.EdgeCount, edges.Count);
QuikGraphAssert.TrueForAll(
trail,
// Edge in graph or part of temporary ones but is a root
edge => edges.Contains(edge) ||
(temporaryEdges.Contains(edge) && Equals(edge.Source, root)));
}
}
public void AddTemporaryEdges(
AdjacencyGraph <int, EquatableEdge <int> > graph,
EquatableEdge <int>[] expectedTemporaryEdges)
{
var algorithm = new EulerianTrailAlgorithm <int, EquatableEdge <int> >(graph);
int edgeCount = graph.EdgeCount;
EquatableEdge <int>[] tmpEdges = algorithm.AddTemporaryEdges(
(source, target) => new EquatableEdge <int>(source, target));
CollectionAssert.AreEquivalent(expectedTemporaryEdges, tmpEdges);
Assert.AreEqual(edgeCount + tmpEdges.Length, graph.EdgeCount);
EquatableEdge <int>[] graphEdges = graph.Edges.ToArray();
foreach (EquatableEdge <int> edge in tmpEdges)
{
Assert.Contains(edge, graphEdges);
}
}
private static void ComputeTrails <TVertex, TEdge>(
IMutableVertexAndEdgeListGraph <TVertex, TEdge> graph,
Func <TVertex, TVertex, TEdge> edgeFactory,
out ICollection <TEdge>[] trails,
out TEdge[] circuit)
where TEdge : IEdge <TVertex>
{
trails = new ICollection <TEdge> [0];
circuit = new TEdge[0];
int circuitCount = EulerianTrailAlgorithm <TVertex, TEdge> .ComputeEulerianPathCount(graph);
if (circuitCount == 0)
{
return;
}
var algorithm = new EulerianTrailAlgorithm <TVertex, TEdge>(graph);
algorithm.AddTemporaryEdges((s, t) => edgeFactory(s, t));
algorithm.Compute();
trails = algorithm.Trails().ToArray();
algorithm.RemoveTemporaryEdges();
Assert.IsNotNull(algorithm.Circuit);
circuit = algorithm.Circuit;
// Lets make sure all the edges are in the trail
var edges = new HashSet <TEdge>();
foreach (TEdge edge in graph.Edges)
{
Assert.IsTrue(edges.Add(edge));
}
foreach (ICollection <TEdge> trail in trails)
{
Assert.AreEqual(graph.EdgeCount, edges.Count);
QuikGraphAssert.TrueForAll(
trail,
edge => edges.Contains(edge));
}
}
private static void ComputeTrail <TVertex, TEdge>(
[NotNull] IMutableVertexAndEdgeListGraph <TVertex, TEdge> graph,
[NotNull, InstantHandle] Func <TVertex, TVertex, TEdge> edgeFactory)
where TEdge : IEdge <TVertex>
{
if (graph.VertexCount == 0)
{
return;
}
int circuitCount = EulerianTrailAlgorithm <TVertex, TEdge> .ComputeEulerianPathCount(graph);
if (circuitCount == 0)
{
return;
}
var algorithm = new EulerianTrailAlgorithm <TVertex, TEdge>(graph);
algorithm.AddTemporaryEdges((s, t) => edgeFactory(s, t));
algorithm.Compute();
var trails = algorithm.Trails();
algorithm.RemoveTemporaryEdges();
// Lets make sure all the edges are in the trail
var edgeColors = new Dictionary <TEdge, GraphColor>(graph.EdgeCount);
foreach (TEdge edge in graph.Edges)
{
edgeColors.Add(edge, GraphColor.White);
}
foreach (ICollection <TEdge> trail in trails)
{
foreach (TEdge edge in trail)
{
Assert.IsTrue(edgeColors.ContainsKey(edge));
}
}
}
public void ComputeTrail(IMutableVertexAndEdgeListGraph<string,Edge<string>> g)
{
if (g.VertexCount == 0)
return;
GraphConsoleSerializer.DisplayGraph(g);
int oddCount = 0;
foreach (string v in g.Vertices)
if (g.OutDegree(v) % 2 == 0)
oddCount++;
int circuitCount = EulerianTrailAlgorithm<string,Edge<string>>.ComputeEulerianPathCount(g);
if (circuitCount == 0)
return;
EulerianTrailAlgorithm<string, Edge<string>> trail = new EulerianTrailAlgorithm<string, Edge<string>>(g);
trail.AddTemporaryEdges(new EdgeFactory<string>());
trail.Compute();
ICollection<ICollection<Edge<string>>> trails = trail.Trails();
trail.RemoveTemporaryEdges();
Console.WriteLine("trails: {0}", trails.Count);
int index = 0;
foreach (ICollection<Edge<string>> t in trails)
{
Console.WriteLine("trail {0}", index++);
foreach (Edge<string> edge in t)
Console.WriteLine("\t{0}", t);
}
// lets make sure all the edges are in the trail
Dictionary<Edge<string>, GraphColor> edgeColors = new Dictionary<Edge<string>, GraphColor>(g.EdgeCount);
foreach (Edge<string> edge in g.Edges)
edgeColors.Add(edge, GraphColor.White);
foreach (ICollection<Edge<string>> t in trails)
foreach (Edge<string> edge in t)
CollectionAssert.ContainsKey(edgeColors, edge);
}
public void Constructor()
{
var graph = new AdjacencyGraph <int, Edge <int> >();
var algorithm = new EulerianTrailAlgorithm <int, Edge <int> >(graph);
AssertAlgorithmProperties(algorithm, graph);
algorithm = new EulerianTrailAlgorithm <int, Edge <int> >(null, graph);
AssertAlgorithmProperties(algorithm, graph);
#region Local function
void AssertAlgorithmProperties <TVertex, TEdge>(
EulerianTrailAlgorithm <TVertex, TEdge> algo,
IMutableVertexAndEdgeListGraph <TVertex, TEdge> g)
where TEdge : IEdge <TVertex>
{
AssertAlgorithmState(algo, g);
CollectionAssert.IsEmpty(algo.Circuit);
}
#endregion
}
private static string ComputeTrails <TVertex, TEdge>(
IMutableVertexAndEdgeListGraph <TVertex, TEdge> g,
TVertex root,
Func <TVertex, TVertex, TEdge> edgeFactory,
out ICollection <TEdge>[] trails,
out TEdge[] circuit)
where TEdge : IEdge <TVertex>
{
trails = new ICollection <TEdge> [0];
circuit = new TEdge[0];
int circuitCount = EulerianTrailAlgorithm <TVertex, TEdge> .ComputeEulerianPathCount(g);
if (circuitCount == 0)
{
return("No Eulerian path found.");
}
var algorithm = new EulerianTrailAlgorithm <TVertex, TEdge>(g);
algorithm.AddTemporaryEdges((s, t) => edgeFactory(s, t));
algorithm.Compute();
try
{
trails = algorithm.Trails(root).ToArray();
}
catch (System.Exception ex)
{
return(ex.Message);
}
algorithm.RemoveTemporaryEdges();
circuit = algorithm.Circuit;
return(null);
}
public void ComputeEulerianPathCount_Throws()
{
// ReSharper disable once AssignNullToNotNullAttribute
Assert.Throws <ArgumentNullException>(
() => EulerianTrailAlgorithm <int, Edge <int> > .ComputeEulerianPathCount(null));
}
public int ComputeEulerianPathCount(AdjacencyGraph <int, Edge <int> > graph)
{
return(EulerianTrailAlgorithm <int, Edge <int> > .ComputeEulerianPathCount(graph));
}
