search-4e.ipynb

    "    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",