Practical HW1 Usman Khan.ipynb

{
 "cells": [
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "# Practical Homework 1\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 286,
   "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 / mpl.ratio, fig.canvas.height / mpl.ratio);\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",
       "        // select the cell after this one\n",
       "        var index = IPython.notebook.find_cell_index(this.cell_info[0]);\n",
       "        IPython.notebook.select(index + 1);\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=\"640\">"
      ],
      "text/plain": [
       "<IPython.core.display.HTML object>"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    },
    {
     "data": {
      "text/plain": [
       "[<matplotlib.lines.Line2D at 0x236e1bbff60>]"
      ]
     },
     "execution_count": 286,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "\n",
    "\n",
    "import numpy as np\n",
    "%matplotlib notebook\n",
    "import matplotlib.pyplot as plt\n",
    "\n",
    "\n",
    "def StudentCosine(t, f, A):\n",
    "    return A*np.cos(2*np.pi*f*t)\n",
    "\n",
    "T = np.arange(0, 1, 0.0001)\n",
    "x1 = StudentCosine(T, 15, 1)\n",
    "x2 = StudentCosine(T, 30, 1)\n",
    "\n",
    "plt.figure()\n",
    "plt.subplot(2,2, 1)\n",
    "plt.plot(T, x1)\n",
    "\n",
    "plt.subplot(2,2,2)\n",
    "plt.plot(T, x1 * x1)\n",
    "\n",
    "plt.subplot(2,2,3)\n",
    "plt.plot(T, x2)\n",
    "\n",
    "plt.subplot(2,2,4)\n",
    "plt.plot(T, x2 * x1)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 290,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Det A  16.000000000000007\n",
      "\n",
      "Det B  -6.0\n",
      "\n",
      "Sum  [[ 2  1  1]\n",
      " [ 4  2  1]\n",
      " [-3  4  4]]\n",
      "\n",
      "Product  [[ 1  1  3]\n",
      " [ 6  2  2]\n",
      " [ 5 -3  7]]\n",
      "\n",
      "A inv\n",
      "[[ 0.125  0.25  -0.125]\n",
      " [-0.125  0.25   0.125]\n",
      " [ 0.875 -0.25   0.125]]\n",
      "\n",
      "B inv\n",
      "[[ 0.          0.5        -0.16666667]\n",
      " [ 1.         -0.5         0.16666667]\n",
      " [ 0.          0.          0.33333333]]\n",
      "\n",
      "[0.45631099+2.23028502j 0.45631099-2.23028502j 3.08737803+0.j        ]\n",
      "\n",
      "[[-0.09073419-0.37220379j -0.09073419+0.37220379j  0.33825267+0.j        ]\n",
      " [-0.1875877 +0.21120415j -0.1875877 -0.21120415j  0.62214366+0.j        ]\n",
      " [ 0.87945171+0.j          0.87945171-0.j          0.70606119+0.j        ]]\n",
      "\n",
      "[0.45631099+2.23028502j 0.45631099-2.23028502j 3.08737803+0.j        ]\n",
      "\n",
      "[[0.91850016 0.13328029 0.16030898]\n",
      " [1.68262031 0.75852006 0.25323465]\n",
      " [1.96941573 0.34431771 0.56097942]]\n"
     ]
    }
   ],
   "source": [
    "# Matrix Operations\n",
    "\n",
    "A = ([1,0,1], [2, 2, 0], [-3, 4, 1])\n",
    "A = np.asarray(A)\n",
    "det_A = np.linalg.det(A)\n",
    "print('Det A ', det_A)\n",
    "print()\n",
    "\n",
    "B = ([1, 1, 0], [2, 0, 1], [0, 0, 3])\n",
    "B = np.asarray(B)\n",
    "det_B = np.linalg.det(B)\n",
    "print('Det B ', det_B)\n",
    "print()\n",
    "\n",
    "mat_sum = A + B\n",
    "print('Sum ', mat_sum)\n",
    "print()\n",
    "\n",
    "mat_prod = np.matmul(A, B)\n",
    "print('Product ', mat_prod)\n",
    "print()\n",
    "\n",
    "A_inv = np.linalg.inv(A)\n",
    "B_inv = np.linalg.inv(B)\n",
    "\n",
    "print('A inv')\n",
    "print(A_inv)\n",
    "print()\n",
    "\n",
    "print('B inv')\n",
    "print(B_inv)\n",
    "print()\n",
    "\n",
    "A_eig_value, A_eig_vectors = np.linalg.eig(A)\n",
    "# print this\n",
    "print(A_eig_value)\n",
    "print()\n",
    "\n",
    "print(A_eig_vectors)\n",
    "print()\n",
    "print(np.linalg.eigvals(A))\n",
    "e = np.linalg.eigvals(A)\n",
    "print()\n",
    "\n",
    "V = ([e[0], 0, 0], [0, e[1], 0], [0, 0, e[2]])\n",
    "V = np.asarray(V)\n",
    "\n",
    "\n",
    "intermediate = np.matmul(A_eig_vectors, V)\n",
    "final = np.matmul(intermediate, A_inv)\n",
    "final = np.absolute(final)\n",
    "print(final)\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 308,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "True\n"
     ]
    }
   ],
   "source": [
    "# Part E\n",
    "\n",
    "from sympy import *\n",
    "# define a new matrix M for part E\n",
    "M = Matrix([[-1, -2, 2], [4, 3, -4], [0, -2, 1]])\n",
    "\n",
    "P, D = M.diagonalize()\n",
    "# P is the matrix of eigenvectors. D is the diagonal matrix of eigenvalues\n",
    "\n",
    "\n",
    "# check if the decomposition is correct \n",
    "correct_decomp = P*D*P ** -1 == M\n",
    "print(correct_decomp)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 332,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "False\n"
     ]
    },
    {
     "data": {
      "text/latex": [
       "$\\displaystyle \\left[\\begin{matrix}5 & 4 & 1\\\\4 & 6 & 4\\\\1 & 4 & 5\\end{matrix}\\right]$"
      ],
      "text/plain": [
       "Matrix([\n",
       "[5, 4, 1],\n",
       "[4, 6, 4],\n",
       "[1, 4, 5]])"
      ]
     },
     "execution_count": 332,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "# Part F\n",
    "\n",
    "from sympy import *\n",
    "# define a new symmetric matrix M2 for Part F\n",
    "M2 = Matrix([[2, 1, 0], [1, 2, 1], [0, 1, 2]])\n",
    "P2, D2 = M2.diagonalize()\n",
    "# P is the matrix of eigenvectors. D is the diagonal matrix of eigenvalues\n",
    "\n",
    "\n",
    "# check if the decomposition is correct \n",
    "correct_decomp = P2*D2*P2 ** -1 == M2\n",
    "print(correct_decomp)\n",
    "\n",
    "check = M2*M2.T\n",
    "print(check) \n",
    "\n",
    "transpose_check = P2 * D2 * P2.T\n",
    "\n",
    "transpose_check == correct_decomp\n",
    "\n",
    "# NOTE: this wasn't working for some reason.. I'm not sure why. The matrix is \n",
    "# symmetric but it wasn't giving the expected answer. Perhaps some bug in sympy multiplication? \n"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Part 2: Playing with Random Observations"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 109,
   "metadata": {},
   "outputs": [
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      "C:\\Users\\usman\\Anaconda3\\lib\\site-packages\\ipykernel_launcher.py:29: RuntimeWarning: invalid value encountered in long_scalars\n",
      "C:\\Users\\usman\\Anaconda3\\lib\\site-packages\\ipykernel_launcher.py:44: RuntimeWarning: invalid value encountered in long_scalars\n"
     ]
    },
    {
     "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 / mpl.ratio, fig.canvas.height / mpl.ratio);\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",
       "        // select the cell after this one\n",
       "        var index = IPython.notebook.find_cell_index(this.cell_info[0]);\n",
       "        IPython.notebook.select(index + 1);\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=\"640\">"
      ],
      "text/plain": [
       "<IPython.core.display.HTML object>"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    }
   ],
   "source": [
    "def FairCoinToss():\n",
    "    choices = [0,1]\n",
    "    result = np.random.choice(choices,1)\n",
    "    if (result[0] == 1):\n",
    "        return \"H\"\n",
    "    else:\n",
    "        return \"T\"\n",
    "\n",
    "# 1000 iterations, results stored in list\n",
    "results = []\n",
    "for i in range(10000):\n",
    "    results.append(FairCoinToss())\n",
    "\n",
    "\n",
    "k = np.arange(0, 10000, 10)\n",
    "np_results = np.asarray(results)\n",
    "\n",
    "H_k = []\n",
    "H_k_norm = []\n",
    "\n",
    "# Finding probability of Heads\n",
    "for num in k:\n",
    "    subsection = np_results[0:num]\n",
    "#     print(subsection)\n",
    "    num_occurrences = 0\n",
    "    for item in subsection:\n",
    "        if (item == 'H'):\n",
    "            num_occurrences += 1\n",
    "    H_k.append(num_occurrences)\n",
    "    H_k_norm.append(num_occurrences / num)\n",
    "\n",
    "H_k_norm[0] = 0\n",
    "\n",
    "T_k = []\n",
    "T_k_norm = []\n",
    "# Finding probability of Tails\n",
    "for num in k:\n",
    "    subsection = np_results[0:num]\n",
    "#     print(subsection)\n",
    "    num_occurrences = 0\n",
    "    for item in subsection:\n",
    "        if (item == 'T'):\n",
    "            num_occurrences += 1\n",
    "    T_k.append(num_occurrences)\n",
    "    T_k_norm.append(num_occurrences / num)\n",
    "\n",
    "T_k_norm[0] = 0\n",
    "\n",
    "    \n",
    "fig = plt.figure()\n",
    "\n",
    "plt.subplot(2, 1, 1)\n",
    "plt.plot(k, H_k_norm)\n",
    "plt.title('H(k)/k vs. k')\n",
    "\n",
    "plt.subplot(2,1,2)\n",
    "plt.plot(k, T_k_norm)\n",
    "plt.title('T(k)/k vs. k')\n",
    "fig.tight_layout()\n",
    "\n"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "We can see that H(k)/k converges to 0.5. Hence, the probability of Heads is 0.5. The value that T(k)/k converges to is the probability of Tails, which we can see is also 0.5. "
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 1,
   "metadata": {},
   "outputs": [
    {
     "ename": "NameError",
     "evalue": "name 'np' is not defined",
     "output_type": "error",
     "traceback": [
      "\u001b[1;31m---------------------------------------------------------------------------\u001b[0m",
      "\u001b[1;31mNameError\u001b[0m                                 Traceback (most recent call last)",
      "\u001b[1;32m<ipython-input-1-e71dff19f5f8>\u001b[0m in \u001b[0;36m<module>\u001b[1;34m\u001b[0m\n\u001b[0;32m     10\u001b[0m \u001b[0mresults\u001b[0m \u001b[1;33m=\u001b[0m \u001b[1;33m[\u001b[0m\u001b[1;33m]\u001b[0m\u001b[1;33m\u001b[0m\u001b[1;33m\u001b[0m\u001b[0m\n\u001b[0;32m     11\u001b[0m \u001b[1;32mfor\u001b[0m \u001b[0mi\u001b[0m \u001b[1;32min\u001b[0m \u001b[0mrange\u001b[0m\u001b[1;33m(\u001b[0m\u001b[1;36m10000\u001b[0m\u001b[1;33m)\u001b[0m\u001b[1;33m:\u001b[0m\u001b[1;33m\u001b[0m\u001b[1;33m\u001b[0m\u001b[0m\n\u001b[1;32m---> 12\u001b[1;33m     \u001b[0mresults\u001b[0m\u001b[1;33m.\u001b[0m\u001b[0mappend\u001b[0m\u001b[1;33m(\u001b[0m\u001b[0mBiasedCoinToss\u001b[0m\u001b[1;33m(\u001b[0m\u001b[1;36m0.2\u001b[0m\u001b[1;33m)\u001b[0m\u001b[1;33m)\u001b[0m\u001b[1;33m\u001b[0m\u001b[1;33m\u001b[0m\u001b[0m\n\u001b[0m\u001b[0;32m     13\u001b[0m \u001b[1;33m\u001b[0m\u001b[0m\n\u001b[0;32m     14\u001b[0m \u001b[1;33m\u001b[0m\u001b[0m\n",
      "\u001b[1;32m<ipython-input-1-e71dff19f5f8>\u001b[0m in \u001b[0;36mBiasedCoinToss\u001b[1;34m(a)\u001b[0m\n\u001b[0;32m      2\u001b[0m     \u001b[0mchoices\u001b[0m \u001b[1;33m=\u001b[0m \u001b[1;33m[\u001b[0m\u001b[1;36m0\u001b[0m\u001b[1;33m,\u001b[0m\u001b[1;36m1\u001b[0m\u001b[1;33m]\u001b[0m\u001b[1;33m\u001b[0m\u001b[1;33m\u001b[0m\u001b[0m\n\u001b[0;32m      3\u001b[0m     \u001b[0mprobs\u001b[0m \u001b[1;33m=\u001b[0m \u001b[1;33m[\u001b[0m\u001b[1;36m1\u001b[0m\u001b[1;33m-\u001b[0m\u001b[0ma\u001b[0m\u001b[1;33m,\u001b[0m \u001b[0ma\u001b[0m\u001b[1;33m]\u001b[0m\u001b[1;33m\u001b[0m\u001b[1;33m\u001b[0m\u001b[0m\n\u001b[1;32m----> 4\u001b[1;33m     \u001b[0mresult\u001b[0m \u001b[1;33m=\u001b[0m \u001b[0mnp\u001b[0m\u001b[1;33m.\u001b[0m\u001b[0mrandom\u001b[0m\u001b[1;33m.\u001b[0m\u001b[0mchoice\u001b[0m\u001b[1;33m(\u001b[0m\u001b[0mchoices\u001b[0m\u001b[1;33m,\u001b[0m\u001b[1;36m1\u001b[0m\u001b[1;33m,\u001b[0m \u001b[0mp\u001b[0m \u001b[1;33m=\u001b[0m \u001b[0mprobs\u001b[0m\u001b[1;33m)\u001b[0m\u001b[1;33m\u001b[0m\u001b[1;33m\u001b[0m\u001b[0m\n\u001b[0m\u001b[0;32m      5\u001b[0m     \u001b[1;32mif\u001b[0m \u001b[1;33m(\u001b[0m\u001b[0mresult\u001b[0m\u001b[1;33m[\u001b[0m\u001b[1;36m0\u001b[0m\u001b[1;33m]\u001b[0m \u001b[1;33m==\u001b[0m \u001b[1;36m1\u001b[0m\u001b[1;33m)\u001b[0m\u001b[1;33m:\u001b[0m\u001b[1;33m\u001b[0m\u001b[1;33m\u001b[0m\u001b[0m\n\u001b[0;32m      6\u001b[0m         \u001b[1;32mreturn\u001b[0m \u001b[1;34m\"H\"\u001b[0m\u001b[1;33m\u001b[0m\u001b[1;33m\u001b[0m\u001b[0m\n",
      "\u001b[1;31mNameError\u001b[0m: name 'np' is not defined"
     ]
    }
   ],
   "source": [
    "def BiasedCoinToss(a):\n",
    "    choices = [0,1]\n",
    "    probs = [1-a, a]\n",
    "    result = np.random.choice(choices,1, p = probs)\n",
    "    if (result[0] == 1):\n",
    "        return \"H\"\n",
    "    else:\n",
    "        return \"T\"\n",
    "\n",
    "results = []\n",
    "for i in range(10000):\n",
    "    results.append(BiasedCoinToss(0.2))\n",
    "\n",
    "\n",
    "k = np.arange(0, 10000, 10)\n",
    "np_results = np.asarray(results)\n",
    "\n",
    "H_k = []\n",
    "H_k_norm = []\n",
    "\n",
    "# Finding probability of Heads\n",
    "for num in k:\n",
    "    subsection = np_results[0:num]\n",
    "#     print(subsection)\n",
    "    num_occurrences = 0\n",
    "    for item in subsection:\n",
    "        if (item == 'H'):\n",
    "            num_occurrences += 1\n",
    "    H_k.append(num_occurrences)\n",
    "    H_k_norm.append(num_occurrences / num)\n",
    "\n",
    "H_k_norm[0] = 0\n",
    "\n",
    "T_k = []\n",
    "T_k_norm = []\n",
    "# Finding probability of Tails\n",
    "for num in k:\n",
    "    subsection = np_results[0:num]\n",
    "#     print(subsection)\n",
    "    num_occurrences = 0\n",
    "    for item in subsection:\n",
    "        if (item == 'T'):\n",
    "            num_occurrences += 1\n",
    "    T_k.append(num_occurrences)\n",
    "    T_k_norm.append(num_occurrences / num)\n",
    "\n",
    "T_k_norm[0] = 0\n",
    "\n",
    "    \n",
    "fig = plt.figure()\n",
    "\n",
    "plt.subplot(2, 1, 1)\n",
    "plt.plot(k, H_k_norm)\n",
    "plt.title('H(k)/k vs. k, a = 0.2')\n",
    "\n",
    "plt.subplot(2,1,2)\n",
    "plt.plot(k, T_k_norm)\n",
    "plt.title('T(k)/k vs. k, a = 0.2')\n",
    "fig.tight_layout()\n",
    "\n"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "H(k)/k converges to 0.2, so the probability of heads is 0.2. T(k)/k converges to 0.8, so the probability of tails is 0.8."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 114,
   "metadata": {},
   "outputs": [
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      "C:\\Users\\usman\\Anaconda3\\lib\\site-packages\\ipykernel_launcher.py:29: RuntimeWarning: invalid value encountered in long_scalars\n",
      "C:\\Users\\usman\\Anaconda3\\lib\\site-packages\\ipykernel_launcher.py:43: RuntimeWarning: invalid value encountered in long_scalars\n"
     ]
    },
    {
     "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 / mpl.ratio, fig.canvas.height / mpl.ratio);\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",
       "        // select the cell after this one\n",
       "        var index = IPython.notebook.find_cell_index(this.cell_info[0]);\n",
       "        IPython.notebook.select(index + 1);\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=\"640\">"
      ],
      "text/plain": [
       "<IPython.core.display.HTML object>"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    }
   ],
   "source": [
    "def BiasedCoinToss(a):\n",
    "    choices = [0,1]\n",
    "    probs = [1-a, a]\n",
    "    result = np.random.choice(choices,1, p = probs)\n",
    "    if (result[0] == 1):\n",
    "        return \"H\"\n",
    "    else:\n",
    "        return \"T\"\n",
    "\n",
    "# 1000 iterations, results stored in a list\n",
    "results = []\n",
    "for i in range(10000):\n",
    "    results.append(BiasedCoinToss(0.6))\n",
    "\n",
    "\n",
    "k = np.arange(0, 10000, 10)\n",
    "np_results = np.asarray(results)\n",
    "\n",
    "H_k = []\n",
    "H_k_norm = []\n",
    "\n",
    "# Finding probability of Heads\n",
    "for num in k:\n",
    "    subsection = np_results[0:num]\n",
    "    num_occurrences = 0\n",
    "    for item in subsection:\n",
    "        if (item == 'H'):\n",
    "            num_occurrences += 1\n",
    "    H_k.append(num_occurrences)\n",
    "    H_k_norm.append(num_occurrences / num)\n",
    "\n",
    "H_k_norm[0] = 0\n",
    "\n",
    "T_k = []\n",
    "T_k_norm = []\n",
    "# Finding probability of Tails\n",
    "for num in k:\n",
    "    subsection = np_results[0:num]\n",
    "    num_occurrences = 0\n",
    "    for item in subsection:\n",
    "        if (item == 'T'):\n",
    "            num_occurrences += 1\n",
    "    T_k.append(num_occurrences)\n",
    "    T_k_norm.append(num_occurrences / num)\n",
    "\n",
    "T_k_norm[0] = 0\n",
    "\n",
    "    \n",
    "fig = plt.figure()\n",
    "\n",
    "plt.subplot(2, 1, 1)\n",
    "plt.plot(k, H_k_norm)\n",
    "plt.title('H(k)/k vs. k, a = 0.6')\n",
    "\n",
    "plt.subplot(2,1,2)\n",
    "plt.plot(k, T_k_norm)\n",
    "plt.title('T(k)/k vs. k, a = 0.6')\n",
    "fig.tight_layout()\n",
    "\n"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "H(k)/k converges to 0.6, so the probability of heads is 0.6. T(k)/k converges to 0.4, so the probability of tails is 0.4. These results illustrate that the probabilities of each outcome sum to 1. "
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": []
  },
  {
   "cell_type": "code",
   "execution_count": 116,
   "metadata": {},
   "outputs": [
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      "C:\\Users\\usman\\Anaconda3\\lib\\site-packages\\ipykernel_launcher.py:26: RuntimeWarning: invalid value encountered in long_scalars\n"
     ]
    },
    {
     "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 / mpl.ratio, fig.canvas.height / mpl.ratio);\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",
       "        // select the cell after this one\n",
       "        var index = IPython.notebook.find_cell_index(this.cell_info[0]);\n",
       "        IPython.notebook.select(index + 1);\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=\"640\">"
      ],
      "text/plain": [
       "<IPython.core.display.HTML object>"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    },
    {
     "data": {
      "text/plain": [
       "Text(0.5, 1.0, '1(k)/k vs. k')"
      ]
     },
     "execution_count": 116,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "def EightSidedDieRolling():\n",
    "    choices = [1,2,3,4,5,6,7,8]\n",
    "    result = np.random.choice(choices,1)\n",
    "    return str(result[0])\n",
    "\n",
    "\n",
    "# 1000 iterations, results stored in a list\n",
    "results = []\n",
    "for i in range(10000):\n",
    "    results.append(EightSidedDieRolling())\n",
    "    \n",
    "k = np.arange(0, 10000, 10)\n",
    "np_results = np.asarray(results)\n",
    "\n",
    "one_k = []\n",
    "one_k_norm = []\n",
    "\n",
    "for num in k:\n",
    "    subsection = np_results[0:num]\n",
    "    num_occurrences = 0\n",
    "    for item in subsection:\n",
    "        if (item == '1'):\n",
    "            num_occurrences += 1\n",
    "    one_k.append(num_occurrences)\n",
    "    one_k_norm.append(num_occurrences / num)\n",
    "\n",
    "one_k_norm[0] = 0\n",
    "plt.figure()\n",
    "plt.plot(k, one_k_norm)\n",
    "plt.title('1(k)/k vs. k')\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 130,
   "metadata": {},
   "outputs": [
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      "C:\\Users\\usman\\Anaconda3\\lib\\site-packages\\numpy\\lib\\function_base.py:393: RuntimeWarning: Mean of empty slice.\n",
      "  avg = a.mean(axis)\n",
      "C:\\Users\\usman\\Anaconda3\\lib\\site-packages\\numpy\\core\\_methods.py:161: RuntimeWarning: invalid value encountered in double_scalars\n",
      "  ret = ret.dtype.type(ret / rcount)\n"
     ]
    },
    {
     "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 / mpl.ratio, fig.canvas.height / mpl.ratio);\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",
       "        // select the cell after this one\n",
       "        var index = IPython.notebook.find_cell_index(this.cell_info[0]);\n",
       "        IPython.notebook.select(index + 1);\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=\"640\">"
      ],
      "text/plain": [
       "<IPython.core.display.HTML object>"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    },
    {
     "data": {
      "text/plain": [
       "Text(0.5, 1.0, 'Average result vs. k')"
      ]
     },
     "execution_count": 130,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "\n",
    "# 1000 iterations, results stored in a list\n",
    "results = []\n",
    "for i in range(10000):\n",
    "    results.append(EightSidedDieRolling())\n",
    "    \n",
    "k = np.arange(0, 10000, 10)\n",
    "np_results = np.asarray(results)\n",
    "\n",
    "avg_k = []\n",
    "\n",
    "for num in k:\n",
    "    subsection = np_results[0:num]\n",
    "    int_sub = []\n",
    "    for item in subsection:\n",
    "        int_sub.append(int(item))\n",
    "    avg_k.append(np.average(int_sub))\n",
    "\n",
    "plt.figure()\n",
    "plt.plot(k, avg_k)\n",
    "plt.title('Average result vs. k')\n",
    "\n"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "C) 1(k)/k, or the probability of rolling a 1, converges to 0.125. This makes sense, because 1/8 = 0.125, and all eight sides are equally likely in a fair die. \n",
    "\n",
    "D) The average appears to converge to 4.5 "
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 117,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Avg result 21.765\n",
      "Calculated sum 21.74285714285714\n"
     ]
    }
   ],
   "source": [
    "def DieExperiment():\n",
    "    eight, seven, six, five, four, three, two, one = False,False, False, False, False, False, False, False\n",
    "    all_rolled = False\n",
    "    attempts = 0\n",
    "    while (not all_rolled):\n",
    "        result = EightSidedDieRolling()\n",
    "        if (result == '8'):\n",
    "            eight = True\n",
    "        elif (result == '7'):\n",
    "            seven = True\n",
    "        elif (result == '6'):\n",
    "            six = True\n",
    "        elif (result == '5'):\n",
    "            five = True\n",
    "        elif (result == '4'):\n",
    "            four = True\n",
    "        elif (result == '3'):\n",
    "            three = True\n",
    "        elif (result == '2'):\n",
    "            two = True\n",
    "        else:\n",
    "            one = True\n",
    "        all_rolled = eight and seven and six and five and four and three and two and one\n",
    "        attempts = attempts + 1\n",
    "    return attempts\n",
    "\n",
    "DieExperiment()\n",
    "\n",
    "exp_results = []\n",
    "for i in range(1000):\n",
    "    exp_results.append(DieExperiment())\n",
    "            \n",
    "avg_result = np.average(exp_results)\n",
    "print(\"Avg result\", avg_result)\n",
    "\n",
    "calculated_sum = 8*(1/1 + 1/2 + 1/3 + 1/4+ 1/5 + 1/6 +1/7 + 1/8)\n",
    "print(\"Calculated sum\", calculated_sum)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "The values match quite closely. "
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Part 3: Real-world Statistics"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 70,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "205\n"
     ]
    }
   ],
   "source": [
    "path_to_data = './covid_19_data.csv'\n",
    "import pandas as pd\n",
    "\n",
    "df = pd.read_csv(path_to_data, delimiter = \",\")\n",
    "\n",
    "# unique entities in Country/region that had at least 1 confirmed case\n",
    "df2 = df[df['Confirmed'] > 0]\n",
    "num_unique = df2['Country/Region'].nunique()\n",
    "print(num_unique) # 205\n",
    "\n",
    "\n",
    "\n"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "A) 205 unique entities"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 197,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/html": [
       "<div>\n",
       "<style scoped>\n",
       "    .dataframe tbody tr th:only-of-type {\n",
       "        vertical-align: middle;\n",
       "    }\n",
       "\n",
       "    .dataframe tbody tr th {\n",
       "        vertical-align: top;\n",
       "    }\n",
       "\n",
       "    .dataframe thead th {\n",
       "        text-align: right;\n",
       "    }\n",
       "</style>\n",
       "<table border=\"1\" class=\"dataframe\">\n",
       "  <thead>\n",
       "    <tr style=\"text-align: right;\">\n",
       "      <th></th>\n",
       "      <th>SNo</th>\n",
       "      <th>ObservationDate</th>\n",
       "      <th>Province/State</th>\n",
       "      <th>Country/Region</th>\n",
       "      <th>Last Update</th>\n",
       "      <th>Confirmed</th>\n",
       "      <th>Deaths</th>\n",
       "      <th>Recovered</th>\n",
       "    </tr>\n",
       "  </thead>\n",
       "  <tbody>\n",
       "    <tr>\n",
       "      <th>8420</th>\n",
       "      <td>8421</td>\n",
       "      <td>03/24/2020</td>\n",
       "      <td>Hubei</td>\n",
       "      <td>Mainland China</td>\n",
       "      <td>2020-03-24 23:41:50</td>\n",
       "      <td>67801.0</td>\n",
       "      <td>3160.0</td>\n",
       "      <td>60324.0</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>8123</th>\n",
       "      <td>8124</td>\n",
       "      <td>03/23/2020</td>\n",
       "      <td>Hubei</td>\n",
       "      <td>Mainland China</td>\n",
       "      <td>2020-03-23 23:23:20</td>\n",
       "      <td>67800.0</td>\n",
       "      <td>3153.0</td>\n",
       "      <td>59882.0</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>7826</th>\n",
       "      <td>7827</td>\n",
       "      <td>03/22/2020</td>\n",
       "      <td>Hubei</td>\n",
       "      <td>Mainland China</td>\n",
       "      <td>3/8/20 5:31</td>\n",
       "      <td>67800.0</td>\n",
       "      <td>3144.0</td>\n",
       "      <td>59433.0</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>7313</th>\n",
       "      <td>7314</td>\n",
       "      <td>03/21/2020</td>\n",
       "      <td>Hubei</td>\n",
       "      <td>Mainland China</td>\n",
       "      <td>2020-03-21T10:13:08</td>\n",
       "      <td>67800.0</td>\n",
       "      <td>3139.0</td>\n",
       "      <td>58946.0</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>7014</th>\n",
       "      <td>7015</td>\n",
       "      <td>03/20/2020</td>\n",
       "      <td>Hubei</td>\n",
       "      <td>Mainland China</td>\n",
       "      <td>2020-03-20T07:43:02</td>\n",
       "      <td>67800.0</td>\n",
       "      <td>3133.0</td>\n",
       "      <td>58382.0</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>...</th>\n",
       "      <td>...</td>\n",
       "      <td>...</td>\n",
       "      <td>...</td>\n",
       "      <td>...</td>\n",
       "      <td>...</td>\n",
       "      <td>...</td>\n",
       "      <td>...</td>\n",
       "      <td>...</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>785</th>\n",
       "      <td>786</td>\n",
       "      <td>02/05/2020</td>\n",
       "      <td>Liaoning</td>\n",
       "      <td>Mainland China</td>\n",
       "      <td>2020-02-05T15:23:02</td>\n",
       "      <td>89.0</td>\n",
       "      <td>0.0</td>\n",
       "      <td>4.0</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>783</th>\n",
       "      <td>784</td>\n",
       "      <td>02/05/2020</td>\n",
       "      <td>Yunnan</td>\n",
       "      <td>Mainland China</td>\n",
       "      <td>2020-02-05T23:33:02</td>\n",
       "      <td>128.0</td>\n",
       "      <td>0.0</td>\n",
       "      <td>5.0</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>781</th>\n",
       "      <td>782</td>\n",
       "      <td>02/05/2020</td>\n",
       "      <td>Guangxi</td>\n",
       "      <td>Mainland China</td>\n",
       "      <td>2020-02-05T12:03:08</td>\n",
       "      <td>150.0</td>\n",
       "      <td>0.0</td>\n",
       "      <td>13.0</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>780</th>\n",
       "      <td>781</td>\n",
       "      <td>02/05/2020</td>\n",
       "      <td>Shaanxi</td>\n",
       "      <td>Mainland China</td>\n",
       "      <td>2020-02-05T08:43:01</td>\n",
       "      <td>165.0</td>\n",
       "      <td>0.0</td>\n",
       "      <td>6.0</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>0</th>\n",
       "      <td>1</td>\n",
       "      <td>01/22/2020</td>\n",
       "      <td>Anhui</td>\n",
       "      <td>Mainland China</td>\n",
       "      <td>1/22/2020 17:00</td>\n",
       "      <td>1.0</td>\n",
       "      <td>0.0</td>\n",
       "      <td>0.0</td>\n",
       "    </tr>\n",
       "  </tbody>\n",
       "</table>\n",
       "<p>1951 rows × 8 columns</p>\n",
       "</div>"
      ],
      "text/plain": [
       "       SNo ObservationDate Province/State  Country/Region  \\\n",
       "8420  8421      03/24/2020          Hubei  Mainland China   \n",
       "8123  8124      03/23/2020          Hubei  Mainland China   \n",
       "7826  7827      03/22/2020          Hubei  Mainland China   \n",
       "7313  7314      03/21/2020          Hubei  Mainland China   \n",
       "7014  7015      03/20/2020          Hubei  Mainland China   \n",
       "...    ...             ...            ...             ...   \n",
       "785    786      02/05/2020       Liaoning  Mainland China   \n",
       "783    784      02/05/2020         Yunnan  Mainland China   \n",
       "781    782      02/05/2020        Guangxi  Mainland China   \n",
       "780    781      02/05/2020        Shaanxi  Mainland China   \n",
       "0        1      01/22/2020          Anhui  Mainland China   \n",
       "\n",
       "              Last Update  Confirmed  Deaths  Recovered  \n",
       "8420  2020-03-24 23:41:50    67801.0  3160.0    60324.0  \n",
       "8123  2020-03-23 23:23:20    67800.0  3153.0    59882.0  \n",
       "7826          3/8/20 5:31    67800.0  3144.0    59433.0  \n",
       "7313  2020-03-21T10:13:08    67800.0  3139.0    58946.0  \n",
       "7014  2020-03-20T07:43:02    67800.0  3133.0    58382.0  \n",
       "...                   ...        ...     ...        ...  \n",
       "785   2020-02-05T15:23:02       89.0     0.0        4.0  \n",
       "783   2020-02-05T23:33:02      128.0     0.0        5.0  \n",
       "781   2020-02-05T12:03:08      150.0     0.0       13.0  \n",
       "780   2020-02-05T08:43:01      165.0     0.0        6.0  \n",
       "0         1/22/2020 17:00        1.0     0.0        0.0  \n",
       "\n",
       "[1951 rows x 8 columns]"
      ]
     },
     "execution_count": 197,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "\n",
    "df_china = df[df['Country/Region'] == 'Mainland China']\n",
    "df_china.tail()\n",
    "\n",
    "df_china.sort_values(by = 'Deaths', ascending = False)\n",
    "# B) Hubei had the most deaths \n",
    "\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 231,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/html": [
       "<div>\n",
       "<style scoped>\n",
       "    .dataframe tbody tr th:only-of-type {\n",
       "        vertical-align: middle;\n",
       "    }\n",
       "\n",
       "    .dataframe tbody tr th {\n",
       "        vertical-align: top;\n",
       "    }\n",
       "\n",
       "    .dataframe thead th {\n",
       "        text-align: right;\n",
       "    }\n",
       "</style>\n",
       "<table border=\"1\" class=\"dataframe\">\n",
       "  <thead>\n",
       "    <tr style=\"text-align: right;\">\n",
       "      <th></th>\n",
       "      <th>SNo</th>\n",
       "      <th>Confirmed</th>\n",
       "      <th>Deaths</th>\n",
       "      <th>Recovered</th>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>Country/Region</th>\n",
       "      <th></th>\n",
       "      <th></th>\n",
       "      <th></th>\n",
       "      <th></th>\n",
       "    </tr>\n",
       "  </thead>\n",
       "  <tbody>\n",
       "    <tr>\n",
       "      <th>Mainland China</th>\n",
       "      <td>5381504</td>\n",
       "      <td>3606533.0</td>\n",
       "      <td>122579.0</td>\n",
       "      <td>1858275.0</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>Italy</th>\n",
       "      <td>170672</td>\n",
       "      <td>571924.0</td>\n",
       "      <td>46856.0</td>\n",
       "      <td>59688.0</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>Iran</th>\n",
       "      <td>149766</td>\n",
       "      <td>278992.0</td>\n",
       "      <td>16870.0</td>\n",
       "      <td>88991.0</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>Spain</th>\n",
       "      <td>171139</td>\n",
       "      <td>232288.0</td>\n",
       "      <td>12448.0</td>\n",
       "      <td>18492.0</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>US</th>\n",
       "      <td>8061334</td>\n",
       "      <td>223838.0</td>\n",
       "      <td>3127.0</td>\n",
       "      <td>1136.0</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>Germany</th>\n",
       "      <td>171851</td>\n",
       "      <td>198142.0</td>\n",
       "      <td>675.0</td>\n",
       "      <td>5258.0</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>South Korea</th>\n",
       "      <td>172461</td>\n",
       "      <td>190800.0</td>\n",
       "      <td>1670.0</td>\n",
       "      <td>21645.0</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>France</th>\n",
       "      <td>774939</td>\n",
       "      <td>144802.0</td>\n",
       "      <td>4825.0</td>\n",
       "      <td>8050.0</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>Switzerland</th>\n",
       "      <td>138339</td>\n",
       "      <td>58069.0</td>\n",
       "      <td>635.0</td>\n",
       "      <td>504.0</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>UK</th>\n",
       "      <td>559167</td>\n",
       "      <td>44503.0</td>\n",
       "      <td>1859.0</td>\n",
       "      <td>1048.0</td>\n",
       "    </tr>\n",
       "  </tbody>\n",
       "</table>\n",
       "</div>"
      ],
      "text/plain": [
       "                    SNo  Confirmed    Deaths  Recovered\n",
       "Country/Region                                         \n",
       "Mainland China  5381504  3606533.0  122579.0  1858275.0\n",
       "Italy            170672   571924.0   46856.0    59688.0\n",
       "Iran             149766   278992.0   16870.0    88991.0\n",
       "Spain            171139   232288.0   12448.0    18492.0\n",
       "US              8061334   223838.0    3127.0     1136.0\n",
       "Germany          171851   198142.0     675.0     5258.0\n",
       "South Korea      172461   190800.0    1670.0    21645.0\n",
       "France           774939   144802.0    4825.0     8050.0\n",
       "Switzerland      138339    58069.0     635.0      504.0\n",
       "UK               559167    44503.0    1859.0     1048.0"
      ]
     },
     "execution_count": 231,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "top10 = df.groupby('Country/Region').sum().sort_values(by = 'Confirmed', ascending = False)[0:10]\n"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "B) Hubei had the most deaths\n",
    "\n",
    "C) The top 10 countries are: Mainland China, Italy, Iran, Spain, US, Germany, South Korea, France, Switzerland, UK"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 284,
   "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 / mpl.ratio, fig.canvas.height / mpl.ratio);\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",
       "        // select the cell after this one\n",
       "        var index = IPython.notebook.find_cell_index(this.cell_info[0]);\n",
       "        IPython.notebook.select(index + 1);\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=\"640\">"
      ],
      "text/plain": [
       "<IPython.core.display.HTML object>"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    },
    {
     "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 / mpl.ratio, fig.canvas.height / mpl.ratio);\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",
       "        // select the cell after this one\n",
       "        var index = IPython.notebook.find_cell_index(this.cell_info[0]);\n",
       "        IPython.notebook.select(index + 1);\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=\"640\">"
      ],
      "text/plain": [
       "<IPython.core.display.HTML object>"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    },
    {
     "data": {
      "text/plain": [
       "<matplotlib.axes._subplots.AxesSubplot at 0x236e28385f8>"
      ]
     },
     "execution_count": 284,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "# Make the bar plots\n",
    "top10.plot.bar(y='Confirmed')\n",
    "top10.plot.bar(y='Deaths')"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 155,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/html": [
       "<div>\n",
       "<style scoped>\n",
       "    .dataframe tbody tr th:only-of-type {\n",
       "        vertical-align: middle;\n",
       "    }\n",
       "\n",
       "    .dataframe tbody tr th {\n",
       "        vertical-align: top;\n",
       "    }\n",
       "\n",
       "    .dataframe thead th {\n",
       "        text-align: right;\n",
       "    }\n",
       "</style>\n",
       "<table border=\"1\" class=\"dataframe\">\n",
       "  <thead>\n",
       "    <tr style=\"text-align: right;\">\n",
       "      <th></th>\n",
       "      <th>SNo</th>\n",
       "      <th>Confirmed</th>\n",
       "      <th>Deaths</th>\n",
       "      <th>Recovered</th>\n",
       "      <th>ratio</th>\n",
       "      <th>Death:Confirmed</th>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>Country/Region</th>\n",
       "      <th></th>\n",
       "      <th></th>\n",
       "      <th></th>\n",
       "      <th></th>\n",
       "      <th></th>\n",
       "      <th></th>\n",
       "    </tr>\n",
       "  </thead>\n",
       "  <tbody>\n",
       "    <tr>\n",
       "      <th>Italy</th>\n",
       "      <td>170672</td>\n",
       "      <td>571924.0</td>\n",
       "      <td>46856.0</td>\n",
       "      <td>59688.0</td>\n",
       "      <td>0.081927</td>\n",
       "      <td>0.081927</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>Iran</th>\n",
       "      <td>149766</td>\n",
       "      <td>278992.0</td>\n",
       "      <td>16870.0</td>\n",
       "      <td>88991.0</td>\n",
       "      <td>0.060468</td>\n",
       "      <td>0.060468</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>Spain</th>\n",
       "      <td>171139</td>\n",
       "      <td>232288.0</td>\n",
       "      <td>12448.0</td>\n",
       "      <td>18492.0</td>\n",
       "      <td>0.053589</td>\n",
       "      <td>0.053589</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>UK</th>\n",
       "      <td>559167</td>\n",
       "      <td>44503.0</td>\n",
       "      <td>1859.0</td>\n",
       "      <td>1048.0</td>\n",
       "      <td>0.041772</td>\n",
       "      <td>0.041772</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>Mainland China</th>\n",
       "      <td>5381504</td>\n",
       "      <td>3606533.0</td>\n",
       "      <td>122579.0</td>\n",
       "      <td>1858275.0</td>\n",
       "      <td>0.033988</td>\n",
       "      <td>0.033988</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>France</th>\n",
       "      <td>774939</td>\n",
       "      <td>144802.0</td>\n",
       "      <td>4825.0</td>\n",
       "      <td>8050.0</td>\n",
       "      <td>0.033321</td>\n",
       "      <td>0.033321</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>US</th>\n",
       "      <td>8061334</td>\n",
       "      <td>223838.0</td>\n",
       "      <td>3127.0</td>\n",
       "      <td>1136.0</td>\n",
       "      <td>0.013970</td>\n",
       "      <td>0.013970</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>Switzerland</th>\n",
       "      <td>138339</td>\n",
       "      <td>58069.0</td>\n",
       "      <td>635.0</td>\n",
       "      <td>504.0</td>\n",
       "      <td>0.010935</td>\n",
       "      <td>0.010935</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>South Korea</th>\n",
       "      <td>172461</td>\n",
       "      <td>190800.0</td>\n",
       "      <td>1670.0</td>\n",
       "      <td>21645.0</td>\n",
       "      <td>0.008753</td>\n",
       "      <td>0.008753</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>Germany</th>\n",
       "      <td>171851</td>\n",
       "      <td>198142.0</td>\n",
       "      <td>675.0</td>\n",
       "      <td>5258.0</td>\n",
       "      <td>0.003407</td>\n",
       "      <td>0.003407</td>\n",
       "    </tr>\n",
       "  </tbody>\n",
       "</table>\n",
       "</div>"
      ],
      "text/plain": [
       "                    SNo  Confirmed    Deaths  Recovered     ratio  \\\n",
       "Country/Region                                                      \n",
       "Italy            170672   571924.0   46856.0    59688.0  0.081927   \n",
       "Iran             149766   278992.0   16870.0    88991.0  0.060468   \n",
       "Spain            171139   232288.0   12448.0    18492.0  0.053589   \n",
       "UK               559167    44503.0    1859.0     1048.0  0.041772   \n",
       "Mainland China  5381504  3606533.0  122579.0  1858275.0  0.033988   \n",
       "France           774939   144802.0    4825.0     8050.0  0.033321   \n",
       "US              8061334   223838.0    3127.0     1136.0  0.013970   \n",
       "Switzerland      138339    58069.0     635.0      504.0  0.010935   \n",
       "South Korea      172461   190800.0    1670.0    21645.0  0.008753   \n",
       "Germany          171851   198142.0     675.0     5258.0  0.003407   \n",
       "\n",
       "                Death:Confirmed  \n",
       "Country/Region                   \n",
       "Italy                  0.081927  \n",
       "Iran                   0.060468  \n",
       "Spain                  0.053589  \n",
       "UK                     0.041772  \n",
       "Mainland China         0.033988  \n",
       "France                 0.033321  \n",
       "US                     0.013970  \n",
       "Switzerland            0.010935  \n",
       "South Korea            0.008753  \n",
       "Germany                0.003407  "
      ]
     },
     "execution_count": 155,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "top10['Death:Confirmed'] = top10['Deaths'] / top10['Confirmed']\n",
    "top10.sort_values(by = 'Death:Confirmed', ascending = False)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "D) Italy has the highest cumulative Death to Confirmed cases ratio "
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 195,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "107.0\n"
     ]
    }
   ],
   "source": [
    "wash = df[df['Province/State'] == 'Washington']\n",
    "latest = wash.loc[wash['ObservationDate'] == '03/24/2020']\n",
    "day_before = wash.loc[wash['ObservationDate'] == '03/23/2020']\n",
    "new_cases = latest.iloc[0,5] - day_before.iloc[0,5]\n",
    "print(new_cases)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "E) New cases in Washington on March 24th 2020: 107\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 230,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "[148. 269. 204. 224. 107.]\n",
      "Mean new cases:  190.4\n",
      "Std deviation of new cases:  57.00035087611303\n"
     ]
    }
   ],
   "source": [
    "new_cases = []\n",
    "wash.iloc[20:25]\n",
    "\n",
    "for i in range(20,25): # start at 20\n",
    "    new_cases.append(wash.iloc[i, 5] - wash.iloc[i-1, 5])\n",
    "\n",
    "new_cases = np.asarray(new_cases)\n",
    "print(new_cases)\n",
    "print('Mean new cases: ', np.mean(new_cases))\n",
    "print('Std deviation of new cases: ', np.std(new_cases))\n"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "F) Mean new cases: 190.4. Std deviation of new cases: 57. "
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 228,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/html": [
       "<div>\n",
       "<style scoped>\n",
       "    .dataframe tbody tr th:only-of-type {\n",
       "        vertical-align: middle;\n",
       "    }\n",
       "\n",
       "    .dataframe tbody tr th {\n",
       "        vertical-align: top;\n",
       "    }\n",
       "\n",
       "    .dataframe thead th {\n",
       "        text-align: right;\n",
       "    }\n",
       "</style>\n",
       "<table border=\"1\" class=\"dataframe\">\n",
       "  <thead>\n",
       "    <tr style=\"text-align: right;\">\n",
       "      <th></th>\n",
       "      <th>SNo</th>\n",
       "      <th>ObservationDate</th>\n",
       "      <th>Province/State</th>\n",
       "      <th>Country/Region</th>\n",
       "      <th>Last Update</th>\n",
       "      <th>Confirmed</th>\n",
       "      <th>Deaths</th>\n",
       "      <th>Recovered</th>\n",
       "    </tr>\n",
       "  </thead>\n",
       "  <tbody>\n",
       "    <tr>\n",
       "      <th>7029</th>\n",
       "      <td>7030</td>\n",
       "      <td>03/20/2020</td>\n",
       "      <td>Washington</td>\n",
       "      <td>US</td>\n",
       "      <td>2020-03-20T23:43:03</td>\n",
       "      <td>1524.0</td>\n",
       "      <td>83.0</td>\n",
       "      <td>0.0</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>7327</th>\n",
       "      <td>7328</td>\n",
       "      <td>03/21/2020</td>\n",
       "      <td>Washington</td>\n",
       "      <td>US</td>\n",
       "      <td>2020-03-21T22:43:04</td>\n",
       "      <td>1793.0</td>\n",
       "      <td>94.0</td>\n",
       "      <td>0.0</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>7906</th>\n",
       "      <td>7907</td>\n",
       "      <td>03/22/2020</td>\n",
       "      <td>Washington</td>\n",
       "      <td>US</td>\n",
       "      <td>3/8/20 5:31</td>\n",
       "      <td>1997.0</td>\n",
       "      <td>97.0</td>\n",
       "      <td>0.0</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>8201</th>\n",
       "      <td>8202</td>\n",
       "      <td>03/23/2020</td>\n",
       "      <td>Washington</td>\n",
       "      <td>US</td>\n",
       "      <td>2020-03-23 23:23:20</td>\n",
       "      <td>2221.0</td>\n",
       "      <td>109.0</td>\n",
       "      <td>0.0</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>8500</th>\n",
       "      <td>8501</td>\n",
       "      <td>03/24/2020</td>\n",
       "      <td>Washington</td>\n",
       "      <td>US</td>\n",
       "      <td>2020-03-24 23:41:50</td>\n",
       "      <td>2328.0</td>\n",
       "      <td>116.0</td>\n",
       "      <td>0.0</td>\n",
       "    </tr>\n",
       "  </tbody>\n",
       "</table>\n",
       "</div>"
      ],
      "text/plain": [
       "       SNo ObservationDate Province/State Country/Region          Last Update  \\\n",
       "7029  7030      03/20/2020     Washington             US  2020-03-20T23:43:03   \n",
       "7327  7328      03/21/2020     Washington             US  2020-03-21T22:43:04   \n",
       "7906  7907      03/22/2020     Washington             US          3/8/20 5:31   \n",
       "8201  8202      03/23/2020     Washington             US  2020-03-23 23:23:20   \n",
       "8500  8501      03/24/2020     Washington             US  2020-03-24 23:41:50   \n",
       "\n",
       "      Confirmed  Deaths  Recovered  \n",
       "7029     1524.0    83.0        0.0  \n",
       "7327     1793.0    94.0        0.0  \n",
       "7906     1997.0    97.0        0.0  \n",
       "8201     2221.0   109.0        0.0  \n",
       "8500     2328.0   116.0        0.0  "
      ]
     },
     "execution_count": 228,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": []
  },
  {
   "cell_type": "code",
   "execution_count": 225,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "1.0"
      ]
     },
     "execution_count": 225,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": []
  }
 ],
 "metadata": {
  "kernelspec": {
   "display_name": "Python 3",
   "language": "python",
   "name": "python3"
  },
  "language_info": {
   "codemirror_mode": {
    "name": "ipython",
    "version": 3
   },
   "file_extension": ".py",
   "mimetype": "text/x-python",
   "name": "python",
   "nbconvert_exporter": "python",
   "pygments_lexer": "ipython3",
   "version": "3.7.1"
  }
 },
 "nbformat": 4,
 "nbformat_minor": 4
}