diff options
Diffstat (limited to 'python')
| -rw-r--r-- | python/exploration/marketing.py | 36 | ||||
| -rw-r--r-- | python/notebooks/Marketing Strategy.ipynb | 3686 |
2 files changed, 3722 insertions, 0 deletions
diff --git a/python/exploration/marketing.py b/python/exploration/marketing.py new file mode 100644 index 00000000..d14d75b6 --- /dev/null +++ b/python/exploration/marketing.py @@ -0,0 +1,36 @@ +from analytics.tranche_functions import BCloss_recov_dist, GHquad +import numpy as np +import pandas as pd +import matplotlib as plt + +gridsize = 500 + +def run_scenario(pool_size, rho, successprob, issuerweights, amount): + #settings and running + Z, w = GHquad(gridsize) + S, _ = BCloss_recov_dist(successprob, issuerweights, amount, rho, Z, w, Ngrid=gridsize+1, defaultflag=False) + raised = np.arange(0, pool_size+pool_size/gridsize, step=pool_size/gridsize) + df = pd.DataFrame(S.flatten(), columns=['Probability'], index=raised) + return df + +def plot_scenarios(df, pool_size): + ''' takes run_scenario df ''' + bins = [0,0.01,50,100,150,200,250,300,350,400,450,500,pool_size] + df1 = df.groupby(pd.cut(df.index,bins,right=False)).sum() + ax = df1.plot(kind='bar') + plt.pyplot.tight_layout() + return ax + +def prob_over(df, amount): + return df[amount:].sum() + +def plot_prob_over(df): + ax = (1-df.cumsum()).plot() + ax.set_title('Probability of raising X amount of AUM') + ax.set_xlabel('Amount Raised') + ax.set_ylabel('Probability') + return ax + +def add_to_plot(df, ax): + ax.plot(1-df.cumsum()) + return ax diff --git a/python/notebooks/Marketing Strategy.ipynb b/python/notebooks/Marketing Strategy.ipynb new file mode 100644 index 00000000..509d939c --- /dev/null +++ b/python/notebooks/Marketing Strategy.ipynb @@ -0,0 +1,3686 @@ +{ + "cells": [ + { + "cell_type": "code", + "execution_count": 111, + "metadata": {}, + "outputs": [], + "source": [ + "import exploration.marketing as mk\n", + "import numpy as np\n", + "import pandas as pd\n", + "import matplotlib as plt" + ] + }, + { + "cell_type": "code", + "execution_count": 112, + "metadata": { + "collapsed": true + }, + "outputs": [], + "source": [ + "#Vary weights:size of investment and success_prob: likelihood of investment" + ] + }, + { + "cell_type": "code", + "execution_count": 113, + "metadata": {}, + "outputs": [], + "source": [ + "##----Now look at the consequence of the different approaches -----##\n", + "#100 prospect of 10mm each, correlation of 30%, likelihood: 10% each- expected capital raised: 100mm\n", + "num_prospect = 100\n", + "pool_size = 1000 #1bn\n", + "rho = .3\n", + "prob = .1\n", + "successprob = np.full((num_prospect, 1), prob)\n", + "issuerweights = np.full(num_prospect, 1/num_prospect)\n", + "amount = np.full(num_prospect, 0.0)" + ] + }, + { + "cell_type": "code", + "execution_count": 114, + "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", + " this.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 overriden (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,iVBORw0KGgoAAAANSUhEUgAAAoAAAAHgCAYAAAA10dzkAAAgAElEQVR4XuydB5RT1dqG3xlg6EWqIL2DgoiABQQBFey9N+zt2q9exYbY27V3xXbt/nYRFJAiKIiNXkS69DL0OvOvL5wzZMKUZHaSySTPXosFZM7eZ5/nfJk8+XY5aaJAAAIQgAAEIAABCKQUgbSUulouFgIQgAAEIAABCEBACCBBAAEIQAACEIAABFKMAAKYYjecy4UABCAAAQhAAAIIIDEAAQhAAAIQgAAEUowAAphiN5zLhQAEIAABCEAAAgggMQABCEAAAhCAAARSjAACmGI3nMuFAAQgAAEIQAACCCAxAAEIQAACEIAABFKMAAKYYjecy4UABCAAAQhAAAIIIDEAAQhAAAIQgAAEUowAAphiN5zLhQAEIAABCEAAAgggMQABCEAAAhCAAARSjAACmGI3nMuFAAQgAAEIQAACCCAxAAEIQAACEIAABFKMAAKYYjecy4UABCAAAQhAAAIIIDEAAQhAAAIQgAAEUowAAphiN5zLhQAEIAABCEAAAgggMQABCEAAAhCAAARSjAACmGI3nMuFAAQgAAEIQAACCCAxAAEIQAACEIAABFKMAAKYYjecy4UABCAAAQhAAAIIIDEAAQhAAAIQgAAEUowAAphiN5zLhQAEIAABCEAAAgggMQABCEAAAhCAAARSjAACmGI3nMuFAAQgAAEIQAACCCAxAAEIQAACEIAABFKMAAKYYjecy4UABCAAAQhAAAIIIDEAAQhAAAIQgAAEUowAAphiN5zLhQAEIAABCEAAAgggMQABCEAAAhCAAARSjAACmGI3nMuFAAQgAAEIQAACCCAxAAEIQAACEIAABFKMAAKYYjecy4UABCAAAQhAAAIIIDEAAQhAAAIQgAAEUowAAphiN5zLhQAEIAABCEAAAgggMQABCEAAAhCAAARSjAACmGI3vARebj9JbwT1e6ekpZK+l3SnpMVRvCb/XJ0lTYxSuwMk3SOplqSVhbQ50vv54UHHZUu6V5K1Y8V+9oOknpL844+R1CXomCh1PaJm7pd0gaR6kjZIqhZR7cgO9u9TE0nzIqhqxxozqx/P0krS75I+l3ROyIn3kjRF0iJJh0qy+E7lYnxqS3oqBhCKEqP/lXSjpG8kHZdHn/z34+mSPsnj589JukZS8GetxWEjSaO893NoNXsfveW9GPw+jwESmkxlAghgKt/9knHt/of9RZJmSCovqbuk2yX9I6mdpI1RupTiFsC23nVMK0AAq0iy4+yYdd5xeX3IRAlJWM2c6MnNA5K+lbQ1igKdVwdMppt5UmXnCrcc4DGbE26FKB53g6QnJZ0m6f+C2n1f0kmSrG8W36levpa0n6TGUQZRlBgt433BtHgzMTdpC/3CWVQBrC6pkqQWkkLj0b6kWDzYex0BjHIg0NxuAggg0ZDoBPKTsoGS7pJ0nqR387kIk8UtkiyLFk4pbgHMq4+hGcC8jiluAbxDkmVX6khaHg7okGMqSNpUhHolqYr9rrUP9jae4Bgnyxp9JOlmSZZpokixEsCixKjJ+sde9u9YSdbGgyE3qagCaF/g7Mvr2167frP2xWa2pNckXYYA8paIJQEEMJZ0aTsaBPKTMhv2tGEZ/5eyf1wfSWdJOl5STS9jaBLYzRtKtaHSUpL+kGQZK2vDL34bR3lDdZY1KCtphKTrJf0ddOyRkv4l6UDvPDaEN9zrT/BQrz8E3NET1iM8If3KG1paEdRmUYaA35R0YR6gbXj0dUn7eNIRLMH2vrcPmZmS7IMtv5Iu6d+SLpZk7WVKGiKpvzdkafX84azgNoKHrEPbtv7aB+shkp7w/rYhUPt/uEzzGgK2jMl93lB4VUmrvAzhFSF9DR4C9j+8bdjRsk6WZbaszARv2M74+MWYWdbZ2jPRtT7b/y3+rAQP2+fHs6mkSZK+k3S114aJgNXNKuTNYlko42rHNvSE2fpg0wvGBNW1zNlcSbdKsvt3ldff8ZIu935mnGyYsaIX23ZNweIezn33731eQ+qhcRwuZ6vXIw8OBX1OhdPXSGPU74Jls3tJqi/pVy+z3TLkC2VRBdDu3Z/ee9fup3//7XeSfam9RdKHCGA0PkJoIz8CCCCxkegE8hPA6yQ97X2overN67K5gjZEY1L3mfcBZ/OuTP5szqB9+D7q/SK3D2ATjrO9X7TGwT/XQu94+/bfwMtu2VBje0lrPWBXevPcpnpiZB+8N0kq532z3+4d5wvgfC/bM0zSvp6szJJ0kCT/2KIIoGUMHg6SKv9+2pwzk+EvvOu08/rFl2eTv8EFBMDLHl/LMFpmxq7R5MGE2oTWRNfEy+Y4XSKpr8fCZNj+5FVMAE247D5Z+yZbpT0pCpdpqACayBhfEx+7v8sk7e19eD4jabrXkdA5gP6Ht70+VtJ73rDbI16MWLbOn5NnmR8TvlckferFhWWgbZjQ7mM4AmjdMCF7wRv2sz7un8cQYF7cbB6hfQmxeWM2B9ZE9WRPWnsHzQf1BdB4WLwbY5uPabJtAm8iaPFmsW1Dmo97c0pPCDppOPe9KAJYGGeb2mB8Labt2vzyc5xj1E5n0mcMbbj+DC/ubc6x3We7B35xEUC7n/ZFzN6HJpv2xdTOaV/cJnv3iCHgRP+EKsH9QwBL8M1Lka77H/YHe9/CTbAsS2CyZ/+2OTT2ge8fZ0MqoRmxnyRZ9sU+WGyBghU/C2gfjvYN3DJkfhsmj6cE8bXJ+SYI9gFg39BDi72PrD1bAGG/wC1z+KV3kC+ANv/LBNEvJkE2dB08hF0UAbT28hsCtuyIfcDYh4nNM/OLSZ9lMoxdfsPjrT1xMlkxwfOLZVBNIkyI/OxXJAtd/IylZRWDF/dEwjRUAC0La4t27BpNePMr+Qmg8QjOhPpDs5aVNPmwhRpLvHmOll32i8WkxVZ+k/nz6ofFimX9jK9lV03MilIs3qwty8jaXFA/Xn0BtOySSbqfWTLZsIUVFpcWn36xuLT5iZY1tXYiue/5LarJLwNYGGfrUyRDwJH0NZIYtX6Y3Ns0E/tSM9TLgNtcvf952VOfn4sA2qISY2WjABZz9sXMrt9+V3VCAIvytqBOJAQQwEhocWxxEAhdBez3waTGsikmZlb844Lly1637NB6SS+GiIz9zIbJLNtjmR6bgO+3ETpR3461D7u/JNkQrhVbqWgfECYOJn4mW365zWvX/u9/8NgvdBtG8otlvTZ7q/0u9V6MtgBas7aC8THvQ2WBJ8EmhSYfBc078zNVJny/hNx4fwGKCVDwNYaz0tkXQF84gpsOl2moAFpblv2zYUyTnNGeZIXGa34CaJlHy3r5xbJtFg8mezYMd7SXKT3Vy/4Ft2vnNekPNwPot2ViZkPB9v9wi/XThnEtU2ZTE/xifbUYtuIL4EPeUL1/jE1rMJGx4V7LsvnF2rNrt/loNiwZyX2PVAAL42x9ikQAI+lrJAJon4sme/YeNZ6+RNtUEMvY1w1agOUqgDYUbyMY9jvE7ot9IbWMrj//kAxguO8OjouYAAIYMTIqxJmA/2FvvyhtKG+Hl/GzjExw8Y8LFRYbyrEhXftGbwsVgotl397xhohNJP02bMjYF0v/eMsE2YeuDXma7P3m/dK2IVGTUVuJbK/bccFz4PwPHutH6ApCG8qzDJI/3BULATQ5suHYZz0hMOkzCbC5gf5wdl631LKddm02BB46nGvDyTZ8aBlEK5F8uJoAWrbDxDy4RMI0rzmAJjCWkTTR8TN29sFq99wfYs9PAEO38PAlyuYEWn9D4yS433a/bUg8HAG0D3ebMmBxYB/21j+TfxvyK6xY9tiyhS95kmTD7zY8bffI5M9fNev33eaQ2fCuX/ITldApFpHc90gFsDDO1tdIBDCSvkYSoyZgFuP2XjG+frEvBPZFMlhk7XeFzcH0vyyE3ke7XzY9wqYK+MW4mWxbBtAWQNnvMnt/2hdSux82FQEBLOwdwc+dCSCAzghpIMYEwl2Zm99xJho2tGW/iIOHMq3bfgbQhpJswn+4GUCbC2hDbHa8v1+XtdfcG3LNSwCLKwNo/bIhYpvHZNdpmQ3br8xWGBZUCsuu2HwyGyK1EsmHq78IxOawBZdImBa0D6D9TrO27Bgb2rR5ezZH0kpRBbCgDKC1aX/CEUD7smEf7DY0a19mbK6qCYTNCc1vzqTPyL5wGHPLCAWXH735atESwEjuu2Ueba6pzaMNLiY3Jqg+k/zkM1S0rY1IBDCSvkYSoyZgodcUfH2WEbcvmlbsS5DNAc1vJbct9rIvjfYF0C/BAmivWQbWvgjY7ynLLtoXCgQwJKj4b/QJIIDRZ0qL0SXgKoDWm3HeHB6bW2PDrlYs42QrgS1bFO4cQD+LaNkmm2BvHxIfBF2uDbXa0GpeApjfHMDzvXlF1kxRM4CWGbIMkWUT/OsLvgs2388+rK19E4gOnsAWdKf8YVBbRGHzx/xim2Tbwg2bC2kZGCuRfLjmJ4CRMC1IAIOvaY23mMfk10pRBdD2bLM9J21+4ZlBJ4hkDqC/D11wZs6ysCZLlkUsbCjYpg/YXDGbk+YXE10TMMtwR0sAI7nvNv/QMsQmsH6xWLMsp2XQiyKAtujCpNhWWhdWIulruDFqvw/sXhtvP76D+2Gidm7QkLkfV5bFs7nCwXNqbUqETRGwL1wWs34JFUB7P1r/bC6p/Z6wggAWdvf5uTMBBNAZIQ3EmEA0BNAWjdgqYMui2LDYNm8bDhsuzG8VsM3P8lcBm+zYMKJ94K72hnMsg2NzhCzDZK/ZtjO2qtg+APMSQH8VsPXDXwVs2TjLJFh/rBRVAH1Gdl5bTWhDgyaofrvWtk3AN8mwjNFhYd4zy0xYptBWW1u7/ipgWxFtWQ3basVKuB+udmx+AmhDZOEyDRVAG0qzVd224tu26rHfa7Yowp8zZ0Ot/gd1XtvAhDM06a8CNia2SMgyOrYFi8WAybVtF5Jfse2ITPTsfhv74C1f/GspbCjY7q19AbEhSRMFk5+7vakH/lw1O7/rELC1Ee59NxGyRRE2LGriZtMCLKtuGxgHr4yOJAPox5LdT5MwY1XQU3nC7Wu4MWpbO9lwrIm+7dEYWvwvKjbX1ObXWjFZs2MttizWbGqHZQZtLrAN+9uXpuDNnkMFMK+4QQDD/CXFYUUngAAWnR0140MgGgJoPfX3AbRJ3Jb9syFcEzsbcvKLfy4TQ8vMmdTZvD979JplwWwRiF9s3pWJkWWBbF6izRmyYSBbaJGXANpKVfsQsgycZQnsvDZEGbz/WlEFMEPS897qTpMNe1+HPibNVkabfOU3Vymvu+nvsWZzmIL3ATTpDR6yDPfD1c6RnwDaz8JlGiqAJkMmYybTNpnexNeG9G0Fc/AQfVEzgNY3Y2r7H5pU2mIVkz77v8WQSWfwqvFQliYHtljIMj22ACe0+EPBthehZfPyKnaP7Vz2haWGt8jFFiHZ/FETrGhlAO3c4d53Y2IZb2Ni3E1yTQDtXlgpSgbQMnA2P9IWW9n8VTtHOPsARitGLaNq12KZzeAvUMH3xObt2nQPy+D6x9i8Qbt2i0Gb3mDZWtsX1H4XBP/esHYQwPh8dnCWQggggIQIBFKDgGVoTFZNFPxFEalx5bG7SpNiE0H7kA99QkTszkrLEIAABKJAAAGMAkSagECCErDspS04sKyEPwfRhq4okROwDZst+2bzSW2yvmUd/eFOy9zZXpQUCEAAAiWGAAJYYm4VHYVAxAT8+WAmLLay0eY3+U+2iLixFK9gQ362ktxE0OZ12YpcG7K3rWeCHxmX4pi4fAhAoKQQQABLyp2inxCAAAQgAAEIQCBKBBDAKIGkGQhAAAIQgAAEIFBSCCCAJeVO0U8IQAACEIAABCAQJQIIYJRA0gwEIAABCEAAAhAoKQQQwJJyp+gnBCAAAQhAAAIQiBIBBNANpPGzTUPXuzVDbQhAAAIQgAAE4kygsvfov+BH+MW5C8V3OgTQjb3tBF/YQ9zdzkBtCEAAAhCAAARiRcAe67g4Vo0ncrsIoNvdsWdeZi5cuFBVqtg/KRCAAAQgAAEIJDqBdevWqUEDe+Jf4JGDtldqyhUE0O2WBwQwMzMTAXTjSG0IQAACEIBA3AiYAFatau6HAMYNepKdCAFMshvK5UAAAhCAQPITQAAlMoBucY4AuvGjNgQgAAEIQCDuBBBABNA16BBAV4LUhwAEIAABCMSZAAKIALqGHALoSpD6EIAABOJMYOfOndq+fXucz8rp4kmgVKlSKl26tNLS8h7oRAARQNd4RABdCVIfAhCAQBwJbNiwQYsWLVJ2dkpu/RZH0sV/qgoVKqhu3brKyMjYozMIIALoGqEIoCtB6kMAAhCIEwHL/M2ePVsmBrVq1co3OxSn7nCaGBEwud+2bZtWrFghu+ctWrRQenp6rrMhgAiga/ghgK4EqQ8BCEAgTgS2bNmiuXPnqnHjxipfvnyczsppiovApk2bNH/+fDVp0kTlypVDAENuBKuA3SITAXTjR20IQAACcSPgC2BeQhC3TnCiuBEo6H6TASQD6BqICKArQepDAAIQiBMBBDBOoBPkNAhgwTeCDKBboCKAbvyoDQEIQCBuBBDA3Khthexnn32mk046qcj3YMCAAfr888/1xx9/5NtGv379tHbt2sBxVg4//HB16NBBTz31VOD/NiR/ww03BP5EsyCACGA04ym0LQQwlnRpGwIQgEAUCZRUATSBeuuttwIkbGsTe4btKaeconvvvVcVK1YsMqF4CaA9LtUWZlSrVi1PAbTFGnYdtjjHSjT6Ze0ggAhgkd8cYVREAMOAxCEQgAAEEoFASRbAZcuW6Y033gjsXzhmzBhdeumluvDCC/Xiiy/mQmuiZStfTRQLK9EQrXAygKH9CM0Ahv48Gv1CAAu7+8wBLJxQwUcEBPDK10erbIVKgSMPa1FLpx5Y37Vd6kMAAhCAQJQJlGQBDB5CNSyXXXaZvv76a73//vvq2bOnhgwZojvuuEOTJk3S0KFDA6+ZHD7++ONauHBhYCXsnXfeqfPPPz+HqonWCy+8oC+//FIjR47U3nvvrUcffVSnn356zjH/+c9/AsPEtnei/fzcc8/V3XffrTJlygSO8QXwqquu0v33369Vq1bp2GOP1auvvpqT8YtkCNiGg23lrl8aNWoU6FvTpk01YcIEderUKednzz77bOD65s2bl+eWPmQAC34DMQfQ7RdMQAAb3PCR0svuSl1nlErX9Pv6qlQ6aN3QUhsCEIBAdAmECoFlyzZv3xndk4TZWvkypcLehzBUoOwU1113nd577z198sknAdlr3759QIZMlGyodfTo0TrzzDMD8+yOOOKIgCzeeuut+v777wPHWzEBrFGjhh5++GF1795d77zzjh566CFNnjxZbdq0CRxjUterVy/Vq1cv8LqJ50033RRoyxdAO+9BBx2kJ554Qra69pJLLlGXLl307rvvBo6JRABtOLh27dqBbGffvn1lT/SwPRuPOuqowH5+zz//fA7hjh076vjjjw8MhedVEEAEMMy3Y5EOCwjgM9/+odLlKumRITMCjUwf2FflM0oVqUEqQQACEIBAbAiECsGmbTvU9u6hsTlZIa1OG9hHFTIKH6bNS6AsE3bMMceod+/essybCZ0tsDjxxBNzztq1a1ftu+++euWVV3JeO+OMM7Rx40Z98803OQJ45ZVX5hpGPvjgg2ViZZnBvMpjjz2mDz/8UBMnTswRQJNEy8LVr79r9MuykZYFXLx4cSBrGIkAWv28hoA/+ugjWV+XLFmismXL6s8//9QBBxygv//+O7CIBAGMPIxJU0XOLLhGzhzAChUrqfkd3wZ+9ufdR6lqhV3pcQoEIAABCCQGgZIsgP/73/8Cmxnv2LEjMA/QZO+ll17StGnTAgJoQ7T77LNPDujq1avrySefDMwT9MvTTz8t+2PS5IuWLS654IILco658cYbAyt6f/jhh8BrlmG0LOJff/0le4yenb9KlSpavnx5jgC+/fbbOW3ai7bow7KQNnTbo0ePqAigPdnDBPOZZ57RWWedpeuvv15TpkzR8OHD8w0uMoAFv+8QQLffS7kWgTS9/RtlZUsT+vdW7Sq5dx13Ow21IQABCEDAlUBJHgK2bJrN6bO5dzYc68/BM8kyAVyzZk3OnDvjZAJo4hYsd/Z/mzc3Z86cAgXQsmsjRozQzz//rG7dugWGWPv06aOqVavqgw8+CAz12pxEKzYHMFQA/U2WR40aFRhajkYG0M518803B6Tvq6++CsiuXY/NScyvIIAIoOvvjILq5xLA1nd9qy3bszTm1p5qUH3XnEAKBCAAAQgkBoFkWgTiE81PAPMbArbHo9l8QCs21GpDyMHDvYccckhgaNVeM9Gzv31htDq2+tiygsECaEPACxYsCIipFVuEYkPURR0CzsjICCxuOfXUU3MFzvTp07XffvsF+mXiacPBBT3SDwFEAGP5myeXALYfMFTrtuzQ8Jt7qFmtXauCKRCAAAQgkBgEUkkAbU6gzfmzIVObK2hZM1u4MWzYsMBGzL4A1qxZU4888kgg02eLNkzmbLFH27Zt9cUXX+i0004LLA7p3LlzYO6gZQNtm5lgAbRFICaO9rdl/0wSbR6hSZyVSDOALVu2DCxcsdXGNt9vr732ygkgE1ubf3jxxRfvsQVOaJQhgAhgLH/z5BLAzg8M04r1W/Xt9YepTV37EQUCEIAABBKFQCoJoDEPZxsYW1Vrsmirhm3Bhq0Itjl2fjFpHDRokLZu3RpY2GGLRCz7FiyAVv+KK64IyOPq1asD2b/XXnstR9wiFUCTVVtpbAtLbKjX/vaL9cVWGdtCGJPSggoCiADG8ndPLgHs+vAILV67WV9c01X7N9i14zkFAhCAAAQSg0BJFcDEoJcYvXjggQcC8xAtS1lYQQARwMJixOXnuQSw1+Mj9ffKjfroikPUpUl1l3apCwEIQAACUSaAAEYZaBybsxXINgfQ9v277777AvsRFlYQQASwsBhx+XkuAez71GjNWLpe/7vkIHVrUdOlXepCAAIQgECUCSCAUQYax+ZsGNnmFJ500kmBDbBtg+jCCgKIABYWIy4/zyWAJzz3oyYtytSgfp3Uq3Udl3apCwEIQAACUSaAAEYZaII3hwAigLEM0VwCePpL4/TLvDV66byO6rtf3Viel7YhAAEIQCBCAghghMBK+OEIIAIYyxDOJYDnvvazxv61Sk+f1UEndti9I3ssO0DbEIAABCAQHgEEMDxOyXIUAogAxjKWcwngRW9M0A8zV+jR09rrjE4NYnle2oYABCAAgQgJ+EJgz44taAPhCJvl8AQlsHnz5sAWMk2aNAk8Ri+4+E8rkVRV0roEvYSYdotHwbnhzSWAV7wzUUOnLtP9J+2n8w5u5NYytSEAAQhAIKoE7Bm69kxbe2KFPdaMktwEVq1aFXhmsW0sHbpoBAGUEEC3+M8lgNe+/7u++vMf3X1cW13crYlby9SGAAQgAIGoEsjOzg48ssxE0CQwPT09qu3TWGIQsPtsj7wz+atWrZrq1t1zTj4CiAC6RmsuAfz3x3/qk18X6T99W+uqw5u5tk19CEAAAhCIMoFt27Zp7ty5ysrKinLLNJdoBEz+7Okm9szj0IIAIoCu8ZpLAPt/NlnvjV+gG49oqeuPaOHaNvUhAAEIQCAGBEz+TAQpyUugTJkyBe4ViAAigK7Rn0sAB3w5VW+Om6drejbTLX1au7ZNfQhAAAIQgAAEYkAAAUQAXcMqlwA+NHi6Xh79ty47rInuOLata9vUhwAEIAABCEAgBgQQQATQNaxyCeAT383UsyP+0gWHNNLAE/dzbZv6EIAABCAAAQjEgAACiAC6hlUuAXxuxGw9/t0sndW5gR4+tb1r29SHAAQgAAEIQCAGBBBABNA1rHIJ4Cuj5+jBwTN0ygH76L9ndnBtm/oQgAAEIAABCMSAAAKIALqGVS4BfHPsXA34apqObV9Xz5/T0bVt6kMAAhCAAAQgEAMCCCAC6BpWuQTQtoCxrWCOaFNHr13YybVt6kMAAhCAAAQgEAMCCCAC6BpWuQTw/35dpJs//lPdW9bS2xd3cW2b+hCAAAQgAAEIxIAAAogAuoZVLgG0x8DZ4+AOblpdH1x+iGvb1IcABCAAAQhAIAYEEEAE0DWscgng0KlLdcU7v6pjw2r69Oqurm1THwIQgAAEIACBGBBAABFA17DKJYA/zFyui974RfvtU0VfX3uYa9vUhwAEIAABCEAgBgQQQATQNaxyCeC4v1bqnNfGq0XtSvr+ph6ubVMfAhCAAAQgAIEYEEAAEUDXsMolgL/OX61TX/xJjWpU0Khberq2TX0IQAACEIAABGJAAAFEAF3DKpcATl6UqeOf+1F1q5bTT7f3dm2b+hCAAAQgAAEIxIAAAph8Ani1pFsk1ZU0VdINksYUEDv286skNZS0UtInkm6XtCXMeMslgDOXrlefp0arRsUM/XrXkWE2wWEQgAAEIAABCMSTAAKYXAJ4pqR3JJkEjpV0haRLJbWVtCCPwDpX0uuSLpY0TlJLSW9K+lDSjWEGYi4BnLtyo3o+PlKVypbWlHv7hNkEh0EAAhCAAAQgEE8CCGByCeB4Sb95GT0/jqZL+tzL6oXG1nOS2kgKHqt9QpLt4BzuEt5cArh47WZ1fXiESqWn6ZqezXPOd1iLmurcuHo8Y5tzQQACEIAABCCQDwEEMHkEMEPSJkmnS/os6H4/LamDpLyW5J4l6SVJR0maIKmppG8kvSXp4Xxipqwk++OXypIWZWZmqkqVKsrcvF0HDPxOWdm5a1evmKHfGBLmFxEEIAABCEAgIQgggMkjgPUkLZZkuy/bcK5f+ku6UFKrfCLuWkmW9UuTVFrSi94Qcn4BOkDSPaE/9AXQXv/898X6bcGawCFbtu/URxMXBf4996FjlJZmp6FAAAIQgAAEIFCcBBDA5BPAQyX9FBRUd0g6X1LrPHOtE+4AACAASURBVALtcEkfSLpTkg0f25itZQxflXRfPoFZYAYwtM76LdvVbsB3gZdn3NdX5cqUKs5459wQgAAEIAABCEhCAJNHAIsyBGyrg3/2Vg37b4jzJL0iqZKkrDDeJbnmAIYev21Hllre+W3g5T/vPkpVK5QJo0kOgQAEIAABCEAglgQQwOQRQIsTy+L9GjKEO03SF/ksArFjh0n6T1CQnS1pkCeAO8MIvgIFMDs7W836Dw7MCZzQv7dqVykXRpMcAgEIQAACEIBALAkggMklgP42MFd6w8CXS7pM0r6S5kt625snaPv8WbH5fDdJsuP8IWCbA2hiaG2FUwoUQGugzV1DtHn7To25tacaVK8QTpscAwEIQAACEIBADAkggMklgBYqtgfgrd5G0FO8/fxGezE0UtI8Sf28/9uiD3+O4D6SVkj6ynttbZhxV6gAdhj4ndZu2q7vb+yuFnVs0TAFAhCAAAQgAIHiJIAAJp8AxjueChXAgx8crqXrtujra7tpv32qxrt/nA8CEIAABCAAgRACCCAC6PqmKFQAezz2g+av2qT/u+oQHdiIzaBdgVMfAhCAAAQg4EoAAUQAXWOoUAE86slRmrVsg9699CB1bV7T9XzUhwAEIAABCEDAkQACiAA6hpAKFcATnvtRkxZlalC/TurVuo7r+agPAQhAAAIQgIAjAQQQAXQMocIF8PSXxumXeWv0wrkddUy7uq7noz4EIAABCEAAAo4EEEAE0DGEChfA818frzGzV+rJM/fXyQfUdz0f9SEAAQhAAAIQcCSAACKAjiFUuABe+tYvGjZ9uR4+pZ3O6tLQ9XzUhwAEIAABCEDAkQACiAA6hlDhAnjNu7/pm8lLNOD4turXtYnr+agPAQhAAAIQgIAjAQQQAXQMocIF8KaP/tCnvy3W7Ue31hU9mrmej/oQgAAEIAABCDgSQAARQMcQKlwAb/90st6fsEA3HdlS1/Vu4Xo+6kMAAhCAAAQg4EgAAUQAHUOocAEc8OVUvTlunq4+vJlu7dva9XzUhwAEIAABCEDAkQACiAA6hlDhAvjwtzP00qg5uqRbE911XFvX81EfAhCAAAQgAAFHAgggAugYQoUL4JPfz9LTw2frvIMb6v6T2rmej/oQgAAEIAABCDgSQAARQMcQKlwAXxj5lx4dMlOnHVhfj5++v+v5qA8BCEAAAhCAgCMBBBABdAyhwgVw0I9zNfDraTp+/3p69uwDXM9HfQhAAAIQgAAEHAkggAigYwgVLoDvjp+vOz6boqPa1tErF3RyPR/1IQABCEAAAhBwJIAAIoCOIVS4AH7y6yL9++M/1b1lLb19cRfX81EfAhCAAAQgAAFHAgggAugYQoUL4NeT/tG/3vtdBzWprg+vOMT1fNSHAAQgAAEIQMCRAAKIADqGUOEC+P20Zbrs7Ynq0KCaPr+mq+v5qA8BCEAAAhCAgCMBBBABdAyhwgVw9KwVumDQBLXeu7KG3NDd9XzUhwAEIAABCEDAkQACiAA6hlDhAjhh7mqd8fJPalqzokb8+3DX81EfAhCAAAQgAAFHAgggAugYQoUL4J8L1+rE58dqn2rlNfa2Xq7noz4EIAABCEAAAo4EEEAE0DGEChfAmUvXq89To1W9YobG/me3AJbPKOV6bupDAAIQgAAEIFAEAgggAliEsMlVpYqkzMzMTFWpYv/cs8xbuVGHPz5yjx8c276unj+no+v5qQ8BCEAAAhCAQIQEEEAEMMKQ2ePwQgVw244sHfvMGM1eviFX5YoZpTR1YF/X81MfAhCAAAQgAIEICSCACGCEIRO5AFqNrKxsbdmxM1B5+bqtgYxgqfQ0/fXA0UpLS3PtA/UhAAEIQAACEIiAAAKIAEYQLnkeWmgGMLRW5qbt2n/gd4GXZ91/tDJKp7v2gfoQgAAEIAABCERAAAFEACMIl+gI4NYdO9XqziGBxv685yhVLV/GtQ/UhwAEIAABCEAgAgIIIAIYQbhERwCzs7PVrP9gZWVLE/r3Vu0q5Vz7QH0IQAACEIAABCIggAAigBGES3QE0Fppe/cQbdq2U6NuOVyNalR07QP1IQABCEAAAhCIgAACiABGEC7RE8AD7/teqzZu09AbuqvV3pVd+0B9CEAAAhCAAAQiIIAAIoARhEv0BLDrwyO0eO1mfX5NV3VoUM21D9SHAAQgAAEIQCACAgggAhhBuERPAHs/MVJzVmzUB5cfrIOb1nDtA/UhAAEIQAACEIiAAAKIAEYQLtETwOOeHaMpi9fpjYs6q2er2q59oD4EIAABCEAAAhEQQAARwAjCJXoCeNqL4zRx/hq9eG5HHd2urmsfqA8BCEAAAhCAQAQEEEAEMIJwiZ4Anv/6eI2ZvVJPnrm/Tj6gvmsfqA8BCEAAAhCAQAQEEEAEMIJwiZ4AXvrWRA2bvkwPntxO5xzU0LUP1IcABCAAAQhAIAICCCACGEG4RE8Ar33/d3315z+6+7i2urhbE9c+UB8CEIAABCAAgQgIIIAIYAThEj0BvPWTP/XRxEW6pU8rXdOzuWsfqA8BCEAAAhCAQAQEEEAEMIJwiZ4A3v3FFL3903xd26u5bj6qlWsfqA8BCEAAAhCAQAQEEEAEMIJwiZ4APjR4ul4e/bcuO6yJ7ji2rWsfqA8BCEAAAhCAQAQEEEAEMIJwiZ4APvn9LD09fLbOO7ih7j+pnWsfqA8BCEAAAhCAQAQEEEAEMIJwiZ4Avjhyjh4ZMkOnHVhfj5++v2sfqA8BCEAAAhCAQAQEEEAEMIJwiZ4Avjl2rgZ8NU3Htq+r58/p6NoH6kMAAhCAAAQgEAEBBBABjCBcoieAH0xYoNs+nawj2tTWaxd2du0D9SEAAQhAAAIQiIAAAogARhAu0RPAL/5YrOs/+ENdm9fQu5ce7NoH6kMAAhCAAAQgEAEBBBABjCBcoieAQ6cu1RXv/KqODavp06u7uvaB+hCAAAQgAAEIREAAAUQAIwiX6AngqFkrdOGgCWpbt4oGX3+Yax+oDwEIQAACEIBABAQQQAQwgnCJngBOmLtaZ7z8k5rWrKgR/z7ctQ/UhwAEIAABCEAgAgIIIAIYQbhETwAnL8rU8c/9qEplS+uMTg0CDaelSX323VtdmlR37RP1IQABCEAAAhAogAACiAC6vkGqSMrMzMxUlSr2z/DKojWb1O2RH/Y4uHGNChp5S8/wGuEoCEAAAhCAAASKRAABRACLFDhBlYokgFbfVgLPXLo+0FTm5u16d/wCVS5XWpMH9HHtE/UhAAEIQAACECADWGAMpBEhTgSKLIDBZ12SuVmHPDRCpdPT9NeDxzh1iMoQgAAEIAABCBRMgAwgGUDX90hUBDBz03btP/C7QF9m3X+0Mkqnu/aL+hCAAAQgAAEI5EMAAUQAXd8cURHAbTuy1PLObwN9+fOeo1S1fBnXflEfAhCAAAQgAAEEMN8YYAjY7e0RFQG0LjTvP1g7srL18+29tXfVcm69ojYEIAABCEAAAvkSIANIBtD17RE1AWw3YKjWb9mhETf3UNNalVz7RX0IQAACEIAABMgAkgGM0bsgagLY5YFhWr5+q76+tpv226dqjLpLsxCAAAQgAAEIkAEkA+j6LoiaAB7+2A+at2qTPr7yEHVuzGbQrjeG+hCAAAQgAIH8CCCACKDruyNqAnj002M0fck6vXVxF/VoWcu1X9SHAAQgAAEIQIAhYIaAY/QuiJoAnvriOP06f41eOq+j+u5XN0bdpVkIQAACEIAABMgAkgF0fRdETQDPf328xsxeqf+esb9O6VjftV/UhwAEIAABCECADCAZwBi9C6ImgJe/PVHfTVum+0/aT+cd3ChG3aVZCEAAAhCAAATIAJIBdH0XRE0Ab/jgd33+xz+645g2uqx7U9d+UR8CEIAABCAAATKAZABj9C6ImgDe/ulkvT9hgW48oqWuP6JFjLpLsxCAAAQgAAEIkAFMvgzg1ZJukWSrKKZKukHSmAJCvZqkBySdImkvSXMl3SxpcJhvj6gJ4H1fT9PrP87VFT2a6vaj24R5eg6DAAQgAAEIQCBSAghgcgngmZLekWQSOFbSFZIuldRW0oI8giPDO265pAclLZLUQNJ6eyRvmMEUNQF84ruZenbEX7rgkEYaeOJ+YZ6ewyAAAQhAAAIQiJQAAphcAjhe0m+SrgoKhOmSPpd0ex7BcaWXLWwtaXukweMdHzUBfGHkX3p0yEyddmB9PX76/kXsDtUgAAEIQAACECiMAAKYPAJo2bxNkk6X9FnQjX9aUgdJPfIIBhvmXe3VO1HSCknvSXpE0s58gqesJPvjl8qWOczMzFSVKuaCRS9vjp2rAV9N07Ht6ur5czsWvSFqQgACEIAABCBQIAEEMHkEsJ6kxZK6ShoXdNf7S7pQUqs8ImGGpMaS3pX0giRbefG8JJPGgflEzgBJ94T+LBoC+NEvC3Xr/01Sz1a19MZFXXjrQgACEIAABCAQIwIIYPIJ4KGSfgqKlzsknS/JhnlDyyxJ5SQ1Ccr43RS0iCSvsItZBvCrP//Rte//roOaVNeHVxwSo5CnWQhAAAIQgAAEEMDkEcCiDAGP8ub+HRH0VjjaWwFsorctjLdI1OYADp++TJe8NVHt61fVl//qFsapOQQCEIAABCAAgaIQQACTRwDt/tsikF+9VcB+PEyT9EU+i0Bs5e85kmzX5SyvwvWS/iPJhpTDKVETwHFzVuqcV8erTpWy+vdRu0as09LS1K15Te1d1RKVFAhAAAIQgAAEokEAAUwuAfS3gbHVvTYMfLmkyyTtK2m+pLe9eYL+imDb8sUE8U1Jz3pzAAdJesbbGzCcGIuaAE5ZnKnjnv1xj3N2arSXPrnKRrYpEIAABCAAAQhEgwACmFwCaDFhewDe6m0EPUXSjZJGe8EyUtI8Sf2Cgscm2z3prRS2RSSvF7IKODTuoiaAWVnZemDwdP29YkPgHBu27tAv89Zo7yrl9HP/3tGId9qAAAQgAAEIQEASAph8AhjvwI6aAIZ23ESw1xOjVLlcaU0e0Cfe18X5IAABCEAAAklLAAFEAF2DO2YCuHzdFnV5cLjS06Q5Dx4TmA9IgQAEIAABCEDAnQACiAC6RlHMBNCGgPe7Z2igfzPu66tyZUq59pX6EIAABCAAAQgwBByIAdJKbm+FmAmgzQls2t8eViL9eucRqlEp+AEkbp2mNgQgAAEIQCCVCZABRABd4z9mAmgda3v3EG3atlOjb+mphjUquPaV+hCAAAQgAAEIkAEkAxiFd0FMBbDT/cO0csNWfXv9YWpT1+1Zw1G4VpqAAAQgAAEIJAUBMoBkAF0DOaYC2OOxHzR/1SZ9cuUh6tS4umtfqQ8BCEAAAhCAABlAMoBReBfEVACPeXqMpi1Zp7cu7qIeLWtFobs0AQEIQAACEIAAGUAygK7vgpgK4OkvjQtsBv3CuR11TLu6rn2lPgQgAAEIQAACZADJAEbhXRBTAez3xgSNnLlCj53WXqd3sifXUSAAAQhAAAIQcCVABpAMoGsMxVQAr3n3N30zeYkGHN9W/bo2ce0r9SEAAQhAAAIQIANIBjAK74KYCuAtH/+pj39dpFv6tNI1PZtHobs0AQEIQAACEIAAGUAygK7vgpgK4IAvp+rNcfN0Tc9muqVPa9e+Uh8CEIAABCAAATKAZACj8C6IqQA+NnSGnv9hjvod2lgDTtg3Ct2lCQhAAAIQgAAEyACSAXR9F8RUAF8Y+ZceHTJTpx9YX4+dvr9rX6kPAQhAAAIQgAAZQDKAUXgXxFQA3xo3T/d8OVXHtNtbL5x7YBS6SxMQgAAEIAABCJABJAPo+i6IqQB+PHGhbvlkUmATaNsMmgIBCEAAAhCAgDsBBBABdI2imArgt5OX6Kp3f1OnRnvpk6sOde0r9SEAAQhAAAIQYAg4YYaA50kaJOlNSQtKWGTGVABHzVqhCwdNUHqaVKls6QCa9PQ0XdmjWeAPBQIQgAAEIACByAmQAUyMDOC1kvpJslUOP0h6XdJnkrZGfkvjXiOmArg0c4t6Pj5Sm7fvzHVhLWpX0vc39Yj7xXJCCEAAAhCAQDIQQAATQwD9WDIBvFjS2ZIs3fWelxn8LYGDLaYCaNe9bst2rVy/y4VnLVuvK//3m+pWLaefbu+dwFjoGgQgAAEIQCBxCSCAiSWAfqSUkXS1pEck2b+nSHpa0huSshMsnGIugMHX+/eKDer1xChVLltak+/tk2Ao6A4EIAABCECgZBBAABNLAE32TpZ0kaQjJf3sDQfXk/Qvb3j4nAQLrbgK4PL1W9TlgeFKS5PmPHBMYD4gBQIQgAAEIACByAgggIkhgB096bOhX5vs9o6k1yTNCLqdnSWNllQ+slsc86PjKoCbt+1Um7uHBC5qyr19chaGxPwqOQEEIAABCEAgiQgggIkhgCZ933vZvs8lbc8jxipKes4TxUQKwbgKYHZ2tprf8a12ZmXr59t7a++q5RKJBX2BAAQgAAEIlAgCCGBiCGAjSfNLRMTs2cm4CqCdfv97v1Pm5u0adlN3Na9duYRio9sQgAAEIACB4iOAACaGAP4tyYZ4V4WEQjVJtgK4afGFSKFnjrsAdn14hBav3azPrj5UBzTcq9AOcgAEIAABCEAAArkJIICJIYBZkvaWtDwkQOt4G0OXTeDAjbsA9n1qtGYsXa93Lumiw1rUSmA0dA0CEIAABCCQmAQQwOIVwBO8sLB5fxdKygwKk1KSbKM7Ww3cKjHDJ9CruAvgaS+O08T5a/TiuR11dLu6CYyGrkEAAhCAAAQSkwACWLwCaJk/K7a3X+h+JrYQxB4Rd7OkrxMzfIpHAPu9MUEjZ67Qo6e11xmdGiQwGroGAQhAAAIQSEwCCGDxCqAfFXO9OYArEzNMCuxV3DOA/3rvN309aYnuPq6tLu7WpAQio8sQgAAEIACB4iWAACaGABZvFLidPe4CePunk/T+hIW66ciWuq53C7feUxsCEIAABCCQggQQwOITwOskvSJpiyT7d0HlmQSOzbgL4APfTNOrY+bq8u5N1f+YNgmMhq5BAAIQgAAEEpMAAlh8AmjDvp28rV/s3/kVmx/INjBBdJ4eNltPDpuls7s01EOntEvMdxa9ggAEIAABCCQwAQSw+AQwgcMioq7FPQP4+o9zdd/X03T8/vX07NkHRNRZDoYABCAAAQhAQEIAEUDX90HcBfCjXxbq1v+bpJ6taumNi7q49p/6EIAABCAAgZQjgAAWnwD+N4JouymCY+N9aNwFcPDkJbr63d9UMaOUmtSyRyRLpdLSdHn3Zjq2PfsCxjsAOB8EIAABCJQ8Aghg8QngD2GGi80B7BXmscVxWNwFcObS9erz1Og9rnX/BtX0xTVdi4MB54QABCAAAQiUKAIIYPEJYIkKlAI6G3cBtL7MWrZe/6zdHOjW7GUb9MDg6Wpas6JG/PvwZOHKdUAAAhCAAARiRgABRABdg6tYBDC409OXrNPRT49RzUoZmninPTmPAgEIQAACEIBAQQQQwOITwE8l9ZO0TpL9u6BySgKHcbEL4OK1m9X14RHKKJWuWQ8cncCo6BoEIAABCEAgMQgggMUngG94G0Cvl2T/LqhclBjhkmcvil0A12/ZrnYDvgt0bsZ9fVWuTKkExkXXIAABCEAAAsVPAAEsPgEs/rsfnR4UuwBmZWWr2R2DlZ0tTbijt2pXLhedK6MVCEAAAhCAQJISQAATSwBrS2olyVb+zpK0vATEXbELoDFqP2Co1m3ZoWE39VDz2pVKADa6CAEIQAACECg+AghgYgigSdTzks6yLe28cNgp6UNJ10jKLL4QKfTMCSGA3R4ZoUVrNuuzqw/VAQ33KrTTHAABCEAAAhBIZQIIYGII4EeSOki6VtJPXgbwUElPS5ok6YwEDtKEEEBbBWyrgd+6uIt6tKyVwLjoGgQgAAEIQKD4CSCAiSGAGyX1kfRjSEgcJmmIpF2Pu0jMkhACeObLP2n83NWBZwPbM4IpEIAABCAAAQjkTwABTAwBXCDpWEmTQ25Ve0mDJdVP4CBOCAG87O2J+n7aMj14cjudc1DDBMZF1yAAAQhAAALFTwABTAwBvFzS6ZIukLTEC4u9Jb3l7RH4cvGHSr49SAgBvOmjP/Tpb4t129GtdWWPZgmMi65BAAIQgAAEip8AAlh8Avi7N9fPj4IWkspKsmygFUtjbbUnnUnqWPyhktgCOODLqXpz3DxdfXgz3dq3dQLjomsQgAAEIACB4ieAABafAN4Twe2/N4Jj431oQmQA//v9LD0zfLbOP7iR7jtpv3gz4HwQgAAEIACBEkUAASw+ASxRgVJAZxNCAF8b87fu/2a6TuxQT0+fdUCysOU6IAABCEAAAjEhgAAigK6BlRAC+NEvC3Xr/01S3arldEizGoFrKp2epvMObqT29au5XiP1IQABCEAAAklFAAFMDAG0zZ9v9Pb7s7l/GSFRVj2Boy4hBPDH2St13uvj98BkewLa3oAUCEAAAhCAAAR2E0AAE0MAB0q6VNJ/Jd0n6QFJjSWdJMl+9kwCB21CCKA9D/irSf9o2botAVRzV27U+xMWat96VfTNdbadIgUCEIAABCAAAZ8AApgYAjhH0nWSvpG03nsqiP/awZLOSeCQTQgBDOXz+4I1OvmFcdqnWnmNva1XAuOjaxCAAAQgAIH4E0AAE0MA7UkgbbwtYGwfQNsU+jdJTSXZdjFV4x8aYZ8xIQXw7xUb1OuJUapctrQm32sPWaFAAAIQgAAEIEAGcHcMpCVAOMz0NoG2SWxjvEzgw5LOlPSspNoJ0Mf8upCQArh64zZ1vO/7QJ//euBolS6VnsAI6RoEIAABCEAgvgTIACZGBtBkb52kByWdJul9SfO8zaCflHRbfMMiorMlpADu2Jml5nd8G7iQ3+46UtUrhq6riegaORgCEIAABCCQVAQQwMQQwNCgsnl/h1ryStKXCR5xCSmAxqzdPUO1fusOjbi5h5rWqpTgGOkeBCAAAQhAIH4EEMDEFMD4RYD7mRJWALs+PEKL127WZ1cfqgMa7uV+pbQAAQhAAAIQSBICCGDiCGArSdd6i0GyJc3w5v/Z/MBELgkrgMc+M0ZT/1mnNy7qrJ6tEnkaZSLfXvoGAQhAAALJSAABTAwB9Of9TZT0kxdoNgzc2dsC5uMEDr6EFcBzXv1Z4+as0tNnddCJHfZJYIR0DQIQgAAEIBBfAghgYgjg35L+J+nukNt/r6Tzve1g4hsZ4Z8tYQXw6nd/1eDJS3XvCfvqwkNtX20KBCAAAQhAAAJGAAFMDAHcJKm9t+gjODJbSPpTUoUEDteEFcDbP50UeBrITUe21HW9DSUFAhCAAAQgAAEEcFcMJMI+gIMl2TDvGyFheZGksyRFspPx1ZJukVRX0lRJN3h7CxYW8XYe237mC+8RdIUd7/88YQXw4W9n6KVRc3Rx1ya6+/i24V4Px0EAAhCAAASSngAZwOITwBOCoque98zfjyT97L1ucwBPl3SPpJfCjETbOPodSSaBYyVd4T1j2OxnQQFtNPKOt6Ho1ckigCZ/JoF99q2j2462B61IZUqlBR4Pl5aWCN4f5l3lMAhAAAIQgECUCSCAxSeAWWHeS1sRXCrMY+1JIvYIuauCjp8u6XNJt+fThrU9yss+HiapWrII4PsTFuj2TyfvcdnX9Wqum46yRdcUCEAAAhCAQGoSQACLTwCjHXH2qAubS2hZw8+CGn9aUgdJPfI5oS00sfmHJ0t6MwwBLCvJ/vilsqRFmZmZqlLFRoMTpyxcvUkXDpqgFRu2Bjq1fWeWtmzP0qHNaui9yyzBSoEABCAAAQikJgEEMHkE0IaRF0vqKmlcUDj3l3ShpLxSXnbsh54grgxTAAd4w9K53jGJKIChb+lRs1YEhLBN3Sr69npLdlIgAAEIQAACqUkAAUwcAbQM3b+DNoK2odvHwlzAYdHrC6A9Qs7fS9Bev8PbSqZ1SIhb5m6SN19w10NzkywDGPqWnrwoU8c/96P2rlJOP/fvnZrveK4aAhCAAAQgwDYwgRhIhNUA53lz8D71FmNYn0zkbFi2n6T3wojWSIeAbVj4d0k7g9pO9/5t8xMtYzgnjPMm7Crg0L7bkPBhj/6gsqXTNeO+viwECePmcggEIAABCCQnATKAiSGAlu17RdKTIWF2k6TLvKxgOBFoi0B+9bJ6/vHTvK1dQheBlJPUPKTR+yVZZvB6SbMkbQvjpCVGADdu3aF97xkauKRpA/uoQkbpMC6PQyAAAQhAAALJRwABTAwBtFUK++axEbQJ2hRJJmvhFH8bmCu9YeDLPYG0tudLetubJ5jfiuBwFoGE9qPECGB2drZa3TlE23ZmaextvQLbwVAgAAEIQAACqUgAAUwMAfzLm+/3ckgQ2j5+Ni8wksdY2B6At3obQZs83ihptNfuSEnzvGHlvOI9qQXQLvigB4dp2bqt+vrabtpvn6qp+J7nmiEAAQhAAAI8Ci5B5gDavn1PSRrkreC1vf+6eaJmw7GhYphIoVtiMoAGre9TozVj6Xq9c0kXHdaiViJxpC8QgAAEIACBuBEgA5gYGUC74bbg4+ag+X7+KmB7NFsilxIlgGe/8rN++nuVnj6rg07ssE8ic6VvEIAABCAAgZgRQACLXwDtSRyW7bMtWdbE7E7HruESJYBXv/urBk9eqntP2FcXHto4dlRoGQIQgAAEIJDABBDA4hdAC48tXuZvbgLHSn5dK1EC2P+zyXpv/AJd37uFbjyyZQnETZchAAEIQAAC7gQQwMQQwF8k3SZpuPstjXsLJUoAHx86U8/98JdOO7B+jgBmlEpXrcrBT7eLO0NOCAEIQAACEIgrAQQwMQTwKEmPSLrL28dvY0gUrItrVER2shIlgK+N+Vv3f2PTK3OX/se01uXdm0V25RwNAQhAAAIQKKEEEMDEEEB78oZfbAWwX+yJIPZ/myeYqKVECeDsPpYRnQAAIABJREFUZet1waAJWr1x1x7XO7OytSMrW71b19br/TonKmP6BQEIQAACEIgqAQQwMQTQngNcUBkV1bse3cZKlACGXvr305bpsrcnav8G1fTFNV2jS4bWIAABCEAAAglKAAEsXgGs4G0AfZKkMpKGSbpO0soEjZe8ulWiBfDX+Wt06ovj1KB6eY25tVcJwk5XIQABCEAAAkUngAAWrwA+5j23911JmyWdI8me1nF60W9p3GuWaAGcv2qjejw2UhUySmnawL5xh8cJIQABCEAAAsVBAAEsXgGcI+kOSR94N7+LpLHes393FkdAFOGcJVoAN2zdof3uGRq47OkD+6p8RiJPtyzC3aEKBCAAAQhAIA8CCGDxCqCtRGgiaXHQvbFMoG1Qt7CERGyJFsDs7Gy1umuItu3I0o//6an6e9moPAUCEIAABCCQ3AQQwOIVQMvy7S1pRVCYrZfUXlJJ2RS6RAugcT/0oeH6J3NLYBGILQahQAACEIAABJKdAAJYvAJo2798K2lrUKAdL2mEpOC9AE9J4EAs8QJ43LNjNGXxOg3q10m9WtdJYNR0DQIQgAAEIBAdAghg8QrgG2HexovCPK44DivxAnjhoAkaNWuFHjutvU7v1KA4GHJOCEAAAhCAQFwJIIDFK4BxvdkxOlmJF8CbPvxDn/6+WLcd3VpX9uBpIDGKE5qFAAQgAIEEIoAAIoCu4VjiBfCBb6bp1TFz1at1bR3Xvm6AR7kypXR4q1qqkFHalQ/1IQABCEAAAglHAAFEAF2DssQL4Cuj5+jBwTP24GDZQMsKUiAAAQhAAALJRgABRABdY7rEC+CydVv0wDfTtXbz9gCLZZlbNHPZeh3Zto5evaCTKx/qQwACEIAABBKOAAKIALoGZYkXwFAAQ6cu1RXv/KoODarpc54P7Bof1IcABCAAgQQkgAAigK5hmXQC+NuCNTrlhXHap1p5jb2N5wO7Bgj1IQABCEAg8QgggAiga1QmnQAuXL1Jhz36gzJKp2vmfX2Vlpbmyoj6EIAABCAAgYQigAAigK4BmXQCuGX7TrW+a0iAy5/3HKWq5cu4MqI+BCAAAQhAIKEIIIAIoGtAJp0AGpB2A4Zq/ZYdGnZTDzWvXcmVEfUhAAEIQAACCUUAAUQAXQMyKQWw1xMj9feKjfrg8oN1cNMaroyoDwEIQAACEEgoAgggAugakEkpgGe+/JPGz12tZ88+QMfvX8+VEfUhAAEIQAACCUUAAUQAXQMyKQXwX+/9pq8nLdHdx7XVxd2auDKiPgQgAAEIQCChCCCACKBrQCalAN771VS9MXaeGlavoEY1KgQY2ePhbunTSi3rVHZlRn0IQAACEIBAsRJAABFA1wBMSgF8b/wC9f9s8h5szju4oe4/qZ0rM+pDAAIQgAAEipUAAogAugZgUgrg9p1ZGj1rRWAlsJXxc1fp/QkLdUSb2nrtws6uzKgPAQhAAAIQKFYCCCAC6BqASSmAoVCGT1+mS96aqHb7VNVX13ZzZUZ9CEAAAhCAQLESQAARQNcATAkBnLI4U8c9+6NqVS6rX+44wpUZ9SEAAQhAAALFSgABRABdAzAlBHDF+q3q/MAw2VPhZt9/tEqXSnflRn0IQAACEIBAsRFAABFA1+BLCQHMyspWyzu/1Y6sbP18e2/tXbWcKzfqQwACEIAABIqNAAKIALoGX0oIoEE69KHh+idziz6/pqs6NKjmyo36EIAABCAAgWIjgAAigK7BlzICeNLzY/XHwrV6+fwD1WffvV25UR8CEIAABCBQbAQQQATQNfhSRgCveGeihk5dptuObq3TD6wf4Fa2TClVKlvalSH1IQABCEAAAnElgAAigK4BlzICePcXU/T2T/Nz8SqVnqbnzj5AR7er68qR+hCAAAQgAIG4EUAAEUDXYEsZAbSNoa/836/atG1nLmZnd2moh07h6SCugUR9CEAAAhCIHwEEEAF0jbaUEUADlZ2dncPrw18W6rZPJ+vwVrX05kVdXDlSHwIQgAAEIBA3AgggAugabCklgMGwRs1aoQsHTVCrOpU19MburhypDwEIQAACEIgbAQQQAXQNtpQVwNnL1uvIJ0ercrnSmjygjytH6kMAAhCAAATiRgABRABdgy1lBXDD1h3a756hAX5T7u3DamDXSKI+BCAAAQjEjQACiAC6BlvKCqCBazdgqNZv2aHvb+yuFnUqu7KkPgQgAAEIQCAuBBBABNA10FJaAPs8OVozl63XWxd3UY+WtVxZUh8CEIAABCAQFwIIIALoGmgpLYD93pigkTNXqN+hjXVosxoBlpXKldZBTWrI9gikQAACEIAABBKRAAKIALrGZUoLYP/PJuu98Qv2YGj7Atr+gBQIQAACEIBAIhJAABFA17hMaQGc+k+mHho8Q5u27QhwXLZuqxav3axzD2qoB05mc2jX4KI+BCAAAQjEhgACiAC6RlZKC2AovA9/WaD//N/kwHxAmxdIgQAEIAABCCQiAQQQAXSNSwQwiODYv1bq3NfGq1mtihp+8+GubKkPAQhAAAIQiAkBBBABdA0sBDCI4PxVG9XjsZEqVyZd0wf2VVoaC0FcA4z6EIAABCAQfQIIIALoGlUIYBDBbTuy1Oqub2WPDJ545xGqWamsK1/qQwACEIAABKJOAAFEAF2DCgEMIXjIQ8O1JHOLPr+mqzo0qObKl/oQgAAEIACBqBNAABFA16BCAEMInvbiOE2cv0ZXdG+qAxruEsAq5crooKbsDegabNSHAAQgAIHoEEAAEUDXSEIAQwje+OEf+uz3xXtw/e8Z++uUjvVdeVMfAhCAAAQg4EwAAUQAXYMIAQwh+OfCtXps6Ext2b4z8JN/1m7WP5lbAk8LGXDCvq68qQ8BCEAAAhBwJoAAIoCuQYQAFkLw3fHzdcdnU9S7dW293q+zK2/qQwACEIAABJwJIIAIoGsQIYCFEBwze4XOf32CmteupGE39XDlTX0IQAACEICAMwEEEAF0DSIEsBCCC1ZtUvfHflBG6XTNGNhX6ensDegadNSHAAQgAAE3AgggAugWQRICWAjBHTuz1PquIdqRla2fbu+lulXLuzKnPgQgAAEIQMCJAAKIADoFkO1wIikzMzNTVarYPyl5Eejx2A+av2qT/nfJQercZK/AIaXT01WKbCABAwEIQAACxUAAAUQAXcMOAQyD4Pmvj9eY2StzHVmpbGm9f9nBale/ahgtcAgEIAABCEAgegQQQATQNZoQwDAIvvPTPN3z5VRlZec++MYjWur6I1qE0QKHQAACEIAABKJHAAFEAF2jCQEMk+DmbTu1IysrcPTrP87VU8Nm66QO9fTUWQeE2QKHQQACEIAABKJDAAFEAF0jCQEsAsEhU5boyv/9pv3rV9UX/+pWhBaoAgEIQAACECg6AQQw+QTwakm3SKoraaqkGySNySdELpN0gaT9vJ//Kqm/pAkRhBQCGAEs/9BZy9brqCdHq3K50pp0z1FKS2NrmCJgpAoEIAABCBSRAAKYXAJ4pqR3JJkEjpV0haRLJbWVtCCPGHnXO26cpC2SbpV0iiR7XtmeD7PNO8gQwCK8+ewxcW3uHqLsbGninUeoZqWyRWiFKhCAAAQgAIGiEUAAk0sAx0v6TdJVQeEwXdLnkm4PI0RKSVoj6V+S3g7jeDsEAQwTVOhh3R4ZoUVrNuv63i3UqEaFwI/3qpihHi1qsVl0EZlSDQIQgAAEwiOAACaPAGZI2iTpdEmfBd3+pyV1kBTOM8gqS1rutfF1PiFkqargdJXVWcQ+gOG94YKPumDQBI2etWKPiq9d0ElHtK0TeYPUgAAEIAABCIRJAAFMHgGs5w3bdpVkQ7p+sTl9F0pqFUZMPC+pjzcn0IaE8yoDJN0T+gMEMAy6IYdMnLdaL42ao207d+0N8/eKDYGM4L96Nte/+4RzuyI/JzUgAAEIQAACRgABTD4BPFTST0HhfYek8yW1LiTkbf7fbZIOlzSpgGPJAMbod8egH+dq4NfT1GffOnr5/E4xOgvNQgACEIAABBBAi4FkWX7pMgT8b0l3SjpC0sQI3xjMAYwQWH6Hj5m9Que/PkHNalXU8JvNwykQgAAEIACB2BAgA5g8AmgRYotAbCsXWwXsl2mSvihgEYhtGWPyZ0O/PxchzBDAIkDLq8qSzM065KERgecDTx/YVxml06PUMs1AAAIQgAAEchNAAJNLAP1tYK70hoEvl2R7/dm2LvO9lb22vYu/ItiGfe+TdI63HYwfHRsk2Z9wCgIYDqUwjsnOzla7Ad9pw9Ydeuy09qpbtXygVs3KGWq9t2GmQAACEIAABKJDAAFMLgG0qLDsn4mdbQQ9RdKNkkZ74TJS0jxJ/bz/278b5RFK90qyxR7hFAQwHEphHnPS82P1x8K1exz9f1cdogMbVQ+zFQ6DAAQgAAEIFEwAAUw+AYx3zCOAUSRuj4h77oe/tMNbGbxs3Rat2bRdt/RppWt6No/imWgKAhCAAARSmQACiAC6xj8C6EqwgPovjPxLjw6ZqRP2r6dnzj4ghmeiaQhAAAIQSCUCCCAC6BrvCKArwQLq/zBjuS568xe1rFNJ390Yzl7eMewMTUMAAhCAQNIQQAARQNdgRgBdCRZQ/5+1m3XowyNUOj1NUwf2UdnS9rQ+CgQgAAEIQMCNAAKIALpFEM8CduVXYH1bGbz/vd9p3ZYdOqxFTVXI2CWAe1cpp/7HtkEIY0qfxiEAAQgkLwEEEAF0jW4ygK4EC6l/4aAJGpXHM4OfP6ejjm1vi70pEIAABCAAgcgIIIAIYGQRs+fRCKArwULq20rgETOWa2fWrmcGD568ROPmrNJVhzfTf/oW9oS/GHeO5iEAAQhAoEQSQAARQNfARQBdCUZY/93x83XHZ1PUvWUtvX1xlwhrczgEIAABCECAZwFbDCTLs4CLK54RwDiT/3PhWp34/FjVqJihiXceobQ0QjjOt4DTQQACECjxBMgAIoCuQYwAuhKMsP6W7Tu17z1DA0PCFxzSSBmldj0zeJ+9yqvfoY0Rwgh5cjgEIACBVCSAACKArnGPALoSLEL9454doymL1+1R891LD1LX5jWL0CJVIAABCEAglQgggAiga7wjgK4Ei1B/2j/r9PWkf+StC9HoWSs0bck63XxkS13bu0URWqQKBCAAAQikEgEEEAF0jXcE0JVgFOoP+nGuBn49TUe0qa3XLuwchRZpAgIQgAAEkpkAAogAusY3AuhKMAr1f52/Rqe+OE41K5XVL3f0Zh5gFJjSBAQgAIFkJoAAIoCu8Y0AuhKMQn1bGLLfPUO1IytbjWtUULq3MrhRjQp68bwDVa4Mj5CLAmaagAAEIJA0BBBABNA1mBFAV4JRqn/uaz9r7F+r9mjt1Qs66ci2daJ0FpqBAAQgAIFkIIAAIoCucYwAuhKMUv3N23Zq6j+Z2vW8EOn1MXM1ZOpSXdGjqW4/uk2UzkIzEIAABCCQDAQQQATQNY4RQFeCMar/8cSFuuWTSerUaC99ctWhMToLzUIAAhCAQEkkgAAigK5xiwC6EoxR/bkrN6rn4yOVUTpdl3ZrknOW5rUr6ZSO9WN0VpqFAAQgAIGSQAABRABd4xQBdCUYo/rZ2dnq8uBwrVi/dY8zfHNdN+1br2qMzkyzEIAABCCQ6AQQQATQNUYRQFeCMaw/Ye5qDZ26VNnexMBRs5ZrzoqNuvPYNrr0sKYxPDNNQwACEIBAIhNAABFA1/hEAF0JxrH+K6Pn6MHBM9gwOo7MORUEIACBRCSAACKArnGJALoSjGP9SYvW6oTnxqpS2dI6u0uDnDO33ruKTj2QeYFxvBWcCgIQgECxEkAAEUDXAEQAXQnGsf6OnVk68P5hyty8fY+zDrupu5rXrhzH3nAqCEAAAhAoLgIIIALoGnsIoCvBONf/+e9V+mHm8pyzDp++XH8t36C7jmurS4JWC8e5W5wOAhCAAATiSAABRABdww0BdCVYzPVfHf23Hhg8XT1b1dIbF3Up5t5weghAAAIQiAcBBBABdI0zBNCVYDHXn75knY5+eoxKpaepduWyOb1pX7+qXjj3wMDrFAhAAAIQSC4CCCAC6BrRCKArwWKub/sFHvHfUYHtYULLx1ceos6NqxdzDzk9BCAAAQhEmwACiAC6xhQC6EowAepv2rZDfwcJ4FPDZmvY9GW6skcz3XZ06wToIV2AAAQgAIFoEkAAEUDXeEIAXQkmYP0v/lis6z/4Q/WqltPJHffJ6WHHhnupd5s6CdhjugQBCEAAApEQQAARwEjiJa9jEUBXgglYf+2mbep0/zDtyPIeIeL10eYDjrutl+pUKZeAvaZLEIAABCAQLgEEEAEMN1byOw4BdCWYoPW/m7pU4+asyund8BnLtHD1Zt134r46/5DGCdprugUBCEAAAuEQQAARwHDipKBjEEBXgiWk/suj5uihb2do33pVdFbn3U8R6dBgL7WrX7WEXAXdhAAEIAABI4AAIoCu7wQE0JVgCak/f9VG9Xhs5B69rZBRSj/3760q5cqUkCuhmxCAAAQggAAigK7vAgTQlWAJqv/G2Ln6Zd7qnB5PmLtGKzds1WOntdfpnXZnBUvQJdFVCEAAAilJAAFEAF0DHwF0JViC6z8zfLb++/0sNa9dST1a1sq5km7Na6pn69ol+MroOgQgAIHkJoAAIoCuEY4AuhIswfXnrdyowx/fc1g4o1S6xvfvrb0qZpTgq6PrEIAABJKXAAKIALpGNwLoSrCE1x88eYkmL87MuYpvJi3RgtWbdO8J++rCQ1ktXMJvL92HAASSlAACiAC6hjYC6EowyerbPMF7v5omywJWKlc65+r67re3Hjy5XZJdLZcDAQhAoGQSQAARQNfIRQBdCSZZ/dUbt6nXEyO1dtP2Pa7suxu7q2Wdykl2xVwOBCAAgZJHAAFEAF2jFgF0JZiE9ddt2a5lmVtyrsz2DxwxY7lscchBTarnvN6jVS21r18tCQlwSRCAAAQSmwACiAC6RigC6EowBeqPmb1C578+YY8r3atCGY27rbfKZ5RKAQpcIgQgAIHEIYAAIoCu0YgAuhJMgfrZ2dl6/ce5mrNiY87VDp++TMvXb9W1vZoHMoNW0tLS1KZuZVVmU+kUiAouEQIQKE4CCCAC6Bp/CKArwRStP+jHuRr49bQ9rr59/ar64pquARmkQAACEIBAbAgggAiga2QhgK4EU7T+pm079K/3fpc9Ys4vC1dv1radWXrk1HayZwzvygpKjWtUVEbp9BQlxWVDAAIQiD4BBBABdI0qBNCVIPVzCDz07XS9POrvPYh0b1lLb13UmawgsQIBCEAgSgQQQATQNZQQQFeC1M8hsGrDVl305i/6Z+3mnNdsW5msbOm+E/dV01qVcrKC+9evpopld+8zCEYIQAACEAifAAKIAIYfLXkfiQC6EqR+gQTu/Wqq3hg7b49jujSprg8vP5isIPEDAQhAoAgEEEAEsAhhk6sKAuhKkPoFErAM4PUf/K4V67fmHPf3io2BuYLnHNRQtSqVDbxeKj1Nx7avq2ZelhCsEIAABCCQPwEEEAF0fX8ggK4EqR8xgf9+P0vPDJ+9R73GNSpoyA3dVa4M+wpGDJUKEIBAShFAABFA14BHAF0JUj9iAlu279SLI+fIsoN++XbKUq3csFU1K5VVWW/FsGUF/9Wzuc7o3CDic1ABAhCAQDITQAARQNf4RgBdCVI/KgQGT16iq9/9bY+2TAbvOq5tjhSWLpWmXq3rqGr5MlE5L41AAAIQKIkEEEAE0DVuEUBXgtSPGoG5Kzdq3ebtOe09/t1MjZm9co/2uzSurvcvPzgwb5ACAQhAIBUJIIAIoGvcI4CuBKkfMwLL1m3R/d9M1/otu6Xwl7mrtXHbzsAG077+VcgorduPaa1zD2oUs77QMAQgAIFEIoAAIoCu8YgAuhKkflwJfPHHYt3w4R/Kzs59WksGHtaiVkAMrdgeg9cc3lxt61mIUyAAAQgkFwEEEAF0jWgE0JUg9eNOYN2W7bKFJH55+NsZ+vS3xXv0o2alDJ16YH2lebnCyuVK66zODVTD23om7h3nhBCAAASiRAABRABdQwkBdCVI/WInsDMrWyNnLteaTbuHigf9OFfTlqzbo28t61TSGZ12ryo2KTx+/3qyYWQKBCAAgZJCAAFEAF1jFQF0JUj9hCRgj6V7d/yCXItKvvzzHy0P2pDa7/gBDavp2HZ1c67DVhibFLIfYULeWjoFAQhIQgARQNc3AgLoSpD6JYbA3ys26PUf52rj1h05fR4xY7nWbdn9f/8HHRpUU7fmNXOOq1ahjM7s3ECVy7H9TIm54XQUAklMAAFEAF3DGwF0JUj9Ek1gxtJ1emvcPG3etntOYX5S2KRmRbWtu3tRiUnhNT2bq1618iWaAZ2HAARKHgEEEAF0jVoE0JUg9ZOOwJwVG/TRxIXauj0r59q+mbwk1/OM/R9UyCilvSpk5BxXvWKGru/dQo1rVsx5ba8KZVh4knRRwgVBoHgJIIAIoGsEIoCuBKmfEgRWrN+qYdOXafvOXVJo29B8+MvCPBeahAKxLWrO7NxQe1cpl/Oj2lXK6uQD9mGeYUpEDxcJgegTQAARQNeoQgBdCVI/ZQns2JmlmcvWy1Yh+1L4ya+LZI+12+ltVGh/ZQY93SQYli02qVR29+rjOlXK6pyDGuV6rV61cmpfv1rKMubCIQCBvAkggAig63sDAXQlSH0IFELghxnLNXzGMnmeGMgeWjbRsorhlOa1K6l8mVI5h5oUHtOubs7zke0H9feqoP32qRpOcxwDAQgkAQEEEAF0DWME0JUg9SFQBAK26OSv5RuUrd3Zw2+nLNUv81bntJaVna0pizO1fWfIY0/yOV+tymVVOuj5yA2qV9ChzWqolP94FEkNa1RQx4Z7KT3ouBoVMxiKLsI9pAoEipMAAph8Ani1pFsk2aZkUyXdIGlMAUF2qqT7JDWTNEfSHZI+iyAoEcAIYHEoBOJNYGnmFk1funtD6+zsbP0wY4Vs9bJfLLM4eVGmtnnzEyPtY8WMUrIsY1qQKDauUSGP1yqqUY0KuZo3ybShbAoEIBBfAghgcgngmZLekWQSOFbSFZIuldRW0oI8QusQTw7v8qTvZEkDJXWTND7MUEQAwwTFYRBIZAJrN23TwtWbc2UPx81ZpQWrN+W8tjMrSxPnrdHitbmPCzfDmNf1WyLRnrscXBrXqCjLRvrFHs9somgrpINfq1+9vKoE7ato/mlD2cHtWd3altkslZ7I+OkbBOJOAAFMLgE0aftN0lVBkTRd0ueSbs8juj6UZAJ3dNDPhkhaI+nsMKMRAQwTFIdBIBkJWEZx8uJMLV+3ez7ijqxs/blorVZv2JZzyfba1H8ytTbocXv22soN4c1jdGFXKj1NGUECaNJZp2o5lS29e16kvWaimFF6tyhavRoVd71m/05PSwsMkdvwtw2LW5P27zLp6SqfUUq2pY9/XPDfgeMCde249MB57f/p3ut2bsueWpv+63aM9Xn3MWkywbWf72p7Vx0KBIpKAAFMHgG0r8b2Vf30kCHcpyV1kNQjjyCxrOCT3h//xzd6w8aN8gkq+1q++6u5VFnSoszMTFWpsnuD26IGJPUgAIHUImALWTYEPVnFsowzl27Qxm27n66yY2e2bG/Fzdt3b7ZtK6jnrdykrTt2v2aZyIWrN+UayrYV1iaayVpMBAPSmLZLEE0OA3JaatffJom7xNE+7HaLoy+TwX+bTvrt7Pp71/G72t8lnP7/g93T2g2U3H8Fzrvr5V3/yPl/Pq/79yhYbH3F3d2W16b3QujP/U7seXzefcnVr3yvo+iiXfSau3kVNXYLO/fWTRv00iXdrXlb/bXng8+LeuISVK8wRiXlUupJWiypq6RxQZ3uL+lCSa3yuBD7et5P0ntBPztH0hshkhdcdYCke0LbQgBLSpjQTwikFoGsrOzA85v9/Rft6k0Il2Ruztl+J/DazmwtW7clZ/sd/zXLUJpY2oIak8n/b+9MgGW7qjL8CchQmoBQMiYQwhRJKaMCUcGimBKGgMUoBGRIGJQwBwRKQEFmCIKiQJgsCIOEQTTMQxiCQhDKEAFLkvAYRSEhJmHKe9Z379rhvLZvqrvPuZ3Tff9d9So33Xvvs/tb+5zzn7X22ufCf3v2YN9NYPp6QAVq+9766k7/v7X1GD/62QUbG4Rvfr9ZZ+O/G/U2/7beousxd5Z182v7ENj94/PYdey9IwD7QBxJ2yYADwFO7ozJpI4jgIO2EICKw+M7390fOA74+Y6zezeMB3AkBs8wQiAE1peAgvCnu3dvbPnjvw0RuWcPe3aXYCzxaAj+QhHZEakbQnL3nr3ab/TFZv3Wzk82/3+z383jbeaWK1797+bnilQ2xuDYWml/1baVe2WlW+fn3+/thd2yflXr1vbY3b5ap90M+L2PtTm6rb7f+JFV/t/4J47VqTr4ZNtOv3RjdlGDPv/cczj6UAOE8QAObtwld7isEPDkz8oawCUbOocLgRAIgRAIgb4EsgZwfdYAOhdMAjmlsoDb3DgNePdFJIG4hu+wzkQ6ETgrSSB9T620D4EQCIEQCIHxEogAXC8B2LaBeUSFgY8CjgQOBs4E3ljrBFtGsOHik2rvP0Xi4cCzsw3MeE/YjCwEQiAEQiAEhiAQAbheAtA54R6Ax9RG0KcCZvUq8iwfA86oxI82f+5Zou/AzkbQJ8wxuRICngNWqoZACIRACITAGAhEAK6fAFz2vIoAXDbxHC8EQiAEQiAEehKIAIwA7DmFNjaSPjvbwPTFmPYhEAIhEAIhsDwCEYARgH1nWwRgX4JpHwIhEAIhEAJLJhABGAHYd8pFAPYlmPYhEAIhEAIhsGQCEYARgH2nXARgX4JpHwIhEAIhEAJLJhABGAHYd8pFAPYlmPYhEAIhEAIhsGQCEYARgH2nXARgX4JpHwKlUJuAAAAPwklEQVQhEAIhEAJLJhABGAHYd8pFAPYlmPYhEAIhEAIhsGQCEYARgH2nXARgX4JpHwIhEAIhEAJLJhABGAHYd8pFAPYlmPYhEAIhEAIhsGQCEYARgH2n3IYA3LVrF/vu658pIRACIRACIRACYyegANx///0d5uWBH459vNsxvl/Yjk53UJ8HAKfvoN+bnxoCIRACIRAC60Tg2sAZ6/SDZv0tEYCzkppeb8MDCOwHnNOvq7TuSWAf4BuxRU+KwzSPLYbhOFQvscdQJPv3E1v0ZzhUD80W8QAORXSH9dME4I6dQCOyd2wxHmPEFuOxhSOJPcZjj9githgNgXgA+5kiJ3M/fkO2ji2GpNmvr9iiH7+hW8ceQxNdvL/YYnF2Q7fc8baIAOw3pXb8BOqHb9DWscWgOHt1Flv0wjd449hjcKQLdxhbLIxu8IY73hYRgP3m1GWAPwGeC/y4X1dp3ZNAbNET4IDNY4sBYQ7QVewxAMSBuogtBgI5QDc73hYRgAPMonQRAiEQAiEQAiEQAqtEIAJwlayVsYZACIRACIRACITAAAQiAAeAmC5CIARCIARCIARCYJUIRACukrUy1hAIgRAIgRAIgRAYgEAE4AAQ00UIhEAIhEAIhEAIrBKBCMDFrfUo4EnA1YAvAY8FPrF4d2k5hYAZ1r8PHAScD3waeDLwlU5dM7leBNwPuBzwYUDb+FaQVq4J/BVw2+rnzcATgZ+E+sIEtM1fAC+ruW9HscXCOOdueA3g+cChNe+/CjwUOKV68tr+DOAo4FeAfwb+qK5V7WB+/pfA3eqD9wCPBs6aezQ7u8GlgGcC9weuCnwbeD3wbGB37LGtk+PWdR++Wd2L7wG8q3PEoc6DXwdeAfwW8H3gb4E/B/Zs66/b5s4jABcDfB/g70pofAp4OPAw4IbA1xfrMq2mEHgf8Bbgs4AX2ecAnohyPrfqvxK4K/CHwP8ALwauCHhBuAC4JPAF4HvAE4ArAW8ATqibXcDPT+A3gbfVC9Q/2hGAscX8LBdpoXD7V0D2Mv8v4Dr1PtP/rA59UHpanReKw6cD3ixv0Hlt5Yn16kRFouVV1YfnU8rsBOT8OOBBJbBvDryumPuAZIk9Zuc5T00fgH4b+DzwDmBSAA7B3f0CPYc837wHXb8E/rPqfjPPeEdVNwJwMXP4NO2Ee2Sn+b/Xk4eekZTtIfCrdbO7DXAS4Cv4FHZHAG+tQ14d2AUcBry/PCTvBfYHvlV17lsn8JVLxGzPaNez11+uua+XVVGhuNb7HVssz97Pq5ve725xSK/rzvVjy0toNb2z3y0hovfi14DTgFuWd9A6/n1yedy7Xvbl/bLVPJLXF9nqgW1FMXJeXZtij+XYVW9cVwAOxd37vHv9XqWz3+9TyoGw3yp7ASMA55+Yl64T+17AOzvNfdK7MaA4SdkeAtcF/qO8gKdWSNeQrx6/H3QO+cUS44bA/gw4HLhR53s9KLrxDQn7VJcyOwG9p7LT4/GxjgCUZWwxO8c+NRVuPtx48/F6803gr4FXV6cHAnoCb1qewnasd1d4V0/VQ4CXAFeYGIjhX22rBytlNgKKgUcAdyhPkdeaD9SD0fFA7DEbx761JgXgUNzfWA+43kdauUk9CHuM0/sO/OJqHwE4P3k9TF5wdTu7Jq2Vp1YIwBBLyvAEnKvewBRvzfPxB3Wj0rvRLV58PSkNzRvWOqAuzt06vrnFsLEX6JTZCOg5NdxlCPhHEwIwtpiN4RC1ZG9RwL291iXp7XO+e7M6BHBpiusEm9fb+p4L1wLuCHi9cv4bzuoWQ12KPz0eKbMR8NrkeljDjW3ZiedJYxh7zMaxb61JATgUd+8nZ9R62jbGpgM8hl7zlSwRgPObbSvDe8IbijRhIWV4AiZx3Bn4nU6Cx1ai44PlAfGpvHvT647KBJAH1hrD4Ue7fj0aQv9cCWk9rJauBzC2WJ7NnbvawptPKyZzKMxv1RGAXqtMSGhFD6F2vFMJQD2Bkw+setiPAwwzp8xGwAejF1YyggmBRoIU5I+v9cZNiMQes/FctNZWArAv965DoY3NhysTDT3fPrPogC/udhGA81sgIeD5mfVt8XLg7rWIvetuT9ixL9nZ28vfJQ96OFoxwcaLrpmOepU+lHD87EB71DwT8CHHxLNWXKfkmkxvTEOFvnoMcUc1dc2xgtmH1Fa0xQPKIRB7LGc6JAQ8J+cIwDmBVXWTQNxuwYXwrbguxxBlkkAWYzqtlfNT8efC3t+r9X/dei3xwAutWakWt+XxyWwyCcT1Us0bYha3a9mSBDK7rfap8GG3haHCL1eigTdBE3Jii9mZLlrTbYz05HWTQF4K3KK8f23xu5+9oA7ig6vZwoYpu0kgtvmXquPfejOMYiQJZHbruPuAgs+M7Fa8Dzy4Quyxx+ws+9TcKgmk73ngw5UhfpNA2tZhnkdH1zrcld0KJgJwsenWtoExxGj8320UjgQOBnw6TxmGgAvbDS26+LZ7Qzq79vPzKF5071LrmUxOcE9At3qZ3AbGLD33bTRhxD263CvKPc9SFifQDQHHFotznLeloV7XH5vk5IOPe5MZ3vU69KbqzBtUEyGGdV3z50PU5DYwhsdcO2hxuYTXr2wDM59FvJ7crjgaAjZBQJavLcFtb7HHfExnre2uBCYHWtwaybC7iX3eC9ySbQjuOhq8/3ykhOD16h5igqHbjq1siQBc3HR6/44pj5MZqWbOuTVJynAEtnqy8snai67lsrX+RqHY3Qhaj1QrbgStmJzcCNpEkJTFCUwKwNhicZbztvShxyQDb0YuizAhpGUB21fbAFdx190I2mtVKz4MTW4E/cfZCHpeU6B33E2BjVQYVTDxxuQyBULzGMUec2OdqYEPNdN2cjDCY5LTUNzdf9YQvw9b7jjxN2XflfX+tYvETJRTKQRCIARCIARCIARCYD0IxAO4HnbMrwiBEAiBEAiBEAiBmQlEAM6MKhVDIARCIARCIARCYD0IRACuhx3zK0IgBEIgBEIgBEJgZgIRgDOjSsUQCIEQCIEQCIEQWA8CEYDrYcf8ihAIgRAIgRAIgRCYmUAE4MyoUjEEQiAEQiAEQiAE1oNABOB62DG/IgRCIARCIARCIARmJhABODOqVAyBEAiBbSHwzHrX9Y23pffNTidfk7WNh0rXIRACq0AgAnAVrJQxhsDqETgE+ATwQeBOKzb8yTecbDV8692mvvwp4NtnfDWbgm6et8z4OqvLAL5TdrtKBOB2kU2/IbCiBCIAV9RwGXYIjJzAa4D/BR4G3LDeyznyIV84vHkE4FeBPwUuDfiO3tfVK6N8D++YSgTgmKyRsYTACAhEAI7ACBlCCKwZgV8Cvl2C6FnAafXezPYz2/s79Qw+DzgIOBm4L3Czeq/tNYB/BB4KnFcN9ZK9sOrtC3yu3sH92fred38eC1yhw/PuwDvrnaB+3MKtvsTd97f6ntwTgSOBc+od0w+asMe1gTOm2GiaUHwHcED9jtbk+fWe2P2A7wBvKh56DbtjaiFg+bwAOBiwzpcA33V9ZtW/a/0Ov/e9s7739DnAz+p73w98XL239GvAY4AP1BjetWZzLT8nBEJgQQIRgAuCS7MQCIEtCTwEeGQJwLsALwcOrHVoNmoC8DPAE0vgGTr9ZoVOnwIYFlW4KfgUUJaXAfcsr6Ji6BjgbsB1ge/Xy99nEYBPKEH0jBKAHvu1wNOAy5cgPLU8ex73e8AFMwjAGwHvL7F4y079pwMfKbHmS+VfXSJXkTcpAC8F/HfV8YXzehZ9Ab0vvP86cMcKMx9dIfbrAK8q4arYvgTwxerjcYBCWSY3iQDMGRsCIdAlEAGY+RACITA0gU+VSFGwKWj0Bt4P+FAdqAnA2wEfrs8Ufc8FFDR6rSwKIL1pegr1Kv6gRN6b6/tfLLGlwFEozuoBfBJw1fL42ZVC7NZAE23zhIBd6/gTwLEo1nYD9wb0BG5VPP59gJtPEYBXrLWAMvr4lA5OKoEqq1YeUL/h6sAdgH8qbt+oCvLTy3kPIB7AoWd7+guBFSUQAbiihsuwQ2CkBG4A6D0z3PndGuMrAIWNYUxLE4BXLu+anz0YsJ5CrxU9WoY7bwr8Rnm2FIQtFGo9vYQKQ72OswrAe1V4tR1HT9mjy0vpZ/MIwNMr/Kqn7cnADyuc3DWPXsvHlqdSz6ai2Hr+fstkFrDrCBXMJtAomvVQKqIt55aXr+uRvCRw2WJnKNuQrx7XVvRqnhUBONIzJsMKgYuJQATgxQQ+hw2BNSWgN00PV1egeJ1xLdvVSqw1Aej6O4WJZZp46wojw6tfAK41kVCiR8vsWdcKPrDCzQqeVhR7Cqh2rZu25YrizH+KS8s8AtAx2daiF9D1eoasXYNn0av4ScBws+Hhs2sNo2HotlZx2pgM2eq5UwAbNr49YMj8/OrrhCnzR8+poWH/dQWg4tTjxgO4piddflYILEIgAnARamkTAiEwjYCeLcOOikCTDrrFkKhrAfXyLSIA9Qy6zk9PYTcErAfOEPCLgEMrcWSf8pR5fJMjnjqnAHTsXymv4EVZeppQVMi2ULbJKwq9R1Vou/VlhrRewYsSgN3jmiBjoovCzvD6l0vwThtbCwFfs9YcWsd1g++LAMxJGwIh0CUQAZj5EAIhMBQBM27fWqFNPU7dohA7rJIRFhGA9qXQ06Ont8+EiJYE4rpBw8CGmf1c75ti0+QJ1wa6Nm4eD6BJFWbkupbPrWwUnq7tmyzTBKDrAM0YfkmJ0sOBvweOKBF35/LgGbadJgDNOD4KeE8JOEPqxwMmkryyxNx7S9i+vcZleFwvoXVMAvm3ChkrPvX+vbSykuMBHGqmp58QWAMCEYBrYMT8hBAYCYF/KAGiyJksruM7pYSIosSs1nlCwPbnOje9i66P08s3uQ2MdRShij7XILp+TiGloJtHAF6/tlYx7Hw5YJ5tYByDHkfDwoZhFZCO2TWKbmPj1jaGcg37ThOAV6nkl1sAVyoh5zYvrodsIlSPnnsPGiY2tK5HUK+i2cUWx9+2gVGM6jmMB3AkJ0mGEQJjIRABOBZLZBwhEAIhEAIhEAIhsCQCEYBLAp3DhEAIhEAIhEAIhMBYCEQAjsUSGUcIhEAIhEAIhEAILIlABOCSQOcwIRACIRACIRACITAWAhGAY7FExhECIRACIRACIRACSyIQAbgk0DlMCIRACIRACIRACIyFQATgWCyRcYRACIRACIRACITAkghEAC4JdA4TAiEQAiEQAiEQAmMhEAE4FktkHCEQAiEQAiEQAiGwJAIRgEsCncOEQAiEQAiEQAiEwFgIRACOxRIZRwiEQAiEQAiEQAgsiUAE4JJA5zAhEAIhEAIhEAIhMBYCEYBjsUTGEQIhEAIhEAIhEAJLIvB/Id0DDJzGE6YAAAAASUVORK5CYII=\" width=\"640\">" + ], + "text/plain": [ + "<IPython.core.display.HTML object>" + ] + }, + "metadata": {}, + "output_type": "display_data" + } + ], + "source": [ + "df = mk.run_scenario(pool_size, rho, successprob, issuerweights, amount)\n", + "ax = mk.plot_prob_over(df)" + ] + }, + { + "cell_type": "code", + "execution_count": 115, + "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", + " this.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 overriden (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,iVBORw0KGgoAAAANSUhEUgAAAoAAAAHgCAYAAAA10dzkAAAgAElEQVR4Xu3dC9y91Zz//7ehUvQtIiqmg6EUJsdBpnKYiRojh9SgA0rFoFCkqBQqTOWsHEaR+BkVchinDtNxlFNqfjl9O8lhoi8piZ//472t/f1f3e1978917Wvde637fl2PR4/ovq611/W81t77vde11rruJDYEEEAAAQQQQACBJSVwpyV1tpwsAggggAACCCCAgAiANAIEEEAAAQQQQGCJCRAAl9gF53QRQAABBBBAAAECIG0AAQQQQAABBBBYYgIEwCV2wTldBBBAAAEEEECAAEgbQAABBBBAAAEElpgAAXCJXXBOFwEEEEAAAQQQIADSBhBAAAEEEEAAgSUmQABcYhec00UAAQQQQAABBAiAtAEEEEAAAQQQQGCJCRAAl9gF53QRQAABBBBAAAECIG0AAQQQQAABBBBYYgIEwCV2wTldBBBAAAEEEECAAEgbQAABBBBAAAEElpgAAXCJXXBOFwEEEEAAAQQQIADSBhBAAAEEEEAAgSUmQABcYhec00UAAQQQQAABBBZ7APT5rS/pt1xqBBBAAAEEEEBgEQisKemnkv48zbks9gC4gaRrpwHiWAQQQAABBBBAoDCB+0m6bpo6LfYAuEzSimuuuUbLlvl/siGAAAIIIIAAAnUK/OY3v9H9739/V34tSb+Z5iyWRABcsWIFAXCaVsKxCCCAAAIIIDBzAQfAtdZy9iMATroYgx5AAuAkJv6OAAIIIIAAAqULEADjV4gAGLdiTwQQQAABBBAoWIAAGL84BMC4FXsigAACCBQs8Kc//Um33XZbwTWkatMKrLLKKrrzne88thgCYFyYABi3Yk8EEEAAgQIF/vznP+tnP/uZbrzxxgJrR5X6Flh77bV13/veV3e60x2naRAA49oEwLgVeyKAAAIIFChw/fXXD8LfuuuuqzXWWGNkMCiw2lSppYCD/s0336xf/OIXcghcb7317lACATCOSgCMW7EnAggggEBhAr7te+WVVw7C3zrrrFNY7ahODoEbbrhhEAIf9KAH3eF2MAEwLk4AjFuxJwIIIIBAYQK///3v9ZOf/EQbbbSRVl999cJqR3VyCNxyyy1avny5Nt54Y931rne93UsQAOPiBMC4FXsigAACCBQmMAyAo8JAYVWlOj0JzHfNCYBxZAJg3Io9EUAAAQQKEyAAFnZBFqA6BMB+kAmA/ThSCgIIIIDADAQIgHdE9+zY0047TTvuuGPnK3LYYYfp9NNP17e//e2xZeyxxx6DyTfez9u2226rLbfcUscdd9zg//u2/H777Tf4p8+NANiPJgGwH0dKQQABBBCYgcB8YWCj1525YDVaftQOrV/LAeqjH/3o4Li73OUug2fYPutZz9Lhhx+uu93tbq3LGx6wUAHQTxHzzFzPyB0VAH/5y18OzsMzs731US+XQwDs3DRudyABsB9HSkEAAQQQmIFA7QHw5z//uT7ykY8MFrA+99xzteeee2r33XfX+973vttpOmh5xrOD4qStj6AV6QGcW4+5PYBz/95HvQiAk65+/O9LKgDm/DXY5ddf/DKxJwIIIIDAKIHaA2DzFqrPb6+99tLnP/95feITn9ATn/hEfelLX9LBBx+s7373u/ryl788+G8Oh29/+9t1zTXXDGbCHnLIIdp1111X8jhovfe979VnP/tZnXXWWYNFk4855hjttNNOK/d57WtfO7hNfO211w7+/vznP19vfOMb5SdteBsGwH333VdHHnmkvPTKDjvsoBNPPHFlj1+bW8C+HXzVVVetfP0NN9xwULdNNtlEF198sR71qEet/Nu73vWuwfl5pu+oxZ7pAezns4AA2I+jCIA9QVIMAggg0EJgsQXAV7ziFTrllFP06U9/ehD2Hvawhw3CkIOSb7Wec8452nnnnQfj7J7ylKcMwuKBBx6or3zlK4P9vTk0eU3Eo446SltvvbVOPvlkvfWtb9X3vvc9PfjBDx7s41D3pCc9Seuvv/7gvzt4vupVrxqUNQyAft2/+7u/0zve8Q55du2LX/xiPeYxj9HHP/7xwT5tAqBvB3utRvd2PvWpTx2s33fve99b//iP/6gHPvCBes973rPyqj/iEY/Q05/+9MGt8Lahn1nA8TcPATBuNe+eBMCeICkGAQQQaCGwmAKge8K23357PfnJT5Z73hzoPMHiGc94xkqRrbbaSltssYVOOOGElf/tuc99rn73u9/pzDP/MubRAXCfffa53W3kxz72sXKwcs/gqO1tb3ubPvnJT+qb3/zmygDokOheuPvd736D/+beSPcCXnfddYNewzYBcFivuZNTPvWpTw3q6qe5rLbaavrOd76jhz/84frxj388mESyWALgSyUdIMnPLvm+JE+LOXdMO3+WpNdL+htJ7o/9gaR3SDq5sb8fgneopJdIuoekiyS9LJUdffsQAKNSE/YjAPYESTEIIIBAC4HaA+DHPvaxwWLGf/zjHwfjAB323v/+9+vyyy8fBEDfot1ggw1WitzznvfUscceOxgnONyOP/54+R+HpmHQ8uSS3XbbbeU++++//2BG7ze+8Y3Bf3MPo3sRf/jDH+qmm24avP6yZcsGT9jw5lvAJ5100soy/d886cO9kL51u8022/QSAP/whz8MAuY73/lO7bLLLnrlK1+pyy67TF/72tfGtoLabgHvnMKbQ+B5kvaWtKekzSVdPeIst02h7n8k/UHSP6UA6GlGX077v1bSwe6FlXSlpEMkbS1pU0m/Db5/CIBBqEm7EQAnCfF3BBBAoH+B2gOge9M8ps9j73w7djgGzyHLAfDXv/71yjF31nMAdHBrhjv/f4+b+9GPfjRvAHTv2te//nVdeOGFesITnjC4xbrddttprbXW0qmnnjq41esxieMC4PD26tlnnz24tdxHD6Bf69WvfvUg9H3uc58bhF2fj8ckjttqC4DunbtU0r6NE7pCkhfPOSj4lvDx7t99g3t4Jf1UkhfbOTodv5qkn0tyMPxAsEwCYBBq0m4EwElC/B0BBBDoX6D2ADh3EshQaFwAHHcL+Oabbx6MB/TmW8C+hdy83fu4xz1ucGvV/81Bz/8eBkYf49nH7hVsBkDfAr766qsHwdSbJ6H4FnXXW8CrrrrqYHLLs5/97Ns1hCuuuEIPechDBvVyz6NvB8/3WL+aAuCqkm6W5Ok3pzXO+nhJW0raZsJbwmHvSZI+K8mrOn5F0iaSHPUfIelbjePPkOT4/v/3Dc9fOAGwp88jAmBPkBSDAAIItBBYagHQYwI95s+3TD1W0L1mnrjx1a9+dbAQ8zAA3ute99LRRx896OnzpA2HOU/22HzzzXXGGWfoOc95zmByyKMf/ejB2EH3BnqZmWYA9CQQB0f/271/DokeR+gQ561tD+CDHvSgwcQVzzb2eL973MOj1/6yOdh6/OGLXvSiOyyBM7c51BQAHZ2v8/lJOr9xIh7j56DmW7ajtrXSce7Z+5Mk3z7+cNrx8elWsgcGuCdwuHlU6IaSthtTpsvyP8NtTUnX+r6+7/0v9o1lYBb7Feb8EEBgqQkstQDo6xtZBsazah0WPWvYEzY8I9hj7IabQ+OHP/xh3XrrrYOJHZ4k4t63ZgD08XvvvfcgPP7qV78a9P598IMfXBnc2gZAh1XPNPbEEt/q9b+Hm+viWcaeCONQOt9WYwB0aLugcVIev+eFezYbc6J/lXr67i7pyenWr3sAz5I0DIAOl9c3jj9R0v0lPXVMmYeliSO3+zMBcPqPTHoApzekBAQQQKCtAI+CaytW5v5vfvObB+MQ3Us5aaspAE57C3ho8cEU7ty71/UWMD2Ak1pWx78TADvCcRgCCCAwhQABcAq8Ag71DGSPAfS6f0ccccRgPcJJW00B0OfiSSCXpNu4w3O7XJLH7EUngXxI0gP8vOXGJJBjJR2TCnTQ9PxtJoGMaT3cAp70tuLvCCCAQF0CBMC6rtfc2vo2sscU7rjjjoMFsL1A9KSttgA4XAZmn3Qb2Gv3OeZuIcnPRjkpjfcbhkH/26sxeqKHg932abavZxG7J9Cbg573e2FaJ9BjCh0OWQaGADjp/cPfEUAAgUUhQABcFJex1UnUFgB9cp7E4WeseCHoyyTtL+mcdNYe1+fRkF7Tz9uRkhwavfz2LZK8HqBnDX+yoTRcCNprCjYXgnbZ0Y1ZwFGpCftxC7gnSIpBAAEEWggQAFtgLZJdawyAJdITAHu6KgTAniApBgEEEGghQABsgbVIdiUA9nMhCYD9OIoA2BMkxSCAAAItBIZhwM+NnW/x4BZFsmvhArfccstgCZmNN9548Bi95jZ8WokkL6X3m2lOxbdZF/NGAOzp6hIAe4KkGAQQQKCFgBcvvvLKK7XuuutqnXXWaXEku9YqcMMNNwyeWeyFpedOGiEAxq8qATBuNe+eBMCeICkGAQQQaCngR4d5AWOHwDXWWGPwKDS2xSfw5z//WX7kncPf2muvrfXW85SK228EwPh1JwDGrQiAPVlRDAIIINCngIPBz372s5VPseizbMoqT8Dhz083GRX0CYDx60UAjFsRAHuyohgEEEAgh4BvB9922205iqbMQgRWWWWVedcKJADGLxQBMG5FAOzJimIQQAABBBDIIUAAjKsSAONWBMCerCgGAQQQQACBHAIEwLgqATBuRQDsyYpiEEAAAQQQyCFAAIyrEgDjVgTAnqwoBgEEEEAAgRwCBMC4KgEwbkUA7MmKYhBAAAEEEMghQACMqxIA41YEwJ6sKAYBBBBAAIEcAgTAuCoBMG5FAOzJimIQQAABBBDIIUAAjKsSAONWBMCerCgGAQQQQACBHAIEwLgqATBuRQDsyYpiEEAAAQQQyCFAAIyrEgDjVgTAnqwoBgEEEEAAgRwCBMC4KgEwbkUA7MmKYhBAAAEEEMghQACMqxIA41YEwJ6sKAYBBBBAAIEcAgTAuCoBMG5FAOzJimIQQAABBBDIIUAAjKsSAONWBMCerCgGAQQQQACBHAIEwLgqATBuRQDsyYpiEEAAAQQQyCFAAIyrEgDjVgTAnqwoBgEEEEAAgRwCBMC4KgEwbkUA7MmKYhBAAAEEEMghQACMqxIA41YEwJ6sKAYBBBBAAIEcAgTAuCoBMG5FAOzJimIQQAABBBDIIUAAjKsSAONWBMCerCgGAQQQQACBHAIEwLgqATBuRQDsyYpiEEAAAQQQyCFAAIyrEgDjVgTAnqwoBgEEEEAAgRwCBMC4KgEwbkUA7MmKYhBAAAEEEMghQACMqxIA41YEwJ6sKAYBBBBAAIEcAgTAuCoBMG5FAOzJimIQQAABBBDIIUAAjKsSAONWBMCerCgGAQQQQACBHAIEwLgqATBuRQDsyYpiEEAAAQQQyCFAAIyrEgDjVgTAnqwoBgEEEEAAgRwCBMC4KgEwbkUA7MmKYhBAAAEEEMghQACMqxIA41YEwJ6sKAYBBBBAAIEcAgTAuCoBMG5FAOzJimIQQAABBBDIIUAAjKsSAONWBMCerCgGAQQQQACBHAIEwLgqATBuRQDsyYpiEEAAAQQQyCFAAIyrEgDjVgTAnqwoBgEEEEAAgRwCBMC4KgEwbkUA7MmKYhBAAAEEEMghUGoAfKmkAyStJ+n7kvaTdO4YgL0k7SbpIenvl0h6vaSLG/v/u6Td5xx/kaTHtkAlALbAmm/X5Uft0FNJFIMAAggggAACXQRKDIA7SzpZkkPgeZL2lrSnpM0lXT3iJD+e9jtf0u8lHSjpWZK2kHRd2t8B8D6SXtg4/g+SftUCjQDYAosA2BMWxSCAAAIIIJBBoMQA6J65SyXt2zjfKySdLumggMGdJf1a0r9KOqkRANeWtGPg+HG7EACnwGseSg9gT5AUgwACCCCAQEeB0gLgqpJulrSTpNMa53S8pC0lbRM4zzUl/SKV8flGAHT4c6/fjZLOlnRw2i9Q5GAXAmBUasJ+BMCeICkGAQQQQACBjgKlBcD1023brST5lu5w85g+j+HbNHCe75G0XRoT6FvC3nxb+SZJV0naWNIRku4i6ZGSbh1T5mqS/M9wc7C8dsWKFVq2zFlwcW8bve7MbCdIAMxGS8EIIIAAAgiEBEoNgI+XdEHjDNxbt6ukzSaclcf/vU7StpK+O8++nlziMLiLpM+M2e8wSYfO/RsBMNSu5t2JADi9ISUggAACCCAwjUBpAXCaW8CvkXSIpKdI+mYA5QeSPijp6DH70gMYQOyyCwGwixrHIIAAAggg0J9AaQHQZ+ZJIF7KxbOAh9vlks6YZxKIl4xx+POt3wsDPOukW80vaUwUmXQYYwAnCQX/TgAMQrEbAggggAACmQRKDIDDZWD2SbeBHdK81p+XdfFtW8/s9fIuwxnBvu3rMX3PS8vBDKk85s//3F2Sb+f+h6TrJW0k6S2S/lrSgyX9NmhLAAxCTdqNADhJiL8jgAACCCCQV6DEAOgzdu+fg53H6l0maX9J5ySKsyQtl7RH+v/+3xuOYDo8Bb/V0xIyD5fkpWAcAr8h6Q2SrmnBSwBsgTXfrgTAniApBgEEEEAAgY4CpQbAjqeT9TACYE+8BMCeICkGAQQQQACBjgIEwDgcATBuNe+eBMCeICkGAQQQQACBjgIEwDgcATBuRQDsyYpiEEAAAQQQyCFAAIyrEgDjVgTAnqwoBgEEEEAAgRwCBMC4KgEwbkUA7MmKYhBAAAEEEMghQACMqxIA41YEwJ6sKAYBBBBAAIEcAgTAuCoBMG5FAOzJimIQQAABBBDIIUAAjKsSAONWBMCerCgGAQQQQACBHAIEwLgqATBuRQDsyYpiEEAAAQQQyCFAAIyrEgDjVgTAnqwoBgEEEEAAgRwCBMC4KgEwbkUA7MmKYhBAAAEEEMghQACMqxIA41YEwJ6sKAYBBBBAAIEcAgTAuCoBMG5FAOzJimIQQAABBBDIIUAAjKsSAONWBMCerCgGAQQQQACBHAIEwLgqATBuRQDsyYpiEEAAAQQQyCFAAIyrEgDjVgTAnqwoBgEEEEAAgRwCBMC4KgEwbkUA7MmKYhBAAAEEEMghQACMqxIA41YEwJ6sKAYBBBBAAIEcAgTAuCoBMG5FAOzJimIQQAABBBDIIUAAjKsSAONWBMCerCgGAQQQQACBHAIEwLgqATBuRQDsyYpiEEAAAQQQyCFAAIyrEgDjVgTAnqwoBgEEEEAAgRwCBMC4KgEwbkUA7MmKYhBAAAEEEMghQACMqxIA41YEwJ6sKAYBBBBAAIEcAgTAuCoBMG5FAOzJimIQQAABBBDIIUAAjKsSAONWBMCerCgGAQQQQACBHAIEwLgqATBuNdMAuNHrzuyppncsZvlRO2Qrm4IRQAABBBBYKAECYFyaABi3IgD2ZEUxCCCAAAII5BAgAMZVCYBxKwJgT1YUgwACCCCAQA4BAmBclQAYtyIA9mRFMQgggAACCOQQIADGVQmAcSsCYE9WFIMAAggggEAOAQJgXJUAGLciAPZkRTEIIIAAAgjkECAAxlUJgHErAmBPVhSDAAIIIIBADgECYFyVABi3IgD2ZEUxCCCAAAII5BAgAMZVCYBxKwJgT1YUgwACCCCAQA4BAmBclQAYtyIA9mRFMQgggAACCOQQIADGVQmAcSsCYE9WFIMAAggggEAOAQJgXJUAGLciAPZkRTEIIIAAAgjkECAAxlUJgHErAmBPVhSDAAIIIIBADgECYFyVABi3IgD2ZEUxCCCAAAII5BAgAMZVCYBxKwJgT1YUgwACCCCAQA6BUgPgSyUdIGk9Sd+XtJ+kc8cA7CVpN0kPSX+/RNLrJV3c2P9Okg6V9BJJ95B0kaSXpbKjrgTAqNSE/ZYftUNPJY0uZqPXnZmt/Nx1z1ZxCkYAAQQQQKAhUGIA3FnSyZIcAs+TtLekPSVtLunqEVfv42m/8yX9XtKBkp4laQtJ16X9XyvpYEl7SLpS0iGStpa0qaTfBlsEATAINWm33CGKADjpCvB3BBBAAIGlLlBiAHTv3KWS9m1cnCsknS7poMAFu7OkX0v6V0knSXLv308lHSfp6HT8apJ+LsnB8AOBMr0LATAINWk3AuAkIf6OAAIIIIBAXoHSAuCqkm6WtJOk0xqnfrykLSVtE+BYU9IvUhmfl7SJpB9JeoSkbzWOP0PSjZJ2D5RJAAwiRXYjAEaU2AcBBBBAAIF8AqUFwPXTbdutJPmW7nDzmD4HNd+ynbS9R9J2aUygbwk/Pt0i3iD1BA6PP0HShmnfUWW6l9D/DDcHy2tXrFihZcvcGbi4t5pvo9Zc98Xdqjg7BBBAAIFSBEoNgA5tFzSQPH5vV0mbTYDz+L/XSdpW0nfTvsMA6HB5feP4EyXdX9JTx5R5WJo4crs/EwCnb7r0AE5vSAkIIIAAAghMI1BaAJzmFvBr0uSOp0j6ZgOl6y1gegCnaVnzHEsAzARLsQgggAACCAQFSguArrYngXgpF88CHm6XS/KYvXGTQLxkjGf2+tbvhXPOfTgJ5FhJx6S/OWh6nCCTQMY0lJpvo9Zc9+D7lt0QQAABBBCYSqDEADhcBmafdBvYa/d5rT8v63JVmtnr5V2GYdC3fY+Q9Lw01m8IcpMk/+PNQc/7v1DSD9I6gb5NzDIwBMBWb6DcvZetKsPOCCCAAAIIdBQoMQD6VNz752DnhaAvk7S/pHPSOZ4laXla08//yf/bkznmbodL8jg+b8OFoL2mYHMhaJcd3VgGJio1Yb/cIYoewJ4uFMUggAACCCxagVIDYIngBMCergoBsCdIikEAAQQQQKCjAAEwDkcAjFvNuycBsCdIikEAAQQQQKCjAAEwDkcAjFsRAHuyohgEEEAAAQRyCBAA46oEwLgVAbAnK4pBAAEEEEAghwABMK5KAIxbEQB7sqIYBBBAAAEEcggQAOOqBMC4FQGwJyuKQQABBBBAIIcAATCuSgCMWxEAe7KiGAQQQAABBHIIEADjqgTAuBUBsCcrikEAAQQQQCCHAAEwrkoAjFsRAHuyohgEEEAAAQRyCBAA46oEwLgVAbAnK4pBAAEEEEAghwABMK5KAIxbEQB7sqIYBBBAAAEEcggQAOOqBMC4FQGwJyuKQQABBBBAIIcAATCuSgCMWxEAe7KiGAQQQAABBHIIEADjqgTAuBUBsCcrikEAAQQQQCCHAAEwrkoAjFsRAHuyohgEEEAAAQRyCBAA46oEwLgVAbAnK4pBAAEEEEAghwABMK5KAIxbEQB7sqIYBBBAAAEEcggQAOOqBMC4FQGwJyuKQQABBBBAIIcAATCuSgCMWxEAe7KiGAQQQAABBHIIEADjqgTAuBUBsCcrikEAAQQQQCCHAAEwrkoAjFsRAHuyohgEEEAAAQRyCBAA46oEwLgVAbAnK4pBAAEEEEAghwABMK5KAIxbEQB7sqIYBBBAAAEEcggQAOOqBMC4FQGwJyuKQQABBBBAIIcAATCuSgCMWxEAe7KiGAQQQAABBHIIEADjqgTAuBUBsCcrikEAAQQQQCCHAAEwrkoAjFsRAHuyohgEEEAAAQRyCBAA46oEwLgVAbAnK4pBAAEEEEAghwABMK5KAIxbEQB7sqIYBBBAAAEEcggQAOOqBMC4FQGwJyuKQQABBBBAIIcAATCuSgCMWxEAe7KiGAQQQAABBHIIEADjqgTAuBUBsCcrikEAAQQQQCCHAAEwrkoAjFsRAHuyohgEEEAAAQRyCBAA46oEwLgVAbAnK4pBAAEEEEAghwABMK5KAIxbEQB7sqIYBBBAAAEEcggQAOOqBMC4FQGwJyuKQQABBBBAIIcAATCuSgCMWxEAe7KiGAQQQAABBHIIEADjqgTAuBUBsCcrikEAAQQQQCCHAAEwrkoAjFsRAHuyohgEEEAAAQRyCBAA46oEwLgVAbAnK4pBAAEEEEAghwABMK5KAIxbEQB7sqIYBBBAAAEEcgiUGgBfKukASetJ+r6k/SSdOwZgC0lvkvRISRtK2l/ScXP2PUzSoXP+288l3bcFKgGwBdZ8uy4/aoeeShpdzEavOzNb+bnrnq3iFIwAAggggEBDoMQAuLOkkyU5BJ4naW9Je0raXNLVI67eoyU9V9Ilko6VdPSYAPgcSU9pHP8nSb9s0RoIgC2wCIA9YVEMAggggAACGQRKDIAXSbpU0r6N871C0umSDppgsDyFv1E9gDtK2nIKQwLgFHjNQ3P3otED2NOFohgEEEAAgUUrUFoAXFXSzZJ2knRaQ/34FN62mSIA+pbyCkm3SnLIfL2kH7e4sgTAFlj0APaERTEIIIAAAghkECgtAK4v6TpJW0k6v3G+Dmu7S9q0YwB8mqQ1JF0p6T6SDpG0mSSPH7xhTJmrSfI/w21NSdeuWLFCy5Y5Cy7ureZetJrrvrhbFWeHAAIIIFCKQKkB8PGSLmggHSxp1xTa5u1cGnMLeO4xd5P0I0nHSPq3MQWOmjgiAuD0TZdbwNMbUgICCCCAAALTCJQWAHPdAh5l9BVJP5wz1rC5Hz2A07SseY4lAGaCpVgEEEAAAQSCAqUFQFfb4/M8o9ezgIfb5ZLOmGISyFwOhzv3AJ6QlpCJcDEGMKIU2IcAGEBiFwQQQAABBDIKlBgAh8vA7JNuA79E0l5pvN5Vkk5K4wSHM4Lda+glYrx9QdLH0z83pR4+//e3S/pcWkZm3TQG0BNKHirJZUY2AmBEKbAPATCAxC4IIIAAAghkFCgxAPp03ft3YFoI+rK0uPM5yeEsSV7uZY/0/zeS9JMRRmdL2jb991MlbS3pXmntvwslvUGSexajGwEwKjVhPwJgT5AUgwACCCCAQEeBUgNgx9PJehgBsCdeAmBPkBSDAAIIIIBARwECYByOABi3mndPAmBPkBSDAAIIIIBARwECYByOABi3IgD2ZEUxCCCAAAII5BAgAMZVCYBxKwJgT1YUgwACCCCAQA4BAmBclQAYtyIA9mRFMQgggAACCOQQIADGVQmAcSsCYE9WFIMAAggggEAOAQJgXJUAGLciAC5M0r0AACAASURBVPZkRTEIIIAAAgjkECAAxlUJgHErAmBPVhSDAAIIIIBADgECYFyVABi3IgD2ZEUxCCCAAAII5BAgAMZVCYBxKwJgT1YUgwACCCCAQA4BAmBclQAYtyIA9mRFMQgggAACCOQQIADGVQmAcSsCYE9WFIMAAggggEAOAQJgXJUAGLciAPZkRTEIIIAAAgjkECAAxlUJgHErAmBPVhSDAAIIIIBADgECYFyVABi3IgD2ZEUxCCCAAAII5BAgAMZVCYBxKwJgR6uNXndmxyMnH7b8qB0m78QeCCCAAAJLQoAAGL/MBMC4FQGwoxUBsCMchyGAAAIItBIgAMa5CIBxKwJgRysCYEc4DkMAAQQQaCVAAIxzEQDjVgTAjlYEwI5wHIYAAggg0EqAABjnIgDGrQiAHa0IgB3hOAwBBBBAoJUAATDORQCMWxEAO1oRADvCcRgCCCCAQCsBAmCciwAYtyIAdrQiAHaE4zAEEEAAgVYCBMA4FwEwbkUA7GhFAOwIx2EIIIAAAq0ECIBxLgJg3IoA2NGKANgRjsMQQAABBFoJEADjXATAuBUBsKMVAbAjHIchgAACCLQSIADGuQiAcSsCYEcrAmBHOA5DAAEEEGglQACMcxEA41YEwI5WBMCOcByGAAIIINBKgAAY5yIAxq0IgB2tCIAd4TgMAQQQQKCVAAEwzkUAjFsRADtaEQA7wnEYAggggEArAQJgnIsAGLciAHa0IgB2hOMwBBBAAIFWAgTAOBcBMG5FAOxoRQDsCMdhCCCAAAKtBAiAcS4CYNyKANjRigDYEY7DEEAAAQRaCRAA41wEwLgVAbCjFQGwIxyHIYAAAgi0EiAAxrkIgHErAmBHKwJgRzgOQwABBBBoJUAAjHMRAONWBMCOVgTAjnAchgACCCDQSoAAGOciAMatCIAdrQiAHeE4DAEEEECglQABMM5FAIxbEQA7WhEAO8JxGAIIIIBAKwECYJyLABi3IgB2tCIAdoTjMAQQQACBVgIEwDgXATBuRQDsaEUA7AjHYQgggAACrQQIgHEuAmDcigDY0YoA2BGOwxBAAAEEWgkQAONcBMC4FQGwoxUBsCMchyGAAAIItBIoNQC+VNIBktaT9H1J+0k6d8yZbSHpTZIeKWlDSftLOm7Evm3KHPVSBMBWTWv8zsuP2qGnkkYXU3OIqrnuWS8qhSOAAAII9CpQYgDcWdLJkhzYzpO0t6Q9JW0u6eoRZ/9oSc+VdImkYyUdPSIAti1z6gCY84vclSNEjX8f5LTHvdfPHwpDAAEEEJiRQIkB8CJJl0rat2FyhaTTJR00wWl5Cn9zewCnKXP4kq16AHOGEALg/K0gpz0BcEafVLwsAggggECvAqUFwFUl3SxpJ0mnNc70eElbStqmQwCctkwCYK9Njt7L+ThrDq89NxOKQwABBBDIKFBaAFxf0nWStpJ0fuO8Xy9pd0mbdgiAXctcTZL/GW5rSrp2xYoVWrbMnYGz64WiB3B29vQATmr5/B0BBBBAoAaBUgPg4yVd0AA8WNKukjabIgC2LfMwSYfOfT0C4PTNmhA13pAewOnbFyUggAACCEwWKC0ATnu7dtQYwK5l0gM4uf102oMASADs1HA4CAEEEECgN4HSAqBPzBM2PKPXs4CH2+WSzphyEkjXMod1YBJIT82OAEgA7KkpUQwCCCCAQEeBEgPgcMmWfdJt4JdI2kuS1/u7StJJaZzgcEawe/i8RIy3L0j6ePrnJkk/TP99UpkRPgJgRCmwDwGQABhoJuyCAAIIIJBRoMQA6NN179+BaSHoy9Lizuckh7O8DJ6kPdL/30jST0YYnS1p28Z/n6/MCDEBMKIU2IcASAAMNBN2QQABBBDIKFBqAMx4yp2LJgB2prv9gQRAAmBPTYliEEAAAQQ6ChAA43AEwLjVvHsSAAmAPTUlikEAAQQQ6ChAAIzDEQDjVgTAjlYsA9MRjsMQQAABBFoJEADjXATAuBUBsKMVAbAjHIchgAACCLQSIADGuQiAcSsCYEcrAmBHOA5DAAEEEGglQACMcxEA41YEwI5WBMCOcByGAAIIINBKgAAY5yIAxq0IgB2tCIAd4TgMAQQQQKCVAAEwzkUAjFsRADtaEQA7wnEYAggggEArAQJgnIsAGLciAHa0IgB2hOMwBBBAAIFWAgTAOBcBMG5FAOxoRQDsCMdhCCCAAAKtBAiAcS4CYNyKANjRigDYEY7DEEAAAQRaCRAA41wEwLgVAbCjFQGwIxyHIYAAAgi0EiAAxrkIgHErAmBHKwJgRzgOQwABBBBoJUAAjHMRAONWBMCOVjUHwJx1N2fuZ0h3vGQchgACCFQpQACMXzYCYNyKANjRKmeIyh2gctadANixQXEYAgggMEaAABhvGgTAuBUBsKNVzhBFAOx4UTgMAQQQWIQCBMD4RSUAxq0IgB2tCIDj4XIH2I6XjMMQQACBKgUIgPHLRgCMWxEAO1oRAAmAHZsOhyGAAAKtBAiAcS4CYNyKANjRigBIAOzYdDgMAQQQaCVAAIxzEQDjVgTAjlYEQAJgx6bDYQgggEArAQJgnIsAGLciAHa0IgASADs2HQ5DAAEEWgkQAONcBMC4FQGwoxUBkADYselwGAIIINBKgAAY5yIAxq0IgB2tCIAEwI5Nh8MQQACBVgIEwDgXATBuRQDsaEUAJAB2bDochgACCLQSIADGuQiAcSsCYEcrAiABsGPT4TAEEECglQABMM5FAIxbEQA7WhEACYAdmw6HIYAAAq0ECIBxLgJg3IoA2NGKAEgA7Nh0OAwBBBBoJUAAjHMRAONWBMCOVgRAAmDHpsNhCCCAQCsBAmCciwAYtyIAdrQiABIAOzYdDkMAAQRaCRAA41wEwLgVAbCjFQGQANix6XAYAggg0EqAABjnIgDGrQiAHa0IgATAjk2HwxBAAIFWAgTAOBcBMG5FAOxoRQAkAHZsOhyGAAIItBIgAMa5CIBxKwJgRysCIAGwY9PhMAQQQKCVAAEwzkUAjFsRADtaEQAJgB2bDochgAACrQQIgHEuAmDcigDY0YoASADs2HQ4DAEEEGglQACMcxEA41YEwI5WBEACYMemw2EIIIBAKwECYJyLABi3IgB2tCIAEgA7Nh0OQwABBFoJEADjXATAuBUBsKMVAZAA2LHpcBgCCCDQSoAAGOciAMatCIAdrQiABMCOTYfDEEAAgVYCBMA4FwEwbkUA7GhFACQAdmw6HIYAAgi0EiAAxrkIgHErAmBHKwIgAbBj0+EwBBBAoJVAqQHwpZIOkLSepO9L2k/SufOc2bMlHSHpAZJ+JOlgSac19v93SbvPOf4iSY9toUUAbIE1367Lj9qhp5JGF0OIGu1Ss7vPKHf9szZKCkcAAQQKEygxAO4s6WRJDoHnSdpb0p6SNpd09Qi/x6Vw+IYU+p4p6U2SniDJIc+bA+B9JL2wcfwfJP2qxfUgALbAIgB2wyK8jnfLGQBzuhNeu70XOAoBBPIKlBgAHdoulbRv49SvkHS6pINGcHxSksPZ0xp/+5KkX0v6l0YAXFvSjlNwEgCnwGsemvOL3K+T88ucuo9vBDndc4eomuve09uSYhBAYIkJlBYAV5V0s6Sd5tzCPV7SlpK2GXF93Ct4bPpn+Of9023jDRsB0OHPvX43Sjo73Sb+RYvrTQBsgUUPYDesnEGk5vBKAOzWnjgKAQQQGCdQWgBcX9J1kraSdH6j0q9PY/g2HXEiDnV7SDql8bfnSfqIpNXSf/Nt5ZskXSVp4zRe8C6SHinp1jE4PnZ4vHdZU9K1K1as0LJlzoLzbzm/yHN/Gbr8nPWvOYhQ9/HtPmebyd3ma677pM8i/o4AAgiMEig1AD5e0gWNCntSx66SNhsTAD3B4xONvz1f0ock3XXMZffkEofBXSR9Zsw+h0k6dO7fCIDTv5EIUbMJUTW7EwCnf99RAgIIINAUKC0A5roFPOqq/0DSByUdTQ/gHQVy9ojUHESo+2zCKwGQLy4EEECgX4HSAqDPzpNALkmzgIdne7mkM+aZBOLbs9s3aL6YxvoNJ4HMVVsn3Wp+iaSTgqSMAQxCTdqNEDWbEFWzOwFw0ruKvyOAAALtBEoMgMNlYPZJt4Ed0vaStEW6bevA5nGCwxnBvl18TprU4ZD4DElHNpaBubsk3879D0nXe3ibpLdI+mtJD5b02yAZATAINWm3moMIdZ9NeCUATnpX8XcEEECgnUCJAdBn4DUAD0wLQV8mybN6HfK8neU1YdPEj+HZPieFvk0aC0EPx/atnpaQebgkLwXjEPgNSV438JoWXATAFljz7UqImk2IqtmdANjTm49iEEAAgSRQagAs8QIRAHu6KjUHEeo+m/BKAOzpzUcxCCCAAAGwdRsgALYmG30AIWo2IapmdwJgT28+ikEAAQQIgK3bAAGwNRkBsC0Zs6/Hi+UMsDndc4fXtm2M/RFAAAELcAs43g4IgHGreffM+UXuF875ZU7dZ9N7mTtE5Wwzueve09uSYhBAYIkJEADjF5wAGLciAHa0yhlEag6vuUNUTvfcde/Y1DgMAQSWuAABMN4ACIBxKwJgR6ucQYQAuDh7Lzs2NQ5DAIElLkAAjDcAAmDcigDY0YoAOB4uZ4DN6U4PYMc3A4chgEBWAQJgnJcAGLciAHa0yhlEcgYon27OuucOUTXXvWNT4zAEEFjiAgTAeAMgAMatCIAdrXIGEQIgt4A7NksOQwCBRShAAIxfVAJg3IoA2NGKAMgt4I5Nh8MQQACBVgIEwDgXATBuRQDsaEUAJAC2bTo524zrkrvnuO35sj8CCPQjQACMOxIA41YEwI5WOb/Mc3+R56x77iBC3WcTvDu+TTgMAQR6ECAAxhEJgHErAmBHq5xBhAA4/qLkdCe8dnwzcBgCCGQVIADGeQmAcSsCYEernEGEAEgA7NIsc7ebLnXiGAQQmF6AABg3JADGrQiAHa0IgLO5FZnTnR7Ajm8GDkMAgawCBMA4LwEwbkUA7GiVM4jk7snJWXdC1OLsvez4NuEwBBDoQYAAGEckAMatCIAdrXKGKALg4gxROdtM7uDd8W3CYQgg0IMAATCOSACMWxEAO1rl/DInABIAuzTL3O2mS504BgEEphcgAMYNCYBxKwJgRysC4Hi4nEEkp3vuXrSa697xbcJhCCDQgwABMI5IAIxbEQA7WuX8Ms8ZoHy6OetOiFqcvZcd3yYchgACPQgQAOOIBMC4FQGwo1XOEEUAXJwhKmebyR28O75NOAwBBHoQIADGEQmAcSsCYEernF/mBEACYJdmmbvddKkTxyCAwPQCBMC4IQEwbkUA7GhFABwPlzOI5HTP3YtG3WfTZjq+xTkMgWIECIDxS0EAjFsRADta5fwyzxmgfLo5606Ioveyy1sqd5vvUieOQaAUAQJg/EoQAONWBMCOVjlDVO4vw5x1JwASALu8pXK3+S514hgEShEgAMavBAEwbkUA7GiVM0Tl/jLMWXcCIAGwy1sqd5vvUieOQaAUAQJg/EoQAONWBMCOVjlDVO4vw5x1JwASALu8pXK3+S514hgEShEgAMavBAEwbkUA7GiVM0Tl/jLMWXcCIAGwy1sqd5vvUieOQaAUAQJg/EoQAONWBMCOVjlDVO4vw5x1JwASALu8pXK3+S514hgEShEgAMavBAEwbkUA7GiVM0Tl/jLMWXcCIAGwy1sqd5vvUieOQaAUAQJg/EoQAONWBMCOVjlDVO4vw5x1JwASALu8pWpu87nr3sWTYxaXAAEwfj0JgHErAmBHq5whKvcXSs66EwAJgF3eUjW3+dx17+LJMYtLgAAYv54EwLgVAbCjVc4QlfsLJWfdCYAEwC5vqZrbfO66d/HkmMUlQACMX08CYNyKANjRKmeIyv2FkrPuBEACYJe3VM1tPnfdu3hyzOISIADGrycBMG5FAOxolTNE5f5CyVl3AiABsMtbquY2n7vuXTw5ZnqBkj4nCYDx60kAjFsRADta5fxwyP2FkrPuBEACYJe3VM1tnrp3ueLlH1PS5yQBMN5eCIBxKwJgR6ucHw41f6EQAAmAXd5SNbd56t7lipd/TM7P+LafkwTAeHshAMatCIAdrXJ+ONT8hdL2g60tf0536r44w6vPKme7qfn9mrvubd/fJe2fs820/awhAMZbBgEwbkUA7GiV88Mh94dyzrq3/WBry0/dx4vlbDc1uxMAZ9Nm2r63S9u/pDZPAIy3DgJg3IoA2NEq54dDzi/y3F+GBMDF2YuWs73nbjO523zN79ea65673ZTU5gmA8S9qAmDcigDY0SrnhwMfyoSoLs0yZ7vJ2d5zf5ETAGfXA1hzuymp7qUGwJdKOkDSepK+L2k/SefO8+H1bElHSHqApB9JOljSaY397yTpUEkvkXQPSRdJelkqO/qZSACMSk3YL+cXCh/KfCh3aaYlfSi3rT91X5xtns9JfrC1/Sxo+6OnxAC4s6STJTkEnidpb0l7Stpc0tUjQB6XwuEbUuh7pqQ3SXpCCno+5LUpFO4h6UpJh0jaWtKmkn4bRCYABqEm7cYH22w+2Gp2b/vBNqkNzv07IWo2Iapmd35szqbN5HZfSp81JQZA985dKmnfRvO6QtLpkg4a0eQ+Kcnh7GmNv31J0q8l/Ysk9/79VNJxko5O+6wm6ecpGH4g+GVBAAxCTdqt5iBC3WcTXpfSh/Kk9w/hNS7E+3U279ea3ZfSZ01pAXBVSTdL2mnOLdzjJW0paZsRzdm9gsemf4Z/3j/dNt5Q0ibptvAjJH2rcfwZkm6UtHvw44QAGISatFvNHw7UfTZfKEvpQ3nS+4cAGBfi/Tqb92vN7kvps6a0ALi+pOskbSXp/EbTfX0Kar5lO3f7gyTf2j2l8YfnSfqIJPf0PT7dSt4g9QQOdztBkgPidmPeIj7W/wy3NSVde80112jZMmfB+beHHPrlSbtM9ffLDh9X7amKXXlwzvpT9/HXCPfxNjnbTU53nxF1H31da3b3GeWsf842Q93n/57MaZ+zzbT9rHEAvP/97+/D1pL0m2nSg2+1TrsNA6BD2wWNwjypY1dJm414AQdA9+J9ovG350v6kKS7NgKgy76+sc+JknzmTx1T6cPSxJFpz4njEUAAAQQQQACBUgXulzrfOtevjwBY0i3guT2AhrmnpF91Fhp/4KB3UZIvQnRSSoZqdCqSundi6+Ug7HthbF0I7q3JejkA914YOxWCfSe2qQ9aCHe/hudJ/Hma2vYRAP36ngRySZoFPKzP5ZI8Zm/cJBCfwPaNyn8xje9rTgLxOMFj0j4Omr9oOQlkGptJxw7GF/bRDTvphTL8nbpnQA0WiX0QqufdcO8ZNFgc7kGoDLthnwE1UGQ17n0FwOEyMPuk28Beu28vSVtIukrSSamrchgGfbv4nLTMi0PiMyQdOWIZGO//Qkk/kOQxhdu2XAYmcK0671LNRR5xhtS982Wf+kDspybsVADundimPgj3qQk7F4B9Z7qpDqzGva8AaC2vAXhgWgj6Mkme1euQ5+0sScvTxI+h7HNS6BvO+PWYwc802IcLQXtNweZC0C67hK2ai0wALKG5rKwD7WY2lwN33NsK1NxmfK4115+6t22tHfbvMwB2ePmqD/F4Q/dQvlXSrZWdCXWf3QXDfjb2uOPeVqDmNuNzrbn+1L1ta+2wPwGwAxqHIIAAAggggAACNQsQAGu+etQdAQQQQAABBBDoIEAA7IDGIQgggAACCCCAQM0CBMCarx51RwABBBBAAAEEOggQADugcQgCCCCAAAIIIFCzAAGw29XzDKXaZv52O1OOmlZgI0l/L8n/XkPSLyV9K62X+ftpC898vNv5Y0bU/SeZX7ev4v3YyKb79yt631L3vlpB+3Kwb2827RG1f9asIum+jc/4HE8fm9b4DscTAGOk20nyE0r8Rf7Xkv5K0s2SLpX0n5I+kh7LEittYffatFH3uSHky5L+o/AvRbfRbcaEqK9KumZhOcOv9jxJr0gByk+wuU7SLenRhA+Q5PD3cUlHp8XSwwUvwI5eqP3lknaU5Cfw3Niouz+ofyzpBEnvL/AxiBtK8oL0fr/6i7z5GednkJ+b6u52//8WwLLNS1D3Nlr97ot9v57R0mr+rLm7pOenzxr/UPZn43DzY2KdDfw5+d9RjIXejwA4v7i/AP0FvZakL0i6eM4X+UNSMHmcpH+X9IbUw7PQ13HU6z08PUbPofX8eeruBTf9uL3jCguCq6fFxL3A+DqSvjPCfv30JnuTpAtLQE918A8Dhwu3ic9KunpO3fxB4Tazi6Rnp0XU/08h9feTeR4t6ZRU92+mHzvD6nnhdrcpB6y/lbSbpK8UUvfj05OD/MFr93HvV9f9j2nfUj6cqfvsGhH2s7Gv+bPGD7rwwyv8gIv5Pmuemb6b/IPaTzQraiMAzn85/AVyhKQzJ/QWbCDplZJ+LukdhVxhP4LvbemLfL7uaAcRN+ZvS3pLIXV3Ndyz52dMO0S5p/K2EXXzr3b3tLnHx48SPLGQ+u+Q2kykOveStHFBvxJflhzdWzZp86MeHcJLCYBu7/4x49vskzY/h9y35D89accF+jt1XyDoES+D/Wzsa/6s8Q92dzx8bwKdf+y/WJI/Tz84G+bxr0oALO2K9Fcf37qLfIkPX7Ht/v3VdHRJ7l2NPvbPdXcYLO4XVm4kykcAAQQQQKCLAAGwixrHIBAXeKAkj3PxAOE/p15i35KvIax6jMsj59T9Ekk3xU9/pnv6R0HT3b3itWzUfXZXCvuFt6/9s+bOknw3x5/xN0j608ITtn9FAmB7s7lHeKD54ZJeNH1RWUq4n6R9x4QQD+IvdRLFEMNt9Ckj6n+epK+lN1wWuCkL9bjRkyQ9XdIKSZ4I4nO5d3pI++fS+LnfTPk6OQ6/SxrKsJeku6aeZNfdM908ecUDmw8Yc1s+R33alukhDa9Kt6eHn3H+YP5pOi+Pdy11o+6zuzLYL7x97Z81HuP3GkmPkuRz8ebxxR477aEFpy88afwVCYBxq3F7eiC8B/37F0Bp2xMkfTGFPA+M9xhFX/N1Jf1DmiX5NEkOUyVuHlv5eUkPTbeDm/X3LWJPDPnnNDmktPo7/G0pySHKYxmb29+lEOVxl7uXVnFJHhTvySmvTuMvPQvY29qSPCPeH2yfkbRfgXX3RCx/IHs8q8eONtuM636QpLenMaOlVZ+6z+6KYD8b+5o/a/aW9E5JHx7zWfPCtJpCKWPT73CFCYCTG70DxnybZ0V64keJAdAzHP8rTfIYdQ7HSnJI9KzPEjfPEvOtgRdIun5OBdeT9LG0DIlna5e2OTQ5cMwNf8N6PlbSl1KoKq3unkSxs6Svj6nYkyWdmnozS6u7e7Q9427cL2//Yn+3JP+4KG2j7rO7ItjPxr7mz5ofSnqrpA+NofNdQc8U9rJfRW4EwMmXxct5+PbRfFb+e4kB0OvOuRfq/445zc3SosRecqXEzWPNtko9faPq56VuvK6bQ2JpmwPgP6alSEbVzb2A7qFyr1ppm909bvG7YyrmNuUfFiW6e31Oj1u8YkzdPXPZP4w8A7i0jbrP7opgPxv7mj9rav9+nTfUzKY5lPeqXsDX09XH9Sj4y9AD40sMgF6w18vYeKHqUZu7qH3rw72YJW7+dfhcSd8YU7knSfpkoT1RJ0t6WFoCwONBmpvHi/i2gJcQ8Dp6pW0en+gfBV7k1LdQm9t9JPncPBZwUu/4LM7rLElehHWPNBanWQeP0flo6v3bdhaVm/Ca1H12FwX72djX/Fnjz/Wz01CZUXq+M+iHGPjzvsiNHsDJl8WLPHqs1hvH7OoxgH60l58OUtrmRZR9m9dhw2u1+cvcvZWeGekxgHumcVyeDFLi9i5Jz0gD+l1/T6bw5gkWrr/fYA7mXoOxtM09e59It4HdG+hJILZ3gHL93fvnNQyH4+tKqr8nNnnhc/cQeymeZrvx2MvLJXmtQwet0jaPF/V4V6+/5Q/nZt23Toudu+34sXClbdR9dlcE+9nY1/xZ43DnNYK9usBwjH3z+9Wzyb3eqO9SFbkRACdfFj/14G5pvNaovf03J3x/2ZS4eSyXZ7f5ttiwl9JT1N1r+W+SPlVipVOdvL6fBwl7LIV7b4brGvq/e6aVx154IkKb9Q4X+nQdorzYtkO3t5+l5wD/z0JXpOXr+QeNxzB6rOLcuvvDrrTHqDVPb800bnRU3f2EkxJnXg/rT91bNtQed8e+R8wWRdX8WePHq3qVjVGfNe5Y8ZNCit0IgMVemt4r5iU8vE6Rt/8teAmPUSfux9UN16MbhigH2JK/yHu/gBSIAAIIIIBAXwIEwHaSVS722O4U2XuBBDyL2aF87nOCF+jleRkEEEAAgaUsQACMXf2qF3uc5xQ9RtC9gn6mYY2bb717Nuc5FVbes1QfVOjkoUmcNdf9q2nSU6kTn+azp+6TWma+v2Ofz3a+kmv+rPGEM49x9GTFIjcC4OTLUv1ij/Ocop+ksXHBs4AnXZ2aPxy89qLDa6ljR+ez97qLnsjiD7jaNs/o948eP72nto26z+6KYT8b+5o/a7wYve/0eLWNIjcC4OTLUv1ij5NPsdo91k+3UWt6xmu12FQcAQQQQGDxCBAAJ1/L6hd7nHyK7JFRoPaHnHspA88C9vIGXlKlprBd85hd6p7xTTmhaOxnY1/zZ81sxKZ8VQLgZMDaF3v0MjVeb85Pdmh+kfv5v16n7neTCWa+xwNH1P98ST+Yec3GV6D2h5x76aBXSXIv6/BzwiHwp2n9xeMKtq95zC51n13Dwn429jV/1ngoj5cim/v96u8nr8E79yEAsxEe86oEwMmXo+bFHjdPC0APx5q5B8fXfN20QrnDnx9X5oV9S9w8zuwkSU9Pi0B7MWXX/96SvDSMV5H3kzRKXA6m5oec++kwr5HkMSxesLrZbrw24EGS3i7pyAIbTc1jdqn77BoU9rOxhgE6EwAAHMdJREFUr/mzxuMTvY6ux9LP/Zz096qfme4nWfmZ9kVuBMDYZal1sUc/Qs0LD+8+YrFkL6b872mQ6hNjDAu+l8OfH7W3l6SL5ry6n6V7QnpKi8+vtK3mh5xfI+nl8zz+0D0l706PVCvNveYxu9R9dq0J+9nY1/xZ46ckfUzSUWPoXps6KPz88SI3AmCRl6W3SvkB514qZVwPnx/rdXGajdrbi/ZYkB+T5h6nueFv+BJeff1LkvzYtdK2mh9y7nbjhbc9y3rU5g+0/y603dQ8Zpe6z+5djP1s7Gv+rPHz0P289yvH0G0q6TuS7job2smvSgCcbFTzHtdJ8lp/47qg3YX9nkJ7cuzuAOiudIfUUZt7Ad31XmIArPkh52el5/zukR6517T32EYv/7KBpG0LfHPUPGaXus+uQWE/G/uaP2v8PHF/Fh4zhu5ASf4M9VCsIjcC4PSXpeTFHg9LA1Q9VusraSxX82HVr5fkwfylLgR9cvqF9eIRg2nds3mipO+lbvbpr2S/JdT8kPOHpoebr5bWKfQYwGG72VrSrZL+QZI/AEvbah6zS91n15qwn419zZ81z5Z0avqs9PPRm5+T/nx058Uukj4zG9rJr0oAnGw0aY/SF3v0OIRXNmYA+3x83T020OFv3K+XSee9EH93z55nKvs2sHsDPQnEQeQ+aSFi9/55hrP/VuJW80PO15T0gjEPOT+l0Ik3wzZQ65hd15+6z+6djP1s7Gv+rHlc+n71v73Khjd/t14gyRMB/e9iNwJgsZem94r5iR/NBvqT3l8hX4EPluQ3mINf8w32P/lekpIRQAABBBBYvAIEwMV7bTmz8gTuIelvJF2fxtiVV8Pb16jG9RdLN43Ub+7i4e5RuFSSJxax5RXAPq/vuNJr/6xpLmLt9+vVs2Fs96oEwJhX1Ys9Nk7RAcRLpvjN5hDi8Yuehl/yVutC1h4a4LGXnuW2Spps47GMfs/5NrYn5vj2tWeSlbbVvP6ix918vTF5xcYejD1s8++U5H9K3GpePLxmd7cF7Gfzjqj5s8ZiNS9ivXKF/9lc+jpetebFHv3UBg+yvUGSbwF7dXJvnjjh26oee+GlVEq9lVrzQtZ/SmssetyiJ9t4tfh9JF0o6RGS3i/pA5KOKPBtUPP6i013D9L+pKT3Ntz/NT2c3WNLS9tqXjy8Zne3A+xn826o+bOm5kWsB1ebHsDJjb7mxR7/Xxr35xDiLzyPAdwh9Up5huenUw/UTpMZZrJHzQtZN+2/Jeldkj7cUPQK8Z6lXeISATWvv9h0/6+0Sv+hDXc/4cT2j5lJi57/RWtePLxmd18V7Gfzhqj5s6bmRawJgMH2XvNij80P5R9L2jPdHhueutfRcwj0kiUlbjUvZG17T1rxF8v/pjXz/GNiuHnGoZdR8S3u0raa119stnkvy/C0NH5uaPygtK5kiWtH1rx4eM3ubhvYz+ZTqObPmpoXsSYABtt7zYs9NkOIF4X2OJ3m2m0OIb79W+pK5TUvZG37Q9IXi5fi8XpQ5zba3N9Kcg/nPYPtcCF3q3n9Rbs/SdKvJH1W0nPmrCG5WXqKiYc/lLbVvHh4ze5uB9jP5t1Q82dNzYtYEwCD7b3mxR79oexepz+mQfC7STqtcd5e1Ndrut0vaLHQu9W8kPXyNNljaOY1Fz3OaLh5TODOaXmbhXad9Ho1r7/oNu9JNsPhLR6k3XT/lxTMS3w+Z82Lh9fs7vcD9pM+FfL8vebPmpoXsSYAtmjPtS722Bz75NP1BAQvnjzc3pbCn78US91qXsh6PlNPvvETNTw+sNTNvWWjFjgtddKQHb0cQ3PzrT1Pghpu/hHkzYPPS9xqXTy8dne3Bexn946o8bPGWjUvYs0kkNm1d165pUDNC1m3PFV2RwABBBBAIK8As4Dz+lI6AuMEvCbj0wvuiXK9PTTAg7TnLkDsdQ3dM3gOl7d3AX8me2yuZxh66Maqkp4pybP2v5AmFPX+oj0WeGdJXhJmuHmimevuR2Ld1uPrLFRRXlPyhZKuWqgX7PF1PiLpYEleDqymbcvGup3nzRlKU+J5VLuINQGwxOZEnaICHrdzuKQXRQ8oaD9PAvHTHfyFWdq2Xlqo+pHpw/fjkl7WCIKe3ewvlRLr7nD6ZknPShNB3ifJX4TDreS6b5qGaLhde9a+J239H0m+PebPas86fLykH5TWYNKal66rhzb4S9vrp3qA//aprq7ztmkB+gKrr38eU6nPpGe9DhfM98Si0raHjanQN9OSR25L3r5bWsXTGPS9Jf1Wkp/C8h+S/iH9WPB7+ZL0/0t83nvti1hzC7jANwRViguUHKKWTTgNf2ifXWiI8hNivFzKyyV5kPZbUwDxB/Ov0/I2fpKMx0yVtnnikBfcfnuquxd+9mLQ/pLx5gBYat1PT86ePe4fNQ6ADk5ep9MB8FPpi3LX0tBTT/YDJB0l6flpUoV7Aj2+2O3EPyIcQHw9StzmTmIZVUdPLirxR898dR9OiCq17s0FxD0m3ZMuPXPfP44fktr8lyS9qsBGU/Mi1gNOegALbFVUaaXAuF/lwx02kfSOwj+Ux13O4SPhSvxC8fI7vu14caq8b+E5RHmg/5PTo+1K7QF0YPLM38+nujuUfDH1SjlUrVtw76UXbHfo+3ZaH9K9Ip6p7wWtvfm2+6kjJrqU8JHh9uBeV08089JGXvvSPxi+lir3REkflOTrUeLmNuIw4jbi6zDcfNvaPzQvL7HSqU5uL9dK8iLnt6T/5s8Xvxe8Duawx7jE29jN9SO9YsWbUugbcrsH2Sso+AdpaVvNi1gTAEtrTdTnDgI1/ypfkW5FXjTmunrciB8FV2IA9Ji/h8+51ehnpfoWn0P3C1JIKbHuvk3qp6t4GZ7htn5aAN23xPxcYN/OK7Xuvt07fJC8A6DHQ/0onYhvDfvLvMR1Ox08/CU9vFXqNuS6/zDV/a/TmqNrFPw55x8OXp7Jwx2GPyBqCIAeJ3pMCtx+bw5XFqih7s21ar1o/jZzwrZ/dHrVgdULbDc1L2JNAOyxQXlpCY97GX5Q91h09qLcw/AdSQ4spW3uifKHsW+Njdr8BeMxIiV+mXuRZ/cq+IN51OZeBX9Ql3gb1bfqPLbS43Ga2zAE+lnGniBSorvHO+3V6HlqhkBfE4crLxRdYt0dlvZo9PjtK+lj6bavz8PuZ6bxdqW9V9275FvVw15j3wp22/eC3N7c3r8q6d6lVXxOfVxPr43qXlcHQn8ult4DODwF9/adkJ59fXRaZqr0ujsAus7+4eahAx4y4Ik3w83jkH0LuMR2U/Mi1gNfbgH382nkRuxfW27IHjdV0+a6e1zXW9Lt1JLq7gHXvr3xxgpDlEOIf7W+c0zdPRbNY9UctErb/OXhcL3diIo5BDoY/lOhIcq3Gf259uIRdd9Aklfvdy9miQHw/empJT6HUdvrJP19ep53aW3mjPTF3Vx0u1lH/5DzLWIPISh98/v22PRDwW3F43VLvgXc9PTniic9eX06T8gpPQD6/ejxicPNP3g+1Pj/b0htxhOISttqXsR6YEkA7K9JeekGf2H6tl5Nm7vYvcae635QYRX3l52fletfgKM2/+1RaTJFYVWvujoOeb5V95sxZ+Hw5B7AEscUuT37NmpzwfPmaXiGs8fZeaJLbZvfp342uSex1LY9Oo1Paz4Pu/Rz8Bhkj130JKjmuMDS6+36vSLV3R0SHh9Y6+YA/ofCz6HWRawJgLW+K6g3AggggAACCCDQVYAewLhctYs9xk+RPRFAAAEEEECgB4HiF/snAE6+ytUv9jjPKZa8jt7kK8MeCCCAAAIIlClQ/PcrAXByw6l+sccJAbDUmaiTrwx7IIAAAgggMBuBmhf7H4gRACc3nJoXe/RjjObb3Lvp2VUlzoicfGXYAwEEEEAAgdkIDNepHffqJS/2TwAMtpmaF3v00jRfkfTzMefqFftLXc4jeHnYbUYCXtjX6zT66QlsCCCAwFITqHmxfwJgsLXWvNijF/T1ulzNdZWap13yQsrByzN4VFapC1lPOgf/gvQ6WAekBa0n7V/S3113P5XCSwdN6mkuqd6uy0/SmnVeX9Ihtqat5jZTs7vbCPazeaeU6l7zYv8EwGBbrnmxRy8I6hXWvQjrqO3Bkr6Q1gEMchS3W8kLWU/C8lMfvG6d16XbatLOhf3dj2zyunSu+/MKq9uk6hyW3P3jodRn0447h5rbTM3uvh7YT3pn5fl7qe41L/ZPAGzZVmtc7HG1NL7PIXCxbiUvZL1YzTkvBBBAAIHKBZgEUvkFpPpVCHiSzb3SI49uqGzcnAP2fVPdPZa0xKd/VNEIWlay5jbT8lSL2x372VwS3BfYnQA4PbgfLbVKesj89KXlKaH2RazvLskPBW8GkUsk3ZSHq7dSnynpNelxdX68mrc/pue9vk3S6b29Uv8F7S/pVZLWb6wW4Gd2/jQ9M/q4/l+ytxL92LH9JD1+Tps5Pz3j9Zu9vVL/BdXcZmp295XEvv/2HCmxZvfI+RW7DwFw+ktzhaQHFbqUSu2LWDs0vUOSx1rcNT0T0m3WgdvPRD0hTaDwbOfStr0lvVPSh9Nzad175rqvm567/EJJfk7niaVVXJIfwO7g+pYxdffEj7dLOrLAuu8o6VOSvjai7h6v+GRJz5V0RoF1r7nN1OzupoD9bN4QNbvPRqzHVyUATo/pX71rSDp7+qJ6L6H2Raw9g/nZkl6dvsy9JI83T8zZTpJ70TwD1b09pW0/TA+RHzcD+0WSDi50EsI1KZyO66H0L/Z3S9qgNHRJl0n6mKSjxtTttZJ2k7RFgXWvuc3U7O6mgP1s3hA1u89GrMdXJQD2iFlgUTUvYm3OX0raOS3ZMYrXvTmnSrp3gfa3SPIyO/93TN08qchPYVm9wLp70pBvubt3e9Tm8PTf6YdPadV3z/DDJF05pmKbpmWD3KNc2lZzm6nZ3e0A+9m8G2p2n41Yj69KAIxj1jgOreZFrH1lPMbP47i8nuGozQHrvyT52pS2eZyZe4Xdezlq861tL6XyqNIqntYmvDYte+Exi83Nt+U/mnr//BSZ0rbvp/odM6ZiB6bz2ry0iqexobW2mZrd3RRqfr/WbF+ze4EfIe2qRACc7FXzOLSaF7H2lflc6iF7/oinmdxHks/PPQ//PPkyLvgeDndnplmz/5nq70kUnsjyD2kduu0lnbvgNZv8gg+V5Dp7GSEHEo9fHNbda+fdms7BXzylbR4y4F5h13+Uu8cB7lLo4tU1t5ma3d2GsZ/NO7lm94hYqYtYD+pOAJx8CWseh1bzIta+MvdPC1X7dqnHGDWDyEMkXS5pB0nurSpx20jSvpIem4Kf6/gzSRdIer+k5SVWOtVpTUkvGFP3UyT9puC6P07SKyX53w7cTXe/n+1f6lZzm6nZ3e0B+9m8K2p2nyRW6iLWBMBJVy79veZxaMNTrHER62Hd/ypN+BgVotzD419YbAgggAACCCDQQoAewMlYNY9Dm3x27IEAAggggAAC0whUuYg1AXDyJa95HNqks6thEetJ51Dr3z2Rwre4n1ThCXxV0ibpn9qq77UNfVvYy/DUttXcZmp2dzvBfjbvltLdq17EmgA4uVHXPg5tvjMseRHryVfmL8uUlLoI96T6+wvRAdwLQte2vSw92u7w2iq+CL7Ia20zpX+RT2rKNb9fa7Yv2b36RawJgJPe9n/5+2Idh1byItaRK+OnD/hpJ/6AY0MAAQQQQGChBKpfxJoAuFBNhddBoE6BKse21ElNrRFAoCKB6hexJgDO39r8RAEvPxKdaeonJPjJD3MXz511m65xEeu5ZhumsVtej87LwVw1a9TA67uH1Y+p82LWHnc2rPv5ko5Ni88GipnJLjWPbblfWn5nlLuX3/Gj7krdam4zNbu7PWA/m3dFre7VL2JNAJy/wf8pfXF7KZjI5rXR/HSKH0d2XoB9al7Eesizv6RXSVq/sW6lg9RPJflpGsctgGOXl/Dt6U9J+lp6jrFDq99v60ryYsR+jN1zJZ3RpfDMx9Q8tuUJkr6YQt5wIeihuxfg9pjep0k6L7Nhl+JrbjM1u/taYd+lxU5/TM3u1S9iTQCcvwG75+8ESX42amR7qSQ/YqqUAFjzItb2foOk10jyQOAvp56/4Zf5dpIOkvR2SUdGLs4C7+Oe449JOmrM675W0m6S3Gtc2lbz2BY/o9iPB/QPh1Gbe14dVtzrUNpWc5up2d3tAPvZvBtqdrdY1YtYEwDnb/Rnpdt2bd4az5N0fZsDMu5b+yLWvlX3ckmnjzHybcp3p+fSZmTsVLQfUechBFeOOXpTSd+RdNdOpec9qOaxLTXXnTaTt13PVzr2s7Gv2X02Yj2+KgGwR8wCi6p9EWv3vD5Sf1nuZdTm3jP3PKxRoD0PaJ/NRXHv+xGSPjLm5b3sjnuWvY5haVvNbaZmd7cD7GfzbqjZfTZiPb4qAbBHzAKLqn0Ra/fA+jm/fp7i3Ik1Ht/o5V82kLRtgfbPlnSqJI9DG45F89hFTwbxWDSPA9xF0mcKrHvNY1s8DMO3eU+U9JU5z4+2+55pYo4ng5S21dxmanZ3O8B+Nu+Gmt0niRW//iIBcNIlrPvvtS9i/dAUnlaTdPacL/OtJd2awpR/RZa4PU7SKyX53w5+3n4m6QJJHp/pf5e61Ty2Zec0BtC9x17GxpsndF0i6d/S5JxS3WtuMzW7uz1gP5t3Rc3u84mVvIj1oN4EwNk0+IV81doXsV5T0gskPXZEiDpFkmdesyEwSmCV9MQS/+1/Jd0G04II4L4gzCNfBPvZ2Vf3ygTA6i4ZFa5QoLmGoXsAr67wHGqsMotYz+aq4T4bd78q9rOzr+6VCYDVXbJwhRfLItajTvjekm6soEen1jUMPT7x641xl57ZfqCkB6YZ7u+U5H9K3WpdxNrPtf5BY+UBL1fjZZCG7u8qdN3IYTuo1d31x3427+ba3WtdxHpwtQmAs2n0C/GqtS9ibaOXpIkeHuvntup1/w6QtEySlw/4QPqCjD6pZSHch69R8xqGbjvrSfpFGhz/SUnvlXShpEdI+ldJnk37iYUEDb5WzYtYN909scmLiJ/ZcHfA2j6tiRnkWLDdanY3EvYL1lRu90I1u9e8iDUBcDbtfcFetfZFrOd+KPsLxk/+eGPjC9ELQB+S1gJcMNjgC9W8hqHbjietOAB6UWUHkUMb5+1eKT/F5DFBi4XcreZFrJvuX02PlXxZA++t6bGCnqVd2lazuy2xn02Lqtm99kWs6QGcTZtfkFetfRHruR/KF6ceJy/xMdy8pIcXiv7bBRFt9yI1r2HY/FD2I+z86LRLG6fv2za+Hmu3I1mQvWteCLrp7kcdusfvooaanzJ0TmNiy4KABl+kZve5nzXYBy96D7vV3OarX8SaW8A9tGCKyCbgD4f7SPITTfyPn5/73careTFfP03DM4VL22pew9DuT5L0K0mflfQcSX7w+XDbLC3AXaJ7zQ9ot7vH+7mtfyvdfv92w/1vUnu/W2mNPbUPL9X06jF1c++9ey4fVWDdhwEQ+4W/ODW3+eoXsSYALnyD5xXjAv5w2F3SinSbd6c5PSJ+Esj5ktaKF7lge9a8hqHdvWj18PPBk1m8buFw+5d0673E5xjXvIj10N3Ott9L0oca7s+Q9LY0YWHBGnLwhWp2HwZAt3nsgxe8p91qbvPVL2JNAOypFVNMFoG5kzs83s+Law433wL2Ewg8MaHErdY1DL1sTXPzIwVvaPyH3dL/PqlE9Iof0D53bJ+fKd58lrQXFV81hcAS6WtePBz72bSo2t2rXsSaADibRs+r9iPwT2kpmC/3UxylIIAAAgggsDQECIBL4zpzluUJeMV+L7VS46LQfg7z+pXWvbyWsLhr5DG8fpRjje3cV6bm+nvm/nvSU3Bqa2W11b3Kxf4JgLW9LZZOfRfzQta+ip657Jm1w2fV1nRlS6+7hwU8K01ieX9a1Hroe680g9kTiErcaq27hzu8T9LfS/IEKI9f9Iz9fdN4Ui8n9PSCH91Yc/29Lurczd/tnkzkxcT/J/2xxMdm1lx3s9a62P+gSRAAS/wKoE4WWAwLWc93JUsPUbXW/RWSvF7eR9LkIE8cOjz9t2GPjpf5KDF411x3P6XkKWnBcIdvT9x6gKR9JPl55F5I3DPKDy70463m+vuzctTm7/fhZC7/u8Q2X3Pda17snwBY6AcR1fqLQO0LWTfXzRt1TVdPszlL/FCuue5emuHNkk5J6B6kfXp6aowXEfctvVIDYM119y1ez9j/RhoecK0kz1r+XLoOfoLJv0nyEkIlbjXX39ZeLshL7Qwnzjn8eTFxT5T7SQL3Mj2lbTXXvebF/gmApb0TqM/tBGpfyNqLhJ7a+PCde3k9/s+3yUoMgDXX3Qtwe8Hk5Q1wL1fjp5m4V/C4ggNgzXV3m/E6ev5S9PY7SQ9vzGL2GKnLJZW4hqHrW3P975mWC/JyWLtKui5dg9vSUBO7l7rVXPeaF/snAJb6jqBei0LACxJ7DTePixq1bSnpkkIDYM11d0/O8yWdOwfdofDrkv4z/b3E4F1z3R06PMZv2HvsHtj90uMEfSkcwn1N/IVf4lZ7/W3q8ZZeKsuPavRzumsIgMO2UGPda17snwBY4qcQdVo0Au5p8uYvwVGbx0d9UNITCzzjmuvu4OFnGI9ydwjxLcp1Cg3eNdf9i41b7aOa9B6px3urAtu7q1R7/Yes/qHjduReP49/9VjjknsAm82htrrXvNg/AbDQDyKqhQAC3QU8e/yR6XbvqFIcAv1oO08MKW2rue7u2fP4sxvHoPp50n5esHtNStxqr3/T1IuFH5V+XHpCznAMYInuc+tUW91rXeyfAFjDu4E6IoAAAggggAACfQuwDEzfopSHgFTzGobUfTYtGPfZuPtVsZ+Nfc3u84ndO/WEewxm0RsBsOjLQ+UqFah5DUPqPptGh/ts3P2q2M/GvmZ3i71E0kcl3ZrWVD5I0gGSvLi1Z5V/IE3ImftM+9loj3hVAmAxl4KKLCKBmtcwpO6zaYi4z8bdr4r9bOxrdh/+cPByXp50tndah9FrjV4o6RGSjkyzst89G97Jr0oAnGzEHgi0Fah5DUPq3vZq97M/7v04dikF+y5q0x9Ts/vwh8N9UwC8OC2948cfDjcvwv3yNBN7eq0MJRAAM6BSJAIIIIAAAggsagH3YPrJQn7msv95sqTvNs7Yzxv/jiTPFC5yIwAWeVmoFAIIIIAAAggULOAA6Mcf+rnXvs3rdRcvatTXS06dn55JXuRpEACLvCxUCgEEEEAAAQQKFpg7ucNPYXlLo76+BfzSNB6wyNMgABZ5WagUAggggAACCFQs8E/pcXxfLvUcCIClXhnqhQACCCCAAAIIZBIgAGaCpVgEEEAAAQQQWJQCi2IRawLgomybnBQCCCCAAAIIZBKofRHrAQsBMFProFgEEEAAAQQQWJQCtS9iTQBclM2Sk0IAAQQQQACBnAK1L2JNAMzZOigbAQQQQAABBBAoVYBbwKVeGeqFAAIIIIAAAghkEiAAZoKlWAQQQAABBBBAoFQBAmCpV4Z6IYAAAggggAACmQQIgJlgKRYBBBBAAAEEEChVgABY6pWhXggggAACCCCAQCYBAmAmWIpFAAEEEEAAAQRKFSAAlnplqBcCCCCAAAIIIJBJgACYCZZiEUAAAQQQQACBUgUIgKVeGeqFAAIIIIAAAghkEiAAZoKlWAQQQAABBBBAoFQBAmCpV4Z6IYAAAggggAACmQQIgJlgKRYBBBBAAAEEEChVgABY6pWhXggggAACCCCAQCYBAmAmWIpFAAEEEEAAAQRKFfj/AFyTdVeHzDlHAAAAAElFTkSuQmCC\" width=\"640\">" + ], + "text/plain": [ + "<IPython.core.display.HTML object>" + ] + }, + "metadata": {}, + "output_type": "display_data" + }, + { + "data": { + "text/plain": [ + "Probability 0.588772\n", + "dtype: float64" + ] + }, + "execution_count": 115, + "metadata": {}, + "output_type": "execute_result" + } + ], + "source": [ + "mk.plot_scenarios(df, pool_size)\n", + "mk.prob_over(df, 50)" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "mk.plot_scenarios(df, pool_size)\n", + "mk.prob_over(df, 100)" + ] + }, + { + "cell_type": "code", + "execution_count": 116, + "metadata": { + "collapsed": true + }, + "outputs": [], + "source": [ + "#40 prospect of 25mm each, correlation of 80%, likelihood: 10% each - expected capital raised: 100mm\n", + "num_prospect = 80\n", + "pool_size = 50*num_prospect #50*80=4bn\n", + "rho = .8\n", + "prob = .025\n", + "successprob = np.full((num_prospect, 1), prob)\n", + "issuerweights = np.full(num_prospect, 1/num_prospect)\n", + "amount = np.full(num_prospect, 0.0)" + ] + }, + { + "cell_type": "code", + "execution_count": 117, + "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", + " this.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 overriden (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 0x7ffb66111c88>" + ] + }, + "execution_count": 117, + "metadata": {}, + "output_type": "execute_result" + } + ], + "source": [ + "df1 = mk.run_scenario(pool_size, rho, successprob, issuerweights, amount)\n", + "#ax1 = deepcopy(ax)\n", + "mk.plot_prob_over(df1)" + ] + }, + { + "cell_type": "code", + "execution_count": 118, + "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", + " this.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 overriden (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": [ + "Probability 0.136514\n", + "dtype: float64" + ] + }, + "execution_count": 118, + "metadata": {}, + "output_type": "execute_result" + } + ], + "source": [ + "mk.plot_scenarios(df1, pool_size)\n", + "mk.prob_over(df1, 50)" + ] + }, + { + "cell_type": "code", + "execution_count": 119, + "metadata": {}, + "outputs": [ + { + "data": { + "text/html": [ + "<div>\n", + "<style>\n", + " .dataframe thead tr:only-child th {\n", + " text-align: right;\n", + " }\n", + "\n", + " .dataframe thead th {\n", + " text-align: left;\n", + " }\n", + "\n", + " .dataframe tbody tr th {\n", + " vertical-align: top;\n", + " }\n", + "</style>\n", + "<table border=\"1\" class=\"dataframe\">\n", + " <thead>\n", + " <tr style=\"text-align: right;\">\n", + " <th></th>\n", + " <th>Probability</th>\n", + " </tr>\n", + " </thead>\n", + " <tbody>\n", + " <tr>\n", + " <th>0.0</th>\n", + " <td>0.830290</td>\n", + " </tr>\n", + " <tr>\n", + " <th>8.0</th>\n", + " <td>0.000000</td>\n", + " </tr>\n", + " <tr>\n", + " <th>16.0</th>\n", + " <td>0.000000</td>\n", + " </tr>\n", + " <tr>\n", + " <th>24.0</th>\n", + " <td>0.000000</td>\n", + " </tr>\n", + " <tr>\n", + " <th>32.0</th>\n", + " <td>0.000000</td>\n", + " </tr>\n", + " <tr>\n", + " <th>40.0</th>\n", + " <td>0.000000</td>\n", + " </tr>\n", + " <tr>\n", + " <th>48.0</th>\n", + " <td>0.033196</td>\n", + " </tr>\n", + " <tr>\n", + " <th>56.0</th>\n", + " <td>0.011065</td>\n", + " </tr>\n", + " <tr>\n", + " <th>64.0</th>\n", + " <td>0.000000</td>\n", + " </tr>\n", + " <tr>\n", + " <th>72.0</th>\n", + " <td>0.000000</td>\n", + " </tr>\n", + " <tr>\n", + " <th>80.0</th>\n", + " <td>0.000000</td>\n", + " </tr>\n", + " <tr>\n", + " <th>88.0</th>\n", + " <td>0.000000</td>\n", + " </tr>\n", + " <tr>\n", + " <th>96.0</th>\n", + " <td>0.011714</td>\n", + " </tr>\n", + " <tr>\n", + " <th>104.0</th>\n", + " <td>0.007809</td>\n", + " </tr>\n", + " <tr>\n", + " <th>112.0</th>\n", + " <td>0.001302</td>\n", + " </tr>\n", + " <tr>\n", + " <th>120.0</th>\n", + " <td>0.000000</td>\n", + " </tr>\n", + " <tr>\n", + " <th>128.0</th>\n", + " <td>0.000000</td>\n", + " </tr>\n", + " <tr>\n", + " <th>136.0</th>\n", + " <td>0.000000</td>\n", + " </tr>\n", + " <tr>\n", + " <th>144.0</th>\n", + " <td>0.005597</td>\n", + " </tr>\n", + " <tr>\n", + " <th>152.0</th>\n", + " <td>0.005597</td>\n", + " </tr>\n", + " <tr>\n", + " <th>160.0</th>\n", + " <td>0.001866</td>\n", + " </tr>\n", + " <tr>\n", + " <th>168.0</th>\n", + " <td>0.000207</td>\n", + " </tr>\n", + " <tr>\n", + " <th>176.0</th>\n", + " <td>0.000000</td>\n", + " </tr>\n", + " <tr>\n", + " <th>184.0</th>\n", + " <td>0.000000</td>\n", + " </tr>\n", + " <tr>\n", + " <th>192.0</th>\n", + " <td>0.003035</td>\n", + " </tr>\n", + " <tr>\n", + " <th>200.0</th>\n", + " <td>0.004047</td>\n", + " </tr>\n", + " <tr>\n", + " <th>208.0</th>\n", + " <td>0.002023</td>\n", + " </tr>\n", + " <tr>\n", + " <th>216.0</th>\n", + " <td>0.000450</td>\n", + " </tr>\n", + " <tr>\n", + " <th>224.0</th>\n", + " <td>0.000037</td>\n", + " </tr>\n", + " <tr>\n", + " <th>232.0</th>\n", + " <td>0.000000</td>\n", + " </tr>\n", + " <tr>\n", + " <th>...</th>\n", + " <td>...</td>\n", + " </tr>\n", + " <tr>\n", + " <th>3768.0</th>\n", + " <td>0.000041</td>\n", + " </tr>\n", + " <tr>\n", + " <th>3776.0</th>\n", + " <td>0.000041</td>\n", + " </tr>\n", + " <tr>\n", + " <th>3784.0</th>\n", + " <td>0.000041</td>\n", + " </tr>\n", + " <tr>\n", + " <th>3792.0</th>\n", + " <td>0.000041</td>\n", + " </tr>\n", + " <tr>\n", + " <th>3800.0</th>\n", + " <td>0.000041</td>\n", + " </tr>\n", + " <tr>\n", + " <th>3808.0</th>\n", + " <td>0.000041</td>\n", + " </tr>\n", + " <tr>\n", + " <th>3816.0</th>\n", + " <td>0.000042</td>\n", + " </tr>\n", + " <tr>\n", + " <th>3824.0</th>\n", + " <td>0.000042</td>\n", + " </tr>\n", + " <tr>\n", + " <th>3832.0</th>\n", + " <td>0.000042</td>\n", + " </tr>\n", + " <tr>\n", + " <th>3840.0</th>\n", + " <td>0.000042</td>\n", + " </tr>\n", + " <tr>\n", + " <th>3848.0</th>\n", + " <td>0.000042</td>\n", + " </tr>\n", + " <tr>\n", + " <th>3856.0</th>\n", + " <td>0.000042</td>\n", + " </tr>\n", + " <tr>\n", + " <th>3864.0</th>\n", + " <td>0.000043</td>\n", + " </tr>\n", + " <tr>\n", + " <th>3872.0</th>\n", + " <td>0.000043</td>\n", + " </tr>\n", + " <tr>\n", + " <th>3880.0</th>\n", + " <td>0.000043</td>\n", + " </tr>\n", + " <tr>\n", + " <th>3888.0</th>\n", + " <td>0.000044</td>\n", + " </tr>\n", + " <tr>\n", + " <th>3896.0</th>\n", + " <td>0.000044</td>\n", + " </tr>\n", + " <tr>\n", + " <th>3904.0</th>\n", + " <td>0.000045</td>\n", + " </tr>\n", + " <tr>\n", + " <th>3912.0</th>\n", + " <td>0.000045</td>\n", + " </tr>\n", + " <tr>\n", + " <th>3920.0</th>\n", + " <td>0.000046</td>\n", + " </tr>\n", + " <tr>\n", + " <th>3928.0</th>\n", + " <td>0.000047</td>\n", + " </tr>\n", + " <tr>\n", + " <th>3936.0</th>\n", + " <td>0.000049</td>\n", + " </tr>\n", + " <tr>\n", + " <th>3944.0</th>\n", + " <td>0.000050</td>\n", + " </tr>\n", + " <tr>\n", + " <th>3952.0</th>\n", + " <td>0.000052</td>\n", + " </tr>\n", + " <tr>\n", + " <th>3960.0</th>\n", + " <td>0.000054</td>\n", + " </tr>\n", + " <tr>\n", + " <th>3968.0</th>\n", + " <td>0.000055</td>\n", + " </tr>\n", + " <tr>\n", + " <th>3976.0</th>\n", + " <td>0.000057</td>\n", + " </tr>\n", + " <tr>\n", + " <th>3984.0</th>\n", + " <td>0.000057</td>\n", + " </tr>\n", + " <tr>\n", + " <th>3992.0</th>\n", + " <td>0.000056</td>\n", + " </tr>\n", + " <tr>\n", + " <th>4000.0</th>\n", + " <td>0.000254</td>\n", + " </tr>\n", + " </tbody>\n", + "</table>\n", + "<p>501 rows × 1 columns</p>\n", + "</div>" + ], + "text/plain": [ + " Probability\n", + "0.0 0.830290\n", + "8.0 0.000000\n", + "16.0 0.000000\n", + "24.0 0.000000\n", + "32.0 0.000000\n", + "40.0 0.000000\n", + "48.0 0.033196\n", + "56.0 0.011065\n", + "64.0 0.000000\n", + "72.0 0.000000\n", + "80.0 0.000000\n", + "88.0 0.000000\n", + "96.0 0.011714\n", + "104.0 0.007809\n", + "112.0 0.001302\n", + "120.0 0.000000\n", + "128.0 0.000000\n", + "136.0 0.000000\n", + "144.0 0.005597\n", + "152.0 0.005597\n", + "160.0 0.001866\n", + "168.0 0.000207\n", + "176.0 0.000000\n", + "184.0 0.000000\n", + "192.0 0.003035\n", + "200.0 0.004047\n", + "208.0 0.002023\n", + "216.0 0.000450\n", + "224.0 0.000037\n", + "232.0 0.000000\n", + "... ...\n", + "3768.0 0.000041\n", + "3776.0 0.000041\n", + "3784.0 0.000041\n", + "3792.0 0.000041\n", + "3800.0 0.000041\n", + "3808.0 0.000041\n", + "3816.0 0.000042\n", + "3824.0 0.000042\n", + "3832.0 0.000042\n", + "3840.0 0.000042\n", + "3848.0 0.000042\n", + "3856.0 0.000042\n", + "3864.0 0.000043\n", + "3872.0 0.000043\n", + "3880.0 0.000043\n", + "3888.0 0.000044\n", + "3896.0 0.000044\n", + "3904.0 0.000045\n", + "3912.0 0.000045\n", + "3920.0 0.000046\n", + "3928.0 0.000047\n", + "3936.0 0.000049\n", + "3944.0 0.000050\n", + "3952.0 0.000052\n", + "3960.0 0.000054\n", + "3968.0 0.000055\n", + "3976.0 0.000057\n", + "3984.0 0.000057\n", + "3992.0 0.000056\n", + "4000.0 0.000254\n", + "\n", + "[501 rows x 1 columns]" + ] + }, + "execution_count": 119, + "metadata": {}, + "output_type": "execute_result" + } + ], + "source": [] + }, + { + "cell_type": "code", + "execution_count": null, + "metadata": { + "collapsed": true + }, + "outputs": [], + "source": [] + } + ], + "metadata": { + "kernelspec": { + "display_name": "Python 3", + "language": "python", + "name": "python3" + }, + "language_info": { + "codemirror_mode": { + "name": "ipython", + "version": 3 + }, + "file_extension": ".py", + "mimetype": "text/x-python", + "name": "python", + "nbconvert_exporter": "python", + "pygments_lexer": "ipython3", + "version": "3.6.1" + } + }, + "nbformat": 4, + "nbformat_minor": 2 +} |