graph.IPYNB

{
 "cells": [
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    " # Simulated Annealing for TSP C implementation\n",
    "\n",
    "made by Daniel Grbac Bravo and Kealan Barry\n",
    "\n",
    " ### How to run the program\n",
    "\n",
    "- `-n` or `-N`: This argument is used to specify the number of cities. The value for this argument should be an integer. If this argument is not provided, the default value of 30 is used.\n",
    "\n",
    "- `-t` or `-T`: This argument is used to specify the initial temperature. The value for this argument should be a float. If this argument is not provided, the default value of 100 is used.\n",
    "\n",
    "- `-c` or `-C`: This argument is used to specify the cooling rate. The value for this argument should be a float. If this argument is not provided, the default value of 0.99 is used.\n",
    "\n",
    "- `-file` or `-FILE`: This argument is used to specify the input file containing the city coordinates. The value for this argument should be the path to the input file. If this argument is not provided, the program will generate random city coordinates.\n",
    "\n",
    "- `-random` or `-RANDOM`: This argument is used to generate random city coordinates. If this argument is not provided, the program will read the city coordinates from the input file specified by the `-file` argument.\n",
    "\n",
    "Note that the program uses `strcmp()` to compare the argument strings, so the arguments are case-sensitive. Also, the program assumes that the arguments are provided in the correct order. If an argument is missing or the value for an argument is not provided, the program will use the default value."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "%%bash\n",
    "make clean\n",
    "rm data.csv\n",
    "rm path.csv\n",
    "make run ARGS=\"-C 0.999 -T 40 -N 100 -random -nui -SAVEALLPATHS\""
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": []
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "import pandas as pd\n",
    "import plotly.graph_objs as go\n",
    "import matplotlib.pyplot as plt"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "nCities = 100;\n",
    "data = pd.read_csv('data.csv', names=['epoch', 'temperature', 'energy'])\n",
    "path_data = pd.read_csv('path.csv', names=['x', 'y'])\n",
    "final_path_data = pd.read_csv('final.csv', names=['x', 'y'])"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "# Split the data into separate paths assuming that each path has 19 points\n",
    "num_paths = len(path_data) // nCities\n",
    "if num_paths > 1000:\n",
    "  exit(1)\n",
    "  \n",
    "paths = [path_data.iloc[i*nCities:(i+1)*nCities].reset_index(drop=True) for i in range(num_paths)]\n",
    "\n",
    "# Create a figure with an initial empty scatter plot\n",
    "fig = go.Figure(\n",
    "    data=[go.Scatter(x=[], y=[], mode='lines+markers')],\n",
    "    layout=go.Layout(\n",
    "        title=dict(text='TSP Paths'),\n",
    "        xaxis=dict(range=[min(path_data['x']), max(path_data['x'])], autorange=False),\n",
    "        yaxis=dict(range=[min(path_data['y']), max(path_data['y'])], autorange=False),\n",
    "        template='plotly_dark',\n",
    "        updatemenus=[dict(\n",
    "            type=\"buttons\",\n",
    "            buttons=[dict(label=\"Play\", method=\"animate\",\n",
    "                          args=[None, {\"frame\": {\"duration\": 5, \"redraw\": True}}]),\n",
    "                     dict(label=\"Pause\", method=\"animate\",\n",
    "                          args=[[None], {\"frame\": {\"duration\": 0, \"redraw\": False}}])]\n",
    "        )]\n",
    "    ),\n",
    "    frames=[go.Frame(data=[go.Scatter(x=path['x'], y=path['y'], mode='lines+markers')],\n",
    "                     name=str(k)) for k, path in enumerate(paths)]\n",
    ")\n",
    "\n",
    "# Show the figure\n",
    "fig.show()"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    " # Generated Graphs from the C implementation of the algorithm "
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "\n",
    "# Create the final path\n",
    "final_path = go.Scatter(x=final_path_data['x'], y=final_path_data['y'], mode='lines+markers',\n",
    "                        marker=dict())\n",
    "\n",
    "# Create a figure with an initial empty scatter plot\n",
    "\n",
    "fig = go.Figure(\n",
    "  \n",
    "    data=[final_path],\n",
    "    layout=go.Layout(\n",
    "        title=dict(text='TSP Paths'),\n",
    "        xaxis=dict(range=[min(path_data['x']), max(path_data['x'])], autorange=False),\n",
    "        yaxis=dict(range=[min(path_data['y']), max(path_data['y'])], autorange=False),\n",
    "        template='plotly_dark'\n",
    "    )\n",
    "    \n",
    ")\n",
    "\n",
    "# mark the start and end points\n",
    "\n",
    "fig.add_trace(go.Scatter(x=[path_data['x'][0]], y=[path_data['y'][0]], mode='markers',\n",
    "                          marker=dict(color='green', size=10)))\n",
    "fig.add_trace(go.Scatter(x=[path_data['x'][len(path_data)-1]], y=[path_data['y'][len(path_data)-1]], mode='markers',\n",
    "                          marker=dict(color='red', size=10, symbol='x')))\n",
    "# Show the figure\n",
    "fig.show()"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "\n",
    "# plot energy vs epoch\n",
    "fig1 = go.Figure()\n",
    "fig1.add_trace(go.Scatter(x=data['epoch'], y=data['energy'], mode='lines', name='Energy'))\n",
    "fig1.update_layout(title='Energy (Distance) per Epoch', xaxis_title='Epoch', yaxis_title='Energy (Path Distance)', template='plotly_dark')\n",
    "fig1.show()\n",
    "\n",
    "# plot temperature vs epoch\n",
    "fig2 = go.Figure()\n",
    "fig2.add_trace(go.Scatter(x=data['epoch'], y=data['temperature'], mode='lines', name='Temperature'))\n",
    "fig2.update_layout(title='Temperature vs Epoch', xaxis_title='Epoch', yaxis_title='Temperature', template='plotly_dark')\n",
    "fig2.show()\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "import plotly.express as px\n",
    "\n",
    "# create scatter plot of temperature vs energy\n",
    "fig3 = px.scatter(data, x='temperature', y='energy', color='epoch', template='plotly_dark')\n",
    "fig3.update_layout(title='Temperature vs Energy', xaxis_title='Temperature', yaxis_title='Energy')\n",
    "fig3.show()"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "# graphs generated for the report and saved to the graphs folder"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "# plot energy vs epoch\n",
    "plt.figure()\n",
    "plt.plot(data['epoch'], data['energy'])\n",
    "plt.title('Energy (Distance) per Epoch')\n",
    "plt.xlabel('Epoch')\n",
    "plt.ylabel('Energy (Path Distance)')\n",
    "plt.savefig('graphs/energy.png')\n",
    "\n",
    "# plot temperature vs epoch\n",
    "plt.figure()\n",
    "plt.plot(data['epoch'], data['temperature'])\n",
    "plt.title('Temperature vs Epoch')\n",
    "plt.xlabel('Epoch')\n",
    "plt.ylabel('Temperature')\n",
    "plt.savefig('graphs/temperature.png')\n",
    "\n",
    "# create scatter plot of temperature vs energy\n",
    "plt.figure()\n",
    "plt.scatter(data['temperature'], data['energy'], c=data['epoch'])\n",
    "plt.title('Temperature vs Energy')\n",
    "plt.xlabel('Temperature')\n",
    "plt.ylabel('Energy (Path Distance)')\n",
    "plt.savefig('graphs/temp_vs_energy.png')\n",
    "\n",
    "# create final path graph\n",
    "\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "# Split the data into separate paths assuming that each path has nCities points\n",
    "num_paths = len(path_data) // nCities\n",
    "paths = [path_data.iloc[i*nCities:(i+1)*nCities].reset_index(drop=True) for i in range(num_paths)]\n",
    "\n",
    "# Create the inital path\n",
    "inital_path = plt.plot(paths[0]['x'], paths[0]['y'], 'b-')\n",
    "\n",
    "# mark the start and end points\n",
    "plt.plot(paths[0]['x'][0], paths[0]['y'][0], 'go')\n",
    "plt.plot(paths[0]['x'][len(paths[0])-1], paths[0]['y'][len(paths[0])-1], 'rx')\n",
    "\n",
    "plt.title('Inital Path')\n",
    "plt.xlabel('x')\n",
    "plt.ylabel('y')\n",
    "plt.savefig('graphs/inital_path.png')\n",
    "plt.show()\n",
    "\n",
    "\n",
    "\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "# create  the final path graph but with mathplotlib and save them to graphs folder\n",
    "\n",
    "path_data = final_path_data\n",
    "\n",
    "final_path = plt.plot(path_data['x'], path_data['y'], 'b-')\n",
    "\n",
    "# mark the start and end points\n",
    "plt.plot(path_data['x'][0], path_data['y'][0], 'go')\n",
    "plt.plot(path_data['x'][len(path_data)-1], path_data['y'][len(path_data)-1], 'rx')\n",
    "\n",
    "plt.title('Final Path')\n",
    "plt.xlabel('x')\n",
    "plt.ylabel('y')\n",
    "plt.savefig('graphs/final_path.png')\n",
    "plt.show()\n"
   ]
  }
 ],
 "metadata": {
  "kernelspec": {
   "display_name": "manim",
   "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"
  }
 },
 "nbformat": 4,
 "nbformat_minor": 2
}