diff --git a/docs/_sources/notebooks/Use-case-facility-location.ipynb.txt b/docs/_sources/notebooks/facility-location.ipynb.txt
similarity index 100%
rename from docs/_sources/notebooks/Use-case-facility-location.ipynb.txt
rename to docs/_sources/notebooks/facility-location.ipynb.txt
diff --git a/docs/_sources/notebooks/Advanced-spaghetti-tutorial.ipynb.txt b/docs/_sources/notebooks/network-analysis.ipynb.txt
similarity index 99%
rename from docs/_sources/notebooks/Advanced-spaghetti-tutorial.ipynb.txt
rename to docs/_sources/notebooks/network-analysis.ipynb.txt
index 05d44ff1..8241bb12 100644
--- a/docs/_sources/notebooks/Advanced-spaghetti-tutorial.ipynb.txt
+++ b/docs/_sources/notebooks/network-analysis.ipynb.txt
@@ -27,8 +27,8 @@
"\n",
"----------------\n",
"\n",
- "## Advanced `pysal.spaghetti` tutorial\n",
- "### Creating and visualizing a `spaghetti.Network` object\n",
+ "## Spatial network analysis\n",
+ "### Demonstrating network representation and cluster detection\n",
"\n",
"**Author: James D. Gaboardi** **
**\n",
"\n",
diff --git a/notebooks/Basic-spaghetti-tutorial.ipynb b/docs/_sources/notebooks/quickstart.ipynb.txt
similarity index 99%
rename from notebooks/Basic-spaghetti-tutorial.ipynb
rename to docs/_sources/notebooks/quickstart.ipynb.txt
index d3f37439..3d2f36c3 100644
--- a/notebooks/Basic-spaghetti-tutorial.ipynb
+++ b/docs/_sources/notebooks/quickstart.ipynb.txt
@@ -10,7 +10,7 @@
"\n",
"\n",
"----------------\n",
- "## Basic `pysal.spaghetti` tutorial\n",
+ "## Quickstart\n",
"### Creating and visualizing a `spaghetti.Network` object\n",
"\n",
"**Author: James D. Gaboardi** ****\n",
diff --git a/docs/_sources/notebooks/tsp.ipynb.txt b/docs/_sources/notebooks/tsp.ipynb.txt
new file mode 100644
index 00000000..7f9311a2
--- /dev/null
+++ b/docs/_sources/notebooks/tsp.ipynb.txt
@@ -0,0 +1,1184 @@
+{
+ "cells": [
+ {
+ "cell_type": "markdown",
+ "metadata": {},
+ "source": [
+ "---------------\n",
+ "\n",
+ "**If any part of this notebook is used in your research, please cite with the reference found in** **[README.md](https://github.com/pysal/spaghetti#bibtex-citation).**\n",
+ "\n",
+ "----------------\n",
+ "\n",
+ "## The Traveling Sales(man)(person) Problem — TSP\n",
+ "### Integrating `pysal/spaghetti` and [pulp](https://github.com/coin-or/pulp) for optimal routing\n",
+ "\n",
+ "**Author: James D. Gaboardi** ****\n",
+ "\n",
+ "**This notebook provides a use case for:**\n",
+ "\n",
+ "1. Introducing the TSP\n",
+ "2. Declaration or a solution class and model parameters\n",
+ "3. Solving the TSP for an optimal tour"
+ ]
+ },
+ {
+ "cell_type": "code",
+ "execution_count": 1,
+ "metadata": {
+ "ExecuteTime": {
+ "end_time": "2020-01-25T22:07:52.936171Z",
+ "start_time": "2020-01-25T22:07:52.568219Z"
+ }
+ },
+ "outputs": [
+ {
+ "name": "stdout",
+ "output_type": "stream",
+ "text": [
+ "2020-01-25T17:07:52-05:00\n",
+ "\n",
+ "CPython 3.7.3\n",
+ "IPython 7.10.2\n",
+ "\n",
+ "compiler : Clang 9.0.0 (tags/RELEASE_900/final)\n",
+ "system : Darwin\n",
+ "release : 19.2.0\n",
+ "machine : x86_64\n",
+ "processor : i386\n",
+ "CPU cores : 4\n",
+ "interpreter: 64bit\n"
+ ]
+ }
+ ],
+ "source": [
+ "%load_ext watermark\n",
+ "%watermark"
+ ]
+ },
+ {
+ "cell_type": "markdown",
+ "metadata": {},
+ "source": [
+ "**In addtion to the base** **[spaghetti requirements](https://github.com/pysal/spaghetti/blob/master/requirements.txt)** **(and their dependecies), this notebook requires installations of:**\n",
+ "\n",
+ "* [geopandas](http://geopandas.org)\n",
+ " * `$ conda install -c conda-forge geopandas`\n",
+ "* [matplotlib](https://matplotlib.org)\n",
+ " * `$ conda install matplotlib`\n",
+ "* [pulp](https://anaconda.org/conda-forge/pulp)\n",
+ " * `$ conda install -c conda-forge pulp` \n",
+ "\n",
+ "-----------------------"
+ ]
+ },
+ {
+ "cell_type": "code",
+ "execution_count": 2,
+ "metadata": {
+ "ExecuteTime": {
+ "end_time": "2020-01-25T22:07:55.423253Z",
+ "start_time": "2020-01-25T22:07:52.940776Z"
+ }
+ },
+ "outputs": [
+ {
+ "name": "stdout",
+ "output_type": "stream",
+ "text": [
+ "watermark 2.0.2\n",
+ "geopandas 0.6.2\n",
+ "pulp 1.6.8\n",
+ "matplotlib 3.1.2\n",
+ "spaghetti 1.4.0\n",
+ "numpy 1.17.3\n",
+ "\n"
+ ]
+ }
+ ],
+ "source": [
+ "import spaghetti\n",
+ "import geopandas\n",
+ "from libpysal import examples\n",
+ "import matplotlib\n",
+ "import numpy\n",
+ "import pulp\n",
+ "try:\n",
+ " from IPython.display import set_matplotlib_formats\n",
+ "\n",
+ " set_matplotlib_formats(\"retina\")\n",
+ "except ImportError:\n",
+ " pass\n",
+ "%matplotlib inline\n",
+ "%watermark -w\n",
+ "%watermark -iv"
+ ]
+ },
+ {
+ "cell_type": "markdown",
+ "metadata": {},
+ "source": [
+ "-----------------------------\n",
+ "\n",
+ "### 1 Introduction\n",
+ "#### Scenario\n",
+ "Detective George B. Königsberg thought he needed to visit **7** crimes scenes in one area of City X this afternoon in order to collect evidence. However, his lieutenant, Anna Nagurney just told him he needs to double that to **14**. He really wants to wrap up early so he can get home to watch the 2012 mathematical thriller, [Travelling Salesman by Timothy Lanzone](https://en.wikipedia.org/wiki/Travelling_Salesman_(2012_film)), with his cat and dog, Euler and Hamilton. Therefore, he decides on calculating an optimal route so that he can visit all **14** crime scenes in one tour while covering the shortest distance. Det. Königsberg utilizes an integer linear programming formulation of the traveling salesperson problem (TSP) to find his best route.\n",
+ "\n",
+ "--------------------------------\n",
+ "\n",
+ "#### Integer Linear Programming Formulation based on Miller, Tucker, and Zemlin (1960).\n",
+ "\n",
+ "$\\begin{array}\n",
+ "\\displaystyle \\normalsize \\textrm{Minimize} & \\displaystyle \\normalsize \\sum_{0 \\leq i \\\\ i \\neq j}^n \\sum_{j \\leq n \\\\ j \\neq i}^n c_{ij}x_{ij} & & & & \\normalsize (1) \\\\\n",
+ "\\normalsize \\textrm{Subject To} & \\displaystyle \\normalsize \\sum_{i=0}^n x_{ij}=1 & \\normalsize j=1,...,n, & \\normalsize j\\neq i; & &\\normalsize (2)\\\\\n",
+ "& \\displaystyle \\normalsize \\sum_{j=0}^n x_{ij}=1 & \\normalsize i=1,...,n, & \\normalsize i\\neq j; & &\\normalsize (3) \\\\\n",
+ "& \\displaystyle \\normalsize u_i - u_j + p x_{ij} \\leq p - 1 & \\normalsize i=1,...,n, & \\normalsize 1 \\leq i \\neq j \\leq n; & &\\normalsize (4) \\\\\n",
+ "& \\normalsize x_{ij} \\in \\{0,1\\} & \\normalsize i=1,...,n, & \\normalsize j=1,...,n; & &\\normalsize (5)\\\\\n",
+ "& \\normalsize u_{i} \\in \\mathbb{Z} & \\normalsize i=1,...,n. & & &\\normalsize (6)\\\\\n",
+ "\\end{array}$\n",
+ "\n",
+ "$\\begin{array}\n",
+ "\\displaystyle \\normalsize \\textrm{Where} & \\small x_{ij} & \\small = & \\small \\begin{cases}\n",
+ " 1, & \\textrm{if node } i \\textrm{ immediately precedes node } j \\textrm{ in the tour}\\\\\n",
+ " 0, & \\textrm{otherwise}\n",
+ " \\end{cases} &&&&\\\\\n",
+ "& \\small c_{ij} & \\small = & \\small \\textrm{distance matrix between all } i,j \\textrm{ pairs} &&&& \\\\\n",
+ "& \\small n & \\small = & \\small \\textrm{the total number of nodes in the tour} &&&&\\\\\n",
+ "& \\small i & \\small = & \\small \\textrm{each potential origin node} &&&&\\\\\n",
+ "& \\small j & \\small = & \\small \\textrm{each potential destination node} &&&&\\\\\n",
+ "& \\small u_i & \\small = & \\small \\textrm{continuous, non-negative real numbers} &&&&\\\\\n",
+ "& \\small p & \\small = & \\small \\textrm{allowed visits prior to return (}n = p \\textrm{ in this formulation)} &&&&\\\\\n",
+ "\\end{array}$\n",
+ "\n",
+ "\n",
+ "---------------------------------\n",
+ "\n",
+ "**References**\n",
+ "\n",
+ "* **Cummings, N.** (2000) [*A brief History of the Travelling Salesman Problem*](https://www.theorsociety.com/about-or/or-methods/heuristics/a-brief-history-of-the-travelling-salesman-problem/). The Operational Research Society. Accessed: 01/2020.\n",
+ "* **Dantzig, G., Fulkerson, R., and Johnson, S.** (1954) *Solution of a Large-Scale Traveling-Salesman Problem*. Journal of the Operational Research Society of America. 2(4)393-410.\n",
+ "* **Flood, Merrill M.** (1956) *The Traveling-Salesman Problem*. 4(1)61-75.\n",
+ "* **Gass, S. I. and Assad, A. A.** (2005) *An Annotated Timeline of Operations Research: An Informal History*. Springer US.\n",
+ "* **Miller, C. E., Tucker, A. W., and Zemlin, R. A.** (1960) *Integer Programming Formulation of Traveling Salesman Problems*. Journal of Association for Computing Machinery. 7(4)326-329.\n",
+ "* **Miller, H. J. and Shaw, S.-L.** (2001) *Geographic Information Systems for Transportation: Principles and Applications*. New York. Oxford University Press.\n",
+ "* **Nemhauser, G. L. and Wolsey, L. A.** (1988) *Integer and Combinatorial Optimization*. John Wiley & Sons, Inc.\n",
+ "\n",
+ "-------------------------------------\n",
+ "\n",
+ "### 2. A model, data and parameters\n",
+ "#### Solution class"
+ ]
+ },
+ {
+ "cell_type": "code",
+ "execution_count": 3,
+ "metadata": {
+ "ExecuteTime": {
+ "end_time": "2020-01-25T22:07:55.463452Z",
+ "start_time": "2020-01-25T22:07:55.431596Z"
+ }
+ },
+ "outputs": [],
+ "source": [
+ "class MTZ_TSP:\n",
+ " def __init__(self, nodes, cij, xij_tag=\"x_%s,%s\", ui_tag=\"u_%s\"):\n",
+ " \"\"\"Instantiate and solve the Traveling Salesperson Problem (TSP)\n",
+ " based the formulation from Miller, Tucker, and Zemlin (1960).\n",
+ " \n",
+ " Parameters\n",
+ " ----------\n",
+ " nodes : geopandas.GeoSeries\n",
+ " All nodes to be visited in the tour.\n",
+ " cij : numpy.array\n",
+ " All-to-all distance matrix for nodes.\n",
+ " xij_tag : str\n",
+ " Tour decision variable names within the model. Default is\n",
+ " 'x_%s,%s' where %s indicates string formatting.\n",
+ " ui_tag : str\n",
+ " Arbitrary real number decision variable names within the model.\n",
+ " Default is 'u_%s' where %s indicates string formatting.\n",
+ " \n",
+ " Attributes\n",
+ " ----------\n",
+ " nodes : geopandas.GeoSeries\n",
+ " See description in above.\n",
+ " p : int\n",
+ " The number of nodes in the set. \n",
+ " rp_0n : range\n",
+ " Range of node IDs in ``nodes`` from 0,...,``p``.\n",
+ " rp_1n : range\n",
+ " Range of node IDs in ``nodes`` from 1,...,``p``.\n",
+ " id : str\n",
+ " Column name for ``nodes``.\n",
+ " cij : numpy.array\n",
+ " See description in above.\n",
+ " xij_tag : str\n",
+ " See description in above.\n",
+ " ui_tag : str\n",
+ " See description in above.\n",
+ " tsp : pulp.LpProblem\n",
+ " Integer Linear Programming problem instance.\n",
+ " xij : numpy.array\n",
+ " Binary tour decision variables (``pulp.LpVariable``).\n",
+ " ui : numpy.array\n",
+ " Continuous arbitrary real number decision variables\n",
+ " (``pulp.LpVariable``).\n",
+ " cycle_ods : dict\n",
+ " Cycle origin-destination lookup keyed by origin with\n",
+ " destination as the value.\n",
+ " tour_pairs : list\n",
+ " OD pairs comprising each abstract tour arc.\n",
+ " \"\"\"\n",
+ "\n",
+ " # all nodes to be visited and the distance matrix\n",
+ " self.nodes, self.cij = nodes, cij\n",
+ " # number of nodes in the set\n",
+ " self.p = self.nodes.shape[0]\n",
+ " # full and truncated range of nodes (p) in the set\n",
+ " self.rp_0n, self.rp_1n = range(self.p), range(1, self.p)\n",
+ " # column name for node IDs\n",
+ " self.id = self.nodes.name\n",
+ " # alpha tag for decision and dummy variable prefixes\n",
+ " self.xij_tag, self.ui_tag = xij_tag, ui_tag\n",
+ "\n",
+ " # instantiate a model\n",
+ " self.tsp = pulp.LpProblem(\"MTZ_TSP\", pulp.LpMinimize)\n",
+ " # create and set the tour decision variables\n",
+ " self.tour_dvs()\n",
+ " # create and set the arbitraty real number decision variables\n",
+ " self.arn_dvs()\n",
+ " # set the objective function\n",
+ " self.objective_func()\n",
+ " # node entry constraints\n",
+ " self.entry_exit_constrs(entry=True)\n",
+ " # node exit constraints\n",
+ " self.entry_exit_constrs(entry=False)\n",
+ " # subtour prevention constraints\n",
+ " self.prevent_subtours()\n",
+ " # solve\n",
+ " self.tsp.solve()\n",
+ " # origin-destination lookup\n",
+ " self.get_decisions(display=display)\n",
+ " # extract the sequence of nodes to construct the optimal tour\n",
+ " self.construct_tour()\n",
+ "\n",
+ " def tour_dvs(self):\n",
+ " \"\"\"Create the tour decision variables - eq (5).\"\"\"\n",
+ "\n",
+ " def _name(_x):\n",
+ " \"\"\"Helper for naming variables\"\"\"\n",
+ " return self.nodes[_x].split(\"_\")[-1]\n",
+ "\n",
+ " xij = numpy.array(\n",
+ " [\n",
+ " [\n",
+ " pulp.LpVariable(self.xij_tag % (_name(i), _name(j)), cat=\"Binary\")\n",
+ " for j in self.rp_0n\n",
+ " ]\n",
+ " for i in self.rp_0n\n",
+ " ]\n",
+ " )\n",
+ "\n",
+ " self.xij = xij\n",
+ "\n",
+ " def arn_dvs(self):\n",
+ " \"\"\"Create arbitrary real number decision variables - eq (6).\"\"\"\n",
+ " ui = numpy.array(\n",
+ " [pulp.LpVariable(self.ui_tag % (i), lowBound=0) for i in self.rp_0n]\n",
+ " )\n",
+ "\n",
+ " self.ui = ui\n",
+ "\n",
+ " def objective_func(self):\n",
+ " \"\"\"Add the objective function - eq (1).\"\"\"\n",
+ " self.tsp += pulp.lpSum(\n",
+ " [\n",
+ " self.cij[i, j] * self.xij[i, j]\n",
+ " for i in self.rp_0n\n",
+ " for j in self.rp_0n\n",
+ " if i != j\n",
+ " ]\n",
+ " )\n",
+ "\n",
+ " def entry_exit_constrs(self, entry=True):\n",
+ " \"\"\"Add entry and exit constraints - eq (2) and (3).\"\"\"\n",
+ " if entry:\n",
+ " for i in self.rp_0n:\n",
+ " self.tsp += (\n",
+ " pulp.lpSum([self.xij[i, j] for j in self.rp_0n if i != j]) == 1\n",
+ " )\n",
+ " # exit constraints\n",
+ " else:\n",
+ " for j in self.rp_0n:\n",
+ " self.tsp += (\n",
+ " pulp.lpSum([self.xij[i, j] for i in self.rp_0n if i != j]) == 1\n",
+ " )\n",
+ "\n",
+ " def prevent_subtours(self):\n",
+ " \"\"\"Add subtour prevention constraints - eq (4).\"\"\"\n",
+ " for i in self.rp_1n:\n",
+ " for j in self.rp_1n:\n",
+ " if i != j:\n",
+ " self.tsp += (\n",
+ " self.ui[i] - self.ui[j] + self.p * self.xij[i, j] <= self.p - 1\n",
+ " )\n",
+ "\n",
+ " def get_decisions(self, display=True):\n",
+ " \"\"\"Fetch the selected decision variables.\"\"\"\n",
+ " cycle_ods = {}\n",
+ " for var in self.tsp.variables():\n",
+ " if var.name.startswith(self.ui_tag[0]):\n",
+ " continue\n",
+ " if var.varValue > 0:\n",
+ " if display:\n",
+ " print(\"%s: %s\" % (var.name, var.varValue))\n",
+ " od = var.name.split(\"_\")[-1]\n",
+ " o, d = [int(tf) for tf in od.split(\",\")]\n",
+ " cycle_ods[o] = d\n",
+ " if display:\n",
+ " print(\"Status: %s\" % pulp.LpStatus[self.tsp.status])\n",
+ "\n",
+ " self.cycle_ods = cycle_ods\n",
+ "\n",
+ " def construct_tour(self):\n",
+ " \"\"\"Construct the tour.\"\"\"\n",
+ " tour_pairs = []\n",
+ " for origin in self.rp_0n:\n",
+ " tour_pairs.append([])\n",
+ " try:\n",
+ " tour_pairs[origin].append(next_origin)\n",
+ " next_origin = self.cycle_ods[next_origin]\n",
+ " tour_pairs[origin].append(next_origin)\n",
+ " except NameError:\n",
+ " next_origin = self.cycle_ods[origin]\n",
+ " tour_pairs[origin].append(origin)\n",
+ " tour_pairs[origin].append(next_origin)\n",
+ "\n",
+ " tour_pairs = {idx: sorted(cp) for idx, cp in enumerate(tour_pairs)}\n",
+ " self.tour_pairs = tour_pairs\n",
+ "\n",
+ " def extract_tour(self, paths, id_col, leg_label=\"leg\"):\n",
+ " \"\"\"Extract the tour (the legs in the journey) as a \n",
+ " ``geopandas.GeoDataFrame`` of ``shapely.geometry.LineString`` objects.\n",
+ " \n",
+ " Parameters\n",
+ " ----------\n",
+ " paths : geopandas.GeoDataFrame\n",
+ " Shortest-path routes between all observations.\n",
+ " id_col : str\n",
+ " ID column name.\n",
+ " leg_label : str\n",
+ " Column name for the tour sequence. Default is 'leg'.\n",
+ " \n",
+ " Returns\n",
+ " -------\n",
+ " tour : geopandas.GeoDataFrame\n",
+ " Optimal tour of ``self.nodes`` squenced by ``leg_label``.\n",
+ " \"\"\"\n",
+ " paths[leg_label] = int\n",
+ " # set label of journey leg for each OD pair.\n",
+ " for leg, cp in self.tour_pairs.items():\n",
+ " paths.loc[(paths[id_col] == tuple(cp)), leg_label] = leg\n",
+ " # extract only paths in the tour\n",
+ " tour = paths[paths[leg_label] != int].copy()\n",
+ " tour.sort_values(by=[leg_label], inplace=True)\n",
+ "\n",
+ " return tour"
+ ]
+ },
+ {
+ "cell_type": "markdown",
+ "metadata": {},
+ "source": [
+ "#### Streets"
+ ]
+ },
+ {
+ "cell_type": "code",
+ "execution_count": 4,
+ "metadata": {
+ "ExecuteTime": {
+ "end_time": "2020-01-25T22:07:55.820062Z",
+ "start_time": "2020-01-25T22:07:55.470126Z"
+ }
+ },
+ "outputs": [],
+ "source": [
+ "streets = geopandas.read_file(examples.get_path(\"streets.shp\"))\n",
+ "streets.crs = \"epsg:2223\"\n",
+ "streets = streets.to_crs(\"epsg:2762\")"
+ ]
+ },
+ {
+ "cell_type": "markdown",
+ "metadata": {},
+ "source": [
+ "#### Crimes"
+ ]
+ },
+ {
+ "cell_type": "code",
+ "execution_count": 5,
+ "metadata": {
+ "ExecuteTime": {
+ "end_time": "2020-01-25T22:07:56.155089Z",
+ "start_time": "2020-01-25T22:07:55.823960Z"
+ }
+ },
+ "outputs": [],
+ "source": [
+ "all_crimes = geopandas.read_file(examples.get_path(\"crimes.shp\"))\n",
+ "all_crimes.crs = \"epsg:2223\"\n",
+ "all_crimes = all_crimes.to_crs(\"epsg:2762\")"
+ ]
+ },
+ {
+ "cell_type": "markdown",
+ "metadata": {
+ "ExecuteTime": {
+ "end_time": "2020-01-21T04:22:00.659016Z",
+ "start_time": "2020-01-21T04:22:00.655646Z"
+ }
+ },
+ "source": [
+ "#### Detective Königsberg's cases"
+ ]
+ },
+ {
+ "cell_type": "code",
+ "execution_count": 6,
+ "metadata": {
+ "ExecuteTime": {
+ "end_time": "2020-01-25T22:07:56.167060Z",
+ "start_time": "2020-01-25T22:07:56.157557Z"
+ }
+ },
+ "outputs": [],
+ "source": [
+ "numpy.random.seed(1960)\n",
+ "koenigsberg_cases = 7 * 2\n",
+ "subset_idx = numpy.random.choice(all_crimes.index, koenigsberg_cases, replace=False)\n",
+ "crimes_scenes = all_crimes[all_crimes.index.isin(subset_idx)].copy()"
+ ]
+ },
+ {
+ "cell_type": "markdown",
+ "metadata": {
+ "ExecuteTime": {
+ "end_time": "2020-01-21T04:39:16.711389Z",
+ "start_time": "2020-01-21T04:39:16.702359Z"
+ }
+ },
+ "source": [
+ "#### Instantiate a network object"
+ ]
+ },
+ {
+ "cell_type": "code",
+ "execution_count": 7,
+ "metadata": {
+ "ExecuteTime": {
+ "end_time": "2020-01-25T22:07:56.888393Z",
+ "start_time": "2020-01-25T22:07:56.173758Z"
+ }
+ },
+ "outputs": [],
+ "source": [
+ "ntw = spaghetti.Network(in_data=streets)\n",
+ "vertices, arcs = spaghetti.element_as_gdf(ntw, vertices=True, arcs=True)"
+ ]
+ },
+ {
+ "cell_type": "markdown",
+ "metadata": {},
+ "source": [
+ "#### Plot"
+ ]
+ },
+ {
+ "cell_type": "code",
+ "execution_count": 8,
+ "metadata": {
+ "ExecuteTime": {
+ "end_time": "2020-01-25T22:07:57.422323Z",
+ "start_time": "2020-01-25T22:07:56.893828Z"
+ }
+ },
+ "outputs": [
+ {
+ "data": {
+ "text/plain": [
+ ""
+ ]
+ },
+ "execution_count": 8,
+ "metadata": {},
+ "output_type": "execute_result"
+ },
+ {
+ "data": {
+ "image/png": "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\n",
+ "text/plain": [
+ ""
+ ]
+ },
+ "metadata": {
+ "needs_background": "light"
+ },
+ "output_type": "display_data"
+ }
+ ],
+ "source": [
+ "base = arcs.plot(linewidth=3, alpha=0.25, color=\"k\", zorder=0, figsize=(10, 10))\n",
+ "vertices.plot(ax=base, markersize=2, color=\"red\", zorder=1)\n",
+ "all_crimes.plot(ax=base, markersize=5, color=\"k\", zorder=2)\n",
+ "crimes_scenes.plot(ax=base, markersize=100, alpha=0.25, color=\"blue\", zorder=2)"
+ ]
+ },
+ {
+ "cell_type": "markdown",
+ "metadata": {},
+ "source": [
+ "#### Associate Detective Königsberg's cases with the network and plot"
+ ]
+ },
+ {
+ "cell_type": "code",
+ "execution_count": 9,
+ "metadata": {
+ "ExecuteTime": {
+ "end_time": "2020-01-25T22:07:57.479752Z",
+ "start_time": "2020-01-25T22:07:57.432432Z"
+ }
+ },
+ "outputs": [],
+ "source": [
+ "ntw.snapobservations(crimes_scenes, \"crime_scenes\")\n",
+ "pp_obs = spaghetti.element_as_gdf(ntw, pp_name=\"crime_scenes\")\n",
+ "pp_obs_snapped = spaghetti.element_as_gdf(ntw, pp_name=\"crime_scenes\", snapped=True)"
+ ]
+ },
+ {
+ "cell_type": "code",
+ "execution_count": 10,
+ "metadata": {
+ "ExecuteTime": {
+ "end_time": "2020-01-25T22:07:57.968145Z",
+ "start_time": "2020-01-25T22:07:57.482697Z"
+ }
+ },
+ "outputs": [
+ {
+ "data": {
+ "text/plain": [
+ ""
+ ]
+ },
+ "execution_count": 10,
+ "metadata": {},
+ "output_type": "execute_result"
+ },
+ {
+ "data": {
+ "image/png": "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\n",
+ "text/plain": [
+ ""
+ ]
+ },
+ "metadata": {
+ "needs_background": "light"
+ },
+ "output_type": "display_data"
+ }
+ ],
+ "source": [
+ "base = arcs.plot(linewidth=3, alpha=0.25, color=\"k\", zorder=0, figsize=(10, 10))\n",
+ "vertices.plot(ax=base, markersize=5, color=\"r\", zorder=1)\n",
+ "pp_obs.plot(ax=base, markersize=20, color=\"k\", zorder=2)\n",
+ "pp_obs_snapped.plot(ax=base, markersize=20, marker=\"x\", color=\"k\", zorder=2)"
+ ]
+ },
+ {
+ "cell_type": "markdown",
+ "metadata": {},
+ "source": [
+ "#### Calculate distance matrix while generating shortest path trees"
+ ]
+ },
+ {
+ "cell_type": "code",
+ "execution_count": 11,
+ "metadata": {
+ "ExecuteTime": {
+ "end_time": "2020-01-25T22:07:58.956237Z",
+ "start_time": "2020-01-25T22:07:57.986814Z"
+ }
+ },
+ "outputs": [
+ {
+ "data": {
+ "text/plain": [
+ "array([[ nan, 877.47164862, 1012.61083447],\n",
+ " [ 877.47164862, nan, 688.1148453 ],\n",
+ " [1012.61083447, 688.1148453 , nan]])"
+ ]
+ },
+ "execution_count": 11,
+ "metadata": {},
+ "output_type": "execute_result"
+ }
+ ],
+ "source": [
+ "d2d_dist, tree = ntw.allneighbordistances(\"crime_scenes\", gen_tree=True)\n",
+ "d2d_dist[:3, :3]"
+ ]
+ },
+ {
+ "cell_type": "code",
+ "execution_count": 12,
+ "metadata": {
+ "ExecuteTime": {
+ "end_time": "2020-01-25T22:07:58.999935Z",
+ "start_time": "2020-01-25T22:07:58.972507Z"
+ }
+ },
+ "outputs": [
+ {
+ "data": {
+ "text/plain": [
+ "([((0, 1), (164, 158)),\n",
+ " ((0, 2), (164, 142)),\n",
+ " ((0, 3), (164, 197)),\n",
+ " ((0, 4), (164, 147))],\n",
+ " [((10, 13), (72, 98)),\n",
+ " ((11, 12), (26, 29)),\n",
+ " ((11, 13), (26, 85)),\n",
+ " ((12, 13), (30, 85))])"
+ ]
+ },
+ "execution_count": 12,
+ "metadata": {},
+ "output_type": "execute_result"
+ }
+ ],
+ "source": [
+ "list(tree.items())[:4], list(tree.items())[-4:]"
+ ]
+ },
+ {
+ "cell_type": "markdown",
+ "metadata": {},
+ "source": [
+ "--------------------------------\n",
+ "### 3. The Travling Salesperson Problem\n",
+ "#### Create decision variables for the crime scene locations"
+ ]
+ },
+ {
+ "cell_type": "code",
+ "execution_count": 13,
+ "metadata": {
+ "ExecuteTime": {
+ "end_time": "2020-01-25T22:07:59.038333Z",
+ "start_time": "2020-01-25T22:07:59.005925Z"
+ }
+ },
+ "outputs": [
+ {
+ "data": {
+ "text/html": [
+ "\n",
+ "\n",
+ "
\n",
+ " \n",
+ " \n",
+ " \n",
+ " id \n",
+ " geometry \n",
+ " dv \n",
+ " \n",
+ " \n",
+ " \n",
+ " \n",
+ " 0 \n",
+ " 0 \n",
+ " POINT (221651.779 266962.433) \n",
+ " x_0 \n",
+ " \n",
+ " \n",
+ " 1 \n",
+ " 1 \n",
+ " POINT (220774.565 266967.614) \n",
+ " x_1 \n",
+ " \n",
+ " \n",
+ " 2 \n",
+ " 2 \n",
+ " POINT (220962.017 267280.644) \n",
+ " x_2 \n",
+ " \n",
+ " \n",
+ " 3 \n",
+ " 3 \n",
+ " POINT (220772.431 267386.410) \n",
+ " x_3 \n",
+ " \n",
+ " \n",
+ " 4 \n",
+ " 4 \n",
+ " POINT (220796.815 267545.820) \n",
+ " x_4 \n",
+ " \n",
+ " \n",
+ " 5 \n",
+ " 5 \n",
+ " POINT (221500.903 267697.915) \n",
+ " x_5 \n",
+ " \n",
+ " \n",
+ " 6 \n",
+ " 6 \n",
+ " POINT (220474.032 267730.529) \n",
+ " x_6 \n",
+ " \n",
+ " \n",
+ " 7 \n",
+ " 7 \n",
+ " POINT (221677.382 267761.314) \n",
+ " x_7 \n",
+ " \n",
+ " \n",
+ " 8 \n",
+ " 8 \n",
+ " POINT (221154.041 267919.810) \n",
+ " x_8 \n",
+ " \n",
+ " \n",
+ " 9 \n",
+ " 9 \n",
+ " POINT (221852.947 268049.045) \n",
+ " x_9 \n",
+ " \n",
+ " \n",
+ " 10 \n",
+ " 10 \n",
+ " POINT (220775.174 268149.629) \n",
+ " x_10 \n",
+ " \n",
+ " \n",
+ " 11 \n",
+ " 11 \n",
+ " POINT (220472.813 268197.482) \n",
+ " x_11 \n",
+ " \n",
+ " \n",
+ " 12 \n",
+ " 12 \n",
+ " POINT (220514.875 268478.203) \n",
+ " x_12 \n",
+ " \n",
+ " \n",
+ " 13 \n",
+ " 13 \n",
+ " POINT (222083.681 268590.979) \n",
+ " x_13 \n",
+ " \n",
+ " \n",
+ "
\n",
+ "
"
+ ],
+ "text/plain": [
+ " id geometry dv\n",
+ "0 0 POINT (221651.779 266962.433) x_0\n",
+ "1 1 POINT (220774.565 266967.614) x_1\n",
+ "2 2 POINT (220962.017 267280.644) x_2\n",
+ "3 3 POINT (220772.431 267386.410) x_3\n",
+ "4 4 POINT (220796.815 267545.820) x_4\n",
+ "5 5 POINT (221500.903 267697.915) x_5\n",
+ "6 6 POINT (220474.032 267730.529) x_6\n",
+ "7 7 POINT (221677.382 267761.314) x_7\n",
+ "8 8 POINT (221154.041 267919.810) x_8\n",
+ "9 9 POINT (221852.947 268049.045) x_9\n",
+ "10 10 POINT (220775.174 268149.629) x_10\n",
+ "11 11 POINT (220472.813 268197.482) x_11\n",
+ "12 12 POINT (220514.875 268478.203) x_12\n",
+ "13 13 POINT (222083.681 268590.979) x_13"
+ ]
+ },
+ "execution_count": 13,
+ "metadata": {},
+ "output_type": "execute_result"
+ }
+ ],
+ "source": [
+ "pp_obs[\"dv\"] = pp_obs[\"id\"].apply(lambda _id: \"x_%s\" % _id)\n",
+ "pp_obs"
+ ]
+ },
+ {
+ "cell_type": "markdown",
+ "metadata": {},
+ "source": [
+ "#### Solve the TSP"
+ ]
+ },
+ {
+ "cell_type": "code",
+ "execution_count": 14,
+ "metadata": {
+ "ExecuteTime": {
+ "end_time": "2020-01-25T22:07:59.912857Z",
+ "start_time": "2020-01-25T22:07:59.050527Z"
+ }
+ },
+ "outputs": [
+ {
+ "name": "stdout",
+ "output_type": "stream",
+ "text": [
+ "x_0,1: 1.0\n",
+ "x_1,2: 1.0\n",
+ "x_10,8: 1.0\n",
+ "x_11,12: 1.0\n",
+ "x_12,10: 1.0\n",
+ "x_13,7: 1.0\n",
+ "x_2,3: 1.0\n",
+ "x_3,4: 1.0\n",
+ "x_4,6: 1.0\n",
+ "x_5,0: 1.0\n",
+ "x_6,11: 1.0\n",
+ "x_7,5: 1.0\n",
+ "x_8,9: 1.0\n",
+ "x_9,13: 1.0\n",
+ "Status: Optimal\n"
+ ]
+ }
+ ],
+ "source": [
+ "mtz_tsp = MTZ_TSP(pp_obs[\"dv\"], d2d_dist)"
+ ]
+ },
+ {
+ "cell_type": "markdown",
+ "metadata": {},
+ "source": [
+ "#### Extract all network shortest paths"
+ ]
+ },
+ {
+ "cell_type": "code",
+ "execution_count": 15,
+ "metadata": {
+ "ExecuteTime": {
+ "end_time": "2020-01-25T22:07:59.959975Z",
+ "start_time": "2020-01-25T22:07:59.922719Z"
+ }
+ },
+ "outputs": [
+ {
+ "data": {
+ "text/html": [
+ "\n",
+ "\n",
+ "
\n",
+ " \n",
+ " \n",
+ " \n",
+ " id \n",
+ " geometry \n",
+ " \n",
+ " \n",
+ " \n",
+ " \n",
+ " 0 \n",
+ " (0, 1) \n",
+ " LINESTRING (221652.388 266992.490, 221523.237 ... \n",
+ " \n",
+ " \n",
+ " 1 \n",
+ " (0, 2) \n",
+ " LINESTRING (221652.388 266992.490, 221523.237 ... \n",
+ " \n",
+ " \n",
+ " 2 \n",
+ " (0, 3) \n",
+ " LINESTRING (221652.388 266992.490, 221523.237 ... \n",
+ " \n",
+ " \n",
+ " 3 \n",
+ " (0, 4) \n",
+ " LINESTRING (221652.388 266992.490, 221523.237 ... \n",
+ " \n",
+ " \n",
+ " 4 \n",
+ " (0, 5) \n",
+ " LINESTRING (221652.388 266992.490, 221523.237 ... \n",
+ " \n",
+ " \n",
+ "
\n",
+ "
"
+ ],
+ "text/plain": [
+ " id geometry\n",
+ "0 (0, 1) LINESTRING (221652.388 266992.490, 221523.237 ...\n",
+ "1 (0, 2) LINESTRING (221652.388 266992.490, 221523.237 ...\n",
+ "2 (0, 3) LINESTRING (221652.388 266992.490, 221523.237 ...\n",
+ "3 (0, 4) LINESTRING (221652.388 266992.490, 221523.237 ...\n",
+ "4 (0, 5) LINESTRING (221652.388 266992.490, 221523.237 ..."
+ ]
+ },
+ "execution_count": 15,
+ "metadata": {},
+ "output_type": "execute_result"
+ }
+ ],
+ "source": [
+ "paths = ntw.shortest_paths(tree, \"crime_scenes\")\n",
+ "paths_gdf = spaghetti.element_as_gdf(ntw, routes=paths)\n",
+ "paths_gdf.head()"
+ ]
+ },
+ {
+ "cell_type": "markdown",
+ "metadata": {},
+ "source": [
+ "#### Extract the tour"
+ ]
+ },
+ {
+ "cell_type": "code",
+ "execution_count": 16,
+ "metadata": {
+ "ExecuteTime": {
+ "end_time": "2020-01-25T22:08:00.037101Z",
+ "start_time": "2020-01-25T22:07:59.965609Z"
+ }
+ },
+ "outputs": [
+ {
+ "data": {
+ "text/html": [
+ "\n",
+ "\n",
+ "
\n",
+ " \n",
+ " \n",
+ " \n",
+ " id \n",
+ " geometry \n",
+ " leg \n",
+ " \n",
+ " \n",
+ " \n",
+ " \n",
+ " 0 \n",
+ " (0, 1) \n",
+ " LINESTRING (221652.388 266992.490, 221523.237 ... \n",
+ " 0 \n",
+ " \n",
+ " \n",
+ " 13 \n",
+ " (1, 2) \n",
+ " LINESTRING (220775.021 267000.303, 220807.418 ... \n",
+ " 1 \n",
+ " \n",
+ " \n",
+ " 25 \n",
+ " (2, 3) \n",
+ " LINESTRING (220961.989 267315.817, 220853.037 ... \n",
+ " 2 \n",
+ " \n",
+ " \n",
+ " 36 \n",
+ " (3, 4) \n",
+ " LINESTRING (220807.120 267386.436, 220806.992 ... \n",
+ " 3 \n",
+ " \n",
+ " \n",
+ " 47 \n",
+ " (4, 6) \n",
+ " LINESTRING (220796.691 267553.295, 220695.386 ... \n",
+ " 4 \n",
+ " \n",
+ " \n",
+ "
\n",
+ "
"
+ ],
+ "text/plain": [
+ " id geometry leg\n",
+ "0 (0, 1) LINESTRING (221652.388 266992.490, 221523.237 ... 0\n",
+ "13 (1, 2) LINESTRING (220775.021 267000.303, 220807.418 ... 1\n",
+ "25 (2, 3) LINESTRING (220961.989 267315.817, 220853.037 ... 2\n",
+ "36 (3, 4) LINESTRING (220807.120 267386.436, 220806.992 ... 3\n",
+ "47 (4, 6) LINESTRING (220796.691 267553.295, 220695.386 ... 4"
+ ]
+ },
+ "execution_count": 16,
+ "metadata": {},
+ "output_type": "execute_result"
+ }
+ ],
+ "source": [
+ "tour = mtz_tsp.extract_tour(paths_gdf, \"id\")\n",
+ "tour.head()"
+ ]
+ },
+ {
+ "cell_type": "markdown",
+ "metadata": {},
+ "source": [
+ "#### Define label helper functions and plot Det. Königsberg's optimal tour"
+ ]
+ },
+ {
+ "cell_type": "code",
+ "execution_count": 17,
+ "metadata": {
+ "ExecuteTime": {
+ "end_time": "2020-01-25T22:08:00.063174Z",
+ "start_time": "2020-01-25T22:08:00.049858Z"
+ }
+ },
+ "outputs": [],
+ "source": [
+ "def tour_labels(t, b):\n",
+ " \"\"\"Label each leg of the tour.\"\"\"\n",
+ "\n",
+ " def _lab_loc(_x):\n",
+ " \"\"\"Helper for labeling location.\"\"\"\n",
+ " return _x.geometry.interpolate(0.5, normalized=True).coords[0]\n",
+ "\n",
+ " kws = {\"size\": 20, \"ha\": \"center\", \"va\": \"bottom\", \"weight\": \"bold\"}\n",
+ " t.apply(lambda x: b.annotate(s=x.leg, xy=_lab_loc(x), **kws), axis=1)\n",
+ "\n",
+ "\n",
+ "def obs_labels(o, b):\n",
+ " \"\"\"Label each point pattern observation.\"\"\"\n",
+ "\n",
+ " def _lab_loc(_x):\n",
+ " \"\"\"Helper for labeling observations.\"\"\"\n",
+ " return _x.geometry.coords[0]\n",
+ "\n",
+ " kws = {\"size\": 14, \"ha\": \"left\", \"va\": \"bottom\", \"style\": \"oblique\", \"color\": \"k\"}\n",
+ " o.apply(lambda x: b.annotate(s=x.id, xy=_lab_loc(x), **kws), axis=1)"
+ ]
+ },
+ {
+ "cell_type": "code",
+ "execution_count": 18,
+ "metadata": {
+ "ExecuteTime": {
+ "end_time": "2020-01-25T22:08:00.711929Z",
+ "start_time": "2020-01-25T22:08:00.065658Z"
+ }
+ },
+ "outputs": [
+ {
+ "data": {
+ "image/png": "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\n",
+ "text/plain": [
+ ""
+ ]
+ },
+ "metadata": {
+ "needs_background": "light"
+ },
+ "output_type": "display_data"
+ }
+ ],
+ "source": [
+ "base = arcs.plot(alpha=0.2, linewidth=1, color=\"k\", figsize=(10, 10), zorder=0)\n",
+ "tour.plot(ax=base, column=\"id\", cmap=\"tab20\", alpha=0.50, linewidth=10, zorder=1)\n",
+ "vertices.plot(ax=base, markersize=1, color=\"r\", zorder=2)\n",
+ "pp_obs.plot(ax=base, markersize=20, color=\"k\", zorder=3)\n",
+ "pp_obs_snapped.plot(ax=base, markersize=20, color=\"k\", marker=\"x\", zorder=2)\n",
+ "# tour leg labels\n",
+ "tour_labels(tour, base)\n",
+ "# crime scene labels\n",
+ "obs_labels(pp_obs, base)"
+ ]
+ },
+ {
+ "cell_type": "markdown",
+ "metadata": {},
+ "source": [
+ "----------------------"
+ ]
+ }
+ ],
+ "metadata": {
+ "hide_input": false,
+ "kernelspec": {
+ "display_name": "Python [conda env:py3_spgh_dev]",
+ "language": "python",
+ "name": "conda-env-py3_spgh_dev-py"
+ },
+ "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"
+ },
+ "latex_envs": {
+ "LaTeX_envs_menu_present": true,
+ "autocomplete": true,
+ "bibliofile": "biblio.bib",
+ "cite_by": "apalike",
+ "current_citInitial": 1,
+ "eqLabelWithNumbers": true,
+ "eqNumInitial": 1,
+ "hotkeys": {
+ "equation": "Ctrl-E",
+ "itemize": "Ctrl-I"
+ },
+ "labels_anchors": false,
+ "latex_user_defs": false,
+ "report_style_numbering": false,
+ "user_envs_cfg": false
+ }
+ },
+ "nbformat": 4,
+ "nbformat_minor": 2
+}
diff --git a/docs/_sources/tutorials.rst.txt b/docs/_sources/tutorials.rst.txt
index b83aebe6..e4be4e4d 100644
--- a/docs/_sources/tutorials.rst.txt
+++ b/docs/_sources/tutorials.rst.txt
@@ -6,20 +6,35 @@ Tutorials
.. toctree::
:maxdepth: 1
- :caption: Basic:
+ :caption: Basic functionality:
- notebooks/Basic-spaghetti-tutorial.ipynb
- notebooks/Connected-components.ipynb
- notebooks/Shortest-path-visualization.ipynb
+ notebooks/quickstart.ipynb
+ notebooks/connected-components.ipynb
+ notebooks/shortest-path-visualization.ipynb
.. toctree::
:maxdepth: 1
- :caption: Advanced:
+ :caption: Advanced functionality:
- notebooks/Advanced-spaghetti-tutorial.ipynb
- notebooks/Use-case-facility-location.ipynb
+ notebooks/network-analysis.ipynb
+
+.. toctree::
+ :maxdepth: 1
+ :caption: Integrations & Applications:
+
+ notebooks/facility-location.ipynb
+ notebooks/tsp.ipynb
Citations:
+ * Advanced functionality:
+ :cite:`doi:10.1002/9780470549094.ch5`, :cite:`doi:10.1002/9781119967101.ch5`, :cite:`doi:10.1111/j.1538-4632.2001.tb00448.x`, :cite:`doi:10.1002/9781119967101.ch6`
+
+ * Integrations & Applications:
+
+ * Facility Location:
+ :cite:`Hakimi1964`, :cite:`ReVelle1970`, :cite:`Toregas1971`, :cite:`Toregas1972`, :cite:`Church1974`, :cite:`ReVelle2005`
+
+ * Traveling Salesperson Problem:
+ :cite:`Dantzig1954`, :cite:`Flood1956`, :cite:`Miller1960`, :cite:`Cummings2000`, :cite:`Miller2001`, :cite:`Gass2005`, :cite:`Bektas2014`
+
-* Advanced tutorial: :cite:`doi:10.1002/9780470549094.ch5`, :cite:`doi:10.1002/9781119967101.ch5`, :cite:`doi:10.1111/j.1538-4632.2001.tb00448.x`, :cite:`doi:10.1002/9781119967101.ch6`
-* Facility Location: :cite:`Hakimi1964`, :cite:`ReVelle1970`, :cite:`Toregas1971`, :cite:`Toregas1972`, :cite:`Church1974`, :cite:`ReVelle2005`
\ No newline at end of file
diff --git a/docs/_static/references.bib b/docs/_static/references.bib
index f520770f..7d82b523 100644
--- a/docs/_static/references.bib
+++ b/docs/_static/references.bib
@@ -152,7 +152,7 @@ @incollection{Cliff1981
}
@article{Tansel1983a,
-author = {Tansel, Barbaros C and Francis, Richard L and Lowe, Timothy J},
+author = {Tansel, Barbaros C. and Francis, Richard L .and Lowe, Timothy J.},
journal = {Management Science},
number = {4},
pages = {482--497},
@@ -285,7 +285,6 @@ @inproceedings{Hagberg2008
}
@article{Foti2012,
-abstract = {Travel models, including activity-based travel models developed in recent years, still generally use traffic analysis zones and ignore local streets in their network representation. In short, they ignore walking scale access and move-ments. This is a well-known and very problematic limitation in current travel models, and by extension, in integrated land use and transportation models, even if the land use models are at a parcel level. This paper describes a new project that involves generating a graph of the urban region that unifies information on parcels and the full street network, including all local streets, into a topological graph, and creates very efficient algorithms to compute point to point accessibilities, as well as accessibility trees to activities, using a set of weights on the edges of the graph to allow shortest path computations from parcels to activities. The objective of this project is to create software infrastructure that can provide an interface between parcel-level land use models, which maintain in-formation on what kinds of businesses and households are located on parcels, and emerging activity-based travel models that are attempting to move down to the local street and parcel level of detail. Current benchmarks have region wide aggregation results (355K queries with a search radius of .5km) performed on a 4 cpu-core machine in 2.8 seconds.},
author = {Foti, Fletcher and Waddell, Paul and Luxen, Dennis},
journal = {{4th Transportation Research Board Conference on Innovations in Travel Modeling (ITM)}},
pages = {1--14},
@@ -388,4 +387,74 @@ @misc{tom_russell_2019_3379659
publisher = {Zenodo},
version = {v1.6.0},
doi = {10.5281/zenodo.3379659}
- }
\ No newline at end of file
+ }
+
+
+ @article{Bektas2014,
+author = {Bektaş, Tolga and Gouveia, Luis},
+doi = {10.1016/j.ejor.2013.07.038},
+issn = {03772217},
+journal = {European Journal of Operational Research},
+number = {3},
+pages = {820--832},
+title = {{Requiem for the Miller-Tucker-Zemlin subtour elimination constraints?}},
+volume = {236},
+year = {2014}
+}
+@article{Miller1960,
+author = {Miller, C. E. and Tucker, A. W. and Zemlin, R. A.},
+doi = {10.1145/321043.321046},
+issn = {1557735X},
+journal = {Journal of the ACM (JACM)},
+number = {4},
+pages = {326--329},
+title = {{Integer Programming Formulation of Traveling Salesman Problems}},
+volume = {7},
+year = {1960}
+}
+@article{Flood1956,
+author = {Flood, Merrill M.},
+journal = {Operations Research},
+number = {1},
+pages = {61--75},
+title = {{The Traveling-Salesman Problem}},
+volume = {4},
+year = {1956}
+}
+@article{Dantzig1954,
+author = {Dantzig, G. and Fulkerson, R. and Johnson, S.},
+journal = {Journal of the Operational Research Society of America},
+number = {4},
+pages = {393--410},
+title = {{Solution of a Large-Scale Traveling-Salesman Problem}},
+volume = {2},
+year = {1954}
+}
+
+@book{Miller2001,
+address = {New York},
+author = {Miller, Harvey J. and Shaw, Shih-Lung},
+publisher = {Oxford University Press},
+title = {{Geographic Information Systems for Transportation}},
+year = {2001}
+}
+
+@book{Gass2005,
+address = {New York},
+author = {Gass, Saul I. and Assad, Arjang A.},
+publisher = {Springer},
+title = {{An Annotated Timeline of Operations Research: An Informal History}},
+year = {2005}
+}
+
+@misc{Cummings2000,
+ author = {Cummings, Nigel},
+ title = {A brief History of the Travelling Salesman Problem},
+ editor = {The Operational Research Society},
+ month = {jun},
+ year = {2000},
+ url = {https://www.theorsociety.com/about-or/or-methods/heuristics/a-brief-history-of-the-travelling-salesman-problem/},
+ note = {Accessed: January, 2020},
+ }
+
+
\ No newline at end of file
diff --git a/docs/api.html b/docs/api.html
index 9e4c0b18..f1361420 100644
--- a/docs/api.html
+++ b/docs/api.html
@@ -23,7 +23,7 @@
-
+
@@ -71,11 +71,12 @@
Tutorials
API
diff --git a/docs/generated/spaghetti.Network.html b/docs/generated/spaghetti.Network.html
index 1f22f148..e8182e6e 100644
--- a/docs/generated/spaghetti.Network.html
+++ b/docs/generated/spaghetti.Network.html
@@ -71,11 +71,12 @@
Tutorials
API
@@ -141,7 +142,7 @@ spaghetti.Network
Tutorials
API
diff --git a/docs/generated/spaghetti.Network.savenetwork.html b/docs/generated/spaghetti.Network.savenetwork.html
index 643fe935..871ded6f 100644
--- a/docs/generated/spaghetti.Network.savenetwork.html
+++ b/docs/generated/spaghetti.Network.savenetwork.html
@@ -71,11 +71,12 @@
Tutorials
API
diff --git a/docs/generated/spaghetti.PointPattern.html b/docs/generated/spaghetti.PointPattern.html
index 0848cb1b..bf8b65ea 100644
--- a/docs/generated/spaghetti.PointPattern.html
+++ b/docs/generated/spaghetti.PointPattern.html
@@ -71,11 +71,12 @@
Tutorials
API
@@ -141,7 +142,7 @@ spaghetti.PointPattern
Tutorials
API
@@ -165,17 +166,17 @@ spaghetti.element_as_gdf
Tutorials
API
diff --git a/docs/genindex.html b/docs/genindex.html
index 8bd5590a..322a4ef1 100644
--- a/docs/genindex.html
+++ b/docs/genindex.html
@@ -70,11 +70,12 @@
Tutorials
API
diff --git a/docs/index.html b/docs/index.html
index ed9433e1..6fcfd5b7 100644
--- a/docs/index.html
+++ b/docs/index.html
@@ -70,11 +70,12 @@
Tutorials
API
@@ -146,7 +147,7 @@ SPAtial GrapHs: nETworks, Topology, & Inference