nsq.ipynb

{
 "cells": [
  {
   "cell_type": "code",
   "execution_count": 17,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "application/javascript": [
       "/* Put everything inside the global mpl namespace */\n",
       "window.mpl = {};\n",
       "\n",
       "\n",
       "mpl.get_websocket_type = function() {\n",
       "    if (typeof(WebSocket) !== 'undefined') {\n",
       "        return WebSocket;\n",
       "    } else if (typeof(MozWebSocket) !== 'undefined') {\n",
       "        return MozWebSocket;\n",
       "    } else {\n",
       "        alert('Your browser does not have WebSocket support.' +\n",
       "              'Please try Chrome, Safari or Firefox ≥ 6. ' +\n",
       "              'Firefox 4 and 5 are also supported but you ' +\n",
       "              'have to enable WebSockets in about:config.');\n",
       "    };\n",
       "}\n",
       "\n",
       "mpl.figure = function(figure_id, websocket, ondownload, parent_element) {\n",
       "    this.id = figure_id;\n",
       "\n",
       "    this.ws = websocket;\n",
       "\n",
       "    this.supports_binary = (this.ws.binaryType != undefined);\n",
       "\n",
       "    if (!this.supports_binary) {\n",
       "        var warnings = document.getElementById(\"mpl-warnings\");\n",
       "        if (warnings) {\n",
       "            warnings.style.display = 'block';\n",
       "            warnings.textContent = (\n",
       "                \"This browser does not support binary websocket messages. \" +\n",
       "                    \"Performance may be slow.\");\n",
       "        }\n",
       "    }\n",
       "\n",
       "    this.imageObj = new Image();\n",
       "\n",
       "    this.context = undefined;\n",
       "    this.message = undefined;\n",
       "    this.canvas = undefined;\n",
       "    this.rubberband_canvas = undefined;\n",
       "    this.rubberband_context = undefined;\n",
       "    this.format_dropdown = undefined;\n",
       "\n",
       "    this.image_mode = 'full';\n",
       "\n",
       "    this.root = $('<div/>');\n",
       "    this._root_extra_style(this.root)\n",
       "    this.root.attr('style', 'display: inline-block');\n",
       "\n",
       "    $(parent_element).append(this.root);\n",
       "\n",
       "    this._init_header(this);\n",
       "    this._init_canvas(this);\n",
       "    this._init_toolbar(this);\n",
       "\n",
       "    var fig = this;\n",
       "\n",
       "    this.waiting = false;\n",
       "\n",
       "    this.ws.onopen =  function () {\n",
       "            fig.send_message(\"supports_binary\", {value: fig.supports_binary});\n",
       "            fig.send_message(\"send_image_mode\", {});\n",
       "            if (mpl.ratio != 1) {\n",
       "                fig.send_message(\"set_dpi_ratio\", {'dpi_ratio': mpl.ratio});\n",
       "            }\n",
       "            fig.send_message(\"refresh\", {});\n",
       "        }\n",
       "\n",
       "    this.imageObj.onload = function() {\n",
       "            if (fig.image_mode == 'full') {\n",
       "                // Full images could contain transparency (where diff images\n",
       "                // almost always do), so we need to clear the canvas so that\n",
       "                // there is no ghosting.\n",
       "                fig.context.clearRect(0, 0, fig.canvas.width, fig.canvas.height);\n",
       "            }\n",
       "            fig.context.drawImage(fig.imageObj, 0, 0);\n",
       "        };\n",
       "\n",
       "    this.imageObj.onunload = function() {\n",
       "        fig.ws.close();\n",
       "    }\n",
       "\n",
       "    this.ws.onmessage = this._make_on_message_function(this);\n",
       "\n",
       "    this.ondownload = ondownload;\n",
       "}\n",
       "\n",
       "mpl.figure.prototype._init_header = function() {\n",
       "    var titlebar = $(\n",
       "        '<div class=\"ui-dialog-titlebar ui-widget-header ui-corner-all ' +\n",
       "        'ui-helper-clearfix\"/>');\n",
       "    var titletext = $(\n",
       "        '<div class=\"ui-dialog-title\" style=\"width: 100%; ' +\n",
       "        'text-align: center; padding: 3px;\"/>');\n",
       "    titlebar.append(titletext)\n",
       "    this.root.append(titlebar);\n",
       "    this.header = titletext[0];\n",
       "}\n",
       "\n",
       "\n",
       "\n",
       "mpl.figure.prototype._canvas_extra_style = function(canvas_div) {\n",
       "\n",
       "}\n",
       "\n",
       "\n",
       "mpl.figure.prototype._root_extra_style = function(canvas_div) {\n",
       "\n",
       "}\n",
       "\n",
       "mpl.figure.prototype._init_canvas = function() {\n",
       "    var fig = this;\n",
       "\n",
       "    var canvas_div = $('<div/>');\n",
       "\n",
       "    canvas_div.attr('style', 'position: relative; clear: both; outline: 0');\n",
       "\n",
       "    function canvas_keyboard_event(event) {\n",
       "        return fig.key_event(event, event['data']);\n",
       "    }\n",
       "\n",
       "    canvas_div.keydown('key_press', canvas_keyboard_event);\n",
       "    canvas_div.keyup('key_release', canvas_keyboard_event);\n",
       "    this.canvas_div = canvas_div\n",
       "    this._canvas_extra_style(canvas_div)\n",
       "    this.root.append(canvas_div);\n",
       "\n",
       "    var canvas = $('<canvas/>');\n",
       "    canvas.addClass('mpl-canvas');\n",
       "    canvas.attr('style', \"left: 0; top: 0; z-index: 0; outline: 0\")\n",
       "\n",
       "    this.canvas = canvas[0];\n",
       "    this.context = canvas[0].getContext(\"2d\");\n",
       "\n",
       "    var backingStore = this.context.backingStorePixelRatio ||\n",
       "\tthis.context.webkitBackingStorePixelRatio ||\n",
       "\tthis.context.mozBackingStorePixelRatio ||\n",
       "\tthis.context.msBackingStorePixelRatio ||\n",
       "\tthis.context.oBackingStorePixelRatio ||\n",
       "\tthis.context.backingStorePixelRatio || 1;\n",
       "\n",
       "    mpl.ratio = (window.devicePixelRatio || 1) / backingStore;\n",
       "\n",
       "    var rubberband = $('<canvas/>');\n",
       "    rubberband.attr('style', \"position: absolute; left: 0; top: 0; z-index: 1;\")\n",
       "\n",
       "    var pass_mouse_events = true;\n",
       "\n",
       "    canvas_div.resizable({\n",
       "        start: function(event, ui) {\n",
       "            pass_mouse_events = false;\n",
       "        },\n",
       "        resize: function(event, ui) {\n",
       "            fig.request_resize(ui.size.width, ui.size.height);\n",
       "        },\n",
       "        stop: function(event, ui) {\n",
       "            pass_mouse_events = true;\n",
       "            fig.request_resize(ui.size.width, ui.size.height);\n",
       "        },\n",
       "    });\n",
       "\n",
       "    function mouse_event_fn(event) {\n",
       "        if (pass_mouse_events)\n",
       "            return fig.mouse_event(event, event['data']);\n",
       "    }\n",
       "\n",
       "    rubberband.mousedown('button_press', mouse_event_fn);\n",
       "    rubberband.mouseup('button_release', mouse_event_fn);\n",
       "    // Throttle sequential mouse events to 1 every 20ms.\n",
       "    rubberband.mousemove('motion_notify', mouse_event_fn);\n",
       "\n",
       "    rubberband.mouseenter('figure_enter', mouse_event_fn);\n",
       "    rubberband.mouseleave('figure_leave', mouse_event_fn);\n",
       "\n",
       "    canvas_div.on(\"wheel\", function (event) {\n",
       "        event = event.originalEvent;\n",
       "        event['data'] = 'scroll'\n",
       "        if (event.deltaY < 0) {\n",
       "            event.step = 1;\n",
       "        } else {\n",
       "            event.step = -1;\n",
       "        }\n",
       "        mouse_event_fn(event);\n",
       "    });\n",
       "\n",
       "    canvas_div.append(canvas);\n",
       "    canvas_div.append(rubberband);\n",
       "\n",
       "    this.rubberband = rubberband;\n",
       "    this.rubberband_canvas = rubberband[0];\n",
       "    this.rubberband_context = rubberband[0].getContext(\"2d\");\n",
       "    this.rubberband_context.strokeStyle = \"#000000\";\n",
       "\n",
       "    this._resize_canvas = function(width, height) {\n",
       "        // Keep the size of the canvas, canvas container, and rubber band\n",
       "        // canvas in synch.\n",
       "        canvas_div.css('width', width)\n",
       "        canvas_div.css('height', height)\n",
       "\n",
       "        canvas.attr('width', width * mpl.ratio);\n",
       "        canvas.attr('height', height * mpl.ratio);\n",
       "        canvas.attr('style', 'width: ' + width + 'px; height: ' + height + 'px;');\n",
       "\n",
       "        rubberband.attr('width', width);\n",
       "        rubberband.attr('height', height);\n",
       "    }\n",
       "\n",
       "    // Set the figure to an initial 600x600px, this will subsequently be updated\n",
       "    // upon first draw.\n",
       "    this._resize_canvas(600, 600);\n",
       "\n",
       "    // Disable right mouse context menu.\n",
       "    $(this.rubberband_canvas).bind(\"contextmenu\",function(e){\n",
       "        return false;\n",
       "    });\n",
       "\n",
       "    function set_focus () {\n",
       "        canvas.focus();\n",
       "        canvas_div.focus();\n",
       "    }\n",
       "\n",
       "    window.setTimeout(set_focus, 100);\n",
       "}\n",
       "\n",
       "mpl.figure.prototype._init_toolbar = function() {\n",
       "    var fig = this;\n",
       "\n",
       "    var nav_element = $('<div/>')\n",
       "    nav_element.attr('style', 'width: 100%');\n",
       "    this.root.append(nav_element);\n",
       "\n",
       "    // Define a callback function for later on.\n",
       "    function toolbar_event(event) {\n",
       "        return fig.toolbar_button_onclick(event['data']);\n",
       "    }\n",
       "    function toolbar_mouse_event(event) {\n",
       "        return fig.toolbar_button_onmouseover(event['data']);\n",
       "    }\n",
       "\n",
       "    for(var toolbar_ind in mpl.toolbar_items) {\n",
       "        var name = mpl.toolbar_items[toolbar_ind][0];\n",
       "        var tooltip = mpl.toolbar_items[toolbar_ind][1];\n",
       "        var image = mpl.toolbar_items[toolbar_ind][2];\n",
       "        var method_name = mpl.toolbar_items[toolbar_ind][3];\n",
       "\n",
       "        if (!name) {\n",
       "            // put a spacer in here.\n",
       "            continue;\n",
       "        }\n",
       "        var button = $('<button/>');\n",
       "        button.addClass('ui-button ui-widget ui-state-default ui-corner-all ' +\n",
       "                        'ui-button-icon-only');\n",
       "        button.attr('role', 'button');\n",
       "        button.attr('aria-disabled', 'false');\n",
       "        button.click(method_name, toolbar_event);\n",
       "        button.mouseover(tooltip, toolbar_mouse_event);\n",
       "\n",
       "        var icon_img = $('<span/>');\n",
       "        icon_img.addClass('ui-button-icon-primary ui-icon');\n",
       "        icon_img.addClass(image);\n",
       "        icon_img.addClass('ui-corner-all');\n",
       "\n",
       "        var tooltip_span = $('<span/>');\n",
       "        tooltip_span.addClass('ui-button-text');\n",
       "        tooltip_span.html(tooltip);\n",
       "\n",
       "        button.append(icon_img);\n",
       "        button.append(tooltip_span);\n",
       "\n",
       "        nav_element.append(button);\n",
       "    }\n",
       "\n",
       "    var fmt_picker_span = $('<span/>');\n",
       "\n",
       "    var fmt_picker = $('<select/>');\n",
       "    fmt_picker.addClass('mpl-toolbar-option ui-widget ui-widget-content');\n",
       "    fmt_picker_span.append(fmt_picker);\n",
       "    nav_element.append(fmt_picker_span);\n",
       "    this.format_dropdown = fmt_picker[0];\n",
       "\n",
       "    for (var ind in mpl.extensions) {\n",
       "        var fmt = mpl.extensions[ind];\n",
       "        var option = $(\n",
       "            '<option/>', {selected: fmt === mpl.default_extension}).html(fmt);\n",
       "        fmt_picker.append(option)\n",
       "    }\n",
       "\n",
       "    // Add hover states to the ui-buttons\n",
       "    $( \".ui-button\" ).hover(\n",
       "        function() { $(this).addClass(\"ui-state-hover\");},\n",
       "        function() { $(this).removeClass(\"ui-state-hover\");}\n",
       "    );\n",
       "\n",
       "    var status_bar = $('<span class=\"mpl-message\"/>');\n",
       "    nav_element.append(status_bar);\n",
       "    this.message = status_bar[0];\n",
       "}\n",
       "\n",
       "mpl.figure.prototype.request_resize = function(x_pixels, y_pixels) {\n",
       "    // Request matplotlib to resize the figure. Matplotlib will then trigger a resize in the client,\n",
       "    // which will in turn request a refresh of the image.\n",
       "    this.send_message('resize', {'width': x_pixels, 'height': y_pixels});\n",
       "}\n",
       "\n",
       "mpl.figure.prototype.send_message = function(type, properties) {\n",
       "    properties['type'] = type;\n",
       "    properties['figure_id'] = this.id;\n",
       "    this.ws.send(JSON.stringify(properties));\n",
       "}\n",
       "\n",
       "mpl.figure.prototype.send_draw_message = function() {\n",
       "    if (!this.waiting) {\n",
       "        this.waiting = true;\n",
       "        this.ws.send(JSON.stringify({type: \"draw\", figure_id: this.id}));\n",
       "    }\n",
       "}\n",
       "\n",
       "\n",
       "mpl.figure.prototype.handle_save = function(fig, msg) {\n",
       "    var format_dropdown = fig.format_dropdown;\n",
       "    var format = format_dropdown.options[format_dropdown.selectedIndex].value;\n",
       "    fig.ondownload(fig, format);\n",
       "}\n",
       "\n",
       "\n",
       "mpl.figure.prototype.handle_resize = function(fig, msg) {\n",
       "    var size = msg['size'];\n",
       "    if (size[0] != fig.canvas.width || size[1] != fig.canvas.height) {\n",
       "        fig._resize_canvas(size[0], size[1]);\n",
       "        fig.send_message(\"refresh\", {});\n",
       "    };\n",
       "}\n",
       "\n",
       "mpl.figure.prototype.handle_rubberband = function(fig, msg) {\n",
       "    var x0 = msg['x0'] / mpl.ratio;\n",
       "    var y0 = (fig.canvas.height - msg['y0']) / mpl.ratio;\n",
       "    var x1 = msg['x1'] / mpl.ratio;\n",
       "    var y1 = (fig.canvas.height - msg['y1']) / mpl.ratio;\n",
       "    x0 = Math.floor(x0) + 0.5;\n",
       "    y0 = Math.floor(y0) + 0.5;\n",
       "    x1 = Math.floor(x1) + 0.5;\n",
       "    y1 = Math.floor(y1) + 0.5;\n",
       "    var min_x = Math.min(x0, x1);\n",
       "    var min_y = Math.min(y0, y1);\n",
       "    var width = Math.abs(x1 - x0);\n",
       "    var height = Math.abs(y1 - y0);\n",
       "\n",
       "    fig.rubberband_context.clearRect(\n",
       "        0, 0, fig.canvas.width, fig.canvas.height);\n",
       "\n",
       "    fig.rubberband_context.strokeRect(min_x, min_y, width, height);\n",
       "}\n",
       "\n",
       "mpl.figure.prototype.handle_figure_label = function(fig, msg) {\n",
       "    // Updates the figure title.\n",
       "    fig.header.textContent = msg['label'];\n",
       "}\n",
       "\n",
       "mpl.figure.prototype.handle_cursor = function(fig, msg) {\n",
       "    var cursor = msg['cursor'];\n",
       "    switch(cursor)\n",
       "    {\n",
       "    case 0:\n",
       "        cursor = 'pointer';\n",
       "        break;\n",
       "    case 1:\n",
       "        cursor = 'default';\n",
       "        break;\n",
       "    case 2:\n",
       "        cursor = 'crosshair';\n",
       "        break;\n",
       "    case 3:\n",
       "        cursor = 'move';\n",
       "        break;\n",
       "    }\n",
       "    fig.rubberband_canvas.style.cursor = cursor;\n",
       "}\n",
       "\n",
       "mpl.figure.prototype.handle_message = function(fig, msg) {\n",
       "    fig.message.textContent = msg['message'];\n",
       "}\n",
       "\n",
       "mpl.figure.prototype.handle_draw = function(fig, msg) {\n",
       "    // Request the server to send over a new figure.\n",
       "    fig.send_draw_message();\n",
       "}\n",
       "\n",
       "mpl.figure.prototype.handle_image_mode = function(fig, msg) {\n",
       "    fig.image_mode = msg['mode'];\n",
       "}\n",
       "\n",
       "mpl.figure.prototype.updated_canvas_event = function() {\n",
       "    // Called whenever the canvas gets updated.\n",
       "    this.send_message(\"ack\", {});\n",
       "}\n",
       "\n",
       "// A function to construct a web socket function for onmessage handling.\n",
       "// Called in the figure constructor.\n",
       "mpl.figure.prototype._make_on_message_function = function(fig) {\n",
       "    return function socket_on_message(evt) {\n",
       "        if (evt.data instanceof Blob) {\n",
       "            /* FIXME: We get \"Resource interpreted as Image but\n",
       "             * transferred with MIME type text/plain:\" errors on\n",
       "             * Chrome.  But how to set the MIME type?  It doesn't seem\n",
       "             * to be part of the websocket stream */\n",
       "            evt.data.type = \"image/png\";\n",
       "\n",
       "            /* Free the memory for the previous frames */\n",
       "            if (fig.imageObj.src) {\n",
       "                (window.URL || window.webkitURL).revokeObjectURL(\n",
       "                    fig.imageObj.src);\n",
       "            }\n",
       "\n",
       "            fig.imageObj.src = (window.URL || window.webkitURL).createObjectURL(\n",
       "                evt.data);\n",
       "            fig.updated_canvas_event();\n",
       "            fig.waiting = false;\n",
       "            return;\n",
       "        }\n",
       "        else if (typeof evt.data === 'string' && evt.data.slice(0, 21) == \"data:image/png;base64\") {\n",
       "            fig.imageObj.src = evt.data;\n",
       "            fig.updated_canvas_event();\n",
       "            fig.waiting = false;\n",
       "            return;\n",
       "        }\n",
       "\n",
       "        var msg = JSON.parse(evt.data);\n",
       "        var msg_type = msg['type'];\n",
       "\n",
       "        // Call the  \"handle_{type}\" callback, which takes\n",
       "        // the figure and JSON message as its only arguments.\n",
       "        try {\n",
       "            var callback = fig[\"handle_\" + msg_type];\n",
       "        } catch (e) {\n",
       "            console.log(\"No handler for the '\" + msg_type + \"' message type: \", msg);\n",
       "            return;\n",
       "        }\n",
       "\n",
       "        if (callback) {\n",
       "            try {\n",
       "                // console.log(\"Handling '\" + msg_type + \"' message: \", msg);\n",
       "                callback(fig, msg);\n",
       "            } catch (e) {\n",
       "                console.log(\"Exception inside the 'handler_\" + msg_type + \"' callback:\", e, e.stack, msg);\n",
       "            }\n",
       "        }\n",
       "    };\n",
       "}\n",
       "\n",
       "// from http://stackoverflow.com/questions/1114465/getting-mouse-location-in-canvas\n",
       "mpl.findpos = function(e) {\n",
       "    //this section is from http://www.quirksmode.org/js/events_properties.html\n",
       "    var targ;\n",
       "    if (!e)\n",
       "        e = window.event;\n",
       "    if (e.target)\n",
       "        targ = e.target;\n",
       "    else if (e.srcElement)\n",
       "        targ = e.srcElement;\n",
       "    if (targ.nodeType == 3) // defeat Safari bug\n",
       "        targ = targ.parentNode;\n",
       "\n",
       "    // jQuery normalizes the pageX and pageY\n",
       "    // pageX,Y are the mouse positions relative to the document\n",
       "    // offset() returns the position of the element relative to the document\n",
       "    var x = e.pageX - $(targ).offset().left;\n",
       "    var y = e.pageY - $(targ).offset().top;\n",
       "\n",
       "    return {\"x\": x, \"y\": y};\n",
       "};\n",
       "\n",
       "/*\n",
       " * return a copy of an object with only non-object keys\n",
       " * we need this to avoid circular references\n",
       " * http://stackoverflow.com/a/24161582/3208463\n",
       " */\n",
       "function simpleKeys (original) {\n",
       "  return Object.keys(original).reduce(function (obj, key) {\n",
       "    if (typeof original[key] !== 'object')\n",
       "        obj[key] = original[key]\n",
       "    return obj;\n",
       "  }, {});\n",
       "}\n",
       "\n",
       "mpl.figure.prototype.mouse_event = function(event, name) {\n",
       "    var canvas_pos = mpl.findpos(event)\n",
       "\n",
       "    if (name === 'button_press')\n",
       "    {\n",
       "        this.canvas.focus();\n",
       "        this.canvas_div.focus();\n",
       "    }\n",
       "\n",
       "    var x = canvas_pos.x * mpl.ratio;\n",
       "    var y = canvas_pos.y * mpl.ratio;\n",
       "\n",
       "    this.send_message(name, {x: x, y: y, button: event.button,\n",
       "                             step: event.step,\n",
       "                             guiEvent: simpleKeys(event)});\n",
       "\n",
       "    /* This prevents the web browser from automatically changing to\n",
       "     * the text insertion cursor when the button is pressed.  We want\n",
       "     * to control all of the cursor setting manually through the\n",
       "     * 'cursor' event from matplotlib */\n",
       "    event.preventDefault();\n",
       "    return false;\n",
       "}\n",
       "\n",
       "mpl.figure.prototype._key_event_extra = function(event, name) {\n",
       "    // Handle any extra behaviour associated with a key event\n",
       "}\n",
       "\n",
       "mpl.figure.prototype.key_event = function(event, name) {\n",
       "\n",
       "    // Prevent repeat events\n",
       "    if (name == 'key_press')\n",
       "    {\n",
       "        if (event.which === this._key)\n",
       "            return;\n",
       "        else\n",
       "            this._key = event.which;\n",
       "    }\n",
       "    if (name == 'key_release')\n",
       "        this._key = null;\n",
       "\n",
       "    var value = '';\n",
       "    if (event.ctrlKey && event.which != 17)\n",
       "        value += \"ctrl+\";\n",
       "    if (event.altKey && event.which != 18)\n",
       "        value += \"alt+\";\n",
       "    if (event.shiftKey && event.which != 16)\n",
       "        value += \"shift+\";\n",
       "\n",
       "    value += 'k';\n",
       "    value += event.which.toString();\n",
       "\n",
       "    this._key_event_extra(event, name);\n",
       "\n",
       "    this.send_message(name, {key: value,\n",
       "                             guiEvent: simpleKeys(event)});\n",
       "    return false;\n",
       "}\n",
       "\n",
       "mpl.figure.prototype.toolbar_button_onclick = function(name) {\n",
       "    if (name == 'download') {\n",
       "        this.handle_save(this, null);\n",
       "    } else {\n",
       "        this.send_message(\"toolbar_button\", {name: name});\n",
       "    }\n",
       "};\n",
       "\n",
       "mpl.figure.prototype.toolbar_button_onmouseover = function(tooltip) {\n",
       "    this.message.textContent = tooltip;\n",
       "};\n",
       "mpl.toolbar_items = [[\"Home\", \"Reset original view\", \"fa fa-home icon-home\", \"home\"], [\"Back\", \"Back to  previous view\", \"fa fa-arrow-left icon-arrow-left\", \"back\"], [\"Forward\", \"Forward to next view\", \"fa fa-arrow-right icon-arrow-right\", \"forward\"], [\"\", \"\", \"\", \"\"], [\"Pan\", \"Pan axes with left mouse, zoom with right\", \"fa fa-arrows icon-move\", \"pan\"], [\"Zoom\", \"Zoom to rectangle\", \"fa fa-square-o icon-check-empty\", \"zoom\"], [\"\", \"\", \"\", \"\"], [\"Download\", \"Download plot\", \"fa fa-floppy-o icon-save\", \"download\"]];\n",
       "\n",
       "mpl.extensions = [\"eps\", \"jpeg\", \"pdf\", \"png\", \"ps\", \"raw\", \"svg\", \"tif\"];\n",
       "\n",
       "mpl.default_extension = \"png\";var comm_websocket_adapter = function(comm) {\n",
       "    // Create a \"websocket\"-like object which calls the given IPython comm\n",
       "    // object with the appropriate methods. Currently this is a non binary\n",
       "    // socket, so there is still some room for performance tuning.\n",
       "    var ws = {};\n",
       "\n",
       "    ws.close = function() {\n",
       "        comm.close()\n",
       "    };\n",
       "    ws.send = function(m) {\n",
       "        //console.log('sending', m);\n",
       "        comm.send(m);\n",
       "    };\n",
       "    // Register the callback with on_msg.\n",
       "    comm.on_msg(function(msg) {\n",
       "        //console.log('receiving', msg['content']['data'], msg);\n",
       "        // Pass the mpl event to the overridden (by mpl) onmessage function.\n",
       "        ws.onmessage(msg['content']['data'])\n",
       "    });\n",
       "    return ws;\n",
       "}\n",
       "\n",
       "mpl.mpl_figure_comm = function(comm, msg) {\n",
       "    // This is the function which gets called when the mpl process\n",
       "    // starts-up an IPython Comm through the \"matplotlib\" channel.\n",
       "\n",
       "    var id = msg.content.data.id;\n",
       "    // Get hold of the div created by the display call when the Comm\n",
       "    // socket was opened in Python.\n",
       "    var element = $(\"#\" + id);\n",
       "    var ws_proxy = comm_websocket_adapter(comm)\n",
       "\n",
       "    function ondownload(figure, format) {\n",
       "        window.open(figure.imageObj.src);\n",
       "    }\n",
       "\n",
       "    var fig = new mpl.figure(id, ws_proxy,\n",
       "                           ondownload,\n",
       "                           element.get(0));\n",
       "\n",
       "    // Call onopen now - mpl needs it, as it is assuming we've passed it a real\n",
       "    // web socket which is closed, not our websocket->open comm proxy.\n",
       "    ws_proxy.onopen();\n",
       "\n",
       "    fig.parent_element = element.get(0);\n",
       "    fig.cell_info = mpl.find_output_cell(\"<div id='\" + id + \"'></div>\");\n",
       "    if (!fig.cell_info) {\n",
       "        console.error(\"Failed to find cell for figure\", id, fig);\n",
       "        return;\n",
       "    }\n",
       "\n",
       "    var output_index = fig.cell_info[2]\n",
       "    var cell = fig.cell_info[0];\n",
       "\n",
       "};\n",
       "\n",
       "mpl.figure.prototype.handle_close = function(fig, msg) {\n",
       "    var width = fig.canvas.width/mpl.ratio\n",
       "    fig.root.unbind('remove')\n",
       "\n",
       "    // Update the output cell to use the data from the current canvas.\n",
       "    fig.push_to_output();\n",
       "    var dataURL = fig.canvas.toDataURL();\n",
       "    // Re-enable the keyboard manager in IPython - without this line, in FF,\n",
       "    // the notebook keyboard shortcuts fail.\n",
       "    IPython.keyboard_manager.enable()\n",
       "    $(fig.parent_element).html('<img src=\"' + dataURL + '\" width=\"' + width + '\">');\n",
       "    fig.close_ws(fig, msg);\n",
       "}\n",
       "\n",
       "mpl.figure.prototype.close_ws = function(fig, msg){\n",
       "    fig.send_message('closing', msg);\n",
       "    // fig.ws.close()\n",
       "}\n",
       "\n",
       "mpl.figure.prototype.push_to_output = function(remove_interactive) {\n",
       "    // Turn the data on the canvas into data in the output cell.\n",
       "    var width = this.canvas.width/mpl.ratio\n",
       "    var dataURL = this.canvas.toDataURL();\n",
       "    this.cell_info[1]['text/html'] = '<img src=\"' + dataURL + '\" width=\"' + width + '\">';\n",
       "}\n",
       "\n",
       "mpl.figure.prototype.updated_canvas_event = function() {\n",
       "    // Tell IPython that the notebook contents must change.\n",
       "    IPython.notebook.set_dirty(true);\n",
       "    this.send_message(\"ack\", {});\n",
       "    var fig = this;\n",
       "    // Wait a second, then push the new image to the DOM so\n",
       "    // that it is saved nicely (might be nice to debounce this).\n",
       "    setTimeout(function () { fig.push_to_output() }, 1000);\n",
       "}\n",
       "\n",
       "mpl.figure.prototype._init_toolbar = function() {\n",
       "    var fig = this;\n",
       "\n",
       "    var nav_element = $('<div/>')\n",
       "    nav_element.attr('style', 'width: 100%');\n",
       "    this.root.append(nav_element);\n",
       "\n",
       "    // Define a callback function for later on.\n",
       "    function toolbar_event(event) {\n",
       "        return fig.toolbar_button_onclick(event['data']);\n",
       "    }\n",
       "    function toolbar_mouse_event(event) {\n",
       "        return fig.toolbar_button_onmouseover(event['data']);\n",
       "    }\n",
       "\n",
       "    for(var toolbar_ind in mpl.toolbar_items){\n",
       "        var name = mpl.toolbar_items[toolbar_ind][0];\n",
       "        var tooltip = mpl.toolbar_items[toolbar_ind][1];\n",
       "        var image = mpl.toolbar_items[toolbar_ind][2];\n",
       "        var method_name = mpl.toolbar_items[toolbar_ind][3];\n",
       "\n",
       "        if (!name) { continue; };\n",
       "\n",
       "        var button = $('<button class=\"btn btn-default\" href=\"#\" title=\"' + name + '\"><i class=\"fa ' + image + ' fa-lg\"></i></button>');\n",
       "        button.click(method_name, toolbar_event);\n",
       "        button.mouseover(tooltip, toolbar_mouse_event);\n",
       "        nav_element.append(button);\n",
       "    }\n",
       "\n",
       "    // Add the status bar.\n",
       "    var status_bar = $('<span class=\"mpl-message\" style=\"text-align:right; float: right;\"/>');\n",
       "    nav_element.append(status_bar);\n",
       "    this.message = status_bar[0];\n",
       "\n",
       "    // Add the close button to the window.\n",
       "    var buttongrp = $('<div class=\"btn-group inline pull-right\"></div>');\n",
       "    var button = $('<button class=\"btn btn-mini btn-primary\" href=\"#\" title=\"Stop Interaction\"><i class=\"fa fa-power-off icon-remove icon-large\"></i></button>');\n",
       "    button.click(function (evt) { fig.handle_close(fig, {}); } );\n",
       "    button.mouseover('Stop Interaction', toolbar_mouse_event);\n",
       "    buttongrp.append(button);\n",
       "    var titlebar = this.root.find($('.ui-dialog-titlebar'));\n",
       "    titlebar.prepend(buttongrp);\n",
       "}\n",
       "\n",
       "mpl.figure.prototype._root_extra_style = function(el){\n",
       "    var fig = this\n",
       "    el.on(\"remove\", function(){\n",
       "\tfig.close_ws(fig, {});\n",
       "    });\n",
       "}\n",
       "\n",
       "mpl.figure.prototype._canvas_extra_style = function(el){\n",
       "    // this is important to make the div 'focusable\n",
       "    el.attr('tabindex', 0)\n",
       "    // reach out to IPython and tell the keyboard manager to turn it's self\n",
       "    // off when our div gets focus\n",
       "\n",
       "    // location in version 3\n",
       "    if (IPython.notebook.keyboard_manager) {\n",
       "        IPython.notebook.keyboard_manager.register_events(el);\n",
       "    }\n",
       "    else {\n",
       "        // location in version 2\n",
       "        IPython.keyboard_manager.register_events(el);\n",
       "    }\n",
       "\n",
       "}\n",
       "\n",
       "mpl.figure.prototype._key_event_extra = function(event, name) {\n",
       "    var manager = IPython.notebook.keyboard_manager;\n",
       "    if (!manager)\n",
       "        manager = IPython.keyboard_manager;\n",
       "\n",
       "    // Check for shift+enter\n",
       "    if (event.shiftKey && event.which == 13) {\n",
       "        this.canvas_div.blur();\n",
       "        event.shiftKey = false;\n",
       "        // Send a \"J\" for go to next cell\n",
       "        event.which = 74;\n",
       "        event.keyCode = 74;\n",
       "        manager.command_mode();\n",
       "        manager.handle_keydown(event);\n",
       "    }\n",
       "}\n",
       "\n",
       "mpl.figure.prototype.handle_save = function(fig, msg) {\n",
       "    fig.ondownload(fig, null);\n",
       "}\n",
       "\n",
       "\n",
       "mpl.find_output_cell = function(html_output) {\n",
       "    // Return the cell and output element which can be found *uniquely* in the notebook.\n",
       "    // Note - this is a bit hacky, but it is done because the \"notebook_saving.Notebook\"\n",
       "    // IPython event is triggered only after the cells have been serialised, which for\n",
       "    // our purposes (turning an active figure into a static one), is too late.\n",
       "    var cells = IPython.notebook.get_cells();\n",
       "    var ncells = cells.length;\n",
       "    for (var i=0; i<ncells; i++) {\n",
       "        var cell = cells[i];\n",
       "        if (cell.cell_type === 'code'){\n",
       "            for (var j=0; j<cell.output_area.outputs.length; j++) {\n",
       "                var data = cell.output_area.outputs[j];\n",
       "                if (data.data) {\n",
       "                    // IPython >= 3 moved mimebundle to data attribute of output\n",
       "                    data = data.data;\n",
       "                }\n",
       "                if (data['text/html'] == html_output) {\n",
       "                    return [cell, data, j];\n",
       "                }\n",
       "            }\n",
       "        }\n",
       "    }\n",
       "}\n",
       "\n",
       "// Register the function which deals with the matplotlib target/channel.\n",
       "// The kernel may be null if the page has been refreshed.\n",
       "if (IPython.notebook.kernel != null) {\n",
       "    IPython.notebook.kernel.comm_manager.register_target('matplotlib', mpl.mpl_figure_comm);\n",
       "}\n"
      ],
      "text/plain": [
       "<IPython.core.display.Javascript object>"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    },
    {
     "data": {
      "text/html": [
       "<img src=\"data:image/png;base64,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\" width=\"640\">"
      ],
      "text/plain": [
       "<IPython.core.display.HTML object>"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    }
   ],
   "source": [
    "%matplotlib notebook\n",
    "\n",
    "import numpy as np\n",
    "import matplotlib.pyplot as plt\n",
    "\n",
    "c = 200\n",
    "\n",
    "def getnsq(l):\n",
    "    lst = []\n",
    "    for x in range(1, l+1):\n",
    "        if l % x == 0:\n",
    "            lst.append(x)\n",
    "    \n",
    "    ln = len(lst)\n",
    "    mp = -(-ln // 2)\n",
    "    m = ()\n",
    "    if ln % 2 == 1:\n",
    "        m = (lst[mp - 1], lst[mp - 1])\n",
    "        return m\n",
    "    else:\n",
    "        m = (lst[mp - 1], lst[mp])\n",
    "        return m\n",
    "\n",
    "px = np.asarray([])\n",
    "py = np.asarray([])\n",
    "\n",
    "for sx in range(1, c+1):\n",
    "    for sy in range(1,c+1):\n",
    "        ax,ay = getnsq(sx*sy)\n",
    "        \n",
    "        if (ax,ay) == (sx,sy):\n",
    "            px = np.append(px, [ax])\n",
    "            py = np.append(py, [ay])\n",
    "\n",
    "jx = np.concatenate((px, py))\n",
    "jy = np.concatenate((py, px))\n",
    "\n",
    "plt.scatter(jx, jy, s=0.1)\n",
    "plt.show()"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": []
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": []
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": []
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": []
  }
 ],
 "metadata": {
  "kernelspec": {
   "display_name": "Python 2",
   "language": "python",
   "name": "python2"
  },
  "language_info": {
   "codemirror_mode": {
    "name": "ipython",
    "version": 2
   },
   "file_extension": ".py",
   "mimetype": "text/x-python",
   "name": "python",
   "nbconvert_exporter": "python",
   "pygments_lexer": "ipython2",
   "version": "2.7.15"
  }
 },
 "nbformat": 4,
 "nbformat_minor": 2
}