public void IsolatedGraph(bool value)
{
Graph graph = new MatrixGraph(10, true);
graph.AddEdge(0, 9, 10);
graph.AddEdge(2, 0, 5);
Graph isolatedGraph = graph.IsolatedGraph(value);
Assert.Equal(10, isolatedGraph.VerticesCount);
Assert.Equal(value, isolatedGraph.Directed);
Assert.Equal(0, isolatedGraph.EdgesCount);
}
public void ReverseGraph()
{
Graph graph = new MatrixGraph(10, true);
graph.AddEdge(0, 9, 10);
graph.AddEdge(2, 0, 5);
Graph reversedGraph = graph.ReversedGraph();
Assert.Equal(1, reversedGraph.GetOutDegree(9));
Assert.Equal(1, reversedGraph.GetInDegree(2));
Assert.Equal(2, reversedGraph.EdgesCount);
}
public void GraphOfSameType(bool value)
{
Graph graph = new MatrixGraph(10, true);
graph.AddEdge(0, 9, 10);
graph.AddEdge(2, 0, 5);
Graph sameTypeGraph = graph.NewGraphOfSameType(5, value);
Assert.Equal(5, sameTypeGraph.VerticesCount);
Assert.Equal(value, sameTypeGraph.Directed);
Assert.Equal(0, sameTypeGraph.EdgesCount);
Assert.IsType <MatrixGraph>(sameTypeGraph);
}
public void UndirectedGraphAddEdgeAndDeleteEdge()
{
Graph graph = new MatrixGraph(10, false);
graph.AddEdge(0, 9, 10);
graph.AddEdge(2, 0, 5);
Assert.Equal(2, graph.GetOutDegree(0));
Assert.Equal(2, graph.GetInDegree(0));
Assert.Equal(2, graph.EdgesCount);
graph.DeleteEdge(0, 9);
Assert.Equal(1, graph.GetOutDegree(0));
Assert.Equal(1, graph.GetInDegree(0));
Assert.Equal(1, graph.EdgesCount);
}
public void TestDirected()
{
var graph = new MatrixGraph(GraphTypes.Directed, 6);
graph.AddEdge(0, 1);
graph.AddEdge(0, 4);
graph.AddEdge(1, 2);
graph.AddEdge(2, 0);
graph.AddEdge(2, 3);
graph.AddEdge(3, 1);
graph.AddEdge(3, 4);
graph.AddEdge(3, 5);
graph.AddEdge(4, 1);
graph.AddEdge(5, 0);
var print = graph.PrintBFS(3);
}
public void TestUndirected()
{
var graph = new MatrixGraph(GraphTypes.Undirected, 5);
graph.AddEdge(0, 1);
graph.AddEdge(0, 4);
graph.AddEdge(1, 4);
graph.AddEdge(1, 3);
graph.AddEdge(1, 2);
graph.AddEdge(2, 3);
graph.AddEdge(3, 4);
var print = graph.PrintBFS(3);
}
private void addEdgeButton_Click(object sender, EventArgs e)
{
if (edgeFrom.Value == edgeTo.Value)
{
return;
}
string newItem = edgeFrom.Value.ToString() + "<------>" + edgeTo.Value.ToString();
string reverseItem = edgeTo.Value.ToString() + "<------>" + edgeFrom.Value.ToString();
if (!listOfEgdes.Items.Contains(newItem) && !listOfEgdes.Items.Contains(reverseItem))
{
listOfEgdes.Items.Add(newItem);
if (graph == null)
{
graph = new MatrixGraph((uint)numberOfVertices.Value);
}
graph.AddEdge(new Edge((int)edgeFrom.Value, (int)edgeTo.Value));
}
}
private void uploadGraphButton_Click(object sender, EventArgs e)
{
clearAllAndCreateNewGraph(true);
OpenFileDialog theDialog = new OpenFileDialog
{
Title = @"Open Text File",
Filter = @"TXT files|*.txt",
InitialDirectory = Directory.GetCurrentDirectory(),
RestoreDirectory = true
};
if (theDialog.ShowDialog() == DialogResult.OK)
{
string filename = theDialog.FileName;
int numOfVertices = 0;
int[,] edges = null;
try
{
numOfVertices = new Parser().Parse(filename, out edges);
}
catch (Exception)
{
MessageBox.Show("Wrong file format!", "Error", MessageBoxButtons.OK, MessageBoxIcon.Error);
graph = null;
return;
}
//graph construction
graph = new MatrixGraph((uint)numOfVertices);
numberOfVertices.Value = numOfVertices;
for (int i = 0; i < edges.GetLength(0); i++)
{
graph.AddEdge(new Edge(edges[i, 0], edges[i, 1]));
listOfEgdes.Items.Add("" + edges[i, 0].ToString() + "<------>" + edges[i, 1].ToString());
}
}
}
public void FloydWarshallTest(bool directed)
{
Graph g = new MatrixGraph(7, directed);
g.AddEdge(0, 1, 5);
g.AddEdge(0, 2, 3);
g.AddEdge(0, 3, 0);
g.AddEdge(1, 4, 3);
g.AddEdge(1, 6, 4);
g.AddEdge(2, 4, 2);
g.AddEdge(2, 5, 1);
g.AddEdge(3, 2, 2);
g.AddEdge(3, 6, 15);
g.AddEdge(4, 6, 3);
g.AddEdge(5, 4, 12);
var result = g.Johnson();
for (int i = 0; i < g.VerticesCount; i++)
{
Assert.Equal(0, result[i][i]);
}
Assert.Equal(5, result[0][1]);
Assert.Equal(2, result[0][2]);
Assert.Equal(0, result[0][3]);
Assert.Equal(4, result[0][4]);
Assert.Equal(3, result[0][5]);
Assert.Equal(7, result[0][6]);
Assert.Equal(double.MaxValue, result[2][0]);
Assert.Equal(double.MaxValue, result[2][1]);
Assert.Equal(double.MaxValue, result[2][3]);
Assert.Equal(2, result[2][4]);
Assert.Equal(1, result[2][5]);
Assert.Equal(5, result[2][6]);
Assert.Equal(double.MaxValue, result[2][0]);
Assert.Equal(double.MaxValue, result[2][1]);
Assert.Equal(double.MaxValue, result[2][3]);
Assert.Equal(2, result[2][4]);
Assert.Equal(1, result[2][5]);
Assert.Equal(5, result[2][6]);
Assert.Equal(double.MaxValue, result[3][0]);
Assert.Equal(double.MaxValue, result[3][1]);
Assert.Equal(2, result[3][2]);
Assert.Equal(4, result[3][4]);
Assert.Equal(3, result[3][5]);
Assert.Equal(7, result[3][6]);
Assert.Equal(double.MaxValue, result[4][0]);
Assert.Equal(double.MaxValue, result[4][1]);
Assert.Equal(double.MaxValue, result[4][2]);
Assert.Equal(double.MaxValue, result[4][3]);
Assert.Equal(double.MaxValue, result[4][5]);
Assert.Equal(3, result[4][6]);
Assert.Equal(double.MaxValue, result[5][0]);
Assert.Equal(double.MaxValue, result[5][1]);
Assert.Equal(double.MaxValue, result[5][2]);
Assert.Equal(double.MaxValue, result[5][3]);
Assert.Equal(12, result[5][4]);
Assert.Equal(15, result[5][6]);
Assert.Equal(double.MaxValue, result[6][0]);
Assert.Equal(double.MaxValue, result[6][1]);
Assert.Equal(double.MaxValue, result[6][2]);
Assert.Equal(double.MaxValue, result[6][3]);
Assert.Equal(double.MaxValue, result[6][4]);
Assert.Equal(double.MaxValue, result[6][5]);
}
public void SimpleKrusalTest()
{
Graph g = new MatrixGraph(7, false);
g.AddEdge(0, 1, 5);
g.AddEdge(0, 2, 3);
g.AddEdge(0, 3, 0);
g.AddEdge(1, 4, 3);
g.AddEdge(1, 6, 4);
g.AddEdge(2, 4, 2);
g.AddEdge(2, 5, 1);
g.AddEdge(3, 2, 2);
g.AddEdge(3, 6, 15);
g.AddEdge(4, 6, 3);
g.AddEdge(5, 4, 12);
var result = g.Kruskal();
Assert.True(result.connected);
Assert.Equal(0, result.tree.GetEdge(0, 3).Weight);
Assert.Equal(2, result.tree.GetEdge(3, 2).Weight);
Assert.Equal(1, result.tree.GetEdge(2, 5).Weight);
Assert.Equal(2, result.tree.GetEdge(2, 4).Weight);
Assert.Equal(3, result.tree.GetEdge(1, 4).Weight);
Assert.Equal(3, result.tree.GetEdge(4, 6).Weight);
Assert.Equal(6, result.tree.EdgesCount);
}
public void SimpleDFSTest(bool value)
{
Random random = new Random();
Graph g = new MatrixGraph(9, value);
g.AddEdge(0, 1, random.NextDouble());
g.AddEdge(0, 2, random.NextDouble());
g.AddEdge(0, 3, random.NextDouble());
g.AddEdge(1, 4, random.NextDouble());
g.AddEdge(1, 6, random.NextDouble());
g.AddEdge(2, 4, random.NextDouble());
g.AddEdge(2, 5, random.NextDouble());
g.AddEdge(3, 7, random.NextDouble());
g.AddEdge(4, 7, random.NextDouble());
g.AddEdge(6, 7, random.NextDouble());
g.AddEdge(5, 8, random.NextDouble());
bool[] tab;
g.DFS(null, null, null, 0, out tab);
foreach (bool b in tab)
{
Assert.True(b);
}
bool[] invTab;
Graph invGraph = g.ReversedGraph();
invGraph.DFS(null, null, null, 0, out invTab);
Assert.True(invTab[0]);
for (int i = 1; i < invTab.Length; i++)
{
Assert.Equal(!value, invTab[i]);
}
}
public void TestDirected_DFS()
{
var graph = new MatrixGraph(GraphTypes.Directed, 7);
graph.AddEdge(0, 1);
graph.AddEdge(0, 3);
graph.AddEdge(1, 2);
graph.AddEdge(1, 3);
graph.AddEdge(1, 4);
graph.AddEdge(2, 0);
graph.AddEdge(2, 4);
graph.AddEdge(3, 2);
graph.AddEdge(4, 5);
graph.AddEdge(5, 6);
graph.AddEdge(6, 3);
var print = graph.PrintDFS(0);
}
public void HasConnection()
{
// Arrange
var myGraph = new MatrixGraph(GraphTypes.Directed, 15);
{
myGraph.AddEdge(0, 1);
myGraph.AddEdge(0, 2);
myGraph.AddEdge(1, 9);
myGraph.AddEdge(1, 2);
myGraph.AddEdge(1, 3);
myGraph.AddEdge(1, 11);
myGraph.AddEdge(11, 9);
myGraph.AddEdge(2, 1);
myGraph.AddEdge(3, 4);
myGraph.AddEdge(3, 8);
myGraph.AddEdge(4, 10);
myGraph.AddEdge(4, 3);
myGraph.AddEdge(4, 5);
myGraph.AddEdge(10, 7);
myGraph.AddEdge(10, 4);
myGraph.AddEdge(7, 6);
myGraph.AddEdge(6, 7);
myGraph.AddEdge(5, 6);
myGraph.AddEdge(5, 2);
myGraph.AddEdge(8, 13);
myGraph.AddEdge(13, 14);
}
var graphMatrix = myGraph.GetGraphRepresentation();
// Practice
bool HasRoute(int node1, int node2)
{
var keepGoing = true;
var vertices = graphMatrix.GetLength(0);
var seachVisited = new int[vertices];
var bfsOrder1 = new Queue <int>(vertices);
bfsOrder1.Enqueue(node1);
var bfsOrder2 = new Queue <int>(vertices);
bfsOrder2.Enqueue(node2);
bool HasVisited(int node, int nodeIndex) =>
(seachVisited[node] & (1 << nodeIndex)) != 0;
while (keepGoing)
{
keepGoing = bfsOrder1.TryDequeue(out int node);
if (keepGoing)
{
for (byte i = 0; i < vertices; i++)
{
if (graphMatrix[node, i] == 1 && !HasVisited(i, 1))
{
bfsOrder1.Enqueue(i);
seachVisited[i] = seachVisited[i] | 1 << 1;
if (HasVisited(i, 2))
{
return(true);
}
}
}
}
keepGoing = bfsOrder2.TryDequeue(out node);
if (keepGoing)
{
for (byte i = 0; i < vertices; i++)
{
if (graphMatrix[node, i] == 1 && !HasVisited(i, 2))
{
bfsOrder2.Enqueue(i);
seachVisited[i] = seachVisited[i] | 1 << 2;
if (HasVisited(i, 1))
{
return(true);
}
}
}
}
}
return(false);
}
Assert.True(HasRoute(2, 10));
Assert.False(HasRoute(11, 8));
}
public void SimpleDijkstraTest(bool directed)
{
Graph g = new MatrixGraph(7, directed);
g.AddEdge(0, 1, 5);
g.AddEdge(0, 2, 0);
g.AddEdge(0, 3, 3);
g.AddEdge(1, 5, 3);
g.AddEdge(1, 6, 4);
g.AddEdge(2, 3, 2);
g.AddEdge(2, 6, 15);
g.AddEdge(3, 5, 2);
g.AddEdge(3, 4, 1);
g.AddEdge(4, 5, 12);
g.AddEdge(5, 6, 3);
var result = g.DAG(0);
Assert.Equal(0, result[0].distance);
Assert.Equal(5, result[1].distance);
Assert.Equal(0, result[2].distance);
Assert.Equal(2, result[3].distance);
Assert.Equal(3, result[4].distance);
Assert.Equal(4, result[5].distance);
Assert.Equal(7, result[6].distance);
}
public void SimpleEqualsTest(bool directed)
{
Graph g = new MatrixGraph(7, directed);
g.AddEdge(0, 1, 5);
g.AddEdge(0, 2, 0);
g.AddEdge(0, 3, 3);
g.AddEdge(1, 5, 3);
g.AddEdge(1, 6, 4);
g.AddEdge(2, 3, 2);
g.AddEdge(2, 6, 15);
g.AddEdge(3, 5, 2);
g.AddEdge(3, 4, 1);
g.AddEdge(4, 5, 12);
g.AddEdge(5, 6, 3);
Graph g2 = new MatrixGraph(7, directed);
g2.AddEdge(0, 1, 5);
g2.AddEdge(0, 2, 0);
g2.AddEdge(0, 3, 3);
g2.AddEdge(1, 5, 3);
g2.AddEdge(1, 6, 4);
g2.AddEdge(2, 3, 2);
g2.AddEdge(2, 6, 15);
g2.AddEdge(3, 5, 2);
g2.AddEdge(3, 4, 1);
g2.AddEdge(4, 5, 12);
g2.AddEdge(5, 6, 3);
bool result = g.Equals(g2);
Assert.True(result);
}
public void SimpleBellmanFordTest(bool directed)
{
Graph g = new MatrixGraph(7, directed);
g.AddEdge(0, 1, 5);
g.AddEdge(0, 2, 3);
g.AddEdge(0, 3, 0);
g.AddEdge(1, 4, 3);
g.AddEdge(1, 6, 4);
g.AddEdge(2, 4, 2);
g.AddEdge(2, 5, 1);
g.AddEdge(3, 2, 2);
g.AddEdge(3, 6, 15);
g.AddEdge(4, 6, 3);
g.AddEdge(5, 4, 12);
var result = g.BellmanFord(0);
Assert.Equal(0, result[0].distance);
Assert.Equal(5, result[1].distance);
Assert.Equal(2, result[2].distance);
Assert.Equal(0, result[3].distance);
Assert.Equal(4, result[4].distance);
Assert.Equal(3, result[5].distance);
Assert.Equal(7, result[6].distance);
}
