private void onLabelCorrecting(object sender, EventArgs e)
{
if (CurrentGraphPanel == null)
{
return;
}
//Make sure one vertex is selected
List <ISelectable> selection = CurrentGraphPanel.GetSelection();
GUIVertex vert;
if (selection.Count <= 0 || selection.Count > 1)
{
return;
}
else if (selection[0] as GUIVertex == null)
{
return;
}
else
{
vert = selection[0] as GUIVertex;
}
List <GUIVertex> verts = CurrentGraphPanel.Vertices;
Graph g = CurrentGraphPanel.Graph;
GraphAlgorithms.LabelCorrecting(g, g.GetVertices().IndexOf(vert.Vertex));
}
public void GetConnectedVerticesReturnsAllVertices()
{
var graph = CreateTestGraph();
var connectedVertices = GraphAlgorithms.GetConnectedSubgraph(graph, graph.Vertices.First()).Vertices;
Assert.That(connectedVertices, Is.EquivalentTo(graph.Vertices));
}
private static void TestBFS()
{
Graph g = new Graph();
Vertex v1 = new Vertex();
Vertex v2 = new Vertex();
Vertex v3 = new Vertex();
Vertex v4 = new Vertex();
Vertex v5 = new Vertex();
Vertex v6 = new Vertex();
Vertex v7 = new Vertex();
g.AddVertex(v1);
g.AddVertex(v2);
g.AddVertex(v3);
g.AddVertex(v4);
g.AddVertex(v5);
g.AddVertex(v6);
g.AddVertex(v7);
g.AddEdge(new Edge(v1, v2));
g.AddEdge(new Edge(v1, v3));
g.AddEdge(new Edge(v2, v6));
g.AddEdge(new Edge(v2, v4));
g.AddEdge(new Edge(v6, v4));
g.AddEdge(new Edge(v4, v5));
List <Edge> path = GraphAlgorithms.BreadthFirstSearch(g, 0, 4);
}
private static void TestResidualNetwork()
{
//Create graph from Figure 6.10
FlowNetwork fn = new FlowNetwork();
Vertex v1 = new Vertex();
Vertex v2 = new Vertex();
Vertex v3 = new Vertex();
Vertex v4 = new Vertex();
fn.AddVertex(v1);
fn.AddVertex(v2);
fn.AddVertex(v3);
fn.AddVertex(v4);
fn.SetSource(v1);
fn.SetSink(v4);
fn.AddEdge(new FlowEdge(v1, v3, 3, 4));
fn.AddEdge(new FlowEdge(v1, v2, 2, 2));
fn.AddEdge(new FlowEdge(v2, v3, 2, 3));
fn.AddEdge(new FlowEdge(v3, v4, 5, 5));
fn.AddEdge(new FlowEdge(v2, v4, 0, 1));
Graph g = GraphAlgorithms.CreateResidualNetwork(fn);
}
public void Undirected()
{
var graph = new Graph <int>(false);
var vertexList = new List <Vertex <int> >();
for (var i = 1; i < 7; i++)
{
vertexList.Add(graph.AddVertex(i));
}
/*
*
* a = 1
* b = 2
* c = 3
* d = 4
* e = 5
* f = 6
*
*/
// a
AddEdge(graph, vertexList, 1, 4, 1);
AddEdge(graph, vertexList, 1, 2, 13);
AddEdge(graph, vertexList, 1, 3, 8);
// b
AddEdge(graph, vertexList, 2, 3, 15);
// c
AddEdge(graph, vertexList, 3, 4, 5);
AddEdge(graph, vertexList, 3, 5, 3);
// d
AddEdge(graph, vertexList, 4, 5, 4);
AddEdge(graph, vertexList, 4, 6, 5);
// e
AddEdge(graph, vertexList, 5, 6, 2);
var resultGraph = GraphAlgorithms.KruskalsAlgorithm(graph);
Assert.AreEqual(resultGraph.ContainsEdge(1, 2), true);
Assert.AreEqual(resultGraph.ContainsEdge(1, 4), true);
Assert.AreEqual(resultGraph.ContainsEdge(3, 5), true);
Assert.AreEqual(resultGraph.ContainsEdge(4, 5), true);
Assert.AreEqual(resultGraph.ContainsEdge(5, 6), true);
Assert.AreEqual(resultGraph.Edges.Count, 5);
double totalCost = 0;
foreach (var edge in resultGraph.Edges)
{
totalCost += edge.Weight;
}
Assert.AreEqual(totalCost, 23);
}
public void SubgraphConstructedCorrectly()
{
var vertices = new List <Vertex <object> >
{
new Vertex <object>(1),
new Vertex <object>(2),
new Vertex <object>(3),
new Vertex <object>(4),
new Vertex <object>(5),
new Vertex <object>(6),
new Vertex <object>(7)
};
var edges = new List <Edge <object> >
{
new Edge <object>(1, 1, 3),
new Edge <object>(2, 2, 3),
new Edge <object>(3, 3, 4),
new Edge <object>(4, 3, 5),
new Edge <object>(5, 4, 5),
new Edge <object>(6, 5, 6),
new Edge <object>(7, 5, 7)
};
var testGraph = new Graph <object, object>(vertices, edges);
var subgraphVertices = new uint[] { 3, 4, 5 };
var subGraph = GraphAlgorithms.GetSubgraph(testGraph, subgraphVertices);
Assert.That(subGraph.Vertices.Select(v => v.Id), Is.EquivalentTo(subgraphVertices));
Assert.That(subGraph.Edges.Select(v => v.Id), Is.EquivalentTo(new ulong[] { 3, 4, 5 }));
Assert.That(subGraph.GetVertexFromId(3).EdgeIds, Is.EquivalentTo(new ulong[] { 3, 4 }));
Assert.That(subGraph.GetVertexFromId(4).EdgeIds, Is.EquivalentTo(new ulong[] { 3, 5 }));
Assert.That(subGraph.GetVertexFromId(5).EdgeIds, Is.EquivalentTo(new ulong[] { 4, 5 }));
}
private static void TestDijkstra()
{
//Graph for figure 4.15 part A
Graph g = new Graph();
Vertex u1 = new Vertex();
Vertex u2 = new Vertex();
Vertex u3 = new Vertex();
Vertex u4 = new Vertex();
Vertex u5 = new Vertex();
Vertex u6 = new Vertex();
g.AddEdge(new Edge(u1, u2, 2));
g.AddEdge(new Edge(u1, u3, 8));
g.AddEdge(new Edge(u2, u3, 5));
g.AddEdge(new Edge(u2, u4, 3));
g.AddEdge(new Edge(u3, u2, 6));
g.AddEdge(new Edge(u3, u5, 0));
g.AddEdge(new Edge(u4, u3, 1));
g.AddEdge(new Edge(u4, u5, 7));
g.AddEdge(new Edge(u4, u6, 6));
g.AddEdge(new Edge(u5, u4, 4));
g.AddEdge(new Edge(u6, u5, 2));
Console.WriteLine("Dijkstra Output:");
Graph tree = GraphAlgorithms.Dijkstra(g, 0, true);
}
public void DFSTest1()
{
Graph SomeGraph = new Graph();
int[] correctDFS = { 1, 2, 3, 4 };
int[] correctDFS2 = { 1, 3, 4, 2 };
int[] tryDFS = new int[4];
SomeGraph.AddNode(1);
SomeGraph.AddNode(2);
SomeGraph.AddNode(3);
SomeGraph.AddNode(4);
SomeGraph.AddEdge(1, 2);
SomeGraph.AddEdge(1, 3);
SomeGraph.AddEdge(3, 4);
int i = 0;
foreach (int n in GraphAlgorithms.DFS(SomeGraph, 1))
{
tryDFS[i++] = n;
}
try
{
CollectionAssert.AreEqual(correctDFS, tryDFS);
}
catch
{
CollectionAssert.AreEqual(correctDFS2, tryDFS);
}
}
private static void TestDominatingSets()
{
Graph g = new Graph();
g.Directed = false;
Vertex v1 = new Vertex();
Vertex v2 = new Vertex();
Vertex v3 = new Vertex();
Vertex v4 = new Vertex();
Vertex v5 = new Vertex();
Vertex v6 = new Vertex();
Vertex v7 = new Vertex();
g.AddEdge(new Edge(v1, v2));
g.AddEdge(new Edge(v2, v3));
g.AddEdge(new Edge(v3, v4));
g.AddEdge(new Edge(v4, v5));
g.AddEdge(new Edge(v5, v6));
g.AddEdge(new Edge(v6, v7));
//GraphAlgorithms.MinimumDominatingSet(g);
g.AddEdge(new Edge(v7, v1));
GraphAlgorithms.MinimumDominatingSet(g);
}
private void ShortestPath_Click(object sender, RoutedEventArgs e)
{
var graph = GraphArea1.LogicCore.Graph;
var vertices = graph.Vertices.ToList();
if (!vertices.Any())
{
return;
}
var v1 = vertices.First();
var v2 = vertices.Last();
GraphArea1.VertexList[v1].Background = new SolidColorBrush(Colors.OrangeRed);
GraphArea1.VertexList[v2].Background = new SolidColorBrush(Colors.Blue);
var path = GraphAlgorithms.FindShortestPathUndirected(graph: graph, startVertex: v1, endVertex: v2);
HighlightUnOrientedPath(path, Colors.DarkOrange);
path = GraphAlgorithms.FindShortestPath(graph: graph, startVertex: v1, endVertex: v2);
HighlightPath(path, Colors.LimeGreen);
GraphArea1.VertexList[v1].Background = new SolidColorBrush(Colors.OrangeRed);
GraphArea1.VertexList[v2].Background = new SolidColorBrush(Colors.Blue);
}
public void ShortestPathFoundForGraphWithMultipleEdgesBetweenTwoVertices()
{
var vertices = new List <Vertex <object> >
{
new Vertex <object>(0),
new Vertex <object>(1),
new Vertex <object>(2),
new Vertex <object>(3),
new Vertex <object>(4)
};
var edges = new List <Edge <object> >
{
new Edge <object>(0, 0, 1),
new Edge <object>(1, 1, 2),
new Edge <object>(2, 1, 2), // Double edge
new Edge <object>(3, 2, 3),
new Edge <object>(4, 1, 4),
new Edge <object>(5, 2, 4)
};
var graph = new Graph <object, object>(vertices, edges);
Assert.That(() => GraphAlgorithms.ShortestPaths(graph, 0), Throws.Nothing);
var shortestPathLookup = GraphAlgorithms.ShortestPaths(graph, 0);
var pathToV3 = shortestPathLookup.PathTo(vertices.Single(v => v.Id == 3));
Assert.That(pathToV3.PathLength, Is.EqualTo(3));
}
private void Search_Click(object sender, RoutedEventArgs e)
{
var graph = GraphArea1.LogicCore.Graph;
var path = GraphAlgorithms.BfSearch(graph: graph).Take(10);
HighlightVertices(vertices: path, color: Colors.DarkOrange);
}
private static void TestLabelCorrecting()
{
//Graph for figure 5.10 part A
Graph g = new Graph();
g.Directed = true;
Vertex v1 = new Vertex();
Vertex v2 = new Vertex();
Vertex v3 = new Vertex();
Vertex v4 = new Vertex();
Vertex v5 = new Vertex();
Vertex v6 = new Vertex();
g.AddEdge(new Edge(v1, v2, 10));
g.AddEdge(new Edge(v1, v3, 15));
g.AddEdge(new Edge(v2, v3, 25));
g.AddEdge(new Edge(v3, v2, -20));
g.AddEdge(new Edge(v2, v4, 0));
g.AddEdge(new Edge(v2, v5, 5));
g.AddEdge(new Edge(v4, v5, -5));
g.AddEdge(new Edge(v5, v4, 10));
g.AddEdge(new Edge(v5, v3, 30));
Console.WriteLine("Label Correcting Output:");
Graph labelCorrect = GraphAlgorithms.LabelCorrecting(g, 0);
}
public void DijkstraTest1()
{
Graph SomeGraph = new Graph();
SortedDictionary <int, int> correctDijkstraAnswer = new SortedDictionary <int, int>
{
{ 1, 0 },
{ 2, 8 },
{ 3, 3 },
{ 4, 9 }
};
SomeGraph.AddNode(1);
SomeGraph.AddNode(2);
SomeGraph.AddNode(3);
SomeGraph.AddNode(4);
SomeGraph.AddEdge(1, 2, 8);
SomeGraph.AddEdge(1, 3, 3);
SomeGraph.AddEdge(2, 4, 1);
SomeGraph.AddEdge(3, 4, 10);
SomeGraph.AddEdge(1, 4, 100);
SortedDictionary <int, int> tryDijkstra = GraphAlgorithms.Dijkstra(SomeGraph, 1);
CollectionAssert.AreEqual(correctDijkstraAnswer, tryDijkstra);
}
public void GetShortestPathTest()
{
Graph g = CreateGraph();
List <int> path;
GraphAlgorithms.GetShortestPath(g, 0, 5, out path);
}
public void Directed()
{
var graph = new Graph <int>(true);
var vertexList = new List <Vertex <int> >();
for (var i = 1; i < 15; i++)
{
vertexList.Add(graph.AddVertex(i));
}
AddEdge(graph, vertexList, 1, 2, 5);
AddEdge(graph, vertexList, 1, 5, 4);
AddEdge(graph, vertexList, 2, 4, 10);
AddEdge(graph, vertexList, 2, 3, 6);
AddEdge(graph, vertexList, 3, 4, 2);
AddEdge(graph, vertexList, 3, 5, 6);
AddEdge(graph, vertexList, 3, 7, 4);
AddEdge(graph, vertexList, 5, 6, 1);
AddEdge(graph, vertexList, 6, 7, 1);
AddEdge(graph, vertexList, 6, 8, 9);
AddEdge(graph, vertexList, 6, 9, 5);
AddEdge(graph, vertexList, 7, 9, 3);
AddEdge(graph, vertexList, 7, 10, 4);
AddEdge(graph, vertexList, 9, 10, 6);
AddEdge(graph, vertexList, 9, 12, 2);
AddEdge(graph, vertexList, 11, 12, 9);
AddEdge(graph, vertexList, 11, 13, 8);
AddEdge(graph, vertexList, 13, 14, 6);
var resultGraph = GraphAlgorithms.KruskalsAlgorithm(graph);
Assert.AreEqual(resultGraph.ContainsEdge(1, 2), true);
Assert.AreEqual(resultGraph.ContainsEdge(1, 5), true);
Assert.AreEqual(resultGraph.ContainsEdge(5, 6), true);
Assert.AreEqual(resultGraph.ContainsEdge(6, 8), true);
Assert.AreEqual(resultGraph.ContainsEdge(6, 7), true);
Assert.AreEqual(resultGraph.ContainsEdge(7, 3), true);
Assert.AreEqual(resultGraph.ContainsEdge(3, 4), true);
Assert.AreEqual(resultGraph.ContainsEdge(7, 9), true);
Assert.AreEqual(resultGraph.ContainsEdge(7, 10), true);
Assert.AreEqual(resultGraph.ContainsEdge(9, 12), true);
Assert.AreEqual(resultGraph.ContainsEdge(12, 11), true);
Assert.AreEqual(resultGraph.ContainsEdge(11, 13), true);
Assert.AreEqual(resultGraph.ContainsEdge(13, 14), true);
Assert.AreEqual(resultGraph.Edges.Count, 13);
double totalCost = 0;
foreach (var edge in resultGraph.Edges)
{
totalCost += edge.Weight;
}
Assert.AreEqual(totalCost, 58);
}
private static Dictionary <Orbital, Vector3D> CalculateLonePairRepulsion(Graph <Atom, SimpleBond> graph,
IDictionary <uint, Vector3D> forceLookup)
{
var lonePairForceLookup = graph.Vertices
.Select(v => (AtomWithOrbitals)v.Object)
.SelectMany(atom => atom.LonePairs)
.ToDictionary(o => o, o => new Vector3D(0, 0, 0));
foreach (var vertex in graph.Vertices)
{
var adjacentVertices = GraphAlgorithms.GetAdjacentVertices(graph, vertex).Cast <IVertex <Atom> >().ToList();
var currentAtom = (AtomWithOrbitals)vertex.Object;
var filledOuterOrbitals = currentAtom.OuterOrbitals.Where(o => o.IsFull).ToList();
var orbitalNeighborVertexMap = MapBondOrbitalToNeighborVertex(
filledOuterOrbitals, currentAtom, adjacentVertices);
for (var orbitalIdx1 = 0; orbitalIdx1 < filledOuterOrbitals.Count; orbitalIdx1++)
{
var orbital1 = filledOuterOrbitals[orbitalIdx1];
for (var orbitalIdx2 = orbitalIdx1 + 1; orbitalIdx2 < filledOuterOrbitals.Count; orbitalIdx2++)
{
var orbital2 = filledOuterOrbitals[orbitalIdx2];
var repulsiveForce = CalculateRepulsiveForce(orbital1, orbital2);
var orbtial1Vector = currentAtom.Position
.VectorTo(orbital1.MaximumElectronDensityPosition)
.Normalize();
var orbital1ParallelForce = repulsiveForce.ProjectOnto(orbtial1Vector);
var orbital1RepulsiveForce = (repulsiveForce - orbital1ParallelForce).ToVector3D();
var orbtial2Vector = currentAtom.Position
.VectorTo(orbital2.MaximumElectronDensityPosition)
.Normalize();
var orbital2ParallelForce = repulsiveForce.ProjectOnto(orbtial2Vector);
var orbital2RepulsiveForce = (repulsiveForce - orbital2ParallelForce).ToVector3D();
if (orbital1.IsPartOfBond)
{
var neighborVertex = orbitalNeighborVertexMap[orbital1];
forceLookup[neighborVertex.Id] += orbital1RepulsiveForce;
}
else
{
lonePairForceLookup[orbital1] += orbital1RepulsiveForce;
}
if (orbital2.IsPartOfBond)
{
var neighborVertex = orbitalNeighborVertexMap[orbital2];
forceLookup[neighborVertex.Id] += -orbital2RepulsiveForce;
}
else
{
lonePairForceLookup[orbital2] += -orbital2RepulsiveForce;
}
}
}
}
return(lonePairForceLookup);
}
/**********************************/
/* Constructor */
/**********************************/
/*
* Initialize the form, it makes the
* textBox read-only and empty.
*/
public NeatOffice()
{
// Initialization.
InitializeComponent();
textBoxCalcScreen.ReadOnly = true;
textBoxCalcScreen.Text = String.Empty;
graphAlObj = new GraphAlgorithms(toolStripProgressBar, toolStripStatusLabelReady, statusStripProgressBar);
//toolStripStatusLabelGoodDay.Text = "Good Day! Today is " + DateTime.Now.ToString();
}
public void GetConnectedVerticesReturnsOnlyConnectedVertices()
{
var graph = CreateTestGraph();
var nonConnectedVertex = new Vertex <object>(99);
graph.AddVertex(nonConnectedVertex);
var connectedVertices = GraphAlgorithms.GetConnectedSubgraph(graph, graph.Vertices.First()).Vertices;
Assert.That(connectedVertices, Is.EquivalentTo(graph.Vertices.Except(new[] { nonConnectedVertex })));
}
private void onAllPairs(object sender, EventArgs e)
{
if (CurrentGraphPanel == null)
{
return;
}
Graph g = CurrentGraphPanel.Graph;
GraphAlgorithms.AllPairsShortestPath(g);
}
public void ShortestPathThrowsExceptionIfAnyEdgeHasNegativeWeight()
{
// Remove this test if an algorithm with support for
// negative weights has been implemented.
var graph = CreateTestGraph();
graph.Edges.First().Weight = -1;
Assert.Throws <NotImplementedException>(() => GraphAlgorithms.ShortestPaths(graph, graph.GetVertexFromId(0)));
}
private void onPrintMatrix(object sender, EventArgs e)
{
if (CurrentGraphPanel == null)
{
return;
}
Graph g = CurrentGraphPanel.Graph;
g.UpdateMatrix();
GraphAlgorithms.PrintMatrix(g.GetRawMatrix(), g.GetVertices().Count);
}
public static void MarkBackbone(this Molecule molecule, MoleculeReference moleculeReference)
{
var pathsFromFirstAtom = GraphAlgorithms.ShortestPaths(molecule.MoleculeStructure, moleculeReference.FirstAtomId);
var pathToLastAtom = pathsFromFirstAtom.PathTo(molecule.MoleculeStructure.GetVertexFromId(moleculeReference.LastAtomId));
var pathVertices = pathToLastAtom.Path
.SelectMany(edge => new[] { edge.Vertex1Id, edge.Vertex2Id })
.Distinct()
.Select(vId => molecule.MoleculeStructure.GetVertexFromId(vId))
.Select(v => v.Object);
pathVertices.ForEach(atom => atom.IsBackbone = true);
}
private static void TestAllPairs()
{
//Graph for figure 4.15 part B
Graph g = new Graph();
Vertex v1 = new Vertex();
Vertex v2 = new Vertex();
Vertex v3 = new Vertex();
Vertex v4 = new Vertex();
Vertex v5 = new Vertex();
Vertex v6 = new Vertex();
Vertex v7 = new Vertex();
Vertex v8 = new Vertex();
Vertex v9 = new Vertex();
Vertex v10 = new Vertex();
Vertex v11 = new Vertex();
Vertex v12 = new Vertex();
g.AddVertex(v1);
g.AddVertex(v2);
g.AddVertex(v3);
g.AddVertex(v4);
g.AddVertex(v5);
g.AddVertex(v6);
g.AddVertex(v7);
g.AddVertex(v8);
g.AddVertex(v9);
g.AddVertex(v10);
g.AddVertex(v11);
g.AddVertex(v12);
g.AddEdge(new Edge(v1, v2, 5));
g.AddEdge(new Edge(v1, v4, 10));
g.AddEdge(new Edge(v2, v3, 7));
g.AddEdge(new Edge(v2, v5, 1));
g.AddEdge(new Edge(v3, v6, 4));
g.AddEdge(new Edge(v4, v5, 3));
g.AddEdge(new Edge(v5, v6, 3));
g.AddEdge(new Edge(v1, v2, 5));
g.AddEdge(new Edge(v4, v7, 11));
g.AddEdge(new Edge(v1, v2, 5));
g.AddEdge(new Edge(v5, v8, 7));
g.AddEdge(new Edge(v6, v9, 5));
g.AddEdge(new Edge(v7, v10, 9));
g.AddEdge(new Edge(v7, v8, 2));
g.AddEdge(new Edge(v8, v11, 1));
g.AddEdge(new Edge(v8, v9, 0));
g.AddEdge(new Edge(v9, v12, 12));
g.AddEdge(new Edge(v11, v12, 4));
float[,] d = GraphAlgorithms.AllPairsShortestPath(g);
GraphAlgorithms.PrintMatrix(d, g.GetVertices().Count);
}
public void Directed()
{
var graph = new Graph <int>(true);
var vertexList = new List <Vertex <int> >();
for (var i = 1; i < 15; i++)
{
vertexList.Add(graph.AddVertex(i));
}
AddEdge(graph, vertexList, 1, 2, 5);
AddEdge(graph, vertexList, 1, 5, 4);
AddEdge(graph, vertexList, 2, 4, 10);
AddEdge(graph, vertexList, 2, 3, 6);
AddEdge(graph, vertexList, 3, 4, 2);
AddEdge(graph, vertexList, 3, 5, 6);
AddEdge(graph, vertexList, 3, 7, 4);
AddEdge(graph, vertexList, 5, 6, 1);
AddEdge(graph, vertexList, 6, 7, 1);
AddEdge(graph, vertexList, 6, 8, 9);
AddEdge(graph, vertexList, 6, 9, 5);
AddEdge(graph, vertexList, 7, 9, 3);
AddEdge(graph, vertexList, 7, 10, 4);
AddEdge(graph, vertexList, 9, 10, 6);
AddEdge(graph, vertexList, 9, 12, 2);
AddEdge(graph, vertexList, 11, 12, 9);
AddEdge(graph, vertexList, 11, 13, 8);
AddEdge(graph, vertexList, 13, 14, 6);
var resultGraph = GraphAlgorithms.PrimsAlgorithm(graph, vertexList[0]);
Assert.IsTrue(resultGraph.ContainsEdge(1, 2));
Assert.IsTrue(resultGraph.ContainsEdge(1, 5));
Assert.IsTrue(resultGraph.ContainsEdge(5, 6));
Assert.IsTrue(resultGraph.ContainsEdge(6, 8));
Assert.IsTrue(resultGraph.ContainsEdge(6, 7));
Assert.IsTrue(resultGraph.ContainsEdge(7, 3));
Assert.IsTrue(resultGraph.ContainsEdge(3, 4));
Assert.IsTrue(resultGraph.ContainsEdge(7, 9));
Assert.IsTrue(resultGraph.ContainsEdge(7, 10));
Assert.IsTrue(resultGraph.ContainsEdge(9, 12));
Assert.IsTrue(resultGraph.ContainsEdge(12, 11));
Assert.IsTrue(resultGraph.ContainsEdge(11, 13));
Assert.IsTrue(resultGraph.ContainsEdge(13, 14));
Assert.AreEqual(13, resultGraph.Edges.Count);
double totalCost = resultGraph.Edges.Sum(edge => edge.Weight);
Assert.AreEqual(58, totalCost);
}
public void BreadthFirstSearchTest()
{
Graph g = CreateGraph();
Dictionary <int, int> distances;
GraphAlgorithms.BreathFirstSearch(g, 0, out distances);
Assert.AreEqual(0, distances[0], "Distance from 0");
Assert.AreEqual(1, distances[11], "Distance from 11");
Assert.AreEqual(2, distances[6], "Distance from 6");
Assert.AreEqual(3, distances[5], "Distance from 5");
}
public void ShortestPathFindsExpectedPathLengts()
{
var graph = CreateTestGraph();
graph.Edges.Single(e => e.Vertex1Id == 1 && e.Vertex2Id == 3).Weight = 0.5;
var shortestPathLookup = GraphAlgorithms.ShortestPaths(graph, graph.GetVertexFromId(0));
Assert.That(shortestPathLookup.PathLengthTo(graph.GetVertexFromId(0)), Is.EqualTo(0));
Assert.That(shortestPathLookup.PathLengthTo(graph.GetVertexFromId(1)), Is.EqualTo(1));
Assert.That(shortestPathLookup.PathLengthTo(graph.GetVertexFromId(2)), Is.EqualTo(2));
Assert.That(shortestPathLookup.PathLengthTo(graph.GetVertexFromId(3)), Is.EqualTo(1.5));
}
// Find a path between two vertexes
public void FindPath(Vertex <string> FromVertex, Vertex <string> ToVertext)
{
Debug.LogWarning("FromVertex Data: " + FromVertex.Data);
Debug.LogWarning("ToVertex Data: " + ToVertext.Data);
videoQueue.Clear();
Graph <string> pathGraph = GraphAlgorithms.DijkstrasAlgorithm <string>(videoGraph, FromVertex);
var endVertex = pathGraph.GetVertex(ToVertext.Data);
pathQueue.Clear();
pathQueue.Enqueue(ToVertext.Data);
string fromVertexID = FromVertex.Data;
string nextVertexID = null;
var nextVertex = endVertex;
while (nextVertexID != fromVertexID)
{
nextVertexID = nextVertex.IncidentEdges[0].FromVertex.Data;
if (nextVertexID == nextVertex.Data)
{
nextVertexID = nextVertex.IncidentEdges[1].FromVertex.Data;
}
pathQueue.Enqueue(nextVertexID);
Debug.LogWarning("next vertex: " + nextVertexID);
nextVertex = pathGraph.GetVertex(nextVertexID);
}
var pathQueueSize = pathQueue.Count;
List <string>[] tmpList = new List <string> [pathQueueSize];
var pathlist = pathQueue.ToList();
for (int i = pathlist.Count - 1; i > 0; i--)
{
Debug.LogWarning("path list i: " + pathlist[i]);
var list0 = databaseControl.GetVideoList(pathlist[i]);
Debug.LogWarning("path list i-1: " + pathlist[i - 1]);
var list1 = databaseControl.GetVideoList(pathlist[i - 1]);
var commons = list0.Intersect(list1);
Debug.LogWarning(commons.FirstOrDefault());
Debug.LogWarning("videoQueue size: " + videoQueue.Count);
string playInfo = databaseControl.GetPlayInfo(pathlist[i], pathlist[i - 1], commons.FirstOrDefault());
videoQueue.Enqueue(playInfo);
}
reviewMode = false;
StopAllCoroutines();
currentFrameList.Clear();
StartCoroutine(SetLoadFramesForNavigation(videoQueue));
playNavigationMode = true;
}
public void HasCyclesReturnsFalseForDiamondGraph()
{
var graph = new Graph <object, object>(
Enumerable.Range(1, 4).Select(vertexId => new Vertex <object>((uint)vertexId)),
new []
{
new Edge <object>(0, 1, 2, isDirected: true),
new Edge <object>(1, 1, 3, isDirected: true),
new Edge <object>(2, 2, 4, isDirected: true),
new Edge <object>(3, 3, 4, isDirected: true)
});
Assert.That(GraphAlgorithms.HasCycles(graph), Is.False);
}
public void HasCyclesThrowsExceptionForPartiallyUndirectedGraph()
{
var graph = new Graph <object, object>(
Enumerable.Range(1, 4).Select(vertexId => new Vertex <object>((uint)vertexId)),
new []
{
new Edge <object>(0, 1, 2),
new Edge <object>(1, 1, 3),
new Edge <object>(2, 2, 4, isDirected: true),
new Edge <object>(3, 3, 4, isDirected: true)
});
Assert.That(() => GraphAlgorithms.HasCycles(graph), Throws.Exception);
}
