public void Constructor_Throws()
{
var graph = new AdjacencyGraph <int, Edge <int> >();
var chain = new NormalizedMarkovEdgeChain <int, Edge <int> >();
// ReSharper disable ObjectCreationAsStatement
// ReSharper disable AssignNullToNotNullAttribute
Assert.Throws <ArgumentNullException>(
() => new CyclePoppingRandomTreeAlgorithm <int, Edge <int> >(null));
Assert.Throws <ArgumentNullException>(
() => new CyclePoppingRandomTreeAlgorithm <int, Edge <int> >(graph, null));
Assert.Throws <ArgumentNullException>(
() => new CyclePoppingRandomTreeAlgorithm <int, Edge <int> >(null, chain));
Assert.Throws <ArgumentNullException>(
() => new CyclePoppingRandomTreeAlgorithm <int, Edge <int> >(null, null));
Assert.Throws <ArgumentNullException>(
() => new CyclePoppingRandomTreeAlgorithm <int, Edge <int> >(null, graph, null));
Assert.Throws <ArgumentNullException>(
() => new CyclePoppingRandomTreeAlgorithm <int, Edge <int> >(null, null, chain));
Assert.Throws <ArgumentNullException>(
() => new CyclePoppingRandomTreeAlgorithm <int, Edge <int> >(null, null, null));
var algorithm = new CyclePoppingRandomTreeAlgorithm <int, Edge <int> >(graph, chain);
Assert.Throws <ArgumentNullException>(() => algorithm.Rand = null);
// ReSharper restore AssignNullToNotNullAttribute
// ReSharper restore ObjectCreationAsStatement
}
public void ComputeWithRoot_Throws()
{
var graph = new AdjacencyGraph <TestVertex, Edge <TestVertex> >();
var chain = new NormalizedMarkovEdgeChain <TestVertex, Edge <TestVertex> >();
ComputeWithRoot_Throws_Test(
() => new CyclePoppingRandomTreeAlgorithm <TestVertex, Edge <TestVertex> >(graph, chain));
}
public void ClearRootVertex()
{
var graph = new AdjacencyGraph <int, Edge <int> >();
var chain = new NormalizedMarkovEdgeChain <int, Edge <int> >();
var algorithm = new CyclePoppingRandomTreeAlgorithm <int, Edge <int> >(graph, chain);
ClearRootVertex_Test(algorithm);
}
public void SetRootVertex_Throws()
{
var graph = new AdjacencyGraph <TestVertex, Edge <TestVertex> >();
var chain = new NormalizedMarkovEdgeChain <TestVertex, Edge <TestVertex> >();
var algorithm = new CyclePoppingRandomTreeAlgorithm <TestVertex, Edge <TestVertex> >(graph, chain);
SetRootVertex_Throws_Test(algorithm);
}
public void Constructor()
{
var graph = new AdjacencyGraph <int, Edge <int> >();
IMarkovEdgeChain <int, Edge <int> > markovChain1 = new NormalizedMarkovEdgeChain <int, Edge <int> >();
IMarkovEdgeChain <int, Edge <int> > markovChain2 = new WeightedMarkovEdgeChain <int, Edge <int> >(new Dictionary <Edge <int>, double>());
var algorithm = new CyclePoppingRandomTreeAlgorithm <int, Edge <int> >(graph);
AssertAlgorithmProperties(algorithm, graph);
algorithm = new CyclePoppingRandomTreeAlgorithm <int, Edge <int> >(graph, markovChain1);
AssertAlgorithmProperties(algorithm, graph, markovChain1);
algorithm = new CyclePoppingRandomTreeAlgorithm <int, Edge <int> >(graph, markovChain2);
AssertAlgorithmProperties(algorithm, graph, markovChain2);
algorithm = new CyclePoppingRandomTreeAlgorithm <int, Edge <int> >(null, graph, markovChain1);
AssertAlgorithmProperties(algorithm, graph, markovChain1);
var random = new Random(123456);
algorithm.Rand = random;
AssertAlgorithmProperties(algorithm, graph, markovChain1, random);
#region Local function
void AssertAlgorithmProperties <TVertex, TEdge>(
CyclePoppingRandomTreeAlgorithm <TVertex, TEdge> algo,
IVertexListGraph <TVertex, TEdge> g,
IMarkovEdgeChain <TVertex, TEdge> chain = null,
Random rand = null
)
where TEdge : IEdge <TVertex>
{
AssertAlgorithmState(algo, g);
if (chain is null)
{
Assert.IsNotNull(algo.EdgeChain);
}
else
{
Assert.AreSame(chain, algo.EdgeChain);
}
if (rand is null)
{
Assert.IsNotNull(algo.Rand);
}
else
{
Assert.AreSame(rand, algo.Rand);
}
CollectionAssert.IsEmpty(algo.Successors);
CollectionAssert.IsEmpty(algo.VerticesColors);
}
#endregion
}
public void ComputeWithRoot()
{
var graph = new AdjacencyGraph <int, Edge <int> >();
var chain = new NormalizedMarkovEdgeChain <int, Edge <int> >();
graph.AddVertex(0);
var algorithm = new CyclePoppingRandomTreeAlgorithm <int, Edge <int> >(graph, chain);
ComputeWithRoot_Test(algorithm);
}
public void GetVertexColor_Throws()
{
var graph = new AdjacencyGraph <int, Edge <int> >();
graph.AddVertex(0);
var chain = new NormalizedMarkovEdgeChain <int, Edge <int> >();
var algorithm = new CyclePoppingRandomTreeAlgorithm <int, Edge <int> >(graph, chain);
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 chain = new NormalizedMarkovEdgeChain <int, Edge <int> >();
var algorithm = new CyclePoppingRandomTreeAlgorithm <int, Edge <int> >(graph, chain);
algorithm.Compute(1);
Assert.AreEqual(GraphColor.Black, algorithm.GetVertexColor(1));
Assert.AreEqual(GraphColor.Black, algorithm.GetVertexColor(2));
}
public static CyclePoppingRandomTreeAlgorithm <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);
var chain = new NormalizedMarkovEdgeChain <T, Edge <T> >();
var algorithm = new CyclePoppingRandomTreeAlgorithm <T, Edge <T> >(graph, chain);
if (scenario.DoComputation)
{
algorithm.Compute(scenario.Root);
}
return(algorithm);
}
public void RandomWalkWithPredicate()
{
var edge1 = new Edge <int>(1, 2);
var edge2 = new Edge <int>(1, 3);
var edge3 = new Edge <int>(2, 3);
var edge4 = new Edge <int>(3, 4);
var edge5 = new Edge <int>(4, 5);
var edge6 = new Edge <int>(5, 4);
var graph = new AdjacencyGraph <int, Edge <int> >();
graph.AddVerticesAndEdgeRange(new[]
{
edge1, edge2, edge3, edge4, edge5, edge6
});
var chain = new NormalizedMarkovEdgeChain <int, Edge <int> >
{
Rand = new Random(123456)
};
var algorithm = new RandomWalkAlgorithm <int, Edge <int> >(graph, chain)
{
EndPredicate = edge => edge == edge4
};
var encounteredEdges = new List <Edge <int> >();
algorithm.TreeEdge += edge => encounteredEdges.Add(edge);
algorithm.EndVertex += vertex => Assert.AreEqual(3, vertex);
algorithm.Generate(1, int.MaxValue);
CollectionAssert.IsNotEmpty(encounteredEdges);
Assert.AreEqual(3, encounteredEdges.Last().Target);
Assert.IsTrue(
edge2 == encounteredEdges.Last()
||
edge3 == encounteredEdges.Last());
}
private static void RunCyclePoppingRandomTreeAndCheck <TVertex, TEdge>(
IVertexListGraph <TVertex, TEdge> graph,
TVertex root)
where TEdge : IEdge <TVertex>
{
var randomChain = new Random(123456);
var chain = new NormalizedMarkovEdgeChain <TVertex, TEdge>
{
Rand = randomChain
};
var randomAlgorithm = new Random(123456);
var algorithm = new CyclePoppingRandomTreeAlgorithm <TVertex, TEdge>(graph, chain)
{
Rand = randomAlgorithm
};
algorithm.InitializeVertex += vertex =>
{
Assert.AreEqual(GraphColor.White, algorithm.VerticesColors[vertex]);
};
algorithm.FinishVertex += vertex =>
{
Assert.AreEqual(GraphColor.Black, algorithm.VerticesColors[vertex]);
};
algorithm.Compute(root);
Assert.AreEqual(graph.VertexCount, algorithm.VerticesColors.Count);
foreach (TVertex vertex in graph.Vertices)
{
Assert.AreEqual(GraphColor.Black, algorithm.VerticesColors[vertex]);
}
AssertIsTree(root, algorithm.Successors);
}
public void Repro13160()
{
// Create a new graph
var graph = new BidirectionalGraph <int, Edge <int> >(false);
// Adding vertices
for (int i = 0; i < 3; ++i)
{
for (int j = 0; j < 3; ++j)
{
graph.AddVertex(i * 3 + j);
}
}
// Adding Width edges
for (int i = 0; i < 3; ++i)
{
for (int j = 0; j < 2; ++j)
{
graph.AddEdge(
new Edge <int>(i * 3 + j, i * 3 + j + 1));
}
}
// Adding Length edges
for (int i = 0; i < 2; ++i)
{
for (int j = 0; j < 3; ++j)
{
graph.AddEdge(
new Edge <int>(i * 3 + j, (i + 1) * 3 + j));
}
}
// Create cross edges
foreach (Edge <int> edge in graph.Edges)
{
graph.AddEdge(new Edge <int>(edge.Target, edge.Source));
}
// Breaking graph apart
for (int i = 0; i < 3; ++i)
{
for (int j = 0; j < 3; ++j)
{
if (i == 1)
{
graph.RemoveVertex(i * 3 + j);
}
}
}
var randomChain = new Random(123456);
var chain = new NormalizedMarkovEdgeChain <int, Edge <int> >
{
Rand = randomChain
};
var randomAlgorithm = new Random(123456);
var algorithm = new CyclePoppingRandomTreeAlgorithm <int, Edge <int> >(graph, chain)
{
Rand = randomAlgorithm
};
Assert.DoesNotThrow(() => algorithm.Compute(2));
// Successors is not a spanning tree...
}
public void NormalizedMarkovEdgeChain()
{
IVertexAndEdgeListGraph <int, EquatableEdge <int> > graph1 = CreateGraph1();
var chain = new NormalizedMarkovEdgeChain <int, EquatableEdge <int> >
{
Rand = new Random(123456)
};
Assert.IsTrue(chain.TryGetSuccessor(graph1, 1, out EquatableEdge <int> edge));
Assert.AreEqual(1, edge.Source);
Assert.AreEqual(2, edge.Target);
Assert.IsTrue(chain.TryGetSuccessor(graph1, 2, out edge));
Assert.AreEqual(2, edge.Source);
Assert.AreEqual(3, edge.Target);
Assert.IsFalse(chain.TryGetSuccessor(graph1, 3, out edge));
chain = new NormalizedMarkovEdgeChain <int, EquatableEdge <int> >
{
Rand = new Random(123456)
};
EquatableEdge <int>[] edges = graph1.Edges.ToArray();
Assert.IsTrue(chain.TryGetSuccessor(edges, 1, out edge));
Assert.AreEqual(2, edge.Source);
Assert.AreEqual(3, edge.Target);
Assert.IsTrue(chain.TryGetSuccessor(edges, 3, out edge));
Assert.AreEqual(1, edge.Source);
Assert.AreEqual(3, edge.Target);
Assert.IsTrue(chain.TryGetSuccessor(edges, 3, out edge));
Assert.AreEqual(1, edge.Source);
Assert.AreEqual(2, edge.Target);
// etc.
Assert.IsFalse(chain.TryGetSuccessor(Enumerable.Empty <EquatableEdge <int> >(), 1, out _));
IVertexAndEdgeListGraph <int, EquatableEdge <int> > graph2 = CreateGraph2();
chain = new NormalizedMarkovEdgeChain <int, EquatableEdge <int> >
{
Rand = new Random(123456)
};
Assert.IsTrue(chain.TryGetSuccessor(graph2, 1, out edge));
Assert.AreEqual(1, edge.Source);
Assert.AreEqual(2, edge.Target);
Assert.IsTrue(chain.TryGetSuccessor(graph2, 2, out edge));
Assert.AreEqual(2, edge.Source);
Assert.AreEqual(3, edge.Target);
Assert.IsTrue(chain.TryGetSuccessor(graph2, 3, out edge));
Assert.AreEqual(3, edge.Source);
Assert.AreEqual(4, edge.Target);
Assert.IsTrue(chain.TryGetSuccessor(graph2, 4, out edge));
Assert.AreEqual(4, edge.Source);
Assert.AreEqual(5, edge.Target);
Assert.IsTrue(chain.TryGetSuccessor(graph2, 5, out edge));
Assert.AreEqual(5, edge.Source);
Assert.AreEqual(6, edge.Target);
Assert.IsTrue(chain.TryGetSuccessor(graph2, 6, out edge));
Assert.AreEqual(6, edge.Source);
Assert.AreEqual(7, edge.Target);
Assert.IsTrue(chain.TryGetSuccessor(graph2, 7, out edge));
Assert.AreEqual(7, edge.Source);
Assert.AreEqual(4, edge.Target);
Assert.IsTrue(chain.TryGetSuccessor(graph2, 4, out edge));
// Etc.
chain = new NormalizedMarkovEdgeChain <int, EquatableEdge <int> >
{
Rand = new Random(123456)
};
edges = graph2.Edges.ToArray();
Assert.IsTrue(chain.TryGetSuccessor(edges, 1, out edge));
Assert.AreEqual(2, edge.Source);
Assert.AreEqual(3, edge.Target);
Assert.IsTrue(chain.TryGetSuccessor(edges, 3, out edge));
Assert.AreEqual(1, edge.Source);
Assert.AreEqual(3, edge.Target);
Assert.IsTrue(chain.TryGetSuccessor(edges, 3, out edge));
Assert.AreEqual(1, edge.Source);
Assert.AreEqual(2, edge.Target);
// Etc.
}
