diff --git a/Group10.report.pdf b/Group10.report.pdf new file mode 100644 index 0000000..194a3a7 Binary files /dev/null and b/Group10.report.pdf differ diff --git a/HLP_Project_Group10.ipynb b/HLP_Project_Group10.ipynb new file mode 100644 index 0000000..966151c --- /dev/null +++ b/HLP_Project_Group10.ipynb @@ -0,0 +1,1456 @@ +{ + "cells": [ + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "# High Level Programming Course" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "## Project: Delay Tolerant Network" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "### Group 10\n", + "Members: \n", + "\n", + "Ahmed Shahhat 2008561\n", + "\n", + "Fatemeh Nikraftar Khamene 2014329\n", + "\n", + "Mudit Sharma 1216120\n", + "\n", + "Golnaz Tajbakhsh 2016508" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "### First we created a simple network to analyze our algorithms on it and check the delays." + ] + }, + { + "cell_type": "code", + "execution_count": 5, + "metadata": {}, + "outputs": [ + { + "data": { + "image/png": "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\n", + "text/plain": [ + "
" + ] + }, + "metadata": { + "needs_background": "light" + }, + "output_type": "display_data" + } + ], + "source": [ + "import matplotlib.pyplot as plt\n", + "import networkx as nx\n", + "import numpy as np\n", + "\n", + "G1 = nx.Graph()\n", + "\n", + "G1.add_edge(\"a\", \"b\", weight=0.6)\n", + "G1.add_edge(\"a\", \"c\", weight=0.2)\n", + "G1.add_edge(\"c\", \"d\", weight=0.1)\n", + "G1.add_edge(\"c\", \"e\", weight=0.7)\n", + "G1.add_edge(\"c\", \"f\", weight=0.9)\n", + "G1.add_edge(\"a\", \"d\", weight=0.3)\n", + "G1.add_edge(\"a\", \"h\", weight=0.8)\n", + "G1.add_edge(\"h\", \"f\", weight=0.3)\n", + "G1.add_edge(\"h\", \"c\", weight=0.9)\n", + "G1.add_edge(\"b\", \"l\", weight=0.8)\n", + "G1.add_edge(\"b\", \"l\", weight=0.8)\n", + "G1.add_edge(\"l\", \"h\", weight=0.2)\n", + "G1.add_edge(\"l\", \"e\", weight=1.0)\n", + "G1.add_edge(\"i\", \"b\", weight=2.0)\n", + "G1.add_edge(\"i\", \"j\", weight=0.2)\n", + "G1.add_edge(\"b\", \"j\", weight=0.7)\n", + "\n", + "elarge = [(u, v) for (u, v, d) in G1.edges(data=True) if d[\"weight\"] > 0.5]\n", + "esmall = [(u, v) for (u, v, d) in G1.edges(data=True) if d[\"weight\"] <= 0.5]\n", + "\n", + "pos = nx.spring_layout(G1, seed=7) # positions for all nodes - seed for reproducibility\n", + "\n", + "# nodes\n", + "nx.draw_networkx_nodes(G1, pos, node_size=700)\n", + "\n", + "# edges\n", + "nx.draw_networkx_edges(G1, pos, edgelist=elarge, width=6)\n", + "nx.draw_networkx_edges(\n", + " G1, pos, edgelist=esmall, width=6, alpha=0.5, edge_color=\"b\", style=\"dashed\"\n", + ")\n", + "\n", + "# labels\n", + "nx.draw_networkx_labels(G1, pos, font_size=20, font_family=\"sans-serif\")\n", + "\n", + "ax = plt.gca()\n", + "ax.margins(0.08)\n", + "plt.axis(\"off\")\n", + "plt.tight_layout()\n", + "plt.show()" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "# We used 4 algorithms such as :\n", + "1. Bellman_Ford algorithm\n", + "2. Dijkstra algorithm\n", + "3. Floyd-Warshall algorithm\n", + "4. Johnson's algorithm" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "# Bellman_Ford Algorithm" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "#PseudoCode : Bellman_Ford \n", + "\n", + " The algorithm has a running time of O(mn) where n is the number of nodes and m is the number of edges. \n", + " \n", + " It is slower than Dijkstra but can handle negative edge weights.\n", + "\n", + "\n", + " The first thing the algoritim do is to put all nodes at infinity except the source node that will be at 0 cordinate .\n", + " The source node from which the algoritim start should have at less one edge going from it otherwise we will have a result 0 for this node and infiity for all others.\n", + " The code can not handel negitive cycles but can deal with negitive delays.\n", + "\n", + "\n", + "\n", + " Step 1: Prepare the distance and predecessor for each node\n", + " for node in graph:\n", + " distance[node], predecessor[node] = float('inf'), None # the source node from where the algoritim start have 0 distance and all other at inf\n", + " distance[source] = 0\n", + "\n", + "\n", + "\n", + " Step 2: Relax the edges\n", + " for j in (len(G1)-1): # loop for all nodes and cheak each node distances from the other nodes\n", + " for i in node : # updateing the distances with the min values \n", + " if distance[neighbour] > distance[node] + graph[node][neighbour]: # If the distance between the node and the neighbour is lower than the current, store it\n", + " distance[neighbour], predecessor[neighbour] = distance[node] + graph[node][neighbour], node\n", + "\n", + "\n", + "\n", + " Step 3: Check for negative weight cycles\n", + " for node in graph: #raising an error in case of negitive cycles \n", + " for neighbour in graph[node]:\n", + " assert distance[neighbour] <= distance[node] + graph[node][neighbour], \"Negative weight cycle.\"\n", + "\n", + " return distance, predecessor # algoritim output the distance of each node from the source node" + ] + }, + { + "cell_type": "code", + "execution_count": 6, + "metadata": {}, + "outputs": [], + "source": [ + "def bellman_ford(G, start,end, weight = 'weight'):\n", + " # Compute shortest path lengths and predecessors on shortest paths in weighted graphs.\n", + "\n", + " if start not in G:\n", + " raise KeyError(\"Node %s is not found in the graph\"%source)\n", + " numb_nodes = len(G)\n", + "\n", + " dist = {start: 0}\n", + " pred = {start: None}\n", + "\n", + " if numb_nodes == 1:\n", + " return pred, dist\n", + "\n", + " if G.is_multigraph():\n", + " def get_weight(edge_dict):\n", + " return min([eattr.get(weight,1) for eattr in edge_dict.values()])\n", + " else:\n", + " def get_weight(edge_dict):\n", + " return edge_dict.get(weight,1)\n", + "\n", + " for i in range(numb_nodes):\n", + " if i > 5:\n", + " if dist[i] and dist[i-1] and dist[i-2] and dist[i-3] and dist[i-4] and dist[i-5] < 0 :\n", + " break \n", + " no_changes=True\n", + " # Only need edges from nodes in dist b/c all others have dist==inf\n", + " for u, dist_u in list(dist.items()): # get all edges from nodes in dist\n", + " for v, edict in G[u].items(): # double loop handles undirected too\n", + " dist_v = dist_u + get_weight(edict)\n", + " if v not in dist or dist[v] > dist_v:\n", + " dist[v] = dist_v\n", + " pred[v] = u\n", + " no_changes = False\n", + " if no_changes:\n", + " break\n", + " \n", + " #else:\n", + " #raise nx.NetworkXUnbounded(\"Negative cost cycle detected.\")\n", + " return pred, dist" + ] + }, + { + "cell_type": "code", + "execution_count": 7, + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "Bellman Ford Algoritm distances are = {'a': 0, 'b': 0.6, 'c': 0.2, 'd': 0.3, 'h': 0.8, 'l': 1.0, 'i': 1.4999999999999998, 'j': 1.2999999999999998, 'e': 0.8999999999999999, 'f': 1.1}\n", + "Runtime of the program is 0.0\n" + ] + }, + { + "data": { + "text/plain": [ + "Text(0, 0.5, 'Distances')" + ] + }, + "execution_count": 7, + "metadata": {}, + "output_type": "execute_result" + }, + { + "data": { + "image/png": "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\n", + "text/plain": [ + "
" + ] + }, + "metadata": { + "needs_background": "light" + }, + "output_type": "display_data" + } + ], + "source": [ + "import time\n", + "start = time.time()\n", + "pred,distance = bellman_ford(G1,\"a\",\"i\")\n", + "print (\"Bellman Ford Algoritm distances are = \" , distance)\n", + "end = time.time()\n", + "print(f\"Runtime of the program is {end - start}\")\n", + "\n", + "#change type of dict to list for using data for plotting\n", + "data_bel = list(distance.items())\n", + "an_array_bel = np.array(data_bel)\n", + "x = an_array_bel[:,0]\n", + "y = [float(i) for i in an_array_bel[:,1]]\n", + "plt.plot(x,y)\n", + "plt.title('Bellman_Ford Algorithm Distances Results on the Nodes')\n", + "plt.xlabel('Nodes')\n", + "plt.ylabel('Distances')\n" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "# Dijkstra algorithm" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "PseudoCode:\n", + "\n", + "Add the starting vertex s to the initially empty fringe with priority value 0\n", + "\n", + "Add all other vertices to the fringe with priority value of infinity\n", + "\n", + "While the fringe is not empty:\n", + "\n", + " Remove the vertex in the fringe with the minimum priority.\n", + " We'll call this vertex u.\n", + " Its priority is the shortest distance from s to u.\n", + " For each of u's neighbors v:\n", + " If v is not already in the priority queue, do nothing.\n", + " (We've already found the shortest distance from s to v.)\n", + " Otherwise, update v's predecessor to u, and update its priority value to the minimum of:\n", + " Its current priority value\n", + " The shortest distance from s to u + the weight of the edge (u, v)\n", + "\n", + "function Dijkstra(Graph, source):\n", + " \n", + " create vertex set Q\n", + " \n", + " for each vertex v in Graph: // Initialization\n", + " dist[v] ← INFINITY // Unknown distance from source to v\n", + " prev[v] ← UNDEFINED // Previous node in optimal path from source\n", + " add v to Q // All nodes initially in Q (unvisited nodes)\n", + " \n", + " dist[source] ← 0 // Distance from source to source\n", + " \n", + " while Q is not empty:\n", + " u ← vertex in Q with min dist[u] // Node with the least distance\n", + " // will be selected first\n", + " remove u from Q \n", + " \n", + " for each neighbor v of u: // where v is still in Q.\n", + " alt ← dist[u] + length(u, v)\n", + " if alt < dist[v]: // A shorter path to v has been found\n", + " dist[v] ← alt \n", + " prev[v] ← u \n", + "\n", + " return dist[], prev[]" + ] + }, + { + "cell_type": "code", + "execution_count": 8, + "metadata": {}, + "outputs": [], + "source": [ + "from queue import PriorityQueue\n", + "from math import inf \n", + "import networkx as nx\n", + "import matplotlib.pyplot as plt\n", + "import numpy as np\n", + "\n", + "# Dijkstra's shortest path algorithm\n", + "def dijkstra(graph, start,end):\n", + " #Get the shortest path of nodes by going backwards through prev list\n", + " \n", + " def backtrace(prev, start,end):\n", + " node = end\n", + " path = []\n", + " while node != start:\n", + " path.append(node)\n", + " node = prev[node]\n", + " path.append(node) \n", + " path.reverse()\n", + " return path\n", + " \n", + " #get the cost of edges from node to node\n", + " #cost(u,v) = edge_weight(u,v)\n", + " def cost(u, v):\n", + " return graph.get_edge_data(u,v).get('weight')\n", + " \n", + " #main algorithm\n", + " \n", + " prev = {} \n", + " # initialize distances from start to the given node \n", + " dist = {v: inf for v in list(nx.nodes(graph))} \n", + " # nodes we've visited\n", + " visited = set() \n", + " # prioritize nodes from start to node with the shortest distance!\n", + " pq = PriorityQueue() \n", + " \n", + " dist[start] = 0 # dist from start\n", + " pq.put((dist[start], start))\n", + " \n", + " while 0 != pq.qsize():\n", + " curr_cost, curr = pq.get()\n", + " visited.add(curr)\n", + " # print(f'visiting {curr}')\n", + " for neighbor in dict(graph.adjacency()).get(curr):\n", + " # if we found a shorter path \n", + " path = dist[curr] + cost(curr, neighbor)\n", + " if path < dist[neighbor]:\n", + " # update the distance, we found a shorter one\n", + " dist[neighbor] = path\n", + " # update the previous node\n", + " prev[neighbor] = curr\n", + " # if we haven't visited the neighbor\n", + " if neighbor not in visited:\n", + " # insert into priority queue and mark as visited\n", + " visited.add(neighbor)\n", + " pq.put((dist[neighbor],neighbor))\n", + " # else update the entry in the priority queue\n", + " else:\n", + " # remove old\n", + " _ = pq.get((dist[neighbor],neighbor))\n", + " # insert new\n", + " pq.put((dist[neighbor],neighbor))\n", + " \n", + " print(\"Dijkstra's Algo Output:\")\n", + " print(\"Distances\")\n", + " print(dist)\n", + " print(\"Visited\")\n", + " print(visited)\n", + " # print(\"Previous\")\n", + " # print(prev)\n", + "\n", + " \n", + " #after every possible path has been checked done\n", + " return dist, backtrace(prev, start,end), dist[end]" + ] + }, + { + "cell_type": "code", + "execution_count": 9, + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "Dijkstra's Algo Output:\n", + "Distances\n", + "{'a': 0, 'b': 0.6, 'c': 0.2, 'd': 0.3, 'e': 0.8999999999999999, 'f': 1.1, 'h': 0.8, 'l': 1.0, 'i': 1.4999999999999998, 'j': 1.2999999999999998}\n", + "Visited\n", + "{'d', 'a', 'l', 'b', 'i', 'f', 'j', 'c', 'h', 'e'}\n", + "Runtime of the program is 0.0\n" + ] + }, + { + "data": { + "text/plain": [ + "Text(0, 0.5, 'Distances')" + ] + }, + "execution_count": 9, + "metadata": {}, + "output_type": "execute_result" + }, + { + "data": { + "image/png": "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\n", + "text/plain": [ + "
" + ] + }, + "metadata": { + "needs_background": "light" + }, + "output_type": "display_data" + } + ], + "source": [ + "import time\n", + "start = time.time()\n", + "D,_,_ = dijkstra(G1,\"a\",\"i\")\n", + "end = time.time()\n", + "print(f\"Runtime of the program is {end - start}\")\n", + "#change type of dict to list for using data for plotting\n", + "data_dij= list(D.items())\n", + "an_array_dij = np.array(data_dij)\n", + "x = an_array_dij[:,0]\n", + "y = [float(i) for i in an_array_dij[:,1]]\n", + "plt.plot(x,y)\n", + "plt.title('Dijkstra Algorithm Distances Results on the Nodes')\n", + "plt.xlabel('Nodes')\n", + "plt.ylabel('Distances')" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "# Floyd-Warshall Algorithm" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + " PseudoCode : Floyd-Warshall Algorithm for shortest paths\n", + " \n", + " 3 let dist be a |V| × |V| array of minimum distances initialized to ∞ (infinity)\n", + " 4 for each edge (u, v) do\n", + " 5 dist[u][v] ← w(u, v) // The weight of the edge (u, v)\n", + " 6 for each vertex v do\n", + " 7 dist[v][v] ← 0\n", + " 8 for k from 1 to |V|\n", + " 9 for i from 1 to |V|\n", + " 10 for j from 1 to |V|\n", + " 11 if dist[i][j] > dist[i][k] + dist[k][j] \n", + " 12 dist[i][j] ← dist[i][k] + dist[k][j]\n", + " 13 end if" + ] + }, + { + "cell_type": "code", + "execution_count": 10, + "metadata": {}, + "outputs": [], + "source": [ + "from numpy import array, asarray, inf, zeros, minimum, diagonal\n", + "from numpy.random import randint\n", + "import time\n", + "import numpy as np\n", + "from scipy.sparse import csr_matrix\n", + "\n", + "INF = 99999999\n", + "\n", + "def check_adjacency_matrix(adjacency_matrix):\n", + " mat = np.asarray(adjacency_matrix)\n", + " (num_rows, num_cols) = mat.shape\n", + " # print (num_rows,ncols)\n", + " assert num_rows == num_cols\n", + " n = num_rows\n", + " assert (diagonal(mat) == 0.0).all()\n", + " return (mat, n)\n", + "\n", + "def floyd_warshall_c(adjacency_matrix): \n", + " (mat, n) = check_adjacency_matrix(adjacency_matrix)\n", + " mat_list = [mat]\n", + " for k in range(n):\n", + " nxt_mat = zeros((n,n))\n", + " for i in range(n):\n", + " for j in range(n):\n", + " nxt_mat[i,j] = min(mat[i,j], mat[i,k] + mat[k,j])\n", + " mat = nxt_mat\n", + " mat_list.append(mat)\n", + " return mat_list[-1]\n", + "\n", + "def warshall_inplace(adjacency_matrix):\n", + " (mat, n) = check_adjacency_matrix(adjacency_matrix)\n", + "\n", + " for k in range(n):\n", + " for i in range(n):\n", + " for j in range(n):\n", + " mat[i,j] = min(mat[i,j], mat[i,k] + mat[k,j])\n", + " return mat\n", + "\n", + "def graph_to_mat(graph):\n", + " m1 = nx.adjacency_matrix(graph)\n", + " m2 = csr_matrix.toarray(m1)\n", + " for i in range(0,len(graph)):\n", + " for j in range(0,len(graph)):\n", + " if( m2[i][j] == 0 and i!=j):\n", + " m2[i][j] = INF\n", + " if(i == j):\n", + " m2[i][i] = 0\n", + " return m2\n", + "##m2 is now adjacency matrix\n", + "\n", + "def floyd_warshall_output(graph):\n", + " ad_mat = graph_to_mat(graph)\n", + " output = floyd_warshall_c(ad_mat)\n", + " return output\n" + ] + }, + { + "cell_type": "code", + "execution_count": 11, + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "floyd_warshall distances are : [0. 0.6 0.2 0.3 0.9 1.1 0.8 1. 1.5 1.3]\n", + "floyd_warshall distances are : [0.6 0. 0.8 0.9 1.5 1.3 1. 0.8 0.9 0.7]\n", + "floyd_warshall distances are : [0.2 0.8 0. 0.1 0.7 0.9 0.9 1.1 1.7 1.5]\n", + "floyd_warshall distances are : [0.3 0.9 0.1 0. 0.8 1. 1. 1.2 1.8 1.6]\n", + "floyd_warshall distances are : [0.9 1.5 0.7 0.8 0. 1.5 1.2 1. 2.4 2.2]\n", + "floyd_warshall distances are : [1.1 1.3 0.9 1. 1.5 0. 0.3 0.5 2.2 2. ]\n", + "floyd_warshall distances are : [0.8 1. 0.9 1. 1.2 0.3 0. 0.2 1.9 1.7]\n", + "floyd_warshall distances are : [1. 0.8 1.1 1.2 1. 0.5 0.2 0. 1.7 1.5]\n", + "floyd_warshall distances are : [1.5 0.9 1.7 1.8 2.4 2.2 1.9 1.7 0. 0.2]\n", + "floyd_warshall distances are : [1.3 0.7 1.5 1.6 2.2 2. 1.7 1.5 0.2 0. ]\n", + "Runtime of the program is 0.09694457054138184\n" + ] + }, + { + "data": { + "text/plain": [ + "Text(0.5, 1.0, 'Floyd Warshall Algorithm Distances Results on the Nodes')" + ] + }, + "execution_count": 11, + "metadata": {}, + "output_type": "execute_result" + }, + { + "data": { + "image/png": "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\n", + "text/plain": [ + "
" + ] + }, + "metadata": { + "needs_background": "light" + }, + "output_type": "display_data" + } + ], + "source": [ + "import matplotlib.pyplot as plt\n", + "import time\n", + "start = time.time()\n", + "mat = floyd_warshall_output(G1)\n", + "for i in range(0,len(mat)):\n", + " print (\"floyd_warshall distances are :\" , mat[i] )\n", + "end = time.time()\n", + "print(f\"Runtime of the program is {end - start}\")\n", + "\n", + "fig, axes = plt.subplots(nrows=1, ncols=2, figsize=(20,5))\n", + "plt.xlabel('Nodes')\n", + "plt.ylabel('Distances')\n", + "#change type of dict to list for using data for plotting\n", + "data_floyd = list(mat)\n", + "array_floyd = np.array(data_floyd)\n", + "x1 = list(G1.nodes)\n", + "\n", + "for i in range(0,len(G1)):\n", + " y1 = [float(i) for i in array_floyd[:,i]]\n", + " axes[0].plot(x1,y1)\n", + "plt.xlabel('Nodes')\n", + "plt.ylabel('Distances')\n", + "\n", + "##for node \"a\"\n", + "x2 = list(G1.nodes)\n", + "y2 = [float(i) for i in array_floyd[:,0]]\n", + "axes[1].plot(x2,y2)\n", + "plt.title('Floyd Warshall Algorithm Distances Results on the Nodes')" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "# Johnson's Algorithm" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + " pseudo-code describes Johnson's algorithm\n", + " Johnson(G)\n", + " 1.\n", + " create G` where G`.V = G.V + {s},\n", + " G`.E = G.E + ((s, u) for u in G.V), and \n", + " weight(s, u) = 0 for u in G.V\n", + " 2.\n", + " if Bellman-Ford(s) == False\n", + " return \"The input graph has a negative weight cycle\"\n", + " else:\n", + " for vertex v in G`.V:\n", + " h(v) = distance(s, v) computed by Bellman-Ford\n", + " for edge (u, v) in G`.E:\n", + " weight`(u, v) = weight(u, v) + h(u) - h(v)\n", + " 3.\n", + " D = new matrix of distances initialized to infinity\n", + " for vertex u in G.V:\n", + " run Dijkstra(G, weight`, u) to compute distance`(u, v) for all v in G.V\n", + " for each vertex v in G.V:\n", + " D_(u, v) = distance`(u, v) + h(v) - h(u)\n", + " return D" + ] + }, + { + "cell_type": "code", + "execution_count": 12, + "metadata": {}, + "outputs": [], + "source": [ + "import matplotlib.pyplot as plt\n", + "import numpy as np\n", + "\n", + "\n", + "# Implementation of Johnson's algorithm in Python3 \n", + " \n", + "# Import function to initialize the dictionary \n", + "from collections import defaultdict \n", + "MAX_INT = float('Inf') \n", + " \n", + "# Returns the vertex with minimum \n", + "# distance from the source \n", + "def minDistance(dist, visited): \n", + " \n", + " (minimum, minVertex) = (MAX_INT, 0) \n", + " for vertex in range(len(dist)): \n", + " if minimum > dist[vertex] and visited[vertex] == False: \n", + " (minimum, minVertex) = (dist[vertex], vertex) \n", + " \n", + " return minVertex \n", + " \n", + " \n", + "# Dijkstra Algorithm for Modified \n", + "# Graph (removing negative weights) \n", + "\n", + "def Dijkstra(graph, modifiedGraph, src): \n", + " \n", + " # Number of vertices in the graph \n", + " num_vertices = len(graph) \n", + " \n", + " # Dictionary to check if given vertex is \n", + " # already included in the shortest path tree \n", + " sptSet = defaultdict(lambda : False) \n", + " \n", + " # Shortest distance of all vertices from the source \n", + " dist = [MAX_INT] * num_vertices \n", + " \n", + " dist[src] = 0\n", + " \n", + " for count in range(num_vertices): \n", + " \n", + " # The current vertex which is at min Distance \n", + " # from the source and not yet included in the \n", + " # shortest path tree \n", + " curVertex = minDistance(dist, sptSet) \n", + " sptSet[curVertex] = True\n", + " \n", + " for vertex in range(num_vertices):\n", + " \n", + " if ((sptSet[vertex] == False) and\n", + " (dist[vertex] > (dist[curVertex] + \n", + " modifiedGraph[curVertex][vertex])) and\n", + " (graph[curVertex][vertex] != 0)): \n", + " \n", + " dist[vertex] = (dist[curVertex] +\n", + " modifiedGraph[curVertex][vertex]); \n", + " \n", + " # Print the Shortest distance from the source \n", + " \n", + " for vertex in range(num_vertices): \n", + " print ('Vertex ' + str(vertex) + ': ' + str(dist[vertex]))\n", + " \n", + " #return{vertex:dist[vertex]}\n", + " \n", + " return{vertex:dist[vertex] for vertex in range(num_vertices)} \n", + " \n", + "\n", + "# Function to calculate shortest distances from source \n", + "# to all other vertices using Bellman-Ford algorithm \n", + "def BellmanFord(edges, graph, num_vertices): \n", + " \n", + " # Add a source s and calculate its min \n", + " # distance from every other node \n", + " dist = [MAX_INT] * (num_vertices + 1) \n", + " dist[num_vertices] = 0\n", + " \n", + " for i in range(num_vertices): \n", + " edges.append([num_vertices, i, 0]) \n", + " \n", + " for i in range(num_vertices): \n", + " for (src, des, weight) in edges: \n", + " if((dist[src] != MAX_INT) and \n", + " (dist[src] + weight < dist[des])): \n", + " dist[des] = dist[src] + weight \n", + " \n", + " # Don't send the value for the source added\n", + " \n", + " return dist[0:num_vertices] \n", + " \n", + "# Function to implement Johnson Algorithm \n", + "def JohnsonAlgorithm(graph): \n", + " a=nx.to_numpy_array(graph)\n", + " graph=a.tolist()\n", + " \n", + " edges = [] \n", + " \n", + " # Create a list of edges for Bellman-Ford Algorithm \n", + " for i in range(len(graph)): \n", + " for j in range(len(graph[i])): \n", + " \n", + " if graph[i][j] != 0: \n", + " edges.append([i, j, graph[i][j]]) \n", + " \n", + " # Weights used to modify the original weights \n", + " modifyWeights = BellmanFord(edges, graph, len(graph)) \n", + " \n", + " modifiedGraph = [[0 for x in range(len(graph))] for y in\n", + " range(len(graph))] \n", + " \n", + " # Modify the weights to get rid of negative weights \n", + " for i in range(len(graph)): \n", + " for j in range(len(graph[i])): \n", + " \n", + " if graph[i][j] != 0: \n", + " modifiedGraph[i][j] = (graph[i][j] + \n", + " modifyWeights[i] - modifyWeights[j]); \n", + " \n", + " print ('Modified Graph: ' + str(modifiedGraph)) \n", + " \n", + " # Run Dijkstra for every vertex as source one by one \n", + " for src in range(len(graph)): \n", + " print ('\\nShortest Distance with vertex ' +\n", + " str(src) + ' as the source:\\n') \n", + " Dijkstra(graph, modifiedGraph, src)\n", + " \n", + "\n", + "# Driver Code \n", + "# graph = a_to_list\n", + "\n", + "# import time\n", + "\n", + "# start = time.time()\n", + "# JohnsonAlgorithm(graph)\n", + "# end = time.time()\n", + "# al_time=end - start\n", + " \n", + "# print(f\"Runtime of the program is {al_time}\")\n" + ] + }, + { + "cell_type": "code", + "execution_count": 13, + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "Modified Graph: [[0, 0.6, 0.2, 0.3, 0, 0, 0.8, 0, 0, 0], [0.6, 0, 0, 0, 0, 0, 0, 0.8, 2.0, 0.7], [0.2, 0, 0, 0.1, 0.7, 0.9, 0.9, 0, 0, 0], [0.3, 0, 0.1, 0, 0, 0, 0, 0, 0, 0], [0, 0, 0.7, 0, 0, 0, 0, 1.0, 0, 0], [0, 0, 0.9, 0, 0, 0, 0.3, 0, 0, 0], [0.8, 0, 0.9, 0, 0, 0.3, 0, 0.2, 0, 0], [0, 0.8, 0, 0, 1.0, 0, 0.2, 0, 0, 0], [0, 2.0, 0, 0, 0, 0, 0, 0, 0, 0.2], [0, 0.7, 0, 0, 0, 0, 0, 0, 0.2, 0]]\n", + "\n", + "Shortest Distance with vertex 0 as the source:\n", + "\n", + "Vertex 0: 0\n", + "Vertex 1: 0.6\n", + "Vertex 2: 0.2\n", + "Vertex 3: 0.3\n", + "Vertex 4: 0.8999999999999999\n", + "Vertex 5: 1.1\n", + "Vertex 6: 0.8\n", + "Vertex 7: 1.0\n", + "Vertex 8: 1.4999999999999998\n", + "Vertex 9: 1.2999999999999998\n", + "\n", + "Shortest Distance with vertex 1 as the source:\n", + "\n", + "Vertex 0: 0.6\n", + "Vertex 1: 0\n", + "Vertex 2: 0.8\n", + "Vertex 3: 0.8999999999999999\n", + "Vertex 4: 1.5\n", + "Vertex 5: 1.3\n", + "Vertex 6: 1.0\n", + "Vertex 7: 0.8\n", + "Vertex 8: 0.8999999999999999\n", + "Vertex 9: 0.7\n", + "\n", + "Shortest Distance with vertex 2 as the source:\n", + "\n", + "Vertex 0: 0.2\n", + "Vertex 1: 0.8\n", + "Vertex 2: 0\n", + "Vertex 3: 0.1\n", + "Vertex 4: 0.7\n", + "Vertex 5: 0.9\n", + "Vertex 6: 0.9\n", + "Vertex 7: 1.1\n", + "Vertex 8: 1.7\n", + "Vertex 9: 1.5\n", + "\n", + "Shortest Distance with vertex 3 as the source:\n", + "\n", + "Vertex 0: 0.3\n", + "Vertex 1: 0.8999999999999999\n", + "Vertex 2: 0.1\n", + "Vertex 3: 0\n", + "Vertex 4: 0.7999999999999999\n", + "Vertex 5: 1.0\n", + "Vertex 6: 1.0\n", + "Vertex 7: 1.2\n", + "Vertex 8: 1.7999999999999998\n", + "Vertex 9: 1.5999999999999999\n", + "\n", + "Shortest Distance with vertex 4 as the source:\n", + "\n", + "Vertex 0: 0.8999999999999999\n", + "Vertex 1: 1.5\n", + "Vertex 2: 0.7\n", + "Vertex 3: 0.7999999999999999\n", + "Vertex 4: 0\n", + "Vertex 5: 1.5\n", + "Vertex 6: 1.2\n", + "Vertex 7: 1.0\n", + "Vertex 8: 2.4000000000000004\n", + "Vertex 9: 2.2\n", + "\n", + "Shortest Distance with vertex 5 as the source:\n", + "\n", + "Vertex 0: 1.1\n", + "Vertex 1: 1.3\n", + "Vertex 2: 0.9\n", + "Vertex 3: 1.0\n", + "Vertex 4: 1.5\n", + "Vertex 5: 0\n", + "Vertex 6: 0.3\n", + "Vertex 7: 0.5\n", + "Vertex 8: 2.2\n", + "Vertex 9: 2.0\n", + "\n", + "Shortest Distance with vertex 6 as the source:\n", + "\n", + "Vertex 0: 0.8\n", + "Vertex 1: 1.0\n", + "Vertex 2: 0.9\n", + "Vertex 3: 1.0\n", + "Vertex 4: 1.2\n", + "Vertex 5: 0.3\n", + "Vertex 6: 0\n", + "Vertex 7: 0.2\n", + "Vertex 8: 1.9\n", + "Vertex 9: 1.7\n", + "\n", + "Shortest Distance with vertex 7 as the source:\n", + "\n", + "Vertex 0: 1.0\n", + "Vertex 1: 0.8\n", + "Vertex 2: 1.1\n", + "Vertex 3: 1.2000000000000002\n", + "Vertex 4: 1.0\n", + "Vertex 5: 0.5\n", + "Vertex 6: 0.2\n", + "Vertex 7: 0\n", + "Vertex 8: 1.7\n", + "Vertex 9: 1.5\n", + "\n", + "Shortest Distance with vertex 8 as the source:\n", + "\n", + "Vertex 0: 1.5\n", + "Vertex 1: 0.8999999999999999\n", + "Vertex 2: 1.7\n", + "Vertex 3: 1.8\n", + "Vertex 4: 2.4\n", + "Vertex 5: 2.1999999999999997\n", + "Vertex 6: 1.9\n", + "Vertex 7: 1.7\n", + "Vertex 8: 0\n", + "Vertex 9: 0.2\n", + "\n", + "Shortest Distance with vertex 9 as the source:\n", + "\n", + "Vertex 0: 1.2999999999999998\n", + "Vertex 1: 0.7\n", + "Vertex 2: 1.4999999999999998\n", + "Vertex 3: 1.5999999999999999\n", + "Vertex 4: 2.1999999999999997\n", + "Vertex 5: 2.0\n", + "Vertex 6: 1.7\n", + "Vertex 7: 1.5\n", + "Vertex 8: 0.2\n", + "Vertex 9: 0\n", + "Runtime of the program is 0.00699615478515625\n" + ] + } + ], + "source": [ + "start = time.time()\n", + "JohnsonAlgorithm(G1)\n", + "end = time.time()\n", + "print(f\"Runtime of the program is {end - start}\")" + ] + }, + { + "cell_type": "code", + "execution_count": 23, + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "Vertex 0: 0\n", + "Vertex 1: 0.6\n", + "Vertex 2: 0.2\n", + "Vertex 3: 0.3\n", + "Vertex 4: 0.8999999999999999\n", + "Vertex 5: 1.1\n", + "Vertex 6: 0.8\n", + "Vertex 7: 1.0\n", + "Vertex 8: 1.4999999999999998\n", + "Vertex 9: 1.2999999999999998\n", + "Vertex 0: 0\n", + "Vertex 1: 0.6\n", + "Vertex 2: 0.2\n", + "Vertex 3: 0.3\n", + "Vertex 4: 0.8999999999999999\n", + "Vertex 5: 1.1\n", + "Vertex 6: 0.8\n", + "Vertex 7: 1.0\n", + "Vertex 8: 1.4999999999999998\n", + "Vertex 9: 1.2999999999999998\n", + "Vertex 0: 0.6\n", + "Vertex 1: 0\n", + "Vertex 2: 0.8\n", + "Vertex 3: 0.8999999999999999\n", + "Vertex 4: 1.5\n", + "Vertex 5: 1.3\n", + "Vertex 6: 1.0\n", + "Vertex 7: 0.8\n", + "Vertex 8: 0.8999999999999999\n", + "Vertex 9: 0.7\n", + "Vertex 0: 0.2\n", + "Vertex 1: 0.8\n", + "Vertex 2: 0\n", + "Vertex 3: 0.1\n", + "Vertex 4: 0.7\n", + "Vertex 5: 0.9\n", + "Vertex 6: 0.9\n", + "Vertex 7: 1.1\n", + "Vertex 8: 1.7\n", + "Vertex 9: 1.5\n", + "Vertex 0: 0.3\n", + "Vertex 1: 0.8999999999999999\n", + "Vertex 2: 0.1\n", + "Vertex 3: 0\n", + "Vertex 4: 0.7999999999999999\n", + "Vertex 5: 1.0\n", + "Vertex 6: 1.0\n", + "Vertex 7: 1.2\n", + "Vertex 8: 1.7999999999999998\n", + "Vertex 9: 1.5999999999999999\n", + "Vertex 0: 0.8999999999999999\n", + "Vertex 1: 1.5\n", + "Vertex 2: 0.7\n", + "Vertex 3: 0.7999999999999999\n", + "Vertex 4: 0\n", + "Vertex 5: 1.5\n", + "Vertex 6: 1.2\n", + "Vertex 7: 1.0\n", + "Vertex 8: 2.4000000000000004\n", + "Vertex 9: 2.2\n", + "Vertex 0: 1.1\n", + "Vertex 1: 1.3\n", + "Vertex 2: 0.9\n", + "Vertex 3: 1.0\n", + "Vertex 4: 1.5\n", + "Vertex 5: 0\n", + "Vertex 6: 0.3\n", + "Vertex 7: 0.5\n", + "Vertex 8: 2.2\n", + "Vertex 9: 2.0\n", + "Vertex 0: 0.8\n", + "Vertex 1: 1.0\n", + "Vertex 2: 0.9\n", + "Vertex 3: 1.0\n", + "Vertex 4: 1.2\n", + "Vertex 5: 0.3\n", + "Vertex 6: 0\n", + "Vertex 7: 0.2\n", + "Vertex 8: 1.9\n", + "Vertex 9: 1.7\n", + "Vertex 0: 1.0\n", + "Vertex 1: 0.8\n", + "Vertex 2: 1.1\n", + "Vertex 3: 1.2000000000000002\n", + "Vertex 4: 1.0\n", + "Vertex 5: 0.5\n", + "Vertex 6: 0.2\n", + "Vertex 7: 0\n", + "Vertex 8: 1.7\n", + "Vertex 9: 1.5\n", + "Vertex 0: 1.5\n", + "Vertex 1: 0.8999999999999999\n", + "Vertex 2: 1.7\n", + "Vertex 3: 1.8\n", + "Vertex 4: 2.4\n", + "Vertex 5: 2.1999999999999997\n", + "Vertex 6: 1.9\n", + "Vertex 7: 1.7\n", + "Vertex 8: 0\n", + "Vertex 9: 0.2\n", + "Vertex 0: 1.2999999999999998\n", + "Vertex 1: 0.7\n", + "Vertex 2: 1.4999999999999998\n", + "Vertex 3: 1.5999999999999999\n", + "Vertex 4: 2.1999999999999997\n", + "Vertex 5: 2.0\n", + "Vertex 6: 1.7\n", + "Vertex 7: 1.5\n", + "Vertex 8: 0.2\n", + "Vertex 9: 0\n" + ] + }, + { + "data": { + "text/plain": [ + "Text(0, 0.5, 'Distances')" + ] + }, + "execution_count": 23, + "metadata": {}, + "output_type": "execute_result" + }, + { + "data": { + "image/png": "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\n", + "text/plain": [ + "
" + ] + }, + "metadata": { + "needs_background": "light" + }, + "output_type": "display_data" + } + ], + "source": [ + "a=nx.to_numpy_array(G1)\n", + "a_to_list=a.tolist()\n", + "D=Dijkstra(a_to_list,a_to_list,0)\n", + "fig, axes = plt.subplots(nrows=1, ncols=2, figsize=(20,5))\n", + "plt.xlabel('Nodes')\n", + "plt.ylabel('Distances')\n", + "data_dij= list(D.items())\n", + "an_array_dij = np.array(data_dij)\n", + "x1 = ['a','b','c','d','e','f','h','l','i','j']\n", + "y1= [float(i) for i in an_array_dij[:,1]]\n", + "axes[0].plot(x1,y1)\n", + "\n", + "plt.xlabel('Nodes')\n", + "plt.ylabel('Distances')\n", + "plt.title('Johnson Algorithm Distances base on node a')\n", + "for src in range(len(a_to_list)): \n", + " D=Dijkstra(a_to_list,a_to_list,src)\n", + " data_dij= list(D.items())\n", + " an_array_dij = np.array(data_dij)\n", + " x2 = ['a','b','c','d','e','f','h','l','i','j']\n", + " y2 = [float(i) for i in an_array_dij[:,1]]\n", + " axes[1].plot(x2,y2)\n", + "plt.title('Johnson Algorithm Distances base on all nodes') \n", + "plt.xlabel('Nodes')\n", + "plt.ylabel('Distances')\n", + "\n", + "#plt.savefig('plot for all nodes.png', bbox_inches='tight')" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "# Network with random weights" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "### Network with 100 nodes" + ] + }, + { + "cell_type": "code", + "execution_count": 2, + "metadata": {}, + "outputs": [ + { + "data": { + "image/png": "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\n", + "text/plain": [ + "
" + ] + }, + "metadata": {}, + "output_type": "display_data" + } + ], + "source": [ + "import numpy as np\n", + "import networkx as nx\n", + "import matplotlib.pyplot as plt\n", + "\n", + "k1= np.random.randint(-5,20,5450)\n", + "k2= np.random.randint(-5,20,5450)\n", + "k= k1+k2\n", + "\n", + "o= np.random.randint(1,100,5450)\n", + "G2=nx.Graph()\n", + "\n", + "for i in range (1,100):\n", + " for j in range (1,10):\n", + " G2.add_edge(i, o[i*j-i+j], weight=k[i*j-j])\n", + "\n", + "nx.draw(G2, with_labels=True) \n", + "plt.show() " + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "### Here we are going to see the performance of each algorithm for positive delays vs the number of the nodes of the network. We ran the codes before and here we just have the results.\n", + "\n", + "As we can see Dijkstra algorithm is the fastest algorithm then, Bellman_ford , Johnson and at the end we have Floyd_Warshal. Since Floyd_Warshal is the slowest one, we do not use it in the optimization part. \n", + "\n", + "Since Bellman_Ford algorithm and Dijkstra Algorithm runtime are very similaer, in the graph we can not see the Bellman_Ford very good but from the times we understand that Dijkstar is fastar than Bellman_Ford. " + ] + }, + { + "cell_type": "code", + "execution_count": 69, + "metadata": {}, + "outputs": [ + { + "data": { + "text/plain": [ + "" + ] + }, + "execution_count": 69, + "metadata": {}, + "output_type": "execute_result" + }, + { + "data": { + "image/png": "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\n", + "text/plain": [ + "
" + ] + }, + "metadata": { + "needs_background": "light" + }, + "output_type": "display_data" + } + ], + "source": [ + "Bell_man_runtime = [0.023984193801879883,0.025988340377807617,0.06296491622924805,0.07496070861816406,0.0799570083618164]\n", + "Dijkstra_runtime = [0.011992216110229492,0.0199892520904541,0.030983924865722656,0.055970191955566406,0.05597233772277832]\n", + "Floyd_runtime = [9.138299226760864,9.968877792358398,34.31936526298523,77.66709923744202,147.5828127861023]\n", + "Johnson_runtime = [8.657552003860474,8.8374605178833,24.89047360420227,52.356316804885864,90.8533194065094]\n", + "nodes = [100,200,300,400,500]\n", + "plt.plot(nodes,Bell_man_runtime,label='Bellman_Ford',color ='black')\n", + "plt.plot(nodes,Dijkstra_runtime,label='Dijkstra',color ='red')\n", + "plt.plot(nodes,Floyd_runtime,label='Floyd_Warshal',color ='blue')\n", + "plt.plot(nodes,Johnson_runtime,label='Johnson',color= 'green')\n", + "plt.title('Four ALgorithm runtime on the same number of Nodes for positive delays')\n", + "plt.xlabel('Nodes')\n", + "plt.ylabel('Time(Second)')\n", + "plt.legend()" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "# Optimization" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "After we saw the performance of the algorithms we decided to make an optimized algorithm.\n", + "\n", + "We know that Dijkstra algorithm can not work on the networks with negative delays but it has best performance on the network with positive delays and also bellman_ford does not work with negative cycles but has better performance than Johnson's algorithm so first, we check the negative delays(weights) of the network and then the negative cycles of it, then we decide the algorithm to use." + ] + }, + { + "cell_type": "code", + "execution_count": 70, + "metadata": {}, + "outputs": [], + "source": [ + "def Optimization(graph, start, end):\n", + " start1 = time.time()\n", + "\n", + " list1 =[]\n", + " for (u, v, wt) in graph.edges.data('weight'):\n", + " list1.append(wt)\n", + " \n", + " if min(list1) >= 0:\n", + " print(\"Since all the weights are positive we use Dijkstra Algorithm\")\n", + " output = dijkstra(graph, start,end)\n", + " end1 = time.time()\n", + " time_opt = end1 - start1\n", + " print(f\"Runtime of the program is {end1 - start1}\")\n", + " else:\n", + " h,d= bellman_ford(graph, start,end)\n", + " if d[1]>= 0:\n", + " print(\"Since we have negative weights we use Bellman_Ford Algorithm\")\n", + " output = d\n", + " end1 = time.time()\n", + " time_opt = end1 - start1\n", + " print(f\"Runtime of the program is {end1 - start1}\")\n", + " else:\n", + "# G_John = nx.to_numpy_array(graph)\n", + "# G_John_to_list=G_John.tolist()\n", + " print(\"Since we have negative cycles we use Johnson Algorithm\")\n", + " output = JohnsonAlgorithm(graph)\n", + " end1 = time.time()\n", + " time_opt = end1 - start1\n", + " print(f\"Runtime of the program is {end1 - start1}\")\n", + " return output, time_opt" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "#### For this part we are going to see the runtime result of Johnson's algorithm and Optimized algorithm versus the number of nodes of the network. For this part we used random vectors from -4 to 20 to ensure that the network will have negative cycles." + ] + }, + { + "cell_type": "code", + "execution_count": 72, + "metadata": {}, + "outputs": [ + { + "data": { + "text/plain": [ + "" + ] + }, + "execution_count": 72, + "metadata": {}, + "output_type": "execute_result" + }, + { + "data": { + "image/png": "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\n", + "text/plain": [ + "
" + ] + }, + "metadata": { + "needs_background": "light" + }, + "output_type": "display_data" + } + ], + "source": [ + "runtime_opt = [2.8528432846069336,3.6596622467041016,11.19705080986023,27.426850080490112,54.48805904388428]\n", + "runtime_john = [2.7328615188598633,3.3620734214782715,11.050863027572632,26.686607599258423,54.467050313949585]\n", + "nodes = [100,200,300,400,500]\n", + "\n", + "plt.plot(nodes,runtime_opt,label='optimized')\n", + "plt.plot(nodes,runtime_john,label='johnson')\n", + "plt.title('Johnsons Algorithm runtime vs Optimized Algorithm on the same number of Nodes for negative cycles')\n", + "plt.xlabel('Nodes')\n", + "plt.ylabel('Time(Second)')\n", + "plt.legend()" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "#### Now we change the random vector to 1 to 20 to ensure that we have positive delays." + ] + }, + { + "cell_type": "code", + "execution_count": 74, + "metadata": {}, + "outputs": [ + { + "data": { + "text/plain": [ + "" + ] + }, + "execution_count": 74, + "metadata": {}, + "output_type": "execute_result" + }, + { + "data": { + "image/png": "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\n", + "text/plain": [ + "
" + ] + }, + "metadata": { + "needs_background": "light" + }, + "output_type": "display_data" + } + ], + "source": [ + "runtime_opt1 = [0.01595473289489746,0.01894831657409668,0.029916763305664062,0.0668172836303711,0.06582379341125488]\n", + "runtime_john1 = [2.9262874126434326,3.79034686088562,12.649223566055298,29.23004150390625,57.11960220336914]\n", + "nodes = [100,200,300,400,500]\n", + "plt.plot(nodes,runtime_opt1,label='optimized')\n", + "plt.plot(nodes,runtime_john1,label='johnson')\n", + "plt.title('Johnsons Algorithm runtime vs Optimized Algorithm on the same number of Nodes for positive delays')\n", + "plt.xlabel('Nodes')\n", + "plt.ylabel('Time(Second)')\n", + "plt.legend()" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "#### Now we change the random vector both to -1 to 20." + ] + }, + { + "cell_type": "code", + "execution_count": 75, + "metadata": {}, + "outputs": [ + { + "data": { + "text/plain": [ + "" + ] + }, + "execution_count": 75, + "metadata": {}, + "output_type": "execute_result" + }, + { + "data": { + "image/png": "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\n", + "text/plain": [ + "
" + ] + }, + "metadata": { + "needs_background": "light" + }, + "output_type": "display_data" + } + ], + "source": [ + "runtime_opt2 = [0.01496577262878418,0.02692866325378418,0.07081079483032227,0.07978510856628418,0.1057126522064209]\n", + "runtime_john2 = [0.3584282398223877,1.1299817562103271,1.8714807033538818,2.939188241958618,3.008173704147339]\n", + "nodes = [20,40,60,80,100]\n", + "plt.plot(nodes,runtime_opt2,label='optimized')\n", + "plt.plot(nodes,runtime_john2,label='johnson')\n", + "plt.title('Johnsons Algorithm runtime vs Optimized Algorithm on the same number of Nodes')\n", + "plt.xlabel('Nodes')\n", + "plt.ylabel('Time(Second)')\n", + "plt.legend()" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "metadata": {}, + "outputs": [], + "source": [] + } + ], + "metadata": { + "kernelspec": { + "display_name": "Python 3", + "language": "python", + "name": "python3" + }, + "language_info": { + "codemirror_mode": { + "name": "ipython", + "version": 3 + }, + "file_extension": ".py", + "mimetype": "text/x-python", + "name": "python", + "nbconvert_exporter": "python", + "pygments_lexer": "ipython3", + "version": "3.7.3" + } + }, + "nbformat": 4, + "nbformat_minor": 2 +} diff --git a/README.md b/README.md index 4d20dbe..6d330a4 100644 --- a/README.md +++ b/README.md @@ -1,20 +1,45 @@ -# Final Projects for Laboratory of Computational Physics - -In each of the branches of this repo you find all the necessary to complete your final project. -In particular the file Project.ipynb describes the projects and provides guidance to its development. -Other files could be present if needed. - -Each branch is named after the group of students a given project is assigned to. -The groups compositions are listed [here](https://docs.google.com/spreadsheets/d/1UgRLj6IvLYC-3LQBT1lKkr1SPVbn4hbBdVuWV0Ky6nM/edit#gid=0). - -Students are supposed to work together to produce a short report on the assigned task, which will have to be committed to the group branch together with the code developed to achieve the results. The preferred format for the latter is a jupyter notebook, with the proper description, the code implemented for the purpose and the actual results (plots, tables, etc.). The notebook has to be delivered with all the cells executed. - -### Computing Resources - -A Virtual Machine within [CloudVeneto](http://cloudveneto.it/) can be created for each group. Note that, by default, they are not. For some projects though, large datasets are needed, in those cases a VM has been created to store those files. Refer to ClouldInstructions.md for the steps to take in order to use those resources. - -Alternatively, students can use [colab](https://colab.research.google.com/) (for which though no instructions are provided here). - -### Dates for the exams - -Exams will take place on the dates officially scheduled by the university. It is however possible to enable extra dates whenever during the year with the condition that at least 4 groups at the time have to participate to the exam. +# Delay Tolerant Networks +## Group 10 + +In this project, we imported the algorithms for finding the shortest path between the two furthest nodes in a network. +We have four algorithms: Bellman_Ford, Dijkstra, Floyd_Warshal, Johnson. + +We did an optimization based on the properties of the algorithms. + +You can find all the codes in the file HLP_Project_Group10.ipynb + +### The libraries which we used for this project are: + NumPy + + networkx + + matplotlib + + time + + math + + queue + + scipy + +NetworkX is a Python library for studying graphs and networks. + + +## Dijkstra algorithm +Dijkstra algorithm only can have the results on the networks with positive delays, so we used it just for the networks with positive delays. This algorithm is the fastest algorithm among the algorithms for the networks with positive delays. + +![face](https://upload.wikimedia.org/wikipedia/commons/thumb/5/57/Dijkstra_Animation.gif/220px-Dijkstra_Animation.gif) + +## Bellman_Ford algorithm +Bellman_Ford algorithm only can have the results on the networks with both positive and negative delays, but not on networks with negative cycles. After the Dijkstra algorithm, Bellman_Ford is the fastest algorithm on the networks without negative cycles. +![face](https://media.geeksforgeeks.org/wp-content/uploads/bellmanford3.png) + +## Johnson's algorithm +Johnson's algorithm works for all networks with every delay value, but it is slower than Dijkstra and Bellman_ford for positive and negative delays networks. +![face](https://upload.wikimedia.org/wikipedia/commons/thumb/4/4f/Johnson%27s_algorithm.svg/1280px-Johnson%27s_algorithm.svg.png) + +## Floyd_Warshal +Floyd_Warshal is the slowest algorithm among the algorithms. Also, it is like Bellman_Ford, so it does not work with the networks with negative cycles. + +![face](https://upload.wikimedia.org/wikipedia/commons/thumb/2/2e/Floyd-Warshall_example.svg/1280px-Floyd-Warshall_example.svg.png)