search-4e.ipynb

{
 "cells": [
  {
   "cell_type": "markdown",
   "metadata": {
    "button": false,
    "new_sheet": false,
    "run_control": {
     "read_only": false
    }
   },
   "source": [
    "*Note: This is not yet ready, but shows the direction I'm leaning in for Fourth Edition Search.*\n",
    "\n",
    "# State-Space Search\n",
    "\n",
    "This notebook describes several state-space search algorithms, and how they can be used to solve a variety of problems. We start with a simple algorithm and a simple domain: finding a route from city to city.  Later we will explore other algorithms and domains.\n",
    "\n",
    "## The Route-Finding Domain\n",
    "\n",
    "Like all state-space search problems, in a route-finding problem you will be given:\n",
    "- A start state (for example, `'A'` for the city Arad).\n",
    "- A goal state (for example, `'B'` for the city Bucharest).\n",
    "- Actions that can change state (for example, driving from `'A'` to `'S'`).\n",
    "\n",
    "You will be asked to find:\n",
    "- A path from the start state, through intermediate states, to the goal state.\n",
    "\n",
    "We'll use this map:\n",
    "\n",
    "<img src=\"http://robotics.cs.tamu.edu/dshell/cs625/images/map.jpg\" height=\"366\" width=\"603\">\n",
    "\n",
    "A state-space search problem can be represented by a *graph*, where the vertexes of the graph are the states of the problem (in this case, cities) and the edges of the graph are the actions (in this case, driving along a road).\n",
    "\n",
    "We'll represent a city by its single initial letter. \n",
    "We'll represent the graph of connections as a `dict` that maps each city to a list of the neighboring cities (connected by a road). For now we don't explicitly represent the actions, nor the distances\n",
    "between cities."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 1,
   "metadata": {
    "button": false,
    "collapsed": true,
    "new_sheet": false,
    "run_control": {
     "read_only": false
    }
   },
   "outputs": [],
   "source": [
    "romania = {\n",
    " 'A': ['Z', 'T', 'S'],\n",
    " 'B': ['F', 'P', 'G', 'U'],\n",
    " 'C': ['D', 'R', 'P'],\n",
    " 'D': ['M', 'C'],\n",
    " 'E': ['H'],\n",
    " 'F': ['S', 'B'],\n",
    " 'G': ['B'],\n",
    " 'H': ['U', 'E'],\n",
    " 'I': ['N', 'V'],\n",
    " 'L': ['T', 'M'],\n",
    " 'M': ['L', 'D'],\n",
    " 'N': ['I'],\n",
    " 'O': ['Z', 'S'],\n",
    " 'P': ['R', 'C', 'B'],\n",
    " 'R': ['S', 'C', 'P'],\n",
    " 'S': ['A', 'O', 'F', 'R'],\n",
    " 'T': ['A', 'L'],\n",
    " 'U': ['B', 'V', 'H'],\n",
    " 'V': ['U', 'I'],\n",
    " 'Z': ['O', 'A']}"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "button": false,
    "new_sheet": false,
    "run_control": {
     "read_only": false
    }
   },
   "source": [
    "Suppose we want to get from `A` to `B`. Where can we go from the start state, `A`?"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 2,
   "metadata": {
    "button": false,
    "new_sheet": false,
    "run_control": {
     "read_only": false
    }
   },
   "outputs": [
    {
     "data": {
      "text/plain": [
       "['Z', 'T', 'S']"
      ]
     },
     "execution_count": 2,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "romania['A']"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "button": false,
    "new_sheet": false,
    "run_control": {
     "read_only": false
    }
   },
   "source": [
    "We see that from `A` we can get to any of the three cities `['Z', 'T', 'S']`. Which should we choose?  *We don't know.* That's the whole point of *search*: we don't know which immediate action is best, so we'll have to explore, until we find a *path* that leads to the goal. \n",
    "\n",
    "How do we explore? We'll start with a simple algorithm that will get us from `A` to `B`. We'll keep a *frontier*&mdash;a collection of not-yet-explored states&mdash;and expand the frontier outward until it reaches the goal. To be more precise:\n",
    "\n",
    "- Initially, the only state in the frontier is the start state, `'A'`.\n",
    "- Until we reach the goal, or run out of states in the frontier to explore, do the following:\n",
    "  - Remove the first state from the frontier. Call it `s`.\n",
    "  - If `s` is the goal, we're done. Return the path to `s`.\n",
    "  - Otherwise, consider all the neighboring states of `s`. For each one:\n",
    "    - If we have not previously explored the state, add it to the end of the frontier.\n",
    "    - Also keep track of the previous state that led to this new neighboring state; we'll need this to reconstruct the path to the goal, and to keep us from re-visiting previously explored states.\n",
    "    \n",
    "# A Simple Search Algorithm: `breadth_first`\n",
    "    \n",
    "The function `breadth_first` implements this strategy:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 3,
   "metadata": {
    "button": false,
    "collapsed": true,
    "new_sheet": false,
    "run_control": {
     "read_only": false
    }
   },
   "outputs": [],
   "source": [
    "from collections import deque # Doubly-ended queue: pop from left, append to right.\n",
    "\n",
    "def breadth_first(start, goal, neighbors):\n",
    "    \"Find a shortest sequence of states from start to the goal.\"\n",
    "    frontier = deque([start]) # A queue of states\n",
    "    previous = {start: None}  # start has no previous state; other states will\n",
    "    while frontier:\n",
    "        s = frontier.popleft()\n",
    "        if s == goal:\n",
    "            return path(previous, s)\n",
    "        for s2 in neighbors[s]:\n",
    "            if s2 not in previous:\n",
    "                frontier.append(s2)\n",
    "                previous[s2] = s\n",
    "                \n",
    "def path(previous, s): \n",
    "    \"Return a list of states that lead to state s, according to the previous dict.\"\n",
    "    return [] if (s is None) else path(previous, previous[s]) + [s]"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "button": false,
    "new_sheet": false,
    "run_control": {
     "read_only": false
    }
   },
   "source": [
    "A couple of things to note: \n",
    "\n",
    "1. We always add new states to the end of the frontier queue. That means that all the states that are adjacent to the start state will come first in the queue, then all the states that are two steps away, then three steps, etc.\n",
    "That's what we mean by *breadth-first* search.\n",
    "2. We recover the path to an `end` state by following the trail of `previous[end]` pointers, all the way back to `start`.\n",
    "The dict `previous` is a map of `{state: previous_state}`. \n",
    "3. When we finally get an `s` that is the goal state, we know we have found a shortest path, because any other state in the queue must correspond to a path that is as long or longer.\n",
    "3. Note that `previous`  contains all the states that are currently in `frontier` as well as all the states that were in `frontier` in the past.\n",
    "4. If no path to the goal is found, then `breadth_first` returns `None`. If a path is found, it returns the sequence of states on the path.\n",
    "\n",
    "Some examples:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 4,
   "metadata": {
    "button": false,
    "new_sheet": false,
    "run_control": {
     "read_only": false
    }
   },
   "outputs": [
    {
     "data": {
      "text/plain": [
       "['A', 'S', 'F', 'B']"
      ]
     },
     "execution_count": 4,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "breadth_first('A', 'B', romania)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 5,
   "metadata": {
    "button": false,
    "new_sheet": false,
    "run_control": {
     "read_only": false
    }
   },
   "outputs": [
    {
     "data": {
      "text/plain": [
       "['L', 'T', 'A', 'S', 'F', 'B', 'U', 'V', 'I', 'N']"
      ]
     },
     "execution_count": 5,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "breadth_first('L', 'N', romania)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 6,
   "metadata": {
    "button": false,
    "new_sheet": false,
    "run_control": {
     "read_only": false
    }
   },
   "outputs": [
    {
     "data": {
      "text/plain": [
       "['N', 'I', 'V', 'U', 'B', 'F', 'S', 'A', 'T', 'L']"
      ]
     },
     "execution_count": 6,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "breadth_first('N', 'L', romania)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 7,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "['E']"
      ]
     },
     "execution_count": 7,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "breadth_first('E', 'E', romania)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "button": false,
    "new_sheet": false,
    "run_control": {
     "read_only": false
    }
   },
   "source": [
    "Now let's try a different  kind of problem that can be solved with the same search function.\n",
    "\n",
    "## Word Ladders Problem\n",
    "\n",
    "A *word ladder* problem is this: given a start word and a goal word, find the shortest way to transform the start word into the goal word by changing one letter at a time, such that each change results in a word. For example starting with `green` we can reach `grass` in 7 steps:\n",
    "\n",
    "`green` &rarr; `greed` &rarr; `treed` &rarr; `trees` &rarr; `tress` &rarr; `cress` &rarr; `crass` &rarr; `grass`\n",
    "\n",
    "We will need a dictionary of words. We'll use 5-letter words from the [Stanford GraphBase](http://www-cs-faculty.stanford.edu/~uno/sgb.html) project for this purpose. Let's get that file from aimadata."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 8,
   "metadata": {
    "button": false,
    "collapsed": true,
    "new_sheet": false,
    "run_control": {
     "read_only": false
    }
   },
   "outputs": [],
   "source": [
    "from search import *\n",
    "sgb_words = open_data(\"EN-text/sgb-words.txt\")"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "button": false,
    "new_sheet": false,
    "run_control": {
     "read_only": false
    }
   },
   "source": [
    "We can assign `WORDS` to be the set of all the words in this file:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 9,
   "metadata": {
    "button": false,
    "new_sheet": false,
    "run_control": {
     "read_only": false
    }
   },
   "outputs": [
    {
     "data": {
      "text/plain": [
       "5757"
      ]
     },
     "execution_count": 9,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "WORDS = set(sgb_words.read().split())\n",
    "len(WORDS)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "button": false,
    "new_sheet": false,
    "run_control": {
     "read_only": false
    }
   },
   "source": [
    "And define `neighboring_words` to return the set of all words that are a one-letter change away from a given `word`:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 10,
   "metadata": {
    "button": false,
    "collapsed": true,
    "new_sheet": false,
    "run_control": {
     "read_only": false
    }
   },
   "outputs": [],
   "source": [
    "def neighboring_words(word):\n",
    "    \"All words that are one letter away from this word.\"\n",
    "    neighbors = {word[:i] + c + word[i+1:]\n",
    "                 for i in range(len(word))\n",
    "                 for c in 'abcdefghijklmnopqrstuvwxyz'\n",
    "                 if c != word[i]}\n",
    "    return neighbors & WORDS"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "For example:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 11,
   "metadata": {
    "button": false,
    "new_sheet": false,
    "run_control": {
     "read_only": false
    }
   },
   "outputs": [
    {
     "data": {
      "text/plain": [
       "{'cello', 'hallo', 'hells', 'hullo', 'jello'}"
      ]
     },
     "execution_count": 11,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "neighboring_words('hello')"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 12,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "{'would'}"
      ]
     },
     "execution_count": 12,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "neighboring_words('world')"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "button": false,
    "new_sheet": false,
    "run_control": {
     "read_only": false
    }
   },
   "source": [
    "Now we can create  `word_neighbors` as a dict of `{word: {neighboring_word, ...}}`: "
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 13,
   "metadata": {
    "button": false,
    "collapsed": true,
    "new_sheet": false,
    "run_control": {
     "read_only": false
    }
   },
   "outputs": [],
   "source": [
    "word_neighbors = {word: neighboring_words(word)\n",
    "                  for word in WORDS}"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "button": false,
    "new_sheet": false,
    "run_control": {
     "read_only": false
    }
   },
   "source": [
    "Now the `breadth_first` function can be used to solve a word ladder problem:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 14,
   "metadata": {
    "button": false,
    "new_sheet": false,
    "run_control": {
     "read_only": false
    }
   },
   "outputs": [
    {
     "data": {
      "text/plain": [
       "['green', 'greed', 'treed', 'trees', 'treys', 'trays', 'grays', 'grass']"
      ]
     },
     "execution_count": 14,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "breadth_first('green', 'grass', word_neighbors)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 15,
   "metadata": {
    "button": false,
    "new_sheet": false,
    "run_control": {
     "read_only": false
    }
   },
   "outputs": [
    {
     "data": {
      "text/plain": [
       "['smart',\n",
       " 'start',\n",
       " 'stars',\n",
       " 'sears',\n",
       " 'bears',\n",
       " 'beans',\n",
       " 'brans',\n",
       " 'brand',\n",
       " 'braid',\n",
       " 'brain']"
      ]
     },
     "execution_count": 15,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "breadth_first('smart', 'brain', word_neighbors)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 16,
   "metadata": {
    "button": false,
    "new_sheet": false,
    "run_control": {
     "read_only": false
    }
   },
   "outputs": [
    {
     "data": {
      "text/plain": [
       "['frown',\n",
       " 'flown',\n",
       " 'flows',\n",
       " 'slows',\n",
       " 'slots',\n",
       " 'slits',\n",
       " 'spits',\n",
       " 'spite',\n",
       " 'smite',\n",
       " 'smile']"
      ]
     },
     "execution_count": 16,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "breadth_first('frown', 'smile', word_neighbors)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "button": false,
    "new_sheet": false,
    "run_control": {
     "read_only": false
    }
   },
   "source": [
    "# More General Search Algorithms\n",
    "\n",
    "Now we'll embelish the `breadth_first` algorithm to make a family of search algorithms with more capabilities:\n",
    "\n",
    "1. We distinguish between an *action* and the *result* of an action.\n",
    "3. We allow different measures of the cost of a solution (not just the number of steps in the sequence).\n",
    "4. We search through the state space in an order that is more likely to lead to an optimal solution quickly.\n",
    "\n",
    "Here's how we do these things:\n",
    "\n",
    "1. Instead of having a graph of neighboring states, we instead have an object of type *Problem*. A Problem\n",
    "has one method, `Problem.actions(state)` to return a collection of the actions that are allowed in a state,\n",
    "and another method, `Problem.result(state, action)` that says what happens when you take an action.\n",
    "2. We keep a set, `explored` of states that have already been explored. We also have a class, `Frontier`, that makes it efficient to ask if a state is on the frontier.\n",
    "3. Each action has a cost associated with it (in fact, the cost can vary with both the state and the action).\n",
    "4. The `Frontier` class acts as a priority queue, allowing the \"best\" state to be explored next.\n",
    "We represent a sequence of actions and resulting states as a linked list of `Node` objects.\n",
    "\n",
    "The algorithm `breadth_first_search` is basically the same  as `breadth_first`, but using our new conventions:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 17,
   "metadata": {
    "button": false,
    "collapsed": true,
    "new_sheet": false,
    "run_control": {
     "read_only": false
    }
   },
   "outputs": [],
   "source": [
    "def breadth_first_search(problem):\n",
    "    \"Search for goal; paths with least number of steps first.\"\n",
    "    if problem.is_goal(problem.initial): \n",
    "        return Node(problem.initial)\n",
    "    frontier = FrontierQ(Node(problem.initial), LIFO=False)\n",
    "    explored = set()\n",
    "    while frontier:\n",
    "        node = frontier.pop()\n",
    "        explored.add(node.state)\n",
    "        for action in problem.actions(node.state):\n",
    "            child = node.child(problem, action)\n",
    "            if child.state not in explored and child.state not in frontier:\n",
    "                if problem.is_goal(child.state):\n",
    "                    return child\n",
    "                frontier.add(child)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Next is `uniform_cost_search`, in which each step can have a different cost, and we still consider first one os the states with minimum cost so far."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 18,
   "metadata": {
    "button": false,
    "collapsed": true,
    "new_sheet": false,
    "run_control": {
     "read_only": false
    }
   },
   "outputs": [],
   "source": [
    "def uniform_cost_search(problem, costfn=lambda node: node.path_cost):\n",
    "    frontier = FrontierPQ(Node(problem.initial), costfn)\n",
    "    explored = set()\n",
    "    while frontier:\n",
    "        node = frontier.pop()\n",
    "        if problem.is_goal(node.state):\n",
    "            return node\n",
    "        explored.add(node.state)\n",
    "        for action in problem.actions(node.state):\n",
    "            child = node.child(problem, action)\n",
    "            if child.state not in explored and child not in frontier:\n",
    "                frontier.add(child)\n",
    "            elif child in frontier and frontier.cost[child] < child.path_cost:\n",
    "                frontier.replace(child)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Finally, `astar_search`  in which the cost includes an estimate of the distance to the goal as well as the distance travelled so far."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 19,
   "metadata": {
    "button": false,
    "collapsed": true,
    "new_sheet": false,
    "run_control": {
     "read_only": false
    }
   },
   "outputs": [],
   "source": [
    "def astar_search(problem, heuristic):\n",
    "    costfn = lambda node: node.path_cost + heuristic(node.state)\n",
    "    return uniform_cost_search(problem, costfn)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "button": false,
    "new_sheet": false,
    "run_control": {
     "read_only": false
    }
   },
   "source": [
    "# Search Tree Nodes\n",
    "\n",
    "The solution to a search problem is now a linked list of `Node`s, where each `Node`\n",
    "includes a `state` and the `path_cost` of getting to the state. In addition, for every `Node` except for the first (root) `Node`, there is a previous `Node` (indicating the state that lead to this `Node`) and an `action` (indicating the action taken to get here)."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 20,
   "metadata": {
    "button": false,
    "collapsed": true,
    "new_sheet": false,
    "run_control": {
     "read_only": false
    }
   },
   "outputs": [],
   "source": [
    "class Node(object):\n",
    "    \"\"\"A node in a search tree. A search tree is spanning tree over states.\n",
    "    A Node contains a state, the previous node in the tree, the action that\n",
    "    takes us from the previous state to this state, and the path cost to get to \n",
    "    this state. If a state is arrived at by two paths, then there are two nodes \n",
    "    with the same state.\"\"\"\n",
    "\n",
    "    def __init__(self, state, previous=None, action=None, step_cost=1):\n",
    "        \"Create a search tree Node, derived from a previous Node by an action.\"\n",
    "        self.state     = state\n",
    "        self.previous  = previous\n",
    "        self.action    = action\n",
    "        self.path_cost = 0 if previous is None else (previous.path_cost + step_cost)\n",
    "\n",
    "    def __repr__(self): return \"<Node {}: {}>\".format(self.state, self.path_cost)\n",
    "    \n",
    "    def __lt__(self, other): return self.path_cost < other.path_cost\n",
    "    \n",
    "    def child(self, problem, action):\n",
    "        \"The Node you get by taking an action from this Node.\"\n",
    "        result = problem.result(self.state, action)\n",
    "        return Node(result, self, action, \n",
    "                    problem.step_cost(self.state, action, result))    "
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "button": false,
    "new_sheet": false,
    "run_control": {
     "read_only": false
    }
   },
   "source": [
    "# Frontiers\n",
    "\n",
    "A frontier is a collection of Nodes that acts like both a Queue and a Set. A frontier, `f`, supports these operations:\n",
    "\n",
    "* `f.add(node)`: Add a node to the Frontier.\n",
    "\n",
    "* `f.pop()`: Remove and return the \"best\" node from the frontier.\n",
    "\n",
    "* `f.replace(node)`: add this node and remove a previous node with the same state.\n",
    "\n",
    "* `state in f`: Test if some node in the frontier has arrived at state.\n",
    "\n",
    "* `f[state]`: returns the node corresponding to this state in frontier.\n",
    "\n",
    "* `len(f)`: The number of Nodes in the frontier. When the frontier is empty, `f` is *false*.\n",
    "\n",
    "We provide two kinds of frontiers: One for \"regular\" queues, either first-in-first-out (for breadth-first search) or last-in-first-out (for depth-first search), and one for priority queues, where you can specify what cost function on nodes you are trying to minimize."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 21,
   "metadata": {
    "button": false,
    "collapsed": true,
    "new_sheet": false,
    "run_control": {
     "read_only": false
    }
   },
   "outputs": [],
   "source": [
    "from collections import OrderedDict\n",
    "import heapq\n",
    "\n",
    "class FrontierQ(OrderedDict):\n",
    "    \"A Frontier that supports FIFO or LIFO Queue ordering.\"\n",
    "    \n",
    "    def __init__(self, initial, LIFO=False):\n",
    "        \"\"\"Initialize Frontier with an initial Node.\n",
    "        If LIFO is True, pop from the end first; otherwise from front first.\"\"\"\n",
    "        super(FrontierQ, self).__init__()\n",
    "        self.LIFO = LIFO\n",
    "        self.add(initial)\n",
    "    \n",
    "    def add(self, node):\n",
    "        \"Add a node to the frontier.\"\n",
    "        self[node.state] = node\n",
    "        \n",
    "    def pop(self):\n",
    "        \"Remove and return the next Node in the frontier.\"\n",
    "        (state, node) = self.popitem(self.LIFO)\n",
    "        return node\n",
    "    \n",
    "    def replace(self, node):\n",
    "        \"Make this node replace the nold node with the same state.\"\n",
    "        del self[node.state]\n",
    "        self.add(node)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 22,
   "metadata": {
    "button": false,
    "collapsed": true,
    "new_sheet": false,
    "run_control": {
     "read_only": false
    }
   },
   "outputs": [],
   "source": [
    "class FrontierPQ:\n",
    "    \"A Frontier ordered by a cost function; a Priority Queue.\"\n",
    "    \n",
    "    def __init__(self, initial, costfn=lambda node: node.path_cost):\n",
    "        \"Initialize Frontier with an initial Node, and specify a cost function.\"\n",
    "        self.heap   = []\n",
    "        self.states = {}\n",
    "        self.costfn = costfn\n",
    "        self.add(initial)\n",
    "    \n",
    "    def add(self, node):\n",
    "        \"Add node to the frontier.\"\n",
    "        cost = self.costfn(node)\n",
    "        heapq.heappush(self.heap, (cost, node))\n",
    "        self.states[node.state] = node\n",
    "        \n",
    "    def pop(self):\n",
    "        \"Remove and return the Node with minimum cost.\"\n",
    "        (cost, node) = heapq.heappop(self.heap)\n",
    "        self.states.pop(node.state, None) # remove state\n",
    "        return node\n",
    "    \n",
    "    def replace(self, node):\n",
    "        \"Make this node replace a previous node with the same state.\"\n",
    "        if node.state not in self:\n",
    "            raise ValueError('{} not there to replace'.format(node.state))\n",
    "        for (i, (cost, old_node)) in enumerate(self.heap):\n",
    "            if old_node.state == node.state:\n",
    "                self.heap[i] = (self.costfn(node), node)\n",
    "                heapq._siftdown(self.heap, 0, i)\n",
    "                return\n",
    "\n",
    "    def __contains__(self, state): return state in self.states\n",
    "    \n",
    "    def __len__(self): return len(self.heap)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "button": false,
    "new_sheet": false,
    "run_control": {
     "read_only": false
    }
   },
   "source": [
    "# Search Problems\n",
    "\n",
    "`Problem` is the abstract class for all search problems. You can define your own class of problems as a subclass of `Problem`. You will need to override the `actions` and  `result` method to describe how your problem works. You will also have to either override `is_goal` or pass a collection of goal states to the initialization method.  If actions have different costs, you should override the `step_cost` method. "
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 23,
   "metadata": {
    "button": false,
    "collapsed": true,
    "new_sheet": false,
    "run_control": {
     "read_only": false
    }
   },
   "outputs": [],
   "source": [
    "class Problem(object):\n",
    "    \"\"\"The abstract class for a search problem.\"\"\"\n",
    "\n",
    "    def __init__(self, initial=None, goals=(), **additional_keywords):\n",
    "        \"\"\"Provide an initial state and optional goal states.\n",
    "        A subclass can have additional keyword arguments.\"\"\"\n",
    "        self.initial = initial  # The initial state of the problem.\n",
    "        self.goals = goals      # A collection of possible goal states.\n",
    "        self.__dict__.update(**additional_keywords)\n",
    "\n",
    "    def actions(self, state):\n",
    "        \"Return a list of actions executable in this state.\"\n",
    "        raise NotImplementedError # Override this!\n",
    "\n",
    "    def result(self, state, action):\n",
    "        \"The state that results from executing this action in this state.\"\n",
    "        raise NotImplementedError # Override this!\n",
    "\n",
    "    def is_goal(self, state):\n",
    "        \"True if the state is a goal.\" \n",
    "        return state in self.goals # Optionally override this!\n",
    "\n",
    "    def step_cost(self, state, action, result=None):\n",
    "        \"The cost of taking this action from this state.\"\n",
    "        return 1 # Override this if actions have different costs        "
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 24,
   "metadata": {
    "collapsed": true
   },
   "outputs": [],
   "source": [
    "def action_sequence(node):\n",
    "    \"The sequence of actions to get to this node.\"\n",
    "    actions = []\n",
    "    while node.previous:\n",
    "        actions.append(node.action)\n",
    "        node = node.previous\n",
    "    return actions[::-1]\n",
    "\n",
    "def state_sequence(node):\n",
    "    \"The sequence of states to get to this node.\"\n",
    "    states = [node.state]\n",
    "    while node.previous:\n",
    "        node = node.previous\n",
    "        states.append(node.state)\n",
    "    return states[::-1]"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "button": false,
    "new_sheet": false,
    "run_control": {
     "read_only": false
    }
   },
   "source": [
    "# Two Location Vacuum World"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 25,
   "metadata": {
    "button": false,
    "collapsed": true,
    "new_sheet": false,
    "run_control": {
     "read_only": false
    }
   },
   "outputs": [],
   "source": [
    "dirt  = '*'\n",
    "clean = ' '\n",
    "\n",
    "class TwoLocationVacuumProblem(Problem):\n",
    "    \"\"\"A Vacuum in a world with two locations, and dirt.\n",
    "    Each state is a tuple of (location, dirt_in_W, dirt_in_E).\"\"\"\n",
    "\n",
    "    def actions(self, state): return ('W', 'E', 'Suck')\n",
    "    \n",
    "    def is_goal(self, state): return dirt not in state\n",
    " \n",
    "    def result(self, state, action):\n",
    "        \"The state that results from executing this action in this state.\"        \n",
    "        (loc, dirtW, dirtE) = state\n",
    "        if   action == 'W':                   return ('W', dirtW, dirtE)\n",
    "        elif action == 'E':                   return ('E', dirtW, dirtE)\n",
    "        elif action == 'Suck' and loc == 'W': return (loc, clean, dirtE)\n",
    "        elif action == 'Suck' and loc == 'E': return (loc, dirtW, clean) \n",
    "        else: raise ValueError('unknown action: ' + action)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 26,
   "metadata": {
    "button": false,
    "new_sheet": false,
    "run_control": {
     "read_only": false
    }
   },
   "outputs": [
    {
     "data": {
      "text/plain": [
       "<Node ('E', ' ', ' '): 3>"
      ]
     },
     "execution_count": 26,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "problem = TwoLocationVacuumProblem(initial=('W', dirt, dirt))\n",
    "result = uniform_cost_search(problem)\n",
    "result"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 27,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "['Suck', 'E', 'Suck']"
      ]
     },
     "execution_count": 27,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "action_sequence(result)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 28,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "[('W', '*', '*'), ('W', ' ', '*'), ('E', ' ', '*'), ('E', ' ', ' ')]"
      ]
     },
     "execution_count": 28,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "state_sequence(result)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 29,
   "metadata": {
    "button": false,
    "new_sheet": false,
    "run_control": {
     "read_only": false
    }
   },
   "outputs": [
    {
     "data": {
      "text/plain": [
       "['Suck']"
      ]
     },
     "execution_count": 29,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "problem = TwoLocationVacuumProblem(initial=('E', clean, dirt))\n",
    "result = uniform_cost_search(problem)\n",
    "action_sequence(result)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "button": false,
    "new_sheet": false,
    "run_control": {
     "read_only": false
    }
   },
   "source": [
    "# Water Pouring Problem\n",
    "\n",
    "Here is another problem domain, to show you how to define one. The idea is that we have a number of water jugs and a water tap and the goal is to measure out a specific amount of water (in, say, ounces or liters). You can completely fill or empty a jug, but because the jugs don't have markings on them, you can't partially fill them with a specific amount. You can, however, pour one jug into another, stopping when the seconfd is full or the first is empty."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 30,
   "metadata": {
    "button": false,
    "collapsed": true,
    "new_sheet": false,
    "run_control": {
     "read_only": false
    }
   },
   "outputs": [],
   "source": [
    "class PourProblem(Problem):\n",
    "    \"\"\"Problem about pouring water between jugs to achieve some water level.\n",
    "    Each state is a tuples of levels. In the initialization, provide a tuple of \n",
    "    capacities, e.g. PourProblem(capacities=(8, 16, 32), initial=(2, 4, 3), goals={7}), \n",
    "    which means three jugs of capacity 8, 16, 32, currently filled with 2, 4, 3 units of \n",
    "    water, respectively, and the goal is to get a level of 7 in any one of the jugs.\"\"\"\n",
    "    \n",
    "    def actions(self, state):\n",
    "        \"\"\"The actions executable in this state.\"\"\"\n",
    "        jugs = range(len(state))\n",
    "        return ([('Fill', i)    for i in jugs if state[i] != self.capacities[i]] +\n",
    "                [('Dump', i)    for i in jugs if state[i] != 0] +\n",
    "                [('Pour', i, j) for i in jugs for j in jugs if i != j])\n",
    "\n",
    "    def result(self, state, action):\n",
    "        \"\"\"The state that results from executing this action in this state.\"\"\"\n",
    "        result = list(state)\n",
    "        act, i, j = action[0], action[1], action[-1]\n",
    "        if act == 'Fill': # Fill i to capacity\n",
    "            result[i] = self.capacities[i]\n",
    "        elif act == 'Dump': # Empty i\n",
    "            result[i] = 0\n",
    "        elif act == 'Pour':\n",
    "            a, b = state[i], state[j]\n",
    "            result[i], result[j] = ((0, a + b) \n",
    "                                    if (a + b <= self.capacities[j]) else\n",
    "                                    (a + b - self.capacities[j], self.capacities[j]))\n",
    "        else:\n",
    "            raise ValueError('unknown action', action)\n",
    "        return tuple(result)\n",
    "\n",
    "    def is_goal(self, state):\n",
    "        \"\"\"True if any of the jugs has a level equal to one of the goal levels.\"\"\"\n",
    "        return any(level in self.goals for level in state)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 31,
   "metadata": {
    "button": false,
    "new_sheet": false,
    "run_control": {
     "read_only": false
    }
   },
   "outputs": [
    {
     "data": {
      "text/plain": [
       "(2, 13)"
      ]
     },
     "execution_count": 31,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "p7 = PourProblem(initial=(2, 0), capacities=(5, 13), goals={7})\n",
    "p7.result((2, 0),  ('Fill', 1))"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 32,
   "metadata": {
    "button": false,
    "new_sheet": false,
    "run_control": {
     "read_only": false
    }
   },
   "outputs": [
    {
     "data": {
      "text/plain": [
       "[('Pour', 0, 1), ('Fill', 0), ('Pour', 0, 1)]"
      ]
     },
     "execution_count": 32,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "result = uniform_cost_search(p7)\n",
    "action_sequence(result)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "button": false,
    "new_sheet": false,
    "run_control": {
     "read_only": false
    }
   },
   "source": [
    "# Visualization Output"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 33,
   "metadata": {
    "button": false,
    "collapsed": true,
    "new_sheet": false,
    "run_control": {
     "read_only": false
    }
   },
   "outputs": [],
   "source": [
    "def showpath(searcher, problem):\n",
    "    \"Show what happens when searcvher solves problem.\"\n",
    "    problem = Instrumented(problem)\n",
    "    print('\\n{}:'.format(searcher.__name__))\n",
    "    result = searcher(problem)\n",
    "    if result:\n",
    "        actions = action_sequence(result)\n",
    "        state = problem.initial\n",
    "        path_cost = 0\n",
    "        for steps, action in enumerate(actions, 1):\n",
    "            path_cost += problem.step_cost(state, action, 0)\n",
    "            result = problem.result(state, action)\n",
    "            print('  {} =={}==> {}; cost {} after {} steps'\n",
    "                  .format(state, action, result, path_cost, steps,\n",
    "                          '; GOAL!' if problem.is_goal(result) else ''))\n",
    "            state = result\n",
    "    msg = 'GOAL FOUND' if result else 'no solution'\n",
    "    print('{} after {} results and {} goal checks'\n",
    "          .format(msg, problem._counter['result'], problem._counter['is_goal']))\n",
    "        \n",
    "from collections import Counter\n",
    "\n",
    "class Instrumented:\n",
    "    \"Instrument an object to count all the attribute accesses in _counter.\"\n",
    "    def __init__(self, obj):\n",
    "        self._object = obj\n",
    "        self._counter = Counter()\n",
    "    def __getattr__(self, attr):\n",
    "        self._counter[attr] += 1\n",
    "        return getattr(self._object, attr)    "
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 34,
   "metadata": {
    "button": false,
    "new_sheet": false,
    "run_control": {
     "read_only": false
    }
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "\n",
      "uniform_cost_search:\n",
      "  (2, 0) ==('Pour', 0, 1)==> (0, 2); cost 1 after 1 steps\n",
      "  (0, 2) ==('Fill', 0)==> (5, 2); cost 2 after 2 steps\n",
      "  (5, 2) ==('Pour', 0, 1)==> (0, 7); cost 3 after 3 steps\n",
      "GOAL FOUND after 83 results and 22 goal checks\n"
     ]
    }
   ],
   "source": [
    "showpath(uniform_cost_search, p7)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 35,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "\n",
      "uniform_cost_search:\n",
      "  (0, 0) ==('Fill', 0)==> (7, 0); cost 1 after 1 steps\n",
      "  (7, 0) ==('Pour', 0, 1)==> (0, 7); cost 2 after 2 steps\n",
      "  (0, 7) ==('Fill', 0)==> (7, 7); cost 3 after 3 steps\n",
      "  (7, 7) ==('Pour', 0, 1)==> (1, 13); cost 4 after 4 steps\n",
      "  (1, 13) ==('Dump', 1)==> (1, 0); cost 5 after 5 steps\n",
      "  (1, 0) ==('Pour', 0, 1)==> (0, 1); cost 6 after 6 steps\n",
      "  (0, 1) ==('Fill', 0)==> (7, 1); cost 7 after 7 steps\n",
      "  (7, 1) ==('Pour', 0, 1)==> (0, 8); cost 8 after 8 steps\n",
      "  (0, 8) ==('Fill', 0)==> (7, 8); cost 9 after 9 steps\n",
      "  (7, 8) ==('Pour', 0, 1)==> (2, 13); cost 10 after 10 steps\n",
      "GOAL FOUND after 110 results and 32 goal checks\n"
     ]
    }
   ],
   "source": [
    "p = PourProblem(initial=(0, 0), capacities=(7, 13), goals={2})\n",
    "showpath(uniform_cost_search, p)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 36,
   "metadata": {
    "collapsed": true
   },
   "outputs": [],
   "source": [
    "class GreenPourProblem(PourProblem):    \n",
    "    def step_cost(self, state, action, result=None):\n",
    "        \"The cost is the amount of water used in a fill.\"\n",
    "        if action[0] == 'Fill':\n",
    "            i = action[1]\n",
    "            return self.capacities[i] - state[i]\n",
    "        return 0"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 37,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "\n",
      "uniform_cost_search:\n",
      "  (0, 0) ==('Fill', 0)==> (7, 0); cost 7 after 1 steps\n",
      "  (7, 0) ==('Pour', 0, 1)==> (0, 7); cost 7 after 2 steps\n",
      "  (0, 7) ==('Fill', 0)==> (7, 7); cost 14 after 3 steps\n",
      "  (7, 7) ==('Pour', 0, 1)==> (1, 13); cost 14 after 4 steps\n",
      "  (1, 13) ==('Dump', 1)==> (1, 0); cost 14 after 5 steps\n",
      "  (1, 0) ==('Pour', 0, 1)==> (0, 1); cost 14 after 6 steps\n",
      "  (0, 1) ==('Fill', 0)==> (7, 1); cost 21 after 7 steps\n",
      "  (7, 1) ==('Pour', 0, 1)==> (0, 8); cost 21 after 8 steps\n",
      "  (0, 8) ==('Fill', 0)==> (7, 8); cost 28 after 9 steps\n",
      "  (7, 8) ==('Pour', 0, 1)==> (2, 13); cost 28 after 10 steps\n",
      "GOAL FOUND after 184 results and 48 goal checks\n"
     ]
    }
   ],
   "source": [
    "p = GreenPourProblem(initial=(0, 0), capacities=(7, 13), goals={2})\n",
    "showpath(uniform_cost_search, p)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 38,
   "metadata": {
    "button": false,
    "collapsed": true,
    "new_sheet": false,
    "run_control": {
     "read_only": false
    }
   },
   "outputs": [],
   "source": [
    "def compare_searchers(problem, searchers=None):\n",
    "    \"Apply each of the search algorithms to the problem, and show results\"\n",
    "    if searchers is None: \n",
    "        searchers = (breadth_first_search, uniform_cost_search)\n",
    "    for searcher in searchers:\n",
    "        showpath(searcher, problem)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 39,
   "metadata": {
    "button": false,
    "new_sheet": false,
    "run_control": {
     "read_only": false
    }
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "\n",
      "breadth_first_search:\n",
      "  (0, 0) ==('Fill', 0)==> (7, 0); cost 7 after 1 steps\n",
      "  (7, 0) ==('Pour', 0, 1)==> (0, 7); cost 7 after 2 steps\n",
      "  (0, 7) ==('Fill', 0)==> (7, 7); cost 14 after 3 steps\n",
      "  (7, 7) ==('Pour', 0, 1)==> (1, 13); cost 14 after 4 steps\n",
      "  (1, 13) ==('Dump', 1)==> (1, 0); cost 14 after 5 steps\n",
      "  (1, 0) ==('Pour', 0, 1)==> (0, 1); cost 14 after 6 steps\n",
      "  (0, 1) ==('Fill', 0)==> (7, 1); cost 21 after 7 steps\n",
      "  (7, 1) ==('Pour', 0, 1)==> (0, 8); cost 21 after 8 steps\n",
      "  (0, 8) ==('Fill', 0)==> (7, 8); cost 28 after 9 steps\n",
      "  (7, 8) ==('Pour', 0, 1)==> (2, 13); cost 28 after 10 steps\n",
      "GOAL FOUND after 100 results and 31 goal checks\n",
      "\n",
      "uniform_cost_search:\n",
      "  (0, 0) ==('Fill', 0)==> (7, 0); cost 7 after 1 steps\n",
      "  (7, 0) ==('Pour', 0, 1)==> (0, 7); cost 7 after 2 steps\n",
      "  (0, 7) ==('Fill', 0)==> (7, 7); cost 14 after 3 steps\n",
      "  (7, 7) ==('Pour', 0, 1)==> (1, 13); cost 14 after 4 steps\n",
      "  (1, 13) ==('Dump', 1)==> (1, 0); cost 14 after 5 steps\n",
      "  (1, 0) ==('Pour', 0, 1)==> (0, 1); cost 14 after 6 steps\n",
      "  (0, 1) ==('Fill', 0)==> (7, 1); cost 21 after 7 steps\n",
      "  (7, 1) ==('Pour', 0, 1)==> (0, 8); cost 21 after 8 steps\n",
      "  (0, 8) ==('Fill', 0)==> (7, 8); cost 28 after 9 steps\n",
      "  (7, 8) ==('Pour', 0, 1)==> (2, 13); cost 28 after 10 steps\n",
      "GOAL FOUND after 184 results and 48 goal checks\n"
     ]
    }
   ],
   "source": [
    "compare_searchers(p)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "# Random Grid\n",
    "\n",
    "An environment where you can move in any of 4 directions, unless there is an obstacle there.\n",
    "\n",
    "\n",
    "\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 40,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "{(0, 0): [(0, 1), (1, 0)],\n",
       " (0, 1): [(0, 2), (0, 0), (1, 1)],\n",
       " (0, 2): [(0, 3), (0, 1), (1, 2)],\n",
       " (0, 3): [(0, 4), (0, 2), (1, 3)],\n",
       " (0, 4): [(0, 3), (1, 4)],\n",
       " (1, 0): [(1, 1), (2, 0), (0, 0)],\n",
       " (1, 1): [(1, 2), (1, 0), (2, 1), (0, 1)],\n",
       " (1, 2): [(1, 3), (1, 1), (2, 2), (0, 2)],\n",
       " (1, 3): [(1, 4), (1, 2), (2, 3), (0, 3)],\n",
       " (1, 4): [(1, 3), (2, 4), (0, 4)],\n",
       " (2, 0): [(2, 1), (3, 0), (1, 0)],\n",
       " (2, 1): [(2, 2), (2, 0), (3, 1), (1, 1)],\n",
       " (2, 2): [(2, 3), (2, 1), (1, 2)],\n",
       " (2, 3): [(2, 4), (2, 2), (3, 3), (1, 3)],\n",
       " (2, 4): [(2, 3), (1, 4)],\n",
       " (3, 0): [(3, 1), (4, 0), (2, 0)],\n",
       " (3, 1): [(3, 0), (4, 1), (2, 1)],\n",
       " (3, 2): [(3, 3), (3, 1), (4, 2), (2, 2)],\n",
       " (3, 3): [(4, 3), (2, 3)],\n",
       " (3, 4): [(3, 3), (4, 4), (2, 4)],\n",
       " (4, 0): [(4, 1), (3, 0)],\n",
       " (4, 1): [(4, 2), (4, 0), (3, 1)],\n",
       " (4, 2): [(4, 3), (4, 1)],\n",
       " (4, 3): [(4, 4), (4, 2), (3, 3)],\n",
       " (4, 4): [(4, 3)]}"
      ]
     },
     "execution_count": 40,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "import random\n",
    "\n",
    "N, S, E, W = DIRECTIONS = [(0, 1), (0, -1), (1, 0), (-1, 0)]\n",
    "\n",
    "def Grid(width, height, obstacles=0.1):\n",
    "    \"\"\"A 2-D grid, width x height, with obstacles that are either a collection of points,\n",
    "    or a fraction between 0 and 1 indicating the density of obstacles, chosen at random.\"\"\"\n",
    "    grid = {(x, y) for x in range(width) for y in range(height)}\n",
    "    if isinstance(obstacles, (float, int)):\n",
    "        obstacles = random.sample(grid, int(width * height * obstacles))\n",
    "    def neighbors(x, y):\n",
    "        for (dx, dy) in DIRECTIONS:\n",
    "            (nx, ny) = (x + dx, y + dy)\n",
    "            if (nx, ny) not in obstacles and 0 <= nx < width and 0 <= ny < height:\n",
    "                yield (nx, ny)\n",
    "    return {(x, y): list(neighbors(x, y))\n",
    "            for x in range(width) for y in range(height)}\n",
    "\n",
    "Grid(5, 5)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 41,
   "metadata": {
    "collapsed": true
   },
   "outputs": [],
   "source": [
    "class GridProblem(Problem):\n",
    "    \"Create with a call like GridProblem(grid=Grid(10, 10), initial=(0, 0), goal=(9, 9))\"\n",
    "    def actions(self, state): return DIRECTIONS\n",
    "    def result(self, state, action):\n",
    "        #print('ask for result of', state, action)\n",
    "        (x, y) = state\n",
    "        (dx, dy) = action\n",
    "        r = (x + dx, y + dy)\n",
    "        return r if r in self.grid[state] else state"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 42,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "\n",
      "uniform_cost_search:\n",
      "  (0, 0) ==(0, 1)==> (0, 1); cost 1 after 1 steps\n",
      "  (0, 1) ==(0, 1)==> (0, 2); cost 2 after 2 steps\n",
      "  (0, 2) ==(0, 1)==> (0, 3); cost 3 after 3 steps\n",
      "  (0, 3) ==(1, 0)==> (1, 3); cost 4 after 4 steps\n",
      "  (1, 3) ==(1, 0)==> (2, 3); cost 5 after 5 steps\n",
      "  (2, 3) ==(0, 1)==> (2, 4); cost 6 after 6 steps\n",
      "  (2, 4) ==(1, 0)==> (3, 4); cost 7 after 7 steps\n",
      "  (3, 4) ==(1, 0)==> (4, 4); cost 8 after 8 steps\n",
      "GOAL FOUND after 248 results and 69 goal checks\n"
     ]
    }
   ],
   "source": [
    "gp = GridProblem(grid=Grid(5, 5, 0.3), initial=(0, 0), goals={(4, 4)})\n",
    "showpath(uniform_cost_search, gp)\n"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "button": false,
    "new_sheet": false,
    "run_control": {
     "read_only": false
    }
   },
   "source": [
    "# Finding a hard PourProblem\n",
    "\n",
    "What solvable two-jug PourProblem requires the most steps? We can define the hardness as the number of steps, and then iterate over all PourProblems with capacities up to size M, keeping the hardest one."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 43,
   "metadata": {
    "button": false,
    "collapsed": true,
    "new_sheet": false,
    "run_control": {
     "read_only": false
    }
   },
   "outputs": [],
   "source": [
    "def hardness(problem):\n",
    "    L = breadth_first_search(problem)\n",
    "    #print('hardness', problem.initial, problem.capacities, problem.goals, L)\n",
    "    return len(action_sequence(L)) if (L is not None) else 0"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 44,
   "metadata": {
    "button": false,
    "new_sheet": false,
    "run_control": {
     "read_only": false
    }
   },
   "outputs": [
    {
     "data": {
      "text/plain": [
       "3"
      ]
     },
     "execution_count": 44,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "hardness(p7)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 45,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "[('Pour', 0, 1), ('Fill', 0), ('Pour', 0, 1)]"
      ]
     },
     "execution_count": 45,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "action_sequence(breadth_first_search(p7))"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 46,
   "metadata": {
    "button": false,
    "new_sheet": false,
    "run_control": {
     "read_only": false
    }
   },
   "outputs": [
    {
     "data": {
      "text/plain": [
       "((0, 0), (7, 9), {8})"
      ]
     },
     "execution_count": 46,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "C = 9 # Maximum capacity to consider\n",
    "\n",
    "phard = max((PourProblem(initial=(a, b), capacities=(A, B), goals={goal})\n",
    "             for A in range(C+1) for B in range(C+1)\n",
    "             for a in range(A) for b in range(B)\n",
    "             for goal in range(max(A, B))),\n",
    "            key=hardness)\n",
    "\n",
    "phard.initial, phard.capacities, phard.goals"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 47,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "\n",
      "breadth_first_search:\n",
      "  (0, 0) ==('Fill', 1)==> (0, 9); cost 1 after 1 steps\n",
      "  (0, 9) ==('Pour', 1, 0)==> (7, 2); cost 2 after 2 steps\n",
      "  (7, 2) ==('Dump', 0)==> (0, 2); cost 3 after 3 steps\n",
      "  (0, 2) ==('Pour', 1, 0)==> (2, 0); cost 4 after 4 steps\n",
      "  (2, 0) ==('Fill', 1)==> (2, 9); cost 5 after 5 steps\n",
      "  (2, 9) ==('Pour', 1, 0)==> (7, 4); cost 6 after 6 steps\n",
      "  (7, 4) ==('Dump', 0)==> (0, 4); cost 7 after 7 steps\n",
      "  (0, 4) ==('Pour', 1, 0)==> (4, 0); cost 8 after 8 steps\n",
      "  (4, 0) ==('Fill', 1)==> (4, 9); cost 9 after 9 steps\n",
      "  (4, 9) ==('Pour', 1, 0)==> (7, 6); cost 10 after 10 steps\n",
      "  (7, 6) ==('Dump', 0)==> (0, 6); cost 11 after 11 steps\n",
      "  (0, 6) ==('Pour', 1, 0)==> (6, 0); cost 12 after 12 steps\n",
      "  (6, 0) ==('Fill', 1)==> (6, 9); cost 13 after 13 steps\n",
      "  (6, 9) ==('Pour', 1, 0)==> (7, 8); cost 14 after 14 steps\n",
      "GOAL FOUND after 150 results and 44 goal checks\n"
     ]
    }
   ],
   "source": [
    "showpath(breadth_first_search, PourProblem(initial=(0, 0), capacities=(7, 9), goals={8}))"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 48,
   "metadata": {
    "button": false,
    "new_sheet": false,
    "run_control": {
     "read_only": false
    }
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "\n",
      "uniform_cost_search:\n",
      "  (0, 0) ==('Fill', 1)==> (0, 9); cost 1 after 1 steps\n",
      "  (0, 9) ==('Pour', 1, 0)==> (7, 2); cost 2 after 2 steps\n",
      "  (7, 2) ==('Dump', 0)==> (0, 2); cost 3 after 3 steps\n",
      "  (0, 2) ==('Pour', 1, 0)==> (2, 0); cost 4 after 4 steps\n",
      "  (2, 0) ==('Fill', 1)==> (2, 9); cost 5 after 5 steps\n",
      "  (2, 9) ==('Pour', 1, 0)==> (7, 4); cost 6 after 6 steps\n",
      "  (7, 4) ==('Dump', 0)==> (0, 4); cost 7 after 7 steps\n",
      "  (0, 4) ==('Pour', 1, 0)==> (4, 0); cost 8 after 8 steps\n",
      "  (4, 0) ==('Fill', 1)==> (4, 9); cost 9 after 9 steps\n",
      "  (4, 9) ==('Pour', 1, 0)==> (7, 6); cost 10 after 10 steps\n",
      "  (7, 6) ==('Dump', 0)==> (0, 6); cost 11 after 11 steps\n",
      "  (0, 6) ==('Pour', 1, 0)==> (6, 0); cost 12 after 12 steps\n",
      "  (6, 0) ==('Fill', 1)==> (6, 9); cost 13 after 13 steps\n",
      "  (6, 9) ==('Pour', 1, 0)==> (7, 8); cost 14 after 14 steps\n",
      "GOAL FOUND after 159 results and 45 goal checks\n"
     ]
    }
   ],
   "source": [
    "showpath(uniform_cost_search, phard)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 49,
   "metadata": {
    "button": false,
    "collapsed": true,
    "new_sheet": false,
    "run_control": {
     "read_only": false
    }
   },
   "outputs": [],
   "source": [
    "class GridProblem(Problem):\n",
    "    \"\"\"A Grid.\"\"\"\n",
    "\n",
    "    def actions(self, state): return ['N', 'S', 'E', 'W']        \n",
    " \n",
    "    def result(self, state, action):\n",
    "        \"\"\"The state that results from executing this action in this state.\"\"\"  \n",
    "        (W, H) = self.size\n",
    "        if action == 'N' and state > W:           return state - W\n",
    "        if action == 'S' and state + W < W * W:   return state + W\n",
    "        if action == 'E' and (state + 1) % W !=0: return state + 1\n",
    "        if action == 'W' and state % W != 0:      return state - 1\n",
    "        return state"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 50,
   "metadata": {
    "button": false,
    "new_sheet": false,
    "run_control": {
     "read_only": false
    }
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "\n",
      "breadth_first_search:\n",
      "  0 ==S==> 10; cost 1 after 1 steps\n",
      "  10 ==S==> 20; cost 2 after 2 steps\n",
      "  20 ==S==> 30; cost 3 after 3 steps\n",
      "  30 ==S==> 40; cost 4 after 4 steps\n",
      "  40 ==E==> 41; cost 5 after 5 steps\n",
      "  41 ==E==> 42; cost 6 after 6 steps\n",
      "  42 ==E==> 43; cost 7 after 7 steps\n",
      "  43 ==E==> 44; cost 8 after 8 steps\n",
      "GOAL FOUND after 135 results and 49 goal checks\n",
      "\n",
      "uniform_cost_search:\n",
      "  0 ==S==> 10; cost 1 after 1 steps\n",
      "  10 ==S==> 20; cost 2 after 2 steps\n",
      "  20 ==E==> 21; cost 3 after 3 steps\n",
      "  21 ==E==> 22; cost 4 after 4 steps\n",
      "  22 ==E==> 23; cost 5 after 5 steps\n",
      "  23 ==S==> 33; cost 6 after 6 steps\n",
      "  33 ==S==> 43; cost 7 after 7 steps\n",
      "  43 ==E==> 44; cost 8 after 8 steps\n",
      "GOAL FOUND after 1036 results and 266 goal checks\n"
     ]
    }
   ],
   "source": [
    "compare_searchers(GridProblem(initial=0, goals={44}, size=(10, 10)))"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 51,
   "metadata": {
    "button": false,
    "new_sheet": false,
    "run_control": {
     "read_only": false
    }
   },
   "outputs": [
    {
     "data": {
      "text/plain": [
       "'test_frontier ok'"
      ]
     },
     "execution_count": 51,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "def test_frontier():\n",
    "    \n",
    "    #### Breadth-first search with FIFO Q\n",
    "    f = FrontierQ(Node(1), LIFO=False)\n",
    "    assert 1 in f and len(f) == 1\n",
    "    f.add(Node(2))\n",
    "    f.add(Node(3))\n",
    "    assert 1 in f and 2 in f and 3 in f and len(f) == 3\n",
    "    assert f.pop().state == 1\n",
    "    assert 1 not in f and 2 in f and 3 in f and len(f) == 2\n",
    "    assert f\n",
    "    assert f.pop().state == 2\n",
    "    assert f.pop().state == 3\n",
    "    assert not f\n",
    "    \n",
    "    #### Depth-first search with LIFO Q\n",
    "    f = FrontierQ(Node('a'), LIFO=True)\n",
    "    for s in 'bcdef': f.add(Node(s))\n",
    "    assert len(f) == 6 and 'a' in f and 'c' in f and 'f' in f\n",
    "    for s in 'fedcba': assert f.pop().state == s\n",
    "    assert not f\n",
    "\n",
    "    #### Best-first search with Priority Q\n",
    "    f = FrontierPQ(Node(''), lambda node: len(node.state))\n",
    "    assert '' in f and len(f) == 1 and f\n",
    "    for s in ['book', 'boo', 'bookie', 'bookies', 'cook', 'look', 'b']:\n",
    "        assert s not in f\n",
    "        f.add(Node(s))\n",
    "        assert s in f\n",
    "    assert f.pop().state == ''\n",
    "    assert f.pop().state == 'b'\n",
    "    assert f.pop().state == 'boo'\n",
    "    assert {f.pop().state for _ in '123'} == {'book', 'cook', 'look'}\n",
    "    assert f.pop().state == 'bookie'\n",
    "    \n",
    "    #### Romania: Two paths to Bucharest; cheapest one found first\n",
    "    S    = Node('S')\n",
    "    SF   = Node('F', S, 'S->F', 99)\n",
    "    SFB  = Node('B', SF, 'F->B', 211)\n",
    "    SR   = Node('R', S, 'S->R', 80)\n",
    "    SRP  = Node('P', SR, 'R->P', 97)\n",
    "    SRPB = Node('B', SRP, 'P->B', 101)\n",
    "    f = FrontierPQ(S)\n",
    "    f.add(SF); f.add(SR), f.add(SRP), f.add(SRPB); f.add(SFB)\n",
    "    def cs(n): return (n.path_cost, n.state) # cs: cost and state\n",
    "    assert cs(f.pop()) == (0, 'S')\n",
    "    assert cs(f.pop()) == (80, 'R')\n",
    "    assert cs(f.pop()) == (99, 'F')\n",
    "    assert cs(f.pop()) == (177, 'P')\n",
    "    assert cs(f.pop()) == (278, 'B')\n",
    "    return 'test_frontier ok'\n",
    "\n",
    "test_frontier()"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 52,
   "metadata": {
    "button": false,
    "collapsed": true,
    "new_sheet": false,
    "run_control": {
     "read_only": false
    }
   },
   "outputs": [],
   "source": [
    "# %matplotlib inline\n",
    "import matplotlib.pyplot as plt\n",
    "\n",
    "p = plt.plot([i**2 for i in range(10)])\n",
    "plt.savefig('destination_path.eps', format='eps', dpi=1200)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 53,
   "metadata": {
    "button": false,
    "new_sheet": false,
    "run_control": {
     "read_only": false
    }
   },
   "outputs": [
    {
     "data": {
      "image/png": "iVBORw0KGgoAAAANSUhEUgAAAXQAAAD8CAYAAABn919SAAAABHNCSVQICAgIfAhkiAAAAAlwSFlz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\ngg==\n",
      "text/plain": [
       "<matplotlib.figure.Figure at 0x7f876647a860>"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    },
    {
     "data": {
      "image/png": "iVBORw0KGgoAAAANSUhEUgAAAeYAAAHSCAYAAAA5eGh0AAAABHNCSVQICAgIfAhkiAAAAAlwSFlz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\nMAjFDACAQShmAAAMQjEDAGCQ/wdJuZEoaHGMKwAAAABJRU5ErkJggg==\n",
      "text/plain": [
       "<matplotlib.figure.Figure at 0x7f874e648390>"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    }
   ],
   "source": [
    "import itertools\n",
    "import random\n",
    "# http://stackoverflow.com/questions/10194482/custom-matplotlib-plot-chess-board-like-table-with-colored-cells\n",
    "\n",
    "from matplotlib.table import Table\n",
    "\n",
    "def main():\n",
    "    grid_table(8, 8)\n",
    "    plt.axis('scaled')\n",
    "    plt.show()\n",
    "\n",
    "def grid_table(nrows, ncols):\n",
    "    fig, ax = plt.subplots()\n",
    "    ax.set_axis_off()\n",
    "    colors = ['white', 'lightgrey', 'dimgrey']\n",
    "    tb = Table(ax, bbox=[0,0,2,2])\n",
    "    for i,j in itertools.product(range(ncols), range(nrows)):\n",
    "        tb.add_cell(i, j, 2./ncols, 2./nrows, text='{:0.2f}'.format(0.1234), \n",
    "                    loc='center', facecolor=random.choice(colors), edgecolor='grey') # facecolors=\n",
    "    ax.add_table(tb)\n",
    "    #ax.plot([0, .3], [.2, .2])\n",
    "    #ax.add_line(plt.Line2D([0.3, 0.5], [0.7, 0.7], linewidth=2, color='blue'))\n",
    "    return fig\n",
    "\n",
    "main()"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 54,
   "metadata": {
    "collapsed": true
   },
   "outputs": [],
   "source": [
    "import collections\n",
    "class defaultkeydict(collections.defaultdict):\n",
    "    \"\"\"Like defaultdict, but the default_factory is a function of the key.\n",
    "    >>> d = defaultkeydict(abs); d[-42]\n",
    "    42\n",
    "    \"\"\"\n",
    "    def __missing__(self, key):\n",
    "        self[key] = self.default_factory(key)\n",
    "        return self[key]"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "collapsed": true
   },
   "source": [
    "# Simulated Annealing visualisation using TSP\n",
    "\n",
    "Applying simulated annealing in traveling salesman problem to find the shortest tour to travel all cities in Romania. Distance between two cities is taken as the euclidean distance."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 60,
   "metadata": {
    "collapsed": true
   },
   "outputs": [],
   "source": [
    "class TSP_problem(Problem):\n",
    "\n",
    "    '''\n",
    "    subclass of Problem to define various functions \n",
    "    '''\n",
    "\n",
    "    def two_opt(self, state):\n",
    "        '''\n",
    "        Neighbour generating function for Traveling Salesman Problem\n",
    "        '''\n",
    "        state2 = state[:]\n",
    "        l = random.randint(0, len(state2) - 1)\n",
    "        r = random.randint(0, len(state2) - 1)\n",
    "        if l > r:\n",
    "            l, r = r,l\n",
    "        state2[l : r + 1] = reversed(state2[l : r + 1])\n",
    "        return state2\n",
    "\n",
    "    def actions(self, state):\n",
    "        '''\n",
    "        action that can be excuted in given state\n",
    "        '''\n",
    "        return [self.two_opt]\n",
    "    \n",
    "    def result(self, state, action):\n",
    "        '''\n",
    "        result after applying the given action on the given state\n",
    "        '''\n",
    "        return action(state)\n",
    "\n",
    "    def path_cost(self, c, state1, action, state2):\n",
    "        '''\n",
    "        total distance for the Traveling Salesman to be covered if in state2\n",
    "        '''\n",
    "        cost = 0\n",
    "        for i in range(len(state2) - 1):\n",
    "            cost += distances[state2[i]][state2[i + 1]]\n",
    "        cost += distances[state2[0]][state2[-1]]\n",
    "        return cost\n",
    " \n",
    "    def value(self, state):\n",
    "        '''\n",
    "        value of path cost given negative for the given state\n",
    "        '''\n",
    "        return -1 * self.path_cost(None, None, None, state)\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 61,
   "metadata": {
    "collapsed": true
   },
   "outputs": [],
   "source": [
    "def init():\n",
    "    ''' \n",
    "    Initialisation function for matplotlib animation\n",
    "    '''\n",
    "    line.set_data([], [])\n",
    "    for name, coordinates in romania_map.locations.items():\n",
    "            ax.annotate(\n",
    "            name,\n",
    "            xy=coordinates, xytext=(-10, 5), textcoords='offset points', size = 10)\n",
    "    text.set_text(\"Cost = 0 i = 0\" )\n",
    "\n",
    "    return line, \n",
    "\n",
    "def animate(i):\n",
    "    '''\n",
    "    Animation function to set next path and print its cost.\n",
    "    '''\n",
    "    x, y = [], []\n",
    "    for name in states[i]:\n",
    "        x.append(romania_map.locations[name][0])\n",
    "        y.append(romania_map.locations[name][1])\n",
    "    x.append(romania_map.locations[states[i][0]][0])\n",
    "    y.append(romania_map.locations[states[i][0]][1])\n",
    "    line.set_data(x,y) \n",
    "    text.set_text(\"Cost = \" + str('{:.2f}'.format(TSP_problem.path_cost(None, None, None, None, states[i]))))\n",
    "    return line,"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 62,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "application/javascript": [
       "/* Put everything inside the global mpl namespace */\n",
       "window.mpl = {};\n",
       "\n",
       "\n",
       "mpl.get_websocket_type = function() {\n",
       "    if (typeof(WebSocket) !== 'undefined') {\n",
       "        return WebSocket;\n",
       "    } else if (typeof(MozWebSocket) !== 'undefined') {\n",
       "        return MozWebSocket;\n",
       "    } else {\n",
       "        alert('Your browser does not have WebSocket support.' +\n",
       "              'Please try Chrome, Safari or Firefox ≥ 6. ' +\n",
       "              'Firefox 4 and 5 are also supported but you ' +\n",
       "              'have to enable WebSockets in about:config.');\n",
       "    };\n",
       "}\n",
       "\n",
       "mpl.figure = function(figure_id, websocket, ondownload, parent_element) {\n",
       "    this.id = figure_id;\n",
       "\n",
       "    this.ws = websocket;\n",
       "\n",
       "    this.supports_binary = (this.ws.binaryType != undefined);\n",
       "\n",
       "    if (!this.supports_binary) {\n",
       "        var warnings = document.getElementById(\"mpl-warnings\");\n",
       "        if (warnings) {\n",
       "            warnings.style.display = 'block';\n",
       "            warnings.textContent = (\n",
       "                \"This browser does not support binary websocket messages. \" +\n",
       "                    \"Performance may be slow.\");\n",
       "        }\n",
       "    }\n",
       "\n",
       "    this.imageObj = new Image();\n",
       "\n",
       "    this.context = undefined;\n",
       "    this.message = undefined;\n",
       "    this.canvas = undefined;\n",
       "    this.rubberband_canvas = undefined;\n",
       "    this.rubberband_context = undefined;\n",
       "    this.format_dropdown = undefined;\n",
       "\n",
       "    this.image_mode = 'full';\n",
       "\n",
       "    this.root = $('<div/>');\n",
       "    this._root_extra_style(this.root)\n",
       "    this.root.attr('style', 'display: inline-block');\n",
       "\n",
       "    $(parent_element).append(this.root);\n",
       "\n",
       "    this._init_header(this);\n",
       "    this._init_canvas(this);\n",
       "    this._init_toolbar(this);\n",
       "\n",
       "    var fig = this;\n",
       "\n",
       "    this.waiting = false;\n",
       "\n",
       "    this.ws.onopen =  function () {\n",
       "            fig.send_message(\"supports_binary\", {value: fig.supports_binary});\n",
       "            fig.send_message(\"send_image_mode\", {});\n",
       "            if (mpl.ratio != 1) {\n",
       "                fig.send_message(\"set_dpi_ratio\", {'dpi_ratio': mpl.ratio});\n",
       "            }\n",
       "            fig.send_message(\"refresh\", {});\n",
       "        }\n",
       "\n",
       "    this.imageObj.onload = function() {\n",
       "            if (fig.image_mode == 'full') {\n",
       "                // Full images could contain transparency (where diff images\n",
       "                // almost always do), so we need to clear the canvas so that\n",
       "                // there is no ghosting.\n",
       "                fig.context.clearRect(0, 0, fig.canvas.width, fig.canvas.height);\n",
       "            }\n",
       "            fig.context.drawImage(fig.imageObj, 0, 0);\n",
       "        };\n",
       "\n",
       "    this.imageObj.onunload = function() {\n",
       "        fig.ws.close();\n",
       "    }\n",
       "\n",
       "    this.ws.onmessage = this._make_on_message_function(this);\n",
       "\n",
       "    this.ondownload = ondownload;\n",
       "}\n",
       "\n",
       "mpl.figure.prototype._init_header = function() {\n",
       "    var titlebar = $(\n",
       "        '<div class=\"ui-dialog-titlebar ui-widget-header ui-corner-all ' +\n",
       "        'ui-helper-clearfix\"/>');\n",
       "    var titletext = $(\n",
       "        '<div class=\"ui-dialog-title\" style=\"width: 100%; ' +\n",
       "        'text-align: center; padding: 3px;\"/>');\n",
       "    titlebar.append(titletext)\n",
       "    this.root.append(titlebar);\n",
       "    this.header = titletext[0];\n",
       "}\n",
       "\n",
       "\n",
       "\n",
       "mpl.figure.prototype._canvas_extra_style = function(canvas_div) {\n",
       "\n",
       "}\n",
       "\n",
       "\n",
       "mpl.figure.prototype._root_extra_style = function(canvas_div) {\n",
       "\n",
       "}\n",
       "\n",
       "mpl.figure.prototype._init_canvas = function() {\n",
       "    var fig = this;\n",
       "\n",
       "    var canvas_div = $('<div/>');\n",
       "\n",
       "    canvas_div.attr('style', 'position: relative; clear: both; outline: 0');\n",
       "\n",
       "    function canvas_keyboard_event(event) {\n",
       "        return fig.key_event(event, event['data']);\n",
       "    }\n",
       "\n",
       "    canvas_div.keydown('key_press', canvas_keyboard_event);\n",
       "    canvas_div.keyup('key_release', canvas_keyboard_event);\n",
       "    this.canvas_div = canvas_div\n",
       "    this._canvas_extra_style(canvas_div)\n",
       "    this.root.append(canvas_div);\n",
       "\n",
       "    var canvas = $('<canvas/>');\n",
       "    canvas.addClass('mpl-canvas');\n",
       "    canvas.attr('style', \"left: 0; top: 0; z-index: 0; outline: 0\")\n",
       "\n",
       "    this.canvas = canvas[0];\n",
       "    this.context = canvas[0].getContext(\"2d\");\n",
       "\n",
       "    var backingStore = this.context.backingStorePixelRatio ||\n",
       "\tthis.context.webkitBackingStorePixelRatio ||\n",
       "\tthis.context.mozBackingStorePixelRatio ||\n",
       "\tthis.context.msBackingStorePixelRatio ||\n",
       "\tthis.context.oBackingStorePixelRatio ||\n",
       "\tthis.context.backingStorePixelRatio || 1;\n",
       "\n",
       "    mpl.ratio = (window.devicePixelRatio || 1) / backingStore;\n",
       "\n",
       "    var rubberband = $('<canvas/>');\n",
       "    rubberband.attr('style', \"position: absolute; left: 0; top: 0; z-index: 1;\")\n",
       "\n",
       "    var pass_mouse_events = true;\n",
       "\n",
       "    canvas_div.resizable({\n",
       "        start: function(event, ui) {\n",
       "            pass_mouse_events = false;\n",
       "        },\n",
       "        resize: function(event, ui) {\n",
       "            fig.request_resize(ui.size.width, ui.size.height);\n",
       "        },\n",
       "        stop: function(event, ui) {\n",
       "            pass_mouse_events = true;\n",
       "            fig.request_resize(ui.size.width, ui.size.height);\n",
       "        },\n",
       "    });\n",
       "\n",
       "    function mouse_event_fn(event) {\n",
       "        if (pass_mouse_events)\n",
       "            return fig.mouse_event(event, event['data']);\n",
       "    }\n",
       "\n",
       "    rubberband.mousedown('button_press', mouse_event_fn);\n",
       "    rubberband.mouseup('button_release', mouse_event_fn);\n",
       "    // Throttle sequential mouse events to 1 every 20ms.\n",
       "    rubberband.mousemove('motion_notify', mouse_event_fn);\n",
       "\n",
       "    rubberband.mouseenter('figure_enter', mouse_event_fn);\n",
       "    rubberband.mouseleave('figure_leave', mouse_event_fn);\n",
       "\n",
       "    canvas_div.on(\"wheel\", function (event) {\n",
       "        event = event.originalEvent;\n",
       "        event['data'] = 'scroll'\n",
       "        if (event.deltaY < 0) {\n",
       "            event.step = 1;\n",
       "        } else {\n",
       "            event.step = -1;\n",
       "        }\n",
       "        mouse_event_fn(event);\n",
       "    });\n",
       "\n",
       "    canvas_div.append(canvas);\n",
       "    canvas_div.append(rubberband);\n",
       "\n",
       "    this.rubberband = rubberband;\n",
       "    this.rubberband_canvas = rubberband[0];\n",
       "    this.rubberband_context = rubberband[0].getContext(\"2d\");\n",
       "    this.rubberband_context.strokeStyle = \"#000000\";\n",
       "\n",
       "    this._resize_canvas = function(width, height) {\n",
       "        // Keep the size of the canvas, canvas container, and rubber band\n",
       "        // canvas in synch.\n",
       "        canvas_div.css('width', width)\n",
       "        canvas_div.css('height', height)\n",
       "\n",
       "        canvas.attr('width', width * mpl.ratio);\n",
       "        canvas.attr('height', height * mpl.ratio);\n",
       "        canvas.attr('style', 'width: ' + width + 'px; height: ' + height + 'px;');\n",
       "\n",
       "        rubberband.attr('width', width);\n",
       "        rubberband.attr('height', height);\n",
       "    }\n",
       "\n",
       "    // Set the figure to an initial 600x600px, this will subsequently be updated\n",
       "    // upon first draw.\n",
       "    this._resize_canvas(600, 600);\n",
       "\n",
       "    // Disable right mouse context menu.\n",
       "    $(this.rubberband_canvas).bind(\"contextmenu\",function(e){\n",
       "        return false;\n",
       "    });\n",
       "\n",
       "    function set_focus () {\n",
       "        canvas.focus();\n",
       "        canvas_div.focus();\n",
       "    }\n",
       "\n",
       "    window.setTimeout(set_focus, 100);\n",
       "}\n",
       "\n",
       "mpl.figure.prototype._init_toolbar = function() {\n",
       "    var fig = this;\n",
       "\n",
       "    var nav_element = $('<div/>')\n",
       "    nav_element.attr('style', 'width: 100%');\n",
       "    this.root.append(nav_element);\n",
       "\n",
       "    // Define a callback function for later on.\n",
       "    function toolbar_event(event) {\n",
       "        return fig.toolbar_button_onclick(event['data']);\n",
       "    }\n",
       "    function toolbar_mouse_event(event) {\n",
       "        return fig.toolbar_button_onmouseover(event['data']);\n",
       "    }\n",
       "\n",
       "    for(var toolbar_ind in mpl.toolbar_items) {\n",
       "        var name = mpl.toolbar_items[toolbar_ind][0];\n",
       "        var tooltip = mpl.toolbar_items[toolbar_ind][1];\n",
       "        var image = mpl.toolbar_items[toolbar_ind][2];\n",
       "        var method_name = mpl.toolbar_items[toolbar_ind][3];\n",
       "\n",
       "        if (!name) {\n",
       "            // put a spacer in here.\n",
       "            continue;\n",
       "        }\n",
       "        var button = $('<button/>');\n",
       "        button.addClass('ui-button ui-widget ui-state-default ui-corner-all ' +\n",
       "                        'ui-button-icon-only');\n",
       "        button.attr('role', 'button');\n",
       "        button.attr('aria-disabled', 'false');\n",
       "        button.click(method_name, toolbar_event);\n",
       "        button.mouseover(tooltip, toolbar_mouse_event);\n",
       "\n",
       "        var icon_img = $('<span/>');\n",
       "        icon_img.addClass('ui-button-icon-primary ui-icon');\n",
       "        icon_img.addClass(image);\n",
       "        icon_img.addClass('ui-corner-all');\n",
       "\n",
       "        var tooltip_span = $('<span/>');\n",
       "        tooltip_span.addClass('ui-button-text');\n",
       "        tooltip_span.html(tooltip);\n",
       "\n",
       "        button.append(icon_img);\n",
       "        button.append(tooltip_span);\n",
       "\n",
       "        nav_element.append(button);\n",
       "    }\n",
       "\n",
       "    var fmt_picker_span = $('<span/>');\n",
       "\n",
       "    var fmt_picker = $('<select/>');\n",
       "    fmt_picker.addClass('mpl-toolbar-option ui-widget ui-widget-content');\n",
       "    fmt_picker_span.append(fmt_picker);\n",
       "    nav_element.append(fmt_picker_span);\n",
       "    this.format_dropdown = fmt_picker[0];\n",
       "\n",
       "    for (var ind in mpl.extensions) {\n",
       "        var fmt = mpl.extensions[ind];\n",
       "        var option = $(\n",
       "            '<option/>', {selected: fmt === mpl.default_extension}).html(fmt);\n",
       "        fmt_picker.append(option)\n",
       "    }\n",
       "\n",
       "    // Add hover states to the ui-buttons\n",
       "    $( \".ui-button\" ).hover(\n",
       "        function() { $(this).addClass(\"ui-state-hover\");},\n",
       "        function() { $(this).removeClass(\"ui-state-hover\");}\n",
       "    );\n",
       "\n",
       "    var status_bar = $('<span class=\"mpl-message\"/>');\n",
       "    nav_element.append(status_bar);\n",
       "    this.message = status_bar[0];\n",
       "}\n",
       "\n",
       "mpl.figure.prototype.request_resize = function(x_pixels, y_pixels) {\n",
       "    // Request matplotlib to resize the figure. Matplotlib will then trigger a resize in the client,\n",
       "    // which will in turn request a refresh of the image.\n",
       "    this.send_message('resize', {'width': x_pixels, 'height': y_pixels});\n",
       "}\n",
       "\n",
       "mpl.figure.prototype.send_message = function(type, properties) {\n",
       "    properties['type'] = type;\n",
       "    properties['figure_id'] = this.id;\n",
       "    this.ws.send(JSON.stringify(properties));\n",
       "}\n",
       "\n",
       "mpl.figure.prototype.send_draw_message = function() {\n",
       "    if (!this.waiting) {\n",
       "        this.waiting = true;\n",
       "        this.ws.send(JSON.stringify({type: \"draw\", figure_id: this.id}));\n",
       "    }\n",
       "}\n",
       "\n",
       "\n",
       "mpl.figure.prototype.handle_save = function(fig, msg) {\n",
       "    var format_dropdown = fig.format_dropdown;\n",
       "    var format = format_dropdown.options[format_dropdown.selectedIndex].value;\n",
       "    fig.ondownload(fig, format);\n",
       "}\n",
       "\n",
       "\n",
       "mpl.figure.prototype.handle_resize = function(fig, msg) {\n",
       "    var size = msg['size'];\n",
       "    if (size[0] != fig.canvas.width || size[1] != fig.canvas.height) {\n",
       "        fig._resize_canvas(size[0], size[1]);\n",
       "        fig.send_message(\"refresh\", {});\n",
       "    };\n",
       "}\n",
       "\n",
       "mpl.figure.prototype.handle_rubberband = function(fig, msg) {\n",
       "    var x0 = msg['x0'] / mpl.ratio;\n",
       "    var y0 = (fig.canvas.height - msg['y0']) / mpl.ratio;\n",
       "    var x1 = msg['x1'] / mpl.ratio;\n",
       "    var y1 = (fig.canvas.height - msg['y1']) / mpl.ratio;\n",
       "    x0 = Math.floor(x0) + 0.5;\n",
       "    y0 = Math.floor(y0) + 0.5;\n",
       "    x1 = Math.floor(x1) + 0.5;\n",
       "    y1 = Math.floor(y1) + 0.5;\n",
       "    var min_x = Math.min(x0, x1);\n",
       "    var min_y = Math.min(y0, y1);\n",
       "    var width = Math.abs(x1 - x0);\n",
       "    var height = Math.abs(y1 - y0);\n",
       "\n",
       "    fig.rubberband_context.clearRect(\n",
       "        0, 0, fig.canvas.width, fig.canvas.height);\n",
       "\n",
       "    fig.rubberband_context.strokeRect(min_x, min_y, width, height);\n",
       "}\n",
       "\n",
       "mpl.figure.prototype.handle_figure_label = function(fig, msg) {\n",
       "    // Updates the figure title.\n",
       "    fig.header.textContent = msg['label'];\n",
       "}\n",
       "\n",
       "mpl.figure.prototype.handle_cursor = function(fig, msg) {\n",
       "    var cursor = msg['cursor'];\n",
       "    switch(cursor)\n",
       "    {\n",
       "    case 0:\n",
       "        cursor = 'pointer';\n",
       "        break;\n",
       "    case 1:\n",
       "        cursor = 'default';\n",
       "        break;\n",
       "    case 2:\n",
       "        cursor = 'crosshair';\n",
       "        break;\n",
       "    case 3:\n",
       "        cursor = 'move';\n",
       "        break;\n",
       "    }\n",
       "    fig.rubberband_canvas.style.cursor = cursor;\n",
       "}\n",
       "\n",
       "mpl.figure.prototype.handle_message = function(fig, msg) {\n",
       "    fig.message.textContent = msg['message'];\n",
       "}\n",
       "\n",
       "mpl.figure.prototype.handle_draw = function(fig, msg) {\n",
       "    // Request the server to send over a new figure.\n",
       "    fig.send_draw_message();\n",
       "}\n",
       "\n",
       "mpl.figure.prototype.handle_image_mode = function(fig, msg) {\n",
       "    fig.image_mode = msg['mode'];\n",
       "}\n",
       "\n",
       "mpl.figure.prototype.updated_canvas_event = function() {\n",
       "    // Called whenever the canvas gets updated.\n",
       "    this.send_message(\"ack\", {});\n",
       "}\n",
       "\n",
       "// A function to construct a web socket function for onmessage handling.\n",
       "// Called in the figure constructor.\n",
       "mpl.figure.prototype._make_on_message_function = function(fig) {\n",
       "    return function socket_on_message(evt) {\n",
       "        if (evt.data instanceof Blob) {\n",
       "            /* FIXME: We get \"Resource interpreted as Image but\n",
       "             * transferred with MIME type text/plain:\" errors on\n",
       "             * Chrome.  But how to set the MIME type?  It doesn't seem\n",
       "             * to be part of the websocket stream */\n",
       "            evt.data.type = \"image/png\";\n",
       "\n",
       "            /* Free the memory for the previous frames */\n",
       "            if (fig.imageObj.src) {\n",
       "                (window.URL || window.webkitURL).revokeObjectURL(\n",
       "                    fig.imageObj.src);\n",
       "            }\n",
       "\n",
       "            fig.imageObj.src = (window.URL || window.webkitURL).createObjectURL(\n",
       "                evt.data);\n",
       "            fig.updated_canvas_event();\n",
       "            fig.waiting = false;\n",
       "            return;\n",
       "        }\n",
       "        else if (typeof evt.data === 'string' && evt.data.slice(0, 21) == \"data:image/png;base64\") {\n",
       "            fig.imageObj.src = evt.data;\n",
       "            fig.updated_canvas_event();\n",
       "            fig.waiting = false;\n",
       "            return;\n",
       "        }\n",
       "\n",
       "        var msg = JSON.parse(evt.data);\n",
       "        var msg_type = msg['type'];\n",
       "\n",
       "        // Call the  \"handle_{type}\" callback, which takes\n",
       "        // the figure and JSON message as its only arguments.\n",
       "        try {\n",
       "            var callback = fig[\"handle_\" + msg_type];\n",
       "        } catch (e) {\n",
       "            console.log(\"No handler for the '\" + msg_type + \"' message type: \", msg);\n",
       "            return;\n",
       "        }\n",
       "\n",
       "        if (callback) {\n",
       "            try {\n",
       "                // console.log(\"Handling '\" + msg_type + \"' message: \", msg);\n",
       "                callback(fig, msg);\n",
       "            } catch (e) {\n",
       "                console.log(\"Exception inside the 'handler_\" + msg_type + \"' callback:\", e, e.stack, msg);\n",
       "            }\n",
       "        }\n",
       "    };\n",
       "}\n",
       "\n",
       "// from http://stackoverflow.com/questions/1114465/getting-mouse-location-in-canvas\n",
       "mpl.findpos = function(e) {\n",
       "    //this section is from http://www.quirksmode.org/js/events_properties.html\n",
       "    var targ;\n",
       "    if (!e)\n",
       "        e = window.event;\n",
       "    if (e.target)\n",
       "        targ = e.target;\n",
       "    else if (e.srcElement)\n",
       "        targ = e.srcElement;\n",
       "    if (targ.nodeType == 3) // defeat Safari bug\n",
       "        targ = targ.parentNode;\n",
       "\n",
       "    // jQuery normalizes the pageX and pageY\n",
       "    // pageX,Y are the mouse positions relative to the document\n",
       "    // offset() returns the position of the element relative to the document\n",
       "    var x = e.pageX - $(targ).offset().left;\n",
       "    var y = e.pageY - $(targ).offset().top;\n",
       "\n",
       "    return {\"x\": x, \"y\": y};\n",
       "};\n",
       "\n",
       "/*\n",
       " * return a copy of an object with only non-object keys\n",
       " * we need this to avoid circular references\n",
       " * http://stackoverflow.com/a/24161582/3208463\n",
       " */\n",
       "function simpleKeys (original) {\n",
       "  return Object.keys(original).reduce(function (obj, key) {\n",
       "    if (typeof original[key] !== 'object')\n",
       "        obj[key] = original[key]\n",
       "    return obj;\n",
       "  }, {});\n",
       "}\n",
       "\n",
       "mpl.figure.prototype.mouse_event = function(event, name) {\n",
       "    var canvas_pos = mpl.findpos(event)\n",
       "\n",
       "    if (name === 'button_press')\n",
       "    {\n",
       "        this.canvas.focus();\n",
       "        this.canvas_div.focus();\n",
       "    }\n",
       "\n",
       "    var x = canvas_pos.x * mpl.ratio;\n",
       "    var y = canvas_pos.y * mpl.ratio;\n",
       "\n",
       "    this.send_message(name, {x: x, y: y, button: event.button,\n",
       "                             step: event.step,\n",
       "                             guiEvent: simpleKeys(event)});\n",
       "\n",
       "    /* This prevents the web browser from automatically changing to\n",
       "     * the text insertion cursor when the button is pressed.  We want\n",
       "     * to control all of the cursor setting manually through the\n",
       "     * 'cursor' event from matplotlib */\n",
       "    event.preventDefault();\n",
       "    return false;\n",
       "}\n",
       "\n",
       "mpl.figure.prototype._key_event_extra = function(event, name) {\n",
       "    // Handle any extra behaviour associated with a key event\n",
       "}\n",
       "\n",
       "mpl.figure.prototype.key_event = function(event, name) {\n",
       "\n",
       "    // Prevent repeat events\n",
       "    if (name == 'key_press')\n",
       "    {\n",
       "        if (event.which === this._key)\n",
       "            return;\n",
       "        else\n",
       "            this._key = event.which;\n",
       "    }\n",
       "    if (name == 'key_release')\n",
       "        this._key = null;\n",
       "\n",
       "    var value = '';\n",
       "    if (event.ctrlKey && event.which != 17)\n",
       "        value += \"ctrl+\";\n",
       "    if (event.altKey && event.which != 18)\n",
       "        value += \"alt+\";\n",
       "    if (event.shiftKey && event.which != 16)\n",
       "        value += \"shift+\";\n",
       "\n",
       "    value += 'k';\n",
       "    value += event.which.toString();\n",
       "\n",
       "    this._key_event_extra(event, name);\n",
       "\n",
       "    this.send_message(name, {key: value,\n",
       "                             guiEvent: simpleKeys(event)});\n",
       "    return false;\n",
       "}\n",
       "\n",
       "mpl.figure.prototype.toolbar_button_onclick = function(name) {\n",
       "    if (name == 'download') {\n",
       "        this.handle_save(this, null);\n",
       "    } else {\n",
       "        this.send_message(\"toolbar_button\", {name: name});\n",
       "    }\n",
       "};\n",
       "\n",
       "mpl.figure.prototype.toolbar_button_onmouseover = function(tooltip) {\n",
       "    this.message.textContent = tooltip;\n",
       "};\n",
       "mpl.toolbar_items = [[\"Home\", \"Reset original view\", \"fa fa-home icon-home\", \"home\"], [\"Back\", \"Back to  previous view\", \"fa fa-arrow-left icon-arrow-left\", \"back\"], [\"Forward\", \"Forward to next view\", \"fa fa-arrow-right icon-arrow-right\", \"forward\"], [\"\", \"\", \"\", \"\"], [\"Pan\", \"Pan axes with left mouse, zoom with right\", \"fa fa-arrows icon-move\", \"pan\"], [\"Zoom\", \"Zoom to rectangle\", \"fa fa-square-o icon-check-empty\", \"zoom\"], [\"\", \"\", \"\", \"\"], [\"Download\", \"Download plot\", \"fa fa-floppy-o icon-save\", \"download\"]];\n",
       "\n",
       "mpl.extensions = [\"eps\", \"jpeg\", \"pdf\", \"png\", \"ps\", \"raw\", \"svg\", \"tif\"];\n",
       "\n",
       "mpl.default_extension = \"png\";var comm_websocket_adapter = function(comm) {\n",
       "    // Create a \"websocket\"-like object which calls the given IPython comm\n",
       "    // object with the appropriate methods. Currently this is a non binary\n",
       "    // socket, so there is still some room for performance tuning.\n",
       "    var ws = {};\n",
       "\n",
       "    ws.close = function() {\n",
       "        comm.close()\n",
       "    };\n",
       "    ws.send = function(m) {\n",
       "        //console.log('sending', m);\n",
       "        comm.send(m);\n",
       "    };\n",
       "    // Register the callback with on_msg.\n",
       "    comm.on_msg(function(msg) {\n",
       "        //console.log('receiving', msg['content']['data'], msg);\n",
       "        // Pass the mpl event to the overridden (by mpl) onmessage function.\n",
       "        ws.onmessage(msg['content']['data'])\n",
       "    });\n",
       "    return ws;\n",
       "}\n",
       "\n",
       "mpl.mpl_figure_comm = function(comm, msg) {\n",
       "    // This is the function which gets called when the mpl process\n",
       "    // starts-up an IPython Comm through the \"matplotlib\" channel.\n",
       "\n",
       "    var id = msg.content.data.id;\n",
       "    // Get hold of the div created by the display call when the Comm\n",
       "    // socket was opened in Python.\n",
       "    var element = $(\"#\" + id);\n",
       "    var ws_proxy = comm_websocket_adapter(comm)\n",
       "\n",
       "    function ondownload(figure, format) {\n",
       "        window.open(figure.imageObj.src);\n",
       "    }\n",
       "\n",
       "    var fig = new mpl.figure(id, ws_proxy,\n",
       "                           ondownload,\n",
       "                           element.get(0));\n",
       "\n",
       "    // Call onopen now - mpl needs it, as it is assuming we've passed it a real\n",
       "    // web socket which is closed, not our websocket->open comm proxy.\n",
       "    ws_proxy.onopen();\n",
       "\n",
       "    fig.parent_element = element.get(0);\n",
       "    fig.cell_info = mpl.find_output_cell(\"<div id='\" + id + \"'></div>\");\n",
       "    if (!fig.cell_info) {\n",
       "        console.error(\"Failed to find cell for figure\", id, fig);\n",
       "        return;\n",
       "    }\n",
       "\n",
       "    var output_index = fig.cell_info[2]\n",
       "    var cell = fig.cell_info[0];\n",
       "\n",
       "};\n",
       "\n",
       "mpl.figure.prototype.handle_close = function(fig, msg) {\n",
       "    var width = fig.canvas.width/mpl.ratio\n",
       "    fig.root.unbind('remove')\n",
       "\n",
       "    // Update the output cell to use the data from the current canvas.\n",
       "    fig.push_to_output();\n",
       "    var dataURL = fig.canvas.toDataURL();\n",
       "    // Re-enable the keyboard manager in IPython - without this line, in FF,\n",
       "    // the notebook keyboard shortcuts fail.\n",
       "    IPython.keyboard_manager.enable()\n",
       "    $(fig.parent_element).html('<img src=\"' + dataURL + '\" width=\"' + width + '\">');\n",
       "    fig.close_ws(fig, msg);\n",
       "}\n",
       "\n",
       "mpl.figure.prototype.close_ws = function(fig, msg){\n",
       "    fig.send_message('closing', msg);\n",
       "    // fig.ws.close()\n",
       "}\n",
       "\n",
       "mpl.figure.prototype.push_to_output = function(remove_interactive) {\n",
       "    // Turn the data on the canvas into data in the output cell.\n",
       "    var width = this.canvas.width/mpl.ratio\n",
       "    var dataURL = this.canvas.toDataURL();\n",
       "    this.cell_info[1]['text/html'] = '<img src=\"' + dataURL + '\" width=\"' + width + '\">';\n",
       "}\n",
       "\n",
       "mpl.figure.prototype.updated_canvas_event = function() {\n",
       "    // Tell IPython that the notebook contents must change.\n",
       "    IPython.notebook.set_dirty(true);\n",
       "    this.send_message(\"ack\", {});\n",
       "    var fig = this;\n",
       "    // Wait a second, then push the new image to the DOM so\n",
       "    // that it is saved nicely (might be nice to debounce this).\n",
       "    setTimeout(function () { fig.push_to_output() }, 1000);\n",
       "}\n",
       "\n",
       "mpl.figure.prototype._init_toolbar = function() {\n",
       "    var fig = this;\n",
       "\n",
       "    var nav_element = $('<div/>')\n",
       "    nav_element.attr('style', 'width: 100%');\n",
       "    this.root.append(nav_element);\n",
       "\n",
       "    // Define a callback function for later on.\n",
       "    function toolbar_event(event) {\n",
       "        return fig.toolbar_button_onclick(event['data']);\n",
       "    }\n",
       "    function toolbar_mouse_event(event) {\n",
       "        return fig.toolbar_button_onmouseover(event['data']);\n",
       "    }\n",
       "\n",
       "    for(var toolbar_ind in mpl.toolbar_items){\n",
       "        var name = mpl.toolbar_items[toolbar_ind][0];\n",
       "        var tooltip = mpl.toolbar_items[toolbar_ind][1];\n",
       "        var image = mpl.toolbar_items[toolbar_ind][2];\n",
       "        var method_name = mpl.toolbar_items[toolbar_ind][3];\n",
       "\n",
       "        if (!name) { continue; };\n",
       "\n",
       "        var button = $('<button class=\"btn btn-default\" href=\"#\" title=\"' + name + '\"><i class=\"fa ' + image + ' fa-lg\"></i></button>');\n",
       "        button.click(method_name, toolbar_event);\n",
       "        button.mouseover(tooltip, toolbar_mouse_event);\n",
       "        nav_element.append(button);\n",
       "    }\n",
       "\n",
       "    // Add the status bar.\n",
       "    var status_bar = $('<span class=\"mpl-message\" style=\"text-align:right; float: right;\"/>');\n",
       "    nav_element.append(status_bar);\n",
       "    this.message = status_bar[0];\n",
       "\n",
       "    // Add the close button to the window.\n",
       "    var buttongrp = $('<div class=\"btn-group inline pull-right\"></div>');\n",
       "    var button = $('<button class=\"btn btn-mini btn-primary\" href=\"#\" title=\"Stop Interaction\"><i class=\"fa fa-power-off icon-remove icon-large\"></i></button>');\n",
       "    button.click(function (evt) { fig.handle_close(fig, {}); } );\n",
       "    button.mouseover('Stop Interaction', toolbar_mouse_event);\n",
       "    buttongrp.append(button);\n",
       "    var titlebar = this.root.find($('.ui-dialog-titlebar'));\n",
       "    titlebar.prepend(buttongrp);\n",
       "}\n",
       "\n",
       "mpl.figure.prototype._root_extra_style = function(el){\n",
       "    var fig = this\n",
       "    el.on(\"remove\", function(){\n",
       "\tfig.close_ws(fig, {});\n",
       "    });\n",
       "}\n",
       "\n",
       "mpl.figure.prototype._canvas_extra_style = function(el){\n",
       "    // this is important to make the div 'focusable\n",
       "    el.attr('tabindex', 0)\n",
       "    // reach out to IPython and tell the keyboard manager to turn it's self\n",
       "    // off when our div gets focus\n",
       "\n",
       "    // location in version 3\n",
       "    if (IPython.notebook.keyboard_manager) {\n",
       "        IPython.notebook.keyboard_manager.register_events(el);\n",
       "    }\n",
       "    else {\n",
       "        // location in version 2\n",
       "        IPython.keyboard_manager.register_events(el);\n",
       "    }\n",
       "\n",
       "}\n",
       "\n",
       "mpl.figure.prototype._key_event_extra = function(event, name) {\n",
       "    var manager = IPython.notebook.keyboard_manager;\n",
       "    if (!manager)\n",
       "        manager = IPython.keyboard_manager;\n",
       "\n",
       "    // Check for shift+enter\n",
       "    if (event.shiftKey && event.which == 13) {\n",
       "        this.canvas_div.blur();\n",
       "        event.shiftKey = false;\n",
       "        // Send a \"J\" for go to next cell\n",
       "        event.which = 74;\n",
       "        event.keyCode = 74;\n",
       "        manager.command_mode();\n",
       "        manager.handle_keydown(event);\n",
       "    }\n",
       "}\n",
       "\n",
       "mpl.figure.prototype.handle_save = function(fig, msg) {\n",
       "    fig.ondownload(fig, null);\n",
       "}\n",
       "\n",
       "\n",
       "mpl.find_output_cell = function(html_output) {\n",
       "    // Return the cell and output element which can be found *uniquely* in the notebook.\n",
       "    // Note - this is a bit hacky, but it is done because the \"notebook_saving.Notebook\"\n",
       "    // IPython event is triggered only after the cells have been serialised, which for\n",
       "    // our purposes (turning an active figure into a static one), is too late.\n",
       "    var cells = IPython.notebook.get_cells();\n",
       "    var ncells = cells.length;\n",
       "    for (var i=0; i<ncells; i++) {\n",
       "        var cell = cells[i];\n",
       "        if (cell.cell_type === 'code'){\n",
       "            for (var j=0; j<cell.output_area.outputs.length; j++) {\n",
       "                var data = cell.output_area.outputs[j];\n",
       "                if (data.data) {\n",
       "                    // IPython >= 3 moved mimebundle to data attribute of output\n",
       "                    data = data.data;\n",
       "                }\n",
       "                if (data['text/html'] == html_output) {\n",
       "                    return [cell, data, j];\n",
       "                }\n",
       "            }\n",
       "        }\n",
       "    }\n",
       "}\n",
       "\n",
       "// Register the function which deals with the matplotlib target/channel.\n",
       "// The kernel may be null if the page has been refreshed.\n",
       "if (IPython.notebook.kernel != null) {\n",
       "    IPython.notebook.kernel.comm_manager.register_target('matplotlib', mpl.mpl_figure_comm);\n",
       "}\n"
      ],
      "text/plain": [
       "<IPython.core.display.Javascript object>"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    },
    {
     "data": {
      "text/html": [
       "<img src=\"data:image/png;base64,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\" width=\"799.9999880790713\">"
      ],
      "text/plain": [
       "<IPython.core.display.HTML object>"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    }
   ],
   "source": [
    "%matplotlib notebook\n",
    "import matplotlib.pyplot as plt\n",
    "from matplotlib import animation\n",
    "import numpy as np\n",
    "\n",
    "font = {'family': 'roboto',\n",
    "        'color':  'darkred',\n",
    "        'weight': 'normal',\n",
    "        'size': 12,\n",
    "        }\n",
    "\n",
    "cities = []\n",
    "distances ={}\n",
    "states = []\n",
    "\n",
    "# creating plotting area\n",
    "fig = plt.figure(figsize = (8,6))\n",
    "ax = plt.axes(xlim=(60, 600), ylim=(245, 600))\n",
    "line, = ax.plot([], [], c=\"b\",linewidth = 1.5, marker = 'o', markerfacecolor = 'r', markeredgecolor = 'r',markersize = 10)\n",
    "text = ax.text(450, 565, \"\", fontdict = font)\n",
    "\n",
    "# creating initial path\n",
    "for name in romania_map.locations.keys():    \n",
    "    distances[name] = {}\n",
    "    cities.append(name)\n",
    "\n",
    "\n",
    "# distances['city1']['city2'] contains euclidean distance between their coordinates\n",
    "for name_1,coordinates_1 in romania_map.locations.items():\n",
    "    for name_2,coordinates_2 in romania_map.locations.items():\n",
    "        distances[name_1][name_2] = np.linalg.norm([coordinates_1[0] - coordinates_2[0], coordinates_1[1] - coordinates_2[1]])\n",
    "        distances[name_2][name_1] = np.linalg.norm([coordinates_1[0] - coordinates_2[0], coordinates_1[1] - coordinates_2[1]])\n",
    "\n",
    "# creating the problem        \n",
    "tsp_problem = TSP_problem(cities)\n",
    "\n",
    "# all the states as a 2-D list of paths\n",
    "states = simulated_annealing_full(tsp_problem)\n",
    "\n",
    "# calling the matplotlib animation function \n",
    "anim = animation.FuncAnimation(fig, animate, init_func = init,\n",
    "                           frames = len(states), interval = len(states), blit = True, repeat = False)\n",
    "plt.show()"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Iterative Simulated Annealing\n",
    "\n",
    "Providing the output of the previous run as input to the next run to give better performance."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 63,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "application/javascript": [
       "/* Put everything inside the global mpl namespace */\n",
       "window.mpl = {};\n",
       "\n",
       "\n",
       "mpl.get_websocket_type = function() {\n",
       "    if (typeof(WebSocket) !== 'undefined') {\n",
       "        return WebSocket;\n",
       "    } else if (typeof(MozWebSocket) !== 'undefined') {\n",
       "        return MozWebSocket;\n",
       "    } else {\n",
       "        alert('Your browser does not have WebSocket support.' +\n",
       "              'Please try Chrome, Safari or Firefox ≥ 6. ' +\n",
       "              'Firefox 4 and 5 are also supported but you ' +\n",
       "              'have to enable WebSockets in about:config.');\n",
       "    };\n",
       "}\n",
       "\n",
       "mpl.figure = function(figure_id, websocket, ondownload, parent_element) {\n",
       "    this.id = figure_id;\n",
       "\n",
       "    this.ws = websocket;\n",
       "\n",
       "    this.supports_binary = (this.ws.binaryType != undefined);\n",
       "\n",
       "    if (!this.supports_binary) {\n",
       "        var warnings = document.getElementById(\"mpl-warnings\");\n",
       "        if (warnings) {\n",
       "            warnings.style.display = 'block';\n",
       "            warnings.textContent = (\n",
       "                \"This browser does not support binary websocket messages. \" +\n",
       "                    \"Performance may be slow.\");\n",
       "        }\n",
       "    }\n",
       "\n",
       "    this.imageObj = new Image();\n",
       "\n",
       "    this.context = undefined;\n",
       "    this.message = undefined;\n",
       "    this.canvas = undefined;\n",
       "    this.rubberband_canvas = undefined;\n",
       "    this.rubberband_context = undefined;\n",
       "    this.format_dropdown = undefined;\n",
       "\n",
       "    this.image_mode = 'full';\n",
       "\n",
       "    this.root = $('<div/>');\n",
       "    this._root_extra_style(this.root)\n",
       "    this.root.attr('style', 'display: inline-block');\n",
       "\n",
       "    $(parent_element).append(this.root);\n",
       "\n",
       "    this._init_header(this);\n",
       "    this._init_canvas(this);\n",
       "    this._init_toolbar(this);\n",
       "\n",
       "    var fig = this;\n",
       "\n",
       "    this.waiting = false;\n",
       "\n",
       "    this.ws.onopen =  function () {\n",
       "            fig.send_message(\"supports_binary\", {value: fig.supports_binary});\n",
       "            fig.send_message(\"send_image_mode\", {});\n",
       "            if (mpl.ratio != 1) {\n",
       "                fig.send_message(\"set_dpi_ratio\", {'dpi_ratio': mpl.ratio});\n",
       "            }\n",
       "            fig.send_message(\"refresh\", {});\n",
       "        }\n",
       "\n",
       "    this.imageObj.onload = function() {\n",
       "            if (fig.image_mode == 'full') {\n",
       "                // Full images could contain transparency (where diff images\n",
       "                // almost always do), so we need to clear the canvas so that\n",
       "                // there is no ghosting.\n",
       "                fig.context.clearRect(0, 0, fig.canvas.width, fig.canvas.height);\n",
       "            }\n",
       "            fig.context.drawImage(fig.imageObj, 0, 0);\n",
       "        };\n",
       "\n",
       "    this.imageObj.onunload = function() {\n",
       "        fig.ws.close();\n",
       "    }\n",
       "\n",
       "    this.ws.onmessage = this._make_on_message_function(this);\n",
       "\n",
       "    this.ondownload = ondownload;\n",
       "}\n",
       "\n",
       "mpl.figure.prototype._init_header = function() {\n",
       "    var titlebar = $(\n",
       "        '<div class=\"ui-dialog-titlebar ui-widget-header ui-corner-all ' +\n",
       "        'ui-helper-clearfix\"/>');\n",
       "    var titletext = $(\n",
       "        '<div class=\"ui-dialog-title\" style=\"width: 100%; ' +\n",
       "        'text-align: center; padding: 3px;\"/>');\n",
       "    titlebar.append(titletext)\n",
       "    this.root.append(titlebar);\n",
       "    this.header = titletext[0];\n",
       "}\n",
       "\n",
       "\n",
       "\n",
       "mpl.figure.prototype._canvas_extra_style = function(canvas_div) {\n",
       "\n",
       "}\n",
       "\n",
       "\n",
       "mpl.figure.prototype._root_extra_style = function(canvas_div) {\n",
       "\n",
       "}\n",
       "\n",
       "mpl.figure.prototype._init_canvas = function() {\n",
       "    var fig = this;\n",
       "\n",
       "    var canvas_div = $('<div/>');\n",
       "\n",
       "    canvas_div.attr('style', 'position: relative; clear: both; outline: 0');\n",
       "\n",
       "    function canvas_keyboard_event(event) {\n",
       "        return fig.key_event(event, event['data']);\n",
       "    }\n",
       "\n",
       "    canvas_div.keydown('key_press', canvas_keyboard_event);\n",
       "    canvas_div.keyup('key_release', canvas_keyboard_event);\n",
       "    this.canvas_div = canvas_div\n",
       "    this._canvas_extra_style(canvas_div)\n",
       "    this.root.append(canvas_div);\n",
       "\n",
       "    var canvas = $('<canvas/>');\n",
       "    canvas.addClass('mpl-canvas');\n",
       "    canvas.attr('style', \"left: 0; top: 0; z-index: 0; outline: 0\")\n",
       "\n",
       "    this.canvas = canvas[0];\n",
       "    this.context = canvas[0].getContext(\"2d\");\n",
       "\n",
       "    var backingStore = this.context.backingStorePixelRatio ||\n",
       "\tthis.context.webkitBackingStorePixelRatio ||\n",
       "\tthis.context.mozBackingStorePixelRatio ||\n",
       "\tthis.context.msBackingStorePixelRatio ||\n",
       "\tthis.context.oBackingStorePixelRatio ||\n",
       "\tthis.context.backingStorePixelRatio || 1;\n",
       "\n",
       "    mpl.ratio = (window.devicePixelRatio || 1) / backingStore;\n",
       "\n",
       "    var rubberband = $('<canvas/>');\n",
       "    rubberband.attr('style', \"position: absolute; left: 0; top: 0; z-index: 1;\")\n",
       "\n",
       "    var pass_mouse_events = true;\n",
       "\n",
       "    canvas_div.resizable({\n",
       "        start: function(event, ui) {\n",
       "            pass_mouse_events = false;\n",
       "        },\n",
       "        resize: function(event, ui) {\n",
       "            fig.request_resize(ui.size.width, ui.size.height);\n",
       "        },\n",
       "        stop: function(event, ui) {\n",
       "            pass_mouse_events = true;\n",
       "            fig.request_resize(ui.size.width, ui.size.height);\n",
       "        },\n",
       "    });\n",
       "\n",
       "    function mouse_event_fn(event) {\n",
       "        if (pass_mouse_events)\n",
       "            return fig.mouse_event(event, event['data']);\n",
       "    }\n",
       "\n",
       "    rubberband.mousedown('button_press', mouse_event_fn);\n",
       "    rubberband.mouseup('button_release', mouse_event_fn);\n",
       "    // Throttle sequential mouse events to 1 every 20ms.\n",
       "    rubberband.mousemove('motion_notify', mouse_event_fn);\n",
       "\n",
       "    rubberband.mouseenter('figure_enter', mouse_event_fn);\n",
       "    rubberband.mouseleave('figure_leave', mouse_event_fn);\n",
       "\n",
       "    canvas_div.on(\"wheel\", function (event) {\n",
       "        event = event.originalEvent;\n",
       "        event['data'] = 'scroll'\n",
       "        if (event.deltaY < 0) {\n",
       "            event.step = 1;\n",
       "        } else {\n",
       "            event.step = -1;\n",
       "        }\n",
       "        mouse_event_fn(event);\n",
       "    });\n",
       "\n",
       "    canvas_div.append(canvas);\n",
       "    canvas_div.append(rubberband);\n",
       "\n",
       "    this.rubberband = rubberband;\n",
       "    this.rubberband_canvas = rubberband[0];\n",
       "    this.rubberband_context = rubberband[0].getContext(\"2d\");\n",
       "    this.rubberband_context.strokeStyle = \"#000000\";\n",
       "\n",
       "    this._resize_canvas = function(width, height) {\n",
       "        // Keep the size of the canvas, canvas container, and rubber band\n",
       "        // canvas in synch.\n",
       "        canvas_div.css('width', width)\n",
       "        canvas_div.css('height', height)\n",
       "\n",
       "        canvas.attr('width', width * mpl.ratio);\n",
       "        canvas.attr('height', height * mpl.ratio);\n",
       "        canvas.attr('style', 'width: ' + width + 'px; height: ' + height + 'px;');\n",
       "\n",
       "        rubberband.attr('width', width);\n",
       "        rubberband.attr('height', height);\n",
       "    }\n",
       "\n",
       "    // Set the figure to an initial 600x600px, this will subsequently be updated\n",
       "    // upon first draw.\n",
       "    this._resize_canvas(600, 600);\n",
       "\n",
       "    // Disable right mouse context menu.\n",
       "    $(this.rubberband_canvas).bind(\"contextmenu\",function(e){\n",
       "        return false;\n",
       "    });\n",
       "\n",
       "    function set_focus () {\n",
       "        canvas.focus();\n",
       "        canvas_div.focus();\n",
       "    }\n",
       "\n",
       "    window.setTimeout(set_focus, 100);\n",
       "}\n",
       "\n",
       "mpl.figure.prototype._init_toolbar = function() {\n",
       "    var fig = this;\n",
       "\n",
       "    var nav_element = $('<div/>')\n",
       "    nav_element.attr('style', 'width: 100%');\n",
       "    this.root.append(nav_element);\n",
       "\n",
       "    // Define a callback function for later on.\n",
       "    function toolbar_event(event) {\n",
       "        return fig.toolbar_button_onclick(event['data']);\n",
       "    }\n",
       "    function toolbar_mouse_event(event) {\n",
       "        return fig.toolbar_button_onmouseover(event['data']);\n",
       "    }\n",
       "\n",
       "    for(var toolbar_ind in mpl.toolbar_items) {\n",
       "        var name = mpl.toolbar_items[toolbar_ind][0];\n",
       "        var tooltip = mpl.toolbar_items[toolbar_ind][1];\n",
       "        var image = mpl.toolbar_items[toolbar_ind][2];\n",
       "        var method_name = mpl.toolbar_items[toolbar_ind][3];\n",
       "\n",
       "        if (!name) {\n",
       "            // put a spacer in here.\n",
       "            continue;\n",
       "        }\n",
       "        var button = $('<button/>');\n",
       "        button.addClass('ui-button ui-widget ui-state-default ui-corner-all ' +\n",
       "                        'ui-button-icon-only');\n",
       "        button.attr('role', 'button');\n",
       "        button.attr('aria-disabled', 'false');\n",
       "        button.click(method_name, toolbar_event);\n",
       "        button.mouseover(tooltip, toolbar_mouse_event);\n",
       "\n",
       "        var icon_img = $('<span/>');\n",
       "        icon_img.addClass('ui-button-icon-primary ui-icon');\n",
       "        icon_img.addClass(image);\n",
       "        icon_img.addClass('ui-corner-all');\n",
       "\n",
       "        var tooltip_span = $('<span/>');\n",
       "        tooltip_span.addClass('ui-button-text');\n",
       "        tooltip_span.html(tooltip);\n",
       "\n",
       "        button.append(icon_img);\n",
       "        button.append(tooltip_span);\n",
       "\n",
       "        nav_element.append(button);\n",
       "    }\n",
       "\n",
       "    var fmt_picker_span = $('<span/>');\n",
       "\n",
       "    var fmt_picker = $('<select/>');\n",
       "    fmt_picker.addClass('mpl-toolbar-option ui-widget ui-widget-content');\n",
       "    fmt_picker_span.append(fmt_picker);\n",
       "    nav_element.append(fmt_picker_span);\n",
       "    this.format_dropdown = fmt_picker[0];\n",
       "\n",
       "    for (var ind in mpl.extensions) {\n",
       "        var fmt = mpl.extensions[ind];\n",
       "        var option = $(\n",
       "            '<option/>', {selected: fmt === mpl.default_extension}).html(fmt);\n",
       "        fmt_picker.append(option)\n",
       "    }\n",
       "\n",
       "    // Add hover states to the ui-buttons\n",
       "    $( \".ui-button\" ).hover(\n",
       "        function() { $(this).addClass(\"ui-state-hover\");},\n",
       "        function() { $(this).removeClass(\"ui-state-hover\");}\n",
       "    );\n",
       "\n",
       "    var status_bar = $('<span class=\"mpl-message\"/>');\n",
       "    nav_element.append(status_bar);\n",
       "    this.message = status_bar[0];\n",
       "}\n",
       "\n",
       "mpl.figure.prototype.request_resize = function(x_pixels, y_pixels) {\n",
       "    // Request matplotlib to resize the figure. Matplotlib will then trigger a resize in the client,\n",
       "    // which will in turn request a refresh of the image.\n",
       "    this.send_message('resize', {'width': x_pixels, 'height': y_pixels});\n",
       "}\n",
       "\n",
       "mpl.figure.prototype.send_message = function(type, properties) {\n",
       "    properties['type'] = type;\n",
       "    properties['figure_id'] = this.id;\n",
       "    this.ws.send(JSON.stringify(properties));\n",
       "}\n",
       "\n",
       "mpl.figure.prototype.send_draw_message = function() {\n",
       "    if (!this.waiting) {\n",
       "        this.waiting = true;\n",
       "        this.ws.send(JSON.stringify({type: \"draw\", figure_id: this.id}));\n",
       "    }\n",
       "}\n",
       "\n",
       "\n",
       "mpl.figure.prototype.handle_save = function(fig, msg) {\n",
       "    var format_dropdown = fig.format_dropdown;\n",
       "    var format = format_dropdown.options[format_dropdown.selectedIndex].value;\n",
       "    fig.ondownload(fig, format);\n",
       "}\n",
       "\n",
       "\n",
       "mpl.figure.prototype.handle_resize = function(fig, msg) {\n",
       "    var size = msg['size'];\n",
       "    if (size[0] != fig.canvas.width || size[1] != fig.canvas.height) {\n",
       "        fig._resize_canvas(size[0], size[1]);\n",
       "        fig.send_message(\"refresh\", {});\n",
       "    };\n",
       "}\n",
       "\n",
       "mpl.figure.prototype.handle_rubberband = function(fig, msg) {\n",
       "    var x0 = msg['x0'] / mpl.ratio;\n",
       "    var y0 = (fig.canvas.height - msg['y0']) / mpl.ratio;\n",
       "    var x1 = msg['x1'] / mpl.ratio;\n",
       "    var y1 = (fig.canvas.height - msg['y1']) / mpl.ratio;\n",
       "    x0 = Math.floor(x0) + 0.5;\n",
       "    y0 = Math.floor(y0) + 0.5;\n",
       "    x1 = Math.floor(x1) + 0.5;\n",
       "    y1 = Math.floor(y1) + 0.5;\n",
       "    var min_x = Math.min(x0, x1);\n",
       "    var min_y = Math.min(y0, y1);\n",
       "    var width = Math.abs(x1 - x0);\n",
       "    var height = Math.abs(y1 - y0);\n",
       "\n",
       "    fig.rubberband_context.clearRect(\n",
       "        0, 0, fig.canvas.width, fig.canvas.height);\n",
       "\n",
       "    fig.rubberband_context.strokeRect(min_x, min_y, width, height);\n",
       "}\n",
       "\n",
       "mpl.figure.prototype.handle_figure_label = function(fig, msg) {\n",
       "    // Updates the figure title.\n",
       "    fig.header.textContent = msg['label'];\n",
       "}\n",
       "\n",
       "mpl.figure.prototype.handle_cursor = function(fig, msg) {\n",
       "    var cursor = msg['cursor'];\n",
       "    switch(cursor)\n",
       "    {\n",
       "    case 0:\n",
       "        cursor = 'pointer';\n",
       "        break;\n",
       "    case 1:\n",
       "        cursor = 'default';\n",
       "        break;\n",
       "    case 2:\n",
       "        cursor = 'crosshair';\n",
       "        break;\n",
       "    case 3:\n",
       "        cursor = 'move';\n",
       "        break;\n",
       "    }\n",
       "    fig.rubberband_canvas.style.cursor = cursor;\n",
       "}\n",
       "\n",
       "mpl.figure.prototype.handle_message = function(fig, msg) {\n",
       "    fig.message.textContent = msg['message'];\n",
       "}\n",
       "\n",
       "mpl.figure.prototype.handle_draw = function(fig, msg) {\n",
       "    // Request the server to send over a new figure.\n",
       "    fig.send_draw_message();\n",
       "}\n",
       "\n",
       "mpl.figure.prototype.handle_image_mode = function(fig, msg) {\n",
       "    fig.image_mode = msg['mode'];\n",
       "}\n",
       "\n",
       "mpl.figure.prototype.updated_canvas_event = function() {\n",
       "    // Called whenever the canvas gets updated.\n",
       "    this.send_message(\"ack\", {});\n",
       "}\n",
       "\n",
       "// A function to construct a web socket function for onmessage handling.\n",
       "// Called in the figure constructor.\n",
       "mpl.figure.prototype._make_on_message_function = function(fig) {\n",
       "    return function socket_on_message(evt) {\n",
       "        if (evt.data instanceof Blob) {\n",
       "            /* FIXME: We get \"Resource interpreted as Image but\n",
       "             * transferred with MIME type text/plain:\" errors on\n",
       "             * Chrome.  But how to set the MIME type?  It doesn't seem\n",
       "             * to be part of the websocket stream */\n",
       "            evt.data.type = \"image/png\";\n",
       "\n",
       "            /* Free the memory for the previous frames */\n",
       "            if (fig.imageObj.src) {\n",
       "                (window.URL || window.webkitURL).revokeObjectURL(\n",
       "                    fig.imageObj.src);\n",
       "            }\n",
       "\n",
       "            fig.imageObj.src = (window.URL || window.webkitURL).createObjectURL(\n",
       "                evt.data);\n",
       "            fig.updated_canvas_event();\n",
       "            fig.waiting = false;\n",
       "            return;\n",
       "        }\n",
       "        else if (typeof evt.data === 'string' && evt.data.slice(0, 21) == \"data:image/png;base64\") {\n",
       "            fig.imageObj.src = evt.data;\n",
       "            fig.updated_canvas_event();\n",
       "            fig.waiting = false;\n",
       "            return;\n",
       "        }\n",
       "\n",
       "        var msg = JSON.parse(evt.data);\n",
       "        var msg_type = msg['type'];\n",
       "\n",
       "        // Call the  \"handle_{type}\" callback, which takes\n",
       "        // the figure and JSON message as its only arguments.\n",
       "        try {\n",
       "            var callback = fig[\"handle_\" + msg_type];\n",
       "        } catch (e) {\n",
       "            console.log(\"No handler for the '\" + msg_type + \"' message type: \", msg);\n",
       "            return;\n",
       "        }\n",
       "\n",
       "        if (callback) {\n",
       "            try {\n",
       "                // console.log(\"Handling '\" + msg_type + \"' message: \", msg);\n",
       "                callback(fig, msg);\n",
       "            } catch (e) {\n",
       "                console.log(\"Exception inside the 'handler_\" + msg_type + \"' callback:\", e, e.stack, msg);\n",
       "            }\n",
       "        }\n",
       "    };\n",
       "}\n",
       "\n",
       "// from http://stackoverflow.com/questions/1114465/getting-mouse-location-in-canvas\n",
       "mpl.findpos = function(e) {\n",
       "    //this section is from http://www.quirksmode.org/js/events_properties.html\n",
       "    var targ;\n",
       "    if (!e)\n",
       "        e = window.event;\n",
       "    if (e.target)\n",
       "        targ = e.target;\n",
       "    else if (e.srcElement)\n",
       "        targ = e.srcElement;\n",
       "    if (targ.nodeType == 3) // defeat Safari bug\n",
       "        targ = targ.parentNode;\n",
       "\n",
       "    // jQuery normalizes the pageX and pageY\n",
       "    // pageX,Y are the mouse positions relative to the document\n",
       "    // offset() returns the position of the element relative to the document\n",
       "    var x = e.pageX - $(targ).offset().left;\n",
       "    var y = e.pageY - $(targ).offset().top;\n",
       "\n",
       "    return {\"x\": x, \"y\": y};\n",
       "};\n",
       "\n",
       "/*\n",
       " * return a copy of an object with only non-object keys\n",
       " * we need this to avoid circular references\n",
       " * http://stackoverflow.com/a/24161582/3208463\n",
       " */\n",
       "function simpleKeys (original) {\n",
       "  return Object.keys(original).reduce(function (obj, key) {\n",
       "    if (typeof original[key] !== 'object')\n",
       "        obj[key] = original[key]\n",
       "    return obj;\n",
       "  }, {});\n",
       "}\n",
       "\n",
       "mpl.figure.prototype.mouse_event = function(event, name) {\n",
       "    var canvas_pos = mpl.findpos(event)\n",
       "\n",
       "    if (name === 'button_press')\n",
       "    {\n",
       "        this.canvas.focus();\n",
       "        this.canvas_div.focus();\n",
       "    }\n",
       "\n",
       "    var x = canvas_pos.x * mpl.ratio;\n",
       "    var y = canvas_pos.y * mpl.ratio;\n",
       "\n",
       "    this.send_message(name, {x: x, y: y, button: event.button,\n",
       "                             step: event.step,\n",
       "                             guiEvent: simpleKeys(event)});\n",
       "\n",
       "    /* This prevents the web browser from automatically changing to\n",
       "     * the text insertion cursor when the button is pressed.  We want\n",
       "     * to control all of the cursor setting manually through the\n",
       "     * 'cursor' event from matplotlib */\n",
       "    event.preventDefault();\n",
       "    return false;\n",
       "}\n",
       "\n",
       "mpl.figure.prototype._key_event_extra = function(event, name) {\n",
       "    // Handle any extra behaviour associated with a key event\n",
       "}\n",
       "\n",
       "mpl.figure.prototype.key_event = function(event, name) {\n",
       "\n",
       "    // Prevent repeat events\n",
       "    if (name == 'key_press')\n",
       "    {\n",
       "        if (event.which === this._key)\n",
       "            return;\n",
       "        else\n",
       "            this._key = event.which;\n",
       "    }\n",
       "    if (name == 'key_release')\n",
       "        this._key = null;\n",
       "\n",
       "    var value = '';\n",
       "    if (event.ctrlKey && event.which != 17)\n",
       "        value += \"ctrl+\";\n",
       "    if (event.altKey && event.which != 18)\n",
       "        value += \"alt+\";\n",
       "    if (event.shiftKey && event.which != 16)\n",
       "        value += \"shift+\";\n",
       "\n",
       "    value += 'k';\n",
       "    value += event.which.toString();\n",
       "\n",
       "    this._key_event_extra(event, name);\n",
       "\n",
       "    this.send_message(name, {key: value,\n",
       "                             guiEvent: simpleKeys(event)});\n",
       "    return false;\n",
       "}\n",
       "\n",
       "mpl.figure.prototype.toolbar_button_onclick = function(name) {\n",
       "    if (name == 'download') {\n",
       "        this.handle_save(this, null);\n",
       "    } else {\n",
       "        this.send_message(\"toolbar_button\", {name: name});\n",
       "    }\n",
       "};\n",
       "\n",
       "mpl.figure.prototype.toolbar_button_onmouseover = function(tooltip) {\n",
       "    this.message.textContent = tooltip;\n",
       "};\n",
       "mpl.toolbar_items = [[\"Home\", \"Reset original view\", \"fa fa-home icon-home\", \"home\"], [\"Back\", \"Back to  previous view\", \"fa fa-arrow-left icon-arrow-left\", \"back\"], [\"Forward\", \"Forward to next view\", \"fa fa-arrow-right icon-arrow-right\", \"forward\"], [\"\", \"\", \"\", \"\"], [\"Pan\", \"Pan axes with left mouse, zoom with right\", \"fa fa-arrows icon-move\", \"pan\"], [\"Zoom\", \"Zoom to rectangle\", \"fa fa-square-o icon-check-empty\", \"zoom\"], [\"\", \"\", \"\", \"\"], [\"Download\", \"Download plot\", \"fa fa-floppy-o icon-save\", \"download\"]];\n",
       "\n",
       "mpl.extensions = [\"eps\", \"jpeg\", \"pdf\", \"png\", \"ps\", \"raw\", \"svg\", \"tif\"];\n",
       "\n",
       "mpl.default_extension = \"png\";var comm_websocket_adapter = function(comm) {\n",
       "    // Create a \"websocket\"-like object which calls the given IPython comm\n",
       "    // object with the appropriate methods. Currently this is a non binary\n",
       "    // socket, so there is still some room for performance tuning.\n",
       "    var ws = {};\n",
       "\n",
       "    ws.close = function() {\n",
       "        comm.close()\n",
       "    };\n",
       "    ws.send = function(m) {\n",
       "        //console.log('sending', m);\n",
       "        comm.send(m);\n",
       "    };\n",
       "    // Register the callback with on_msg.\n",
       "    comm.on_msg(function(msg) {\n",
       "        //console.log('receiving', msg['content']['data'], msg);\n",
       "        // Pass the mpl event to the overridden (by mpl) onmessage function.\n",
       "        ws.onmessage(msg['content']['data'])\n",
       "    });\n",
       "    return ws;\n",
       "}\n",
       "\n",
       "mpl.mpl_figure_comm = function(comm, msg) {\n",
       "    // This is the function which gets called when the mpl process\n",
       "    // starts-up an IPython Comm through the \"matplotlib\" channel.\n",
       "\n",
       "    var id = msg.content.data.id;\n",
       "    // Get hold of the div created by the display call when the Comm\n",
       "    // socket was opened in Python.\n",
       "    var element = $(\"#\" + id);\n",
       "    var ws_proxy = comm_websocket_adapter(comm)\n",
       "\n",
       "    function ondownload(figure, format) {\n",
       "        window.open(figure.imageObj.src);\n",
       "    }\n",
       "\n",
       "    var fig = new mpl.figure(id, ws_proxy,\n",
       "                           ondownload,\n",
       "                           element.get(0));\n",
       "\n",
       "    // Call onopen now - mpl needs it, as it is assuming we've passed it a real\n",
       "    // web socket which is closed, not our websocket->open comm proxy.\n",
       "    ws_proxy.onopen();\n",
       "\n",
       "    fig.parent_element = element.get(0);\n",
       "    fig.cell_info = mpl.find_output_cell(\"<div id='\" + id + \"'></div>\");\n",
       "    if (!fig.cell_info) {\n",
       "        console.error(\"Failed to find cell for figure\", id, fig);\n",
       "        return;\n",
       "    }\n",
       "\n",
       "    var output_index = fig.cell_info[2]\n",
       "    var cell = fig.cell_info[0];\n",
       "\n",
       "};\n",
       "\n",
       "mpl.figure.prototype.handle_close = function(fig, msg) {\n",
       "    var width = fig.canvas.width/mpl.ratio\n",
       "    fig.root.unbind('remove')\n",
       "\n",
       "    // Update the output cell to use the data from the current canvas.\n",
       "    fig.push_to_output();\n",
       "    var dataURL = fig.canvas.toDataURL();\n",
       "    // Re-enable the keyboard manager in IPython - without this line, in FF,\n",
       "    // the notebook keyboard shortcuts fail.\n",
       "    IPython.keyboard_manager.enable()\n",
       "    $(fig.parent_element).html('<img src=\"' + dataURL + '\" width=\"' + width + '\">');\n",
       "    fig.close_ws(fig, msg);\n",
       "}\n",
       "\n",
       "mpl.figure.prototype.close_ws = function(fig, msg){\n",
       "    fig.send_message('closing', msg);\n",
       "    // fig.ws.close()\n",
       "}\n",
       "\n",
       "mpl.figure.prototype.push_to_output = function(remove_interactive) {\n",
       "    // Turn the data on the canvas into data in the output cell.\n",
       "    var width = this.canvas.width/mpl.ratio\n",
       "    var dataURL = this.canvas.toDataURL();\n",
       "    this.cell_info[1]['text/html'] = '<img src=\"' + dataURL + '\" width=\"' + width + '\">';\n",
       "}\n",
       "\n",
       "mpl.figure.prototype.updated_canvas_event = function() {\n",
       "    // Tell IPython that the notebook contents must change.\n",
       "    IPython.notebook.set_dirty(true);\n",
       "    this.send_message(\"ack\", {});\n",
       "    var fig = this;\n",
       "    // Wait a second, then push the new image to the DOM so\n",
       "    // that it is saved nicely (might be nice to debounce this).\n",
       "    setTimeout(function () { fig.push_to_output() }, 1000);\n",
       "}\n",
       "\n",
       "mpl.figure.prototype._init_toolbar = function() {\n",
       "    var fig = this;\n",
       "\n",
       "    var nav_element = $('<div/>')\n",
       "    nav_element.attr('style', 'width: 100%');\n",
       "    this.root.append(nav_element);\n",
       "\n",
       "    // Define a callback function for later on.\n",
       "    function toolbar_event(event) {\n",
       "        return fig.toolbar_button_onclick(event['data']);\n",
       "    }\n",
       "    function toolbar_mouse_event(event) {\n",
       "        return fig.toolbar_button_onmouseover(event['data']);\n",
       "    }\n",
       "\n",
       "    for(var toolbar_ind in mpl.toolbar_items){\n",
       "        var name = mpl.toolbar_items[toolbar_ind][0];\n",
       "        var tooltip = mpl.toolbar_items[toolbar_ind][1];\n",
       "        var image = mpl.toolbar_items[toolbar_ind][2];\n",
       "        var method_name = mpl.toolbar_items[toolbar_ind][3];\n",
       "\n",
       "        if (!name) { continue; };\n",
       "\n",
       "        var button = $('<button class=\"btn btn-default\" href=\"#\" title=\"' + name + '\"><i class=\"fa ' + image + ' fa-lg\"></i></button>');\n",
       "        button.click(method_name, toolbar_event);\n",
       "        button.mouseover(tooltip, toolbar_mouse_event);\n",
       "        nav_element.append(button);\n",
       "    }\n",
       "\n",
       "    // Add the status bar.\n",
       "    var status_bar = $('<span class=\"mpl-message\" style=\"text-align:right; float: right;\"/>');\n",
       "    nav_element.append(status_bar);\n",
       "    this.message = status_bar[0];\n",
       "\n",
       "    // Add the close button to the window.\n",
       "    var buttongrp = $('<div class=\"btn-group inline pull-right\"></div>');\n",
       "    var button = $('<button class=\"btn btn-mini btn-primary\" href=\"#\" title=\"Stop Interaction\"><i class=\"fa fa-power-off icon-remove icon-large\"></i></button>');\n",
       "    button.click(function (evt) { fig.handle_close(fig, {}); } );\n",
       "    button.mouseover('Stop Interaction', toolbar_mouse_event);\n",
       "    buttongrp.append(button);\n",
       "    var titlebar = this.root.find($('.ui-dialog-titlebar'));\n",
       "    titlebar.prepend(buttongrp);\n",
       "}\n",
       "\n",
       "mpl.figure.prototype._root_extra_style = function(el){\n",
       "    var fig = this\n",
       "    el.on(\"remove\", function(){\n",
       "\tfig.close_ws(fig, {});\n",
       "    });\n",
       "}\n",
       "\n",
       "mpl.figure.prototype._canvas_extra_style = function(el){\n",
       "    // this is important to make the div 'focusable\n",
       "    el.attr('tabindex', 0)\n",
       "    // reach out to IPython and tell the keyboard manager to turn it's self\n",
       "    // off when our div gets focus\n",
       "\n",
       "    // location in version 3\n",
       "    if (IPython.notebook.keyboard_manager) {\n",
       "        IPython.notebook.keyboard_manager.register_events(el);\n",
       "    }\n",
       "    else {\n",
       "        // location in version 2\n",
       "        IPython.keyboard_manager.register_events(el);\n",
       "    }\n",
       "\n",
       "}\n",
       "\n",
       "mpl.figure.prototype._key_event_extra = function(event, name) {\n",
       "    var manager = IPython.notebook.keyboard_manager;\n",
       "    if (!manager)\n",
       "        manager = IPython.keyboard_manager;\n",
       "\n",
       "    // Check for shift+enter\n",
       "    if (event.shiftKey && event.which == 13) {\n",
       "        this.canvas_div.blur();\n",
       "        event.shiftKey = false;\n",
       "        // Send a \"J\" for go to next cell\n",
       "        event.which = 74;\n",
       "        event.keyCode = 74;\n",
       "        manager.command_mode();\n",
       "        manager.handle_keydown(event);\n",
       "    }\n",
       "}\n",
       "\n",
       "mpl.figure.prototype.handle_save = function(fig, msg) {\n",
       "    fig.ondownload(fig, null);\n",
       "}\n",
       "\n",
       "\n",
       "mpl.find_output_cell = function(html_output) {\n",
       "    // Return the cell and output element which can be found *uniquely* in the notebook.\n",
       "    // Note - this is a bit hacky, but it is done because the \"notebook_saving.Notebook\"\n",
       "    // IPython event is triggered only after the cells have been serialised, which for\n",
       "    // our purposes (turning an active figure into a static one), is too late.\n",
       "    var cells = IPython.notebook.get_cells();\n",
       "    var ncells = cells.length;\n",
       "    for (var i=0; i<ncells; i++) {\n",
       "        var cell = cells[i];\n",
       "        if (cell.cell_type === 'code'){\n",
       "            for (var j=0; j<cell.output_area.outputs.length; j++) {\n",
       "                var data = cell.output_area.outputs[j];\n",
       "                if (data.data) {\n",
       "                    // IPython >= 3 moved mimebundle to data attribute of output\n",
       "                    data = data.data;\n",
       "                }\n",
       "                if (data['text/html'] == html_output) {\n",
       "                    return [cell, data, j];\n",
       "                }\n",
       "            }\n",
       "        }\n",
       "    }\n",
       "}\n",
       "\n",
       "// Register the function which deals with the matplotlib target/channel.\n",
       "// The kernel may be null if the page has been refreshed.\n",
       "if (IPython.notebook.kernel != null) {\n",
       "    IPython.notebook.kernel.comm_manager.register_target('matplotlib', mpl.mpl_figure_comm);\n",
       "}\n"
      ],
      "text/plain": [
       "<IPython.core.display.Javascript object>"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    },
    {
     "data": {
      "text/html": [
       "<img src=\"data:image/png;base64,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\" width=\"799.9999880790713\">"
      ],
      "text/plain": [
       "<IPython.core.display.HTML object>"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    }
   ],
   "source": [
    "next_state = cities\n",
    "states = []\n",
    "\n",
    "# creating plotting area\n",
    "fig = plt.figure(figsize = (8,6))\n",
    "ax = plt.axes(xlim=(60, 600), ylim=(245, 600))\n",
    "line, = ax.plot([], [], c=\"b\",linewidth = 1.5, marker = 'o', markerfacecolor = 'r', markeredgecolor = 'r',markersize = 10)\n",
    "text = ax.text(450, 565, \"\", fontdict = font)\n",
    "\n",
    "# to plot only the final states of every simulated annealing iteration\n",
    "for iterations in range(100):\n",
    "    tsp_problem = TSP_problem(next_state)  \n",
    "    states.append(simulated_annealing(tsp_problem))\n",
    "    next_state = states[-1]\n",
    "    \n",
    "anim = animation.FuncAnimation(fig, animate, init_func=init,\n",
    "                           frames=len(states),interval=len(states), blit=True, repeat = False)\n",
    "plt.show()"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "collapsed": true
   },
   "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.6.1"
  },
  "widgets": {
   "state": {},
   "version": "1.1.1"
  }
 },
 "nbformat": 4,
 "nbformat_minor": 1
}