From 09ea78580600832cbc385a8f63662f63085f684c Mon Sep 17 00:00:00 2001
From: "Phyks (Lucas Verney)" <phyks@phyks.me>
Date: Wed, 9 Mar 2016 11:46:35 +0100
Subject: [PATCH] Add logplot and loglogplot methods. Closes
 https://github.com/Phyks/replot/issues/14

---
 Examples.ipynb     | 1652 +++++++++++++++++++++++++++++++++++++++++++-
 README.md          |    5 +
 replot/__init__.py |   38 +-
 3 files changed, 1662 insertions(+), 33 deletions(-)

diff --git a/Examples.ipynb b/Examples.ipynb
index 2ab97c5..64f8f85 100644
--- a/Examples.ipynb
+++ b/Examples.ipynb
@@ -51,7 +51,7 @@
     "\n",
     "# ignore matplotlib warnings about too many figures in the notebook\n",
     "import matplotlib as mpl\n",
-    "mpl.rcParams[\"figure.max_open_warning\"] = 40"
+    "mpl.rcParams[\"figure.max_open_warning\"] = 50"
    ]
   },
   {
@@ -15874,6 +15874,1586 @@
     "    figure.plot(zip(x, y))"
    ]
   },
+  {
+   "cell_type": "code",
+   "execution_count": 16,
+   "metadata": {
+    "collapsed": false
+   },
+   "outputs": [
+    {
+     "data": {
+      "application/javascript": [
+       "/* Put everything inside the global mpl namespace */\n",
+       "window.mpl = {};\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",
+       "            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 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);\n",
+       "        canvas.attr('height', height);\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'];\n",
+       "    var y0 = fig.canvas.height - msg['y0'];\n",
+       "    var x1 = msg['x1'];\n",
+       "    var y1 = fig.canvas.height - msg['y1'];\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;\n",
+       "    var y = canvas_pos.y;\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\", \"pdf\", \"png\", \"ps\", \"raw\", \"svg\"];\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",
+       "    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 + '\">');\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 dataURL = this.canvas.toDataURL();\n",
+       "    this.cell_info[1]['text/html'] = '<img src=\"' + dataURL + '\">';\n",
+       "}\n",
+       "\n",
+       "mpl.figure.prototype.updated_canvas_event = function() {\n",
+       "    // Tell IPython that the notebook contents must change.\n",
+       "    IPython.notebook.set_dirty(true);\n",
+       "    this.send_message(\"ack\", {});\n",
+       "    var fig = this;\n",
+       "    // Wait a second, then push the new image to the DOM so\n",
+       "    // that it is saved nicely (might be nice to debounce this).\n",
+       "    setTimeout(function () { fig.push_to_output() }, 1000);\n",
+       "}\n",
+       "\n",
+       "mpl.figure.prototype._init_toolbar = function() {\n",
+       "    var fig = this;\n",
+       "\n",
+       "    var nav_element = $('<div/>')\n",
+       "    nav_element.attr('style', 'width: 100%');\n",
+       "    this.root.append(nav_element);\n",
+       "\n",
+       "    // Define a callback function for later on.\n",
+       "    function toolbar_event(event) {\n",
+       "        return fig.toolbar_button_onclick(event['data']);\n",
+       "    }\n",
+       "    function toolbar_mouse_event(event) {\n",
+       "        return fig.toolbar_button_onmouseover(event['data']);\n",
+       "    }\n",
+       "\n",
+       "    for(var toolbar_ind in mpl.toolbar_items){\n",
+       "        var name = mpl.toolbar_items[toolbar_ind][0];\n",
+       "        var tooltip = mpl.toolbar_items[toolbar_ind][1];\n",
+       "        var image = mpl.toolbar_items[toolbar_ind][2];\n",
+       "        var method_name = mpl.toolbar_items[toolbar_ind][3];\n",
+       "\n",
+       "        if (!name) { continue; };\n",
+       "\n",
+       "        var button = $('<button class=\"btn btn-default\" href=\"#\" title=\"' + name + '\"><i class=\"fa ' + image + ' fa-lg\"></i></button>');\n",
+       "        button.click(method_name, toolbar_event);\n",
+       "        button.mouseover(tooltip, toolbar_mouse_event);\n",
+       "        nav_element.append(button);\n",
+       "    }\n",
+       "\n",
+       "    // Add the status bar.\n",
+       "    var status_bar = $('<span class=\"mpl-message\" style=\"text-align:right; float: right;\"/>');\n",
+       "    nav_element.append(status_bar);\n",
+       "    this.message = status_bar[0];\n",
+       "\n",
+       "    // Add the close button to the window.\n",
+       "    var buttongrp = $('<div class=\"btn-group inline pull-right\"></div>');\n",
+       "    var button = $('<button class=\"btn btn-mini btn-primary\" href=\"#\" title=\"Stop Interaction\"><i class=\"fa fa-power-off icon-remove icon-large\"></i></button>');\n",
+       "    button.click(function (evt) { fig.handle_close(fig, {}); } );\n",
+       "    button.mouseover('Stop Interaction', toolbar_mouse_event);\n",
+       "    buttongrp.append(button);\n",
+       "    var titlebar = this.root.find($('.ui-dialog-titlebar'));\n",
+       "    titlebar.prepend(buttongrp);\n",
+       "}\n",
+       "\n",
+       "mpl.figure.prototype._root_extra_style = function(el){\n",
+       "    var fig = this\n",
+       "    el.on(\"remove\", function(){\n",
+       "\tfig.close_ws(fig, {});\n",
+       "    });\n",
+       "}\n",
+       "\n",
+       "mpl.figure.prototype._canvas_extra_style = function(el){\n",
+       "    // this is important to make the div 'focusable\n",
+       "    el.attr('tabindex', 0)\n",
+       "    // reach out to IPython and tell the keyboard manager to turn it's self\n",
+       "    // off when our div gets focus\n",
+       "\n",
+       "    // location in version 3\n",
+       "    if (IPython.notebook.keyboard_manager) {\n",
+       "        IPython.notebook.keyboard_manager.register_events(el);\n",
+       "    }\n",
+       "    else {\n",
+       "        // location in version 2\n",
+       "        IPython.keyboard_manager.register_events(el);\n",
+       "    }\n",
+       "\n",
+       "}\n",
+       "\n",
+       "mpl.figure.prototype._key_event_extra = function(event, name) {\n",
+       "    var manager = IPython.notebook.keyboard_manager;\n",
+       "    if (!manager)\n",
+       "        manager = IPython.keyboard_manager;\n",
+       "\n",
+       "    // Check for shift+enter\n",
+       "    if (event.shiftKey && event.which == 13) {\n",
+       "        this.canvas_div.blur();\n",
+       "        event.shiftKey = false;\n",
+       "        // Send a \"J\" for go to next cell\n",
+       "        event.which = 74;\n",
+       "        event.keyCode = 74;\n",
+       "        manager.command_mode();\n",
+       "        manager.handle_keydown(event);\n",
+       "    }\n",
+       "}\n",
+       "\n",
+       "mpl.figure.prototype.handle_save = function(fig, msg) {\n",
+       "    fig.ondownload(fig, null);\n",
+       "}\n",
+       "\n",
+       "\n",
+       "mpl.find_output_cell = function(html_output) {\n",
+       "    // Return the cell and output element which can be found *uniquely* in the notebook.\n",
+       "    // Note - this is a bit hacky, but it is done because the \"notebook_saving.Notebook\"\n",
+       "    // IPython event is triggered only after the cells have been serialised, which for\n",
+       "    // our purposes (turning an active figure into a static one), is too late.\n",
+       "    var cells = IPython.notebook.get_cells();\n",
+       "    var ncells = cells.length;\n",
+       "    for (var i=0; i<ncells; i++) {\n",
+       "        var cell = cells[i];\n",
+       "        if (cell.cell_type === 'code'){\n",
+       "            for (var j=0; j<cell.output_area.outputs.length; j++) {\n",
+       "                var data = cell.output_area.outputs[j];\n",
+       "                if (data.data) {\n",
+       "                    // IPython >= 3 moved mimebundle to data attribute of output\n",
+       "                    data = data.data;\n",
+       "                }\n",
+       "                if (data['text/html'] == html_output) {\n",
+       "                    return [cell, data, j];\n",
+       "                }\n",
+       "            }\n",
+       "        }\n",
+       "    }\n",
+       "}\n",
+       "\n",
+       "// Register the function which deals with the matplotlib target/channel.\n",
+       "// The kernel may be null if the page has been refreshed.\n",
+       "if (IPython.notebook.kernel != null) {\n",
+       "    IPython.notebook.kernel.comm_manager.register_target('matplotlib', mpl.mpl_figure_comm);\n",
+       "}\n"
+      ],
+      "text/plain": [
+       "<IPython.core.display.Javascript object>"
+      ]
+     },
+     "metadata": {},
+     "output_type": "display_data"
+    },
+    {
+     "data": {
+      "text/html": [
+       "<img src=\"data:image/png;base64,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\">"
+      ],
+      "text/plain": [
+       "<IPython.core.display.HTML object>"
+      ]
+     },
+     "metadata": {},
+     "output_type": "display_data"
+    }
+   ],
+   "source": [
+    "# To plot in log scale, you can use the Figure.logplot() method\n",
+    "with replot.Figure() as figure:\n",
+    "    figure.logplot(np.log, (-1, 1))"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 17,
+   "metadata": {
+    "collapsed": false
+   },
+   "outputs": [
+    {
+     "data": {
+      "application/javascript": [
+       "/* Put everything inside the global mpl namespace */\n",
+       "window.mpl = {};\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",
+       "            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 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);\n",
+       "        canvas.attr('height', height);\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'];\n",
+       "    var y0 = fig.canvas.height - msg['y0'];\n",
+       "    var x1 = msg['x1'];\n",
+       "    var y1 = fig.canvas.height - msg['y1'];\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;\n",
+       "    var y = canvas_pos.y;\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\", \"pdf\", \"png\", \"ps\", \"raw\", \"svg\"];\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",
+       "    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 + '\">');\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 dataURL = this.canvas.toDataURL();\n",
+       "    this.cell_info[1]['text/html'] = '<img src=\"' + dataURL + '\">';\n",
+       "}\n",
+       "\n",
+       "mpl.figure.prototype.updated_canvas_event = function() {\n",
+       "    // Tell IPython that the notebook contents must change.\n",
+       "    IPython.notebook.set_dirty(true);\n",
+       "    this.send_message(\"ack\", {});\n",
+       "    var fig = this;\n",
+       "    // Wait a second, then push the new image to the DOM so\n",
+       "    // that it is saved nicely (might be nice to debounce this).\n",
+       "    setTimeout(function () { fig.push_to_output() }, 1000);\n",
+       "}\n",
+       "\n",
+       "mpl.figure.prototype._init_toolbar = function() {\n",
+       "    var fig = this;\n",
+       "\n",
+       "    var nav_element = $('<div/>')\n",
+       "    nav_element.attr('style', 'width: 100%');\n",
+       "    this.root.append(nav_element);\n",
+       "\n",
+       "    // Define a callback function for later on.\n",
+       "    function toolbar_event(event) {\n",
+       "        return fig.toolbar_button_onclick(event['data']);\n",
+       "    }\n",
+       "    function toolbar_mouse_event(event) {\n",
+       "        return fig.toolbar_button_onmouseover(event['data']);\n",
+       "    }\n",
+       "\n",
+       "    for(var toolbar_ind in mpl.toolbar_items){\n",
+       "        var name = mpl.toolbar_items[toolbar_ind][0];\n",
+       "        var tooltip = mpl.toolbar_items[toolbar_ind][1];\n",
+       "        var image = mpl.toolbar_items[toolbar_ind][2];\n",
+       "        var method_name = mpl.toolbar_items[toolbar_ind][3];\n",
+       "\n",
+       "        if (!name) { continue; };\n",
+       "\n",
+       "        var button = $('<button class=\"btn btn-default\" href=\"#\" title=\"' + name + '\"><i class=\"fa ' + image + ' fa-lg\"></i></button>');\n",
+       "        button.click(method_name, toolbar_event);\n",
+       "        button.mouseover(tooltip, toolbar_mouse_event);\n",
+       "        nav_element.append(button);\n",
+       "    }\n",
+       "\n",
+       "    // Add the status bar.\n",
+       "    var status_bar = $('<span class=\"mpl-message\" style=\"text-align:right; float: right;\"/>');\n",
+       "    nav_element.append(status_bar);\n",
+       "    this.message = status_bar[0];\n",
+       "\n",
+       "    // Add the close button to the window.\n",
+       "    var buttongrp = $('<div class=\"btn-group inline pull-right\"></div>');\n",
+       "    var button = $('<button class=\"btn btn-mini btn-primary\" href=\"#\" title=\"Stop Interaction\"><i class=\"fa fa-power-off icon-remove icon-large\"></i></button>');\n",
+       "    button.click(function (evt) { fig.handle_close(fig, {}); } );\n",
+       "    button.mouseover('Stop Interaction', toolbar_mouse_event);\n",
+       "    buttongrp.append(button);\n",
+       "    var titlebar = this.root.find($('.ui-dialog-titlebar'));\n",
+       "    titlebar.prepend(buttongrp);\n",
+       "}\n",
+       "\n",
+       "mpl.figure.prototype._root_extra_style = function(el){\n",
+       "    var fig = this\n",
+       "    el.on(\"remove\", function(){\n",
+       "\tfig.close_ws(fig, {});\n",
+       "    });\n",
+       "}\n",
+       "\n",
+       "mpl.figure.prototype._canvas_extra_style = function(el){\n",
+       "    // this is important to make the div 'focusable\n",
+       "    el.attr('tabindex', 0)\n",
+       "    // reach out to IPython and tell the keyboard manager to turn it's self\n",
+       "    // off when our div gets focus\n",
+       "\n",
+       "    // location in version 3\n",
+       "    if (IPython.notebook.keyboard_manager) {\n",
+       "        IPython.notebook.keyboard_manager.register_events(el);\n",
+       "    }\n",
+       "    else {\n",
+       "        // location in version 2\n",
+       "        IPython.keyboard_manager.register_events(el);\n",
+       "    }\n",
+       "\n",
+       "}\n",
+       "\n",
+       "mpl.figure.prototype._key_event_extra = function(event, name) {\n",
+       "    var manager = IPython.notebook.keyboard_manager;\n",
+       "    if (!manager)\n",
+       "        manager = IPython.keyboard_manager;\n",
+       "\n",
+       "    // Check for shift+enter\n",
+       "    if (event.shiftKey && event.which == 13) {\n",
+       "        this.canvas_div.blur();\n",
+       "        event.shiftKey = false;\n",
+       "        // Send a \"J\" for go to next cell\n",
+       "        event.which = 74;\n",
+       "        event.keyCode = 74;\n",
+       "        manager.command_mode();\n",
+       "        manager.handle_keydown(event);\n",
+       "    }\n",
+       "}\n",
+       "\n",
+       "mpl.figure.prototype.handle_save = function(fig, msg) {\n",
+       "    fig.ondownload(fig, null);\n",
+       "}\n",
+       "\n",
+       "\n",
+       "mpl.find_output_cell = function(html_output) {\n",
+       "    // Return the cell and output element which can be found *uniquely* in the notebook.\n",
+       "    // Note - this is a bit hacky, but it is done because the \"notebook_saving.Notebook\"\n",
+       "    // IPython event is triggered only after the cells have been serialised, which for\n",
+       "    // our purposes (turning an active figure into a static one), is too late.\n",
+       "    var cells = IPython.notebook.get_cells();\n",
+       "    var ncells = cells.length;\n",
+       "    for (var i=0; i<ncells; i++) {\n",
+       "        var cell = cells[i];\n",
+       "        if (cell.cell_type === 'code'){\n",
+       "            for (var j=0; j<cell.output_area.outputs.length; j++) {\n",
+       "                var data = cell.output_area.outputs[j];\n",
+       "                if (data.data) {\n",
+       "                    // IPython >= 3 moved mimebundle to data attribute of output\n",
+       "                    data = data.data;\n",
+       "                }\n",
+       "                if (data['text/html'] == html_output) {\n",
+       "                    return [cell, data, j];\n",
+       "                }\n",
+       "            }\n",
+       "        }\n",
+       "    }\n",
+       "}\n",
+       "\n",
+       "// Register the function which deals with the matplotlib target/channel.\n",
+       "// The kernel may be null if the page has been refreshed.\n",
+       "if (IPython.notebook.kernel != null) {\n",
+       "    IPython.notebook.kernel.comm_manager.register_target('matplotlib', mpl.mpl_figure_comm);\n",
+       "}\n"
+      ],
+      "text/plain": [
+       "<IPython.core.display.Javascript object>"
+      ]
+     },
+     "metadata": {},
+     "output_type": "display_data"
+    },
+    {
+     "data": {
+      "text/html": [
+       "<img src=\"data:image/png;base64,iVBORw0KGgoAAAANSUhEUgAAAoAAAAG4CAYAAADVDFZ+AAAgAElEQVR4nO2dfXBc13mf5dSZpP6jbdzJTMNQikmQdGu79lhNK8/4n7qN2z/dxlLSyUwap0md2olEgBRhoihCiqGEL0IESJCASNggRdhgiBAUREpCBIVIwBIWbNBACRGGCJHEQPjSfmOBXTqxxLf33AvuAiAJAji7e3bPPs/MM1jvLrAvwL1+fzp333seeQQAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAECHX9y6dWv1tm3b/kB9NV0MAAAAAKSZLVu2/I7jt9VtJwCWOX7VdE0AAAAAsHo+7gS4Xdu2bZt3Qt1nFj9QUFDwqHP/OefxBsdX7z7ufP2O879/e+H2HzvP+aaJwgEAAABgHTgB7luOX3IC3UfLA6Bz3wXnvicXbj/hOLjwPUtWAJ0A+FuZrxwAAAAAtHCC3J3FAXDjxo2fVKFww4YNn1j0HN+mTZs+/8jSzwBWGSkYAAAAAPRYHgCd2190Al502XPece7/WuarAwAAgEwzV1Tx2XhhxSXHNtO1QJq4TwB8PNUB8M6dOwIAAADZjerXP++5Ird31cjtokq5XVjRqZMxIIt5wCngD5efAnZC4RfW+xrqTRUIRMXvR0SbVMc1xzeiHQZuzchcfasX/Bxn/7JTRp9++pd0cwZkKcsD4MJ9agjkKXV7YVBkUOc1VINQby6fDxFtUh3XHN+IuW/w8lWJlda5wS9WVi/BvmH3uNbp/ZClFBQUfNkJd4fVwIdji+PX7z62efPmxxZdBua889zP6bwWDQLRTgmAiDnuZFBmX76QWPWLNp4R35jPfYwACNrQIBDtlACImLsGrt6Q+f0vucEvXlwjoa4+8X0wm3icAAja0CAQ7ZQAiJiDOiEvfL5H4jur3fA3X9Us/pHxe55HAARtaBCIdkoARMwt/TemZK62xVv1c4y0dYlvOnz/5xIAQRcaBKKdEgARc8dQz4DES2q9QY+9RyV4ZWTF5xMAQRsaBKKdEgARc8CJoMw2dyQHPY63i2/c/9DvIwCCNjQIRDslACJmt4GBUYk91+Cd8t19UELd/av+XgIgaEODQLRTAiBiljoTkUj7RYnvqHLD31zNSfFfn1jTzyAAgjY0CEQ7JQAiZp8q6KnA5676OQEwcq7bDYRr/jkEQNCFBoFopwRAxOwydLHfPdXrDnrsa5TA4Oi6fxYBELShQSDaKQEQMUsc90v0+NnkPr4nOtzhD52fSQAEbWgQiHZKAEQ0r7qcS2zPEe+Ub0mte7mXVPxcAiBoQ4NAtFMCIKJBp8PuhZwTgx51Le6FnlP18wmAoA0NAtFOCYCIZlRbt6kt3NxVv2er3a3dFu/jm5LXIACCLjQIRDslACJmWLWP75tvS7y4xtvHd/8xCQzdTMtrEQBBGxoEop0SABEz6JhPog1nkoMeLa+JbzKUttcjAII2NAhEOyUAImbGYN+wxMrqvcu7lB6SYO9Q2l+TAAja0CAQ7ZQAiJhmp8Iy29qZWPWbq28V/62ZjLw2ARC0oUEg2ikBEDF9Bq6NyXx5kzfoseuAhN/oTfmgx0oSAEEbGgSinRIAEdOgGvR4/bIb+txBDycEBobHMl4HARC0oUEg2ikBEDG1qtO76jRvYtCjtdM9DWykFgIg6EKDQLRTAiBi6gxeviqx0jpv0KOs3h38MFkPARC0oUEg2ikBEDEFTgZl9tSFxKpftLHNveSL6boIgKANDQLRTgmAiHqqizirizm7gx7FNRLq6svooMdKEgBBGxoEop0SABHXqRr0ON8j8Z3V3qBHVbP4R943X9ciCYCgDQ0C0U4JgIhr1//elMzVtnirfjuqJNL2lvimzQx6rFgnARB0oUEg2ikBEHFthnoGJF5S6w167D0qwSsjxmt6kARA0IYGgWinBEDEVfp+QKLNHclBj6Z28Y37zde1ggRA0IYGgWinBEDEhxsYGJXYcw3eKd/dByV0sd94TauRAAja0CAQ7ZQAiLiCMxGJnOt2P+fn7uNbc1L81yfM17VKCYCgDQ0C0U4JgIj3VwU9FfgSgx5OEFSB0HRda/odCICgCw0C0U4JgIj3qk7xqlO97qDHvkYJDI4ar2k9EgBBGxoEop0SABEXOe6X6PH25D6+JzrENxE0X9c6JQCCNjQIRDslACJ6qsu5qMu6uKd8S2oldGnQeE26EgBBGxoEop0SADHvnQ5LpK0rOehR1yL+G1Pm60qBBEDQhgaBaKcEQMxn/SPj7hZu7qrfs9Xu1m7Zso9vSn4/AiDoQoNAtFMCIOalah/frj6JF9d4+/juPyaBoZvm60qxBEDQhgaBaKcEQMw7x3wSbTyTHPQ49Zr4JkPm60qDBEDQhgaBaKcEQMwng33DEiur9y7vUnpIgr1DxmtKpwRA0IYGgWinBEDMC6fCMtvamVj1m6tvFf+tGfN1pVkCIGhDg0C0UwIg2m7g2pjMlzd5gx67Dkj4jV6rBj1WkgAI2tAgEO2UAIjWqgY9Xr/shj530MMJgYHhMfN1ZVACIGhDg0C0UwIg2qg6vatO8yYGPU53uqeBTdeV8b8DARB0oUEg2ikBEG1TDXbESuu8QY+yenfww3RNpiQAgjY0CEQ7JQCiNU4GZfbUhcSqn7rUi7rki/G6DEoABG1oEIh2SgBEG1QXcVYXc3YHPYprJNTVlzeDHitJAARtaBCIdkoAxJxWDXqc75H4zmpv0KOq2d3ezXhdWSIBELShQSDaKQEQc1X/e1MyV9virfrtqJJI21vim86/QY8V/0YEQNCFBoFopwRAzEVDPQMSL6n1Bj32HpXglXeN15SNEgBBGxoEop0SADGnfD8g0eaO5KBHU7v4xv3m68pSCYCgDQ0C0U4JgJgrBgZGJfZcg3fKd/dBCXX3G68p2yUAgjY0CEQ7JQBi1jsTkUj7Rfdzfu4+vjUnxX99wnxdOSABELShQSDaKQEQs1kV9FTgSwx6nOt2A6HpunJFAiBoQ4NAtFMCIGaroYv97qled9BjX6MEBkeN15RrEgBBGxoEop0SADHrHPdL9PjZ5D6+JzrENxE0X1cOSgAEbWgQiHZKAMRsMnhlRGJ7jninfEtq3cu9mK4plyUAgjY0CEQ7JQBiVjgdlkhbV3LQo65F/DemzNeV4xIAQRsaBKKdEgDRtGrrNrWFm7vq92y1u7Ub+/im6G9LAARdaBCIdkoARGOqfXzffFvixTXePr77j0lg6Kb5uiySAAja0CAQ7ZQAiEYc80m04Uxy0KPlNfFNhszXZZkEQNCGBoFopwRAzLTBvmsSKzvsXd6l9JAEe4eM12SrBEDQhgaBaKcEQMyYU2GZbe1MrPrN1Z8W/60Z83VZLAEQtKFBINopARAzYeDamMyXN3mDHrsOSPiNXgY9MiABELShQSDaKQEQ06oa9Hj9shv63EEPJwQGhsfM15UnEgBBGxoEop0SADFd+m/OyNzh1uSgx+lO9zSw6brySQIgaEODQLRTAiCmQzXYESut8wY9yuol2DdsvKZ8lAAI2tAgEO2UAIgpdTIos6cuJFb9oo1t7iVfjNeVpxIAQRsaBKKdEgAxVaqLOKuLObuDHsU1Eu7qY9DDsARA0IYGgWinBEDUVg16nO+R+M5qb9Cjqtnd3s14XUgABH1oEIh2SgBEHf03pmSursVb9dtRJZG2LvFNM+iRLRIAQRsaBKKdEgBxvYZ6BiReUusNeuw9KsErI8ZrwqUSAEEbGgSinRIAcc1OBGW2uSM56NHULr5xv/m68B4JgKANDQLRTgmAuBYDA6MSe67BO+W7+6CEuvuN14QPlgAI2tAgEO2UAIirciYikXPd7uf83H18a06K//qE+bpwRQmAoA0NAtFOCYD4MFXQU4HPXfXbWe0GQRUITdeFq/i3IwCCLjQIRDslAOJKhi72u6d63UGPfY0SGBw1XhOuXgIgaEODQLRTAiDe13G/RI+3J/fxPdHhDn8YrwvXJAEQtKFBINopARCXqy7nEttzxDvlW1IroUuDxmvC9UkABG1oEIh2SgDEhNNh90LOiUGPuu+7F3o2XheuWwIg3MOWLVt+f+vWrddX+3waBKKdEgDRfR+MjLtbuLmrfs9WS/jCJfbxtUACINxDQUHBFicA/mS1z6dBINopATDPVfv4vvm2xItrvH18nz8mgaGb5uvClEgAtI+PO+Ft17Zt2+a3bNnymcUPOMHuUef+c87jDY6vOo9/9kE/hACIiATAPHbMJ9GGM8lBj1OviW+SQQ+bJABahhPqvuX4JSfAfbQ8ADr3XXDue3Lh9hOOgwu3v+F4aNOmTZ9e9FwCIGKeSwDMT4N91yRWdti7vEvpIQn2DhmvCVMvAdBSnAB3Z3EA3Lhx4ydVKNywYcMnFj3H54S+zz/g+wdW+1o0CEQ7JQDmmVNhmW3tTKz6zdW3iv/WjPm6MC0SAC1leQB0bn9x27Zt0WXPece5/2vLv1etEjrPHXMe/73VvJZqEIGA92ZCRHtUxzXHd34YHB6T+fImb9Bj1wGJvNErft+s8bowfarjWj9tQNZxnwD4+GoD4FoRAADISe7cuSM/77kit3d5gx4/q26Wj6b9psuCDKHb/yELecAp4A+XnwJ2QuEXdF9LvYlYIUC0T1YA7TZwa8Y9zZsY9DjdKf7psPG6MEP//qwA2snyALhwnxoCeUrdXhgUGUzFa6kGod5Mpj/PgIipVR3XHN92qgY7YqV13qBHWb0E+4aN14SZVR3XqcgAkCUUFBR82Ql3h9XAh2OL49fvPrZ58+bHFl0G5rzz3M+l4jVpEIh2SgC00MmgzJ66kFj1izaecS/5YrwuzLgEQNCGBoFopwRAu1QXcZ7ff8wb9CiukVBXHzt65LEEQNCGBoFopwRAS1Q7epzvkfjOam9Hj6pmd3s343WhUQmAoA0NAtFOCYC5r//GlMzVtXirfjuqJNLWJb7psPG60LwEQNCGBoFopwTA3DbUMyDxklpv0GPvUQleGTFeE2aPBEDQhgaBaKcEwBx1IiizzR3JQY+mdvGN+83XhVklARC0oUEg2ikBMPcMDIxK7LkG75Tv7oMSuthvvCbMTgmAoA0NAtFOCYA55ExEIu0X3c/5ufv41pwU//UJ83Vh1koABG1oEIh2SgDMDVXQU4EvMehxrtsNhKbrwuyWAAja0CAQ7ZQAmP2qU7zqVK876LGvUQKDo8ZrwtyQAAja0CAQ7ZQAmMWO+yV6/GxyH98THe7wh/G6MGckAII2NAhEOyUAZqfB/hGJ7TninfItqZXQpUHjNWHuSQAEbWgQiHZKAMwyp8PuhZzjC6t+c3Xfdy/0bLwuzEkJgKANDQLRTgmA2aP/p+MyX/k9b9Xv2WoJX7jEPr6oJQEQtKFBINopATALVPv4vvm2xItrvH18nz8mgaGb5uvCnJcACNrQIBDtlABo+O8/9oFEG84kBz1OvSa+yZDxutAOCYCgDQ0C0U4JgOYM9l2TWNlh7/IupYck2DtkvCa0SwIgaEODQLRTAqABp0Iy+4M3Eqt+c/WnxX9rxnxdaJ0EQNCGBoFopwTAzBq4Nibz5U3eoMeuAxJ+o5dBD0ybBEDQhgaBaKcEwAypBj1ev+yGPnfQo+K7EhgeM18XWi0BELShQSDaKQEwA3/jmzMyd7g1OejR2im+qbDxutB+CYCgDQ0C0U4JgOk1ePmqxErrvEGPsnoJ9g0brwnzRwIgaEODQLRTAmCanAzK7MsXEqt+0cYz4hvzma8L80oCIGhDg0C0UwJg6g1cvSHz+1/yBj2KayTU1cegBxqRAAja0CAQ7ZQAmELVoMerfyfxndXeoEdVs/hHxs3XhXkrARC0oUEg2ikBMEV/x/emZK62xVv121Elkba3xDfNoAealQAI2tAgEO2UAKhvqGdA4iW13qDH3qMSvPKu8ZoQlQRA0IYGgWinBEAN3w9ItLkjOejR1C6+cb/5uhAXJACCNjQIRDslAK7PwMB1iT3X4J3y3X1QQt39xmtCXC4BELShQSDaKQFwjc5EJNJ+0f2cn7uPb81J8V+fMF8X4n0kAII2NAhEOyUAruFv5QQ9FfjcVb+d1RJ5pdsNhKbrQnyQBEDQhgaBaKcEwFX4wayELvZL/DsveoMe+xolMDhqvi7Eh0gABG1oEIh2SgB8iON+iR4/m9zH98Sr4psImq8LcRUSAEEbGgSinRIAH2ywf0Rie454p3xLaiV0adB4TYhrkQAI2tAgEO2UAHgfp8MSaeuS+MKq31xdi/hvTJmvC3GNEgBBGxoEop0SAJf9PUbGZb7ye96q37PVEj7fwz6+mLMSAEEbGgSinRIAF1T7+L75tsSLa7x9fPcfk8DQTfN1IWpIAARtaBCIdkoAdBzzSbThTHLQ49QF8U0y6IG5LwEQtMn7BoFoqfkeAIN91yRWdti7vEvpIQn2DhmvCTFVEgBBm3xuEIg2m7cBcCoss62diVW/ufpW8d+aMV8XYgolAII2edkgEPPAfAyAgWtjMl/e5A167Dog4Td6GfRAKyUAgjb51iAQ88W8CoBq0OP1y27ocwc9nBAYGB4zXxdimiQAgjZ50yAQ88x8CYDq9O7c4dbkoMfpTvc0sOm6ENMpARC0yYcGgZiP5kMADF6+KrHSOm/Qo6xegn3DxmtCzIQEQNDG9gaBmK9aHQAngzL78oXEql+08Yx7yRfjdSFmSAIgaGNtg0DMc20NgIGrN2R+/0veoEdxjYS6+hj0wLyTAAja2NggENHCAKgGPc73SHxntTfoUdUs/pH3zdeFaEACIGhjVYNAxIQ2BUD/e1MyV9virfrtqJJI21vim2bQA/NXAiBoY0uDQMSl2hIAQz0DEi+p9QY99h6V4JV3jdeEaFoCIGhjQ4NAxHvN+QD4fkCizR3JQY+mdvGN+83XhZgFEgBBm5xuEIj4QHM5AAYGRiX2XIN3ynf3QQl19xuvCTGbJACCNrnaIBBxZXMyAM5EJNJ+0f2cn7uPb81J8V+fMF8XYpZJAARtcq5BIOKqzLUAqIKeCnzuqt/Oaom80u0GQtN1IWajBEDQJpcaBCKu3lwKgKGL/RL/zoveoMe+RgkMjhqvCTGbJQCCNrnSIBBxbeZEABz3S/T42eQ+vic6xDcRNF8XYpZLAARtsr5BIOK6zPYAGOwfkdieI94p35JaCV0aNF4TYq5IAARtsrlBIOL6zdoAOB2WSFuXxBdW/ebqWsR/Y8p8XYg5JAEQtMnKBoGI2mZjAPSPjLtbuLmrfs9Wu1u7sY8v4tolAII22dYgEDE1ZlUAVPv4vvm2xItrvH189x+TwNBN83Uh5qgEQNAmaxoEIqbUrAmAYz6JNpxJDnqcek18kyHjfx/EXJYACNpkRYNAxJSbDQEw2DcssbJ67/IupYck2Dtk/O+CaIMEQNDGdINAxPRoNABOhWW2tTOx6jdX3yr+WzPG/yaItkgABG0IgIh2aioABq6NyXx5kzfoseuAhN/oZdADMcUSAEEbAiCinWY8AKpBj9cvu6HPHfRwQmBgeMz43wHRRgmAoA0BENFOMxkA1elddZo3MejR2umeBjb9N0C0VQIgaEMARLTTTAVANdgRK63zBj3K6t3BD9O/O6LtEgBBGwIgop2mPQBOBmX21IXEql+08Yx7yRfTvzdiPkgABG0IgIh2ms4AqC7irC7m7A56FNdIqKuPQQ/EDEoABG0IgIh2mpYAqAY9zvdIfGe1N+hR1exu72b6d0XMNwmAoA0BENFOUx0A/TemZK6uxVv121ElkbYu8U0z6IFoQgIgaEMARLTTVAbAUM+AxEtqvUGPvUcleGXE+O+HmM8SAEEbAiCinaYkAE4EZba5Izno0dQuvnG/8d8NMd8lAII2BEBEO9UNgIHBUYnta/RO+e4+KKHufuO/EyJ6EgBBGwIgop2uOwDORCRyrtv9nJ+7j2/NSfFfnzD++yBiUgIgaEMARLTT9QRAFfRU4HNX/XZWS+SVbjcQmv5dEHGpBEDQhgCIaKdrDYChi/3uqV530GNfo3sK2PTvgIj3lwAI2hAAEe101QFw3C/R4+3JfXxPdLjDH6brR8QHSwAEbQiAiHa6mgCoLucS23PEO+VbUiuhS4PG60bEh0sABG0IgIh2umIAnA67F3JODHrUtbgXejZdMyKuTgIgLGHLli1fcyzcunXrnzhWreZ7CICIdvqgAKi2blNbuLmrfs9Wu1u7sY8vYm5JAIQlbNu27dcX3b7kfPmFh30PARDRTu8JgGof3zfflnhxjbeP7/5jEhi6abxORFy7BED7+PjWrVt3OeFtfsuWLZ9Z/EBBQcGjzv3nnMcbHF+9+7hz+xuOhzZt2vTpu891HvuSc98zq3lBAiCinS4JgGM+iTacSQ56tLwmvsmQ8RoRcX0SAC3DCW7fWghvHy0PgM59F5z7nly4/YTj4P1+hhMUv+L4u85zf/VTn/rULz/sNQmAiHZ6NwCGfjQssbJ67/IupYck2DtkvDZE1JMAaClOuLuzOABu3LjxkyoUbtiw4ROLnuPbtGnT5xd/n/oM4LZt2/qdx446X1/fvHnzYw97LQIgop36p8PyD6/8TWLVb66+Vfy3ZozXhYj6EgAtZXkAdG5/0Ql00WXPeUcFPt3XUgEwEPDeTIhoh8HhMZkvb/IGPXYdkHBnr/h9s8brQsTUqPq2bv+HLOQ+AfDxdAZAALCDO3fuyM97rsjtXd6gx8+qm+Wjab/psgAgDej2f8hCHnAK+MPlp4CdUPgF3ddSbyJWABFz38CtGfc0b2LQ4y875c7Pf87xjWihrABayvIAuHCfGgJ5St1eGBS57xDIWlEBUL2ZTH+eARHXb/DyVYmV1nmDHmX1Euwbdo9rjm9EO1XHdSoyAGQJBQUFX3bC3WE18OHY4vj1u4+pgY5Fl4E57zz3c6l4TRoEYg47GZTZly8kVv2ijW3uJV/UYwRARHslAII2NAjE3DRw9YbM73/JG/QorpFQV9+SHT0IgIj2SgAEbWgQiDmm2tHjfI/Ed1Z7O3pUNbvbuy1/HgEQ0V4JgKANDQIxd/S/NyVztS3eqt+OKom0vSW+6fD9n0sARLRWAiBoQ4NAzA1DPQMSL6n1Bj32HpXglXdXfD4BENFeCYCgDQ0CMct9PyDR5o7koEdTu/jG/Q/9PgIgor0SAEEbGgRi9hoYGJXYcw3eKd/dByXU3b/q7yUAItorARC0oUEgZqEzEYm0X3Q/5+fu41tzUvzXJ9b0MwiAiPZKAARtaBCI2aUKeirwuat+O6sl8kq3GwjX/HMIgIjWSgAEbWgQiFniB7MSutgv8e+86A167GuUwOB76/55BEBEeyUAgjY0CMQscNwv0WNnk/v4nnhVfBNBrZ9JAES0VwIgaEODQDRrsH9EYnuOeKd8S2oldGkwJT+XAIhorwRA0IYGgWjI6bBE2rokvrDqN1f3ffHfmErZzycAItorARC0oUEgZl7/T8dlvvJ73qrfs9USvnBpyT6+KXkNAiCitRIAQRsaBGIGVfv4vvm2xItrvH18nz8mgaGbaXktAiCivRIAQRsaBGJm9I99INGGM8lBj5bXxDcZSt/rEQARrZUACNrQIBDTb7DvmsTKDnuXdyk9JMHeobS/JgEQ0V4JgKANDQIxjU6FZPYHbyRW/ebqT4v/1kxGXpsAiGivBEDQhgaBmB4D18ZkvrzJG/TYdUDCnb0pH/RYSQIgor0SAEEbGgRiilWDHq9fdkOfO+hR8V0JDI9lvA4CIKK9EgBBGxoEYur035yRucOtyUGP053imwqbqYUAiGitBEDQhgaBmBqDl69KrLTOG/Qoq5fgj4aN1kMARLRXAiBoQ4NA1HQyKLMvX0is+kUb28Q35jNeFwEQ0V4JgKANDQJx/Qau3pD5/S95gx7FNRLq6svooMdKEgAR7ZUACNrQIBDXoRr0ON8j8Z3V3qBHVbP4R943X9ciCYCI9koABG1oEIhr0//elMzVtnirfjuqJNL2lvimzQx6rFgnARDRWgmAoA0NAnH1hnoGJF5S6w167D0qwSvvGq/pQRIAEe2VAAja0CAQV+FEUGabO5KDHk3t4hv3m69rBQmAiPZKAARtaBCIKxsYGJXYcw3eKd/dByXU3W+8ptVIAES0VwIgaEODQHyAMxGJnOt2P+fn7uNbc1L81yfM17VKCYCI9koABG1oEIj3qoKeCnyJQQ8nCKpAaLquNf0OBEBEayUAgjY0CMSlhi72u6d63UGPfY0SGBw1XtN6JAAi2isBELShQSAuOO6X6PH25D6+Jzrc4Q/jda1TAiCivRIAQRsaBGJUgldGJLbniHfKt6TWvdyL6Zp0JQAi2isBELShQWBeOx2WSFtXctCjrkX8N6bM15UCCYCI9koABG1oEJiv+kfG3S3c3FW/ndXu1m7Zso9vSn4/AiCitRIAQRsaBOadah/frj6JF9d4+/juPyaBoZvm60qxBEBEeyUAgjY0CMwrx3wSbTiTHPQ49Zr4JnN30GMlCYCI9koABG1oEJgvBvuGJVZW713epfSQBHuHjNeUTgmAiPZKAARtaBBovVNhmW3tTKz6zdW3iv/WjPm60iwBENFeCYCgDQ0CbTZwbUzmy5u8QY9dByT8Rq9Vgx4rSQBEtFcCIGhDg0ArVYMer192Q5876OGEwMDwmPm6MigBENFeCYCgDQ0CbVOd3lWneRODHqc73dPApuvK+N+BAIhorQRA0IYGgTapBjtipXXeoEdZvTv4YbomUxIAEe2VAAja0CDQCieDMnvqQmLVL9p4xr3ki/G6DEoARGNbORQAABaBSURBVLRXAiBoQ4PAXFddxFldzNkd9CiukVBXX94MeqwkARDRXgmAoA0NAnNWNehxvsfdxs0d9Khqdrd3M15XlkgARLRXAiBoQ4PAXNR/Y0rmalu8Vb8dVRJpe0t80/k36LHi34gAiGitBEDQhgaBuWaoZ0DiJbXeoMfeoxK8MmK8pmyUAIhorwRA0IYGgTnjRFBmmzuSgx5N7eIb95uvK0slACLaKwEQtKFBYC4YGBiV2HMN3inf3QcldLHfeE3ZLgEQ0V4JgKANDQKz2pmIRM51u5/zc/fxrTkp/usT5uvKAQmAiPZKAARtaBCYraqgpwJfYtDDCYIqEJquK1ckACLaKwEQtKFBYDaqTvGqU73uoMe+RgkMjhqvKdckACLaKwEQtKFBYFY57pfo8bPJfXxPdLjDH8brykEJgIj2SgAEbWgQmC2qy7nE9hzxTvmW1LqXezFdUy5LAES0VwIgaEODQONOhyXS1pUc9KhrcS/0bLyuHJcAiGivBEDQhgaBJlVbt6kt3NxVv2er3a3d2Mc3RX9bAiCitRIAQRsaBBpR7ePb1Sfx4hpvH9/9xyQwdNN8XRZJAES0VwIgaEODwIw75pNow5nkoMep18Q3yaBHqiUAItorARC0oUFgJg32DUusrN67vEvpIQn2DhmvyVYJgIj2SgAEbWgQmBGnwjLb2plY9ZurbxX/rRnzdVksARDRXgmAoA0NAtNt4NqYzJc3eYMeuw5I+I1eBj0yIAEQ0V4JgKANDQLTphr0eP2yG/rcQQ8nBAaGx8zXlScSABHtlQAI2tAgMB2q07vqNG9i0ON0p3sa2HRd+SQBENFeCYCgDQ0CU23w8lWJldZ5gx5l9e7gh+ma8lECIKK9EgBBGxoEpszJoMyeupBY9Ys2nnEv+WK8rjyVAIhorwRA0IYGgalQXcRZXczZHfQorpFQVx+DHoYlACLaKwEQtKFBoJZq0ON8j8R3VnuDHlXN7vZuxutCAiCixRIAQRsaBK5X/3tTMlfb4q367aiSSNtb4ptm0CNbJAAi2isBELShQeB6DPUMSLyk1hv02HtUgldGjNeESyUAItorARC0oUHgmpwIymxzR3LQo6ldfON+83XhPRIAEe2VAAja0CBwtQYGRiX2XIN3ynf3QQl19xuvCR8sARDRXgmAoA0NAh/qTEQi7Rfdz/m5+/jWnBT/9QnzdeGKEgAR7ZUACNrQIHAlVdBTgS8x6HGu2w2EpuvCVfzbEQARrZUACNrQIPBBhi72u6d63UGPfY0SGBw1XhOuXgIgor0SAEEbGgTe47hfosfPJvfxPdHhDn8YrwvXJAEQ0V4JgKANDQIXqy7nEttzxDvlW1IroUuDxmvC9UkARLRXAiBoQ4NA1+mwRNq6koMedS3ivzFlvi5ctwRARHslAEKCRx99dMPWrVufcfxDx7MbN2785Gq+jwaBaus2tYWbu+r3bLW7tRv7+Oa+BEBEeyUAwhI2bNjwiS1btnzHCYC1q/0eGkQeq/bxffNtiRfXePv47j8mgaGb5uvClEgARLRXAqBdfNwJbru2bds274S4zyx+oKCg4FHn/nPO4w2Or9593Ln9DcdDmzZt+vTi56vnOc95fDUvSoPIU8d8Em04kxz0aHlNfJMh83VhyiQAItorAdAinMD2LccvOeHto+UB0LnvgnPfkwu3n3AcXP79Tkj88mOPPfYrC8/5P87zv7aa16VB5J/BvmGJldV7l3cpPSTB3iHjNWHqJQAi2isB0EKc8HZncQBUn+VToVCd3l30HN+mTZs+v/j7nAD4lW3btr24sCr4kvMzfmk1r0eDyCOnwjLb2plY9ZurbxX/rRnzdWFaJAAi2isB0EKWB0Dn9hedYBdd9px3VrvC9zBUgwgEvDcT2mtweEzmy5u8QY9dByTc2St+36zxujB9quOa4xvRTtVxnYoMAFnEfQLg4+kOgGAvd+7ckZ/3XJHbu7xBj59VN8tH037TZQEAgCapyACQRTzgFPCHy08BO6HwC6l4PfUmYoXATgO3ZtzTvIlBj9Od4p8OG68LM/TvzwogorWyAmghywPgwn1qCOQpdXthUOSeIZD1ohqEejOZ/jwDptbg5asSK63zBj3K6t3BD9M1YWZVxzXHN6KdquM6VTkADKOmeJ1wd1gNfDi2OH797mObN29+bNFlYM47z/1cql6XBmGZk0GZfflCYtUv2njGveSL8bow4xIAEe2VAAja0CDsMXD1hszvf8kb9CiukVBXHzt65LEEQER7JQCCNjQIC1Q7epzvkfjOam9Hj6pmd3s343WhUQmAiPZKAARtaBC5rf+9KZmrbfFW/XZUSaTtLfFNh43XheYlACLaKwEQtKFB5K6hngGJl9R6gx57j0rwyrvGa8LskQCIaK8EQNCGBpGDTgRltrkjOejR1C6+cb/5ujCrJAAi2isBELShQeSWgYFRiT3X4J3y3X1QQt39xmvC7JQAiGivBEDQhgaRI85EJNJ+0f2cn7uPb81J8V+fMF8XZq0EQER7JQCCNjSI7FcFPRX4EoMe57rdQGi6LsxuCYCI9koABG1oENlt6GK/e6rXHfTY1yiBwVHjNWFuSABEtFcCIGhDg8hSx/0SPX42uY/viQ53+MN4XZgzEgAR7ZUACNrQILLP4JURie054p3yLamV0KVB4zVh7kkARLRXAiBoQ4PIIqfDEmnrSg561LWI/8aU+bowJyUAItorARC0oUFkh2rrNrWFm7vq92y1u7Ub+/iijgRARHslAII2NAjDqn1833xb4sU13j6++49JYOim+bow5yUAItorARC0oUEYdMwn0YYzyUGPltfENxkyXxdaIQEQ0V4JgKANDcKMwb5hiZXVe5d3KT0kwd4h4zWhXRIAEe2VAAja0CAy7FRYZls7E6t+c/Wt4r81Y74utE4CIKK9EgBBGxpE5gxcG5P58iZv0GPXAQm/0cugB6ZNAiCivRIAQRsaRAZUgx6vX3ZDnzvo4YTAwPCY+brQagmAiPZKAARtaBBpPkhvzbineRODHqc73dPAputC+yUAItorARC0oUGkz+DlqxIrrfMGPcrq3cEP0zVh/kgARLRXAiBoQ4NIg5NBmT11IbHqF21scy/5YrwuzCsJgIj2SgAEbWgQqVVdxFldzNkd9CiukVBXH4MeaEQCIKK9EgBBGxpEilSDHud7JL6z2hv0qGp2t3czXhfmrQRARHslAII2NIgUHIjvTclcbYu36rejSiJtb4lvmkEPNCsBENFeCYCgDQ1Cz1DPgMRLar1Bj71HJXjlXeM1ISoJgIj2SgAEbWgQ63QiKLPNHclBj6Z28Y37zdeFuCABENFeCYCgDQ1i7QYGRiX2XIN3ynf3QQl19xuvCXG5BEBEeyUAgjY0iDU4E5HIuW73c37uPr41J8V/fcJ8XYj3kQCIaK8EQNCGBrHKg80Jeirwuat+O6sl8kq3GwhN14X4IAmAiPZKAARtaBAPN3Sx3z3V6w567GuUwOCo8ZoQHyYBENFeCYCgDQ1iBcf9Ej1+NrmP74kOd/jDeF2Iq5AAiGivBEDQhgZxf4NXRiS254h3yrekVkKXBo3XhLgWCYCI9koABG1oEMucDkukrSs56FH3ffHfmDJfF+IaJQAi2isBELShQSw6oEbG3S3c3FW/Z6slfOES+/hizkoARLRXAiBoQ4OIevv4dvVJvLjG28d3/zEJDN00XxeihgRARHslAII2ed8gxnwSbTiTHPRoeU18kyHzdSFqSgBEtFcCIGiTzw0i2DcssbJ67/IupYck2DtkvCbEVEkARLRXAiBok5cNYioss62diVW/ufpW8d+aMV8XYgolACLaKwEQtMm3BhG4Nibz5U3eoMeuAxJ+o5dBD7RSAiCivRIAQZu8aRBq0OP1y27ocwc9Kr4rgeEx83UhpkkCIKK9EgBBm3xoEOr0rjrNmxj0ON3pngY2XRdiOiUAItorARC0sb1BBC9flVhpnTfoUVbvDn6YrgkxExIAEe2VAAjaWNsgJoMye+pCYtUv2tjmXvLFeF2IGZIAiGivBEDQxsYGoS7irC7m7A56FNdIqKuPQQ/MOwmAiPZKAARtrGoQatDjfI/Ed1Z7gx5VzeIfed98XYgGJAAi2isBELSxpUH4b0zJXG2Lt+q3o0oibW+Jb5pBD8xfCYCI9koABG1saBChngGJl9R6gx57j0rwyrvGa0I0LQEQ0V4JgKBNTjeIiaDMNnckBz2a2sU37jdfF2IWSABEtFcCIGiTcw3ig1kJ9o/I7MvnE6t+8d0HJdTdb742xCySAIhorwRA0CYnGoQT+tRkb+Qv/1pie44kVvzcfXwP/UD81yfM14iYZRIAEe2VAAjaZHODUMEu8kq3zD9/bEnom3/huEQ6/pbgh7iCBEBEeyUAgjbZ1iDUtm3hN3pl/sCJJaFPrfxFzrwpgXduGa8RMRckACLaKwEQtMmKBvF+QEIX+2Xu8A/cS7gkQt//rpPZly94U71cyBlxTRIAEe2VAAjaGGsQ02EJXv5/Ej12VuK7ahKhT+3cET3eLsHeIa7jh6ghARDRXgmAoE1GG8TdCd6TyQleN/TtrJa5I6cl1H3FvbSL6QML0QYJgIj2SgAEbdLeIBYmeGdP/7XE/rx+6QRvzUkJd/5Q/GMfGD+YEG2TAIhorwRA0CZdDcL/7oREznXL/P5lE7zlTRLp+Dvxj04aP4AQbZYAiGivBEDQJpUNwp3gff3yvRO8e496E7zXmOBFzJQEQER7JQCCNtoNQk3w/s2P3Qsy3zPBe+qCBH/CBC+iCQmAiPZKAARt1tUgpsMS+r9qgvevJL7rwNIJ3qZ2Cf6QCV5E0xIAEe2VAAjarLpBqAneH/9UZk++ev8J3r9lghcxmyQAItorARC0WbFBqAneqzdk9nTnvRO8L74s4b/+ofjGfMYPBES8VwIgor0SAEGb+zUI/7vvL0zwvnTvBO+rTPAi5oIEQER7JQCCNncbRGKCt7r53gneti4JXBsz/oZHxNVLAES0VwIgaBF8eu8/+fBHQw+Y4H1NAj+5zgQvYo5KAES0VwIgrJnRp5/+pVjhC/8lXlR55nZRxe2lE7znJPjDd5jgRbRAAiCivRIAYVWceeqpfzT3zPNfuV1YeTxeWBlOnOItrPyHv286K+G/+4n4JpngRbRJAiCivRIAYSU+Fit8/vF4UeWBeFHFxOLP9Tn3/W2sqPyb0T994Z/TIBDtlACIaK8EQLiH2W+Xb7ldWFl2u6jip0tCX2HlQHx7+a74t/c/uvj5NAhEOyUAItorARBc5r+991/Et1c+Ey+q6Fsc+hxvxgrL9889/cJnHvS9NAhEOyUAItorATCPURO8TsD7g9uFFW/eLqr4KLnSV+GLF5Ufjj9d+SXnaR972M+hQSDaKQEQ0V4JgHmGmuCNP1P+X52Q13a7sPJnyWGOirlYYcXJ+e0V/7n73+/9+Fp+Jg0C0U4JgIj2SgDMA9wJ3sLy/3C7qKLJMbJ4gtcJgq/Eiyp+Z+qbez+x3p9Pg0C0UwIgor0SAO3lY7Fnyv+NE/Bq4oWVk4tC353bhRXdse0V/3P2j/Z+MhUvRINAtFMCIKK9EgAtY/aZv9h6e3vFnztBb2TpZVsqfuKEwWfjT1duTPVr0iAQ7ZQAiGivBEALcCd4iyq2OwHvR0smeAsrbsQKy/fNFVb+q3S+Pg0C0U4JgIj2SgDMUULfrPin889U/qET8rqWTPAWVX4QLyqvi29/4YlHVjHBmwpoEIh2SgBEtFcCYA5x6xt7fzleWPnb8aKKv1oywVtUGY0Vlp+YLyr/T2ud4L0fW7dubXF8ZrXPp0Eg2ikBENFeCYBZjprgnX/m+f94u7Diu0smeIsq/t4Jg+fi28ufev+pon+cqtdzgt8T27ZtO0MAREQCIKK9EgCzk4/Fivb/Znx7xYvxwoqpJRO8RZUXY4Xlfxz5Vvmv3Of7Pu4Et11OgJvfsmXLkp07CgoKHnXuP+c83uD4qvP4Z+/3ws79zzvP++8EQEQkACLaKwEwi3AneAsr99wuqnh32R68V+Lby3fG/9f+X1/p+53w9i3HLznh7aPlAdC574Jz35MLt59wHFy4/Q3HQ5s2bfq0E/z+2+bNm/+18/UPCICISABEtFcCoGFihc//mhPwCh1/vHSCt/K9WFHFc9E/e+FfrvVnOuHtzuIAuHHjxk+qULhhw4ZPLHqOzwl9n1/8fc73fEeFP8fj6nOAztcvrOb1aBCIdkoARLRXAqAB1ARvrLD8fzhB761le/DOONbGn678d49oTPAuD4DO7S86YS667DnvOPd/bfn3/sZv/MavOc9tch7/waccVvN6qkEEAt6bCRHtUR3XHN+IdqqO6/XmDFgD7gTv9vKvOwHv7PIJ3tuFFc3z2yu/mooJXsV9AuDjqw2AAAAAAKCBO8FbVP5bt4sqvueEvNklE7xFFe3xwsonUznBe5cHnAL+cPkp4NWe4gUAAACAlflYbHv5v40XVhyMF1VOL9uD929i2yv/KFy495+ls4DlAXDhPjUE8pS6vTAoMpjOGgAAAACsJ/qnL2yLFZbvdYLe9WV78PY7YXBH7M/2bkh3DQUFBV92wt1hNfCxcDHnr999bPPmzY8tugzMeee5n0t3PQAAAADWoUJdvKi8SIW8JRO8RRWjKgxGt//Fp03XCAAAAACaqNO36jSuOp27cGHmu3vwTqvTvur07yMZ2oMXAAAAANJEYoK3qKJdDXAkP9enBjsqvqcGPdTAh+k6AQAAAEADd4J3e+VX1SVa7pngLaw4qwKhCoam6wQAAAAAPT6mLsLsXoy5sGJm2R68b80/U/mH6Z7gBQAAAIAMoIY11LZranhj2R68P1bbtKnt2kzXmIuoC007Fm7duvVPHKtM1wMAqcU5vn/fObavm64DAFLGLzrHdLXaFlZ9NV1M2lm2B+91xz3qsi6m68p1nDfQry+6fcn58gsGywGAFFNQULDFaRI/MV0HAKQG5z/qfsfx2+q2c2yXOX7VdE1pJV5YMRXfXvFirGj/bz7CBO9iPu784+9ywtv88gtLO//H/+ii6wq+evdx5/Y3HA9t2rQpcQmchQtPP5Pp4gFgRdZyfH/2QT+EAAiQtay5hztfv+P8799euP3HznO+aaLwjMEE7/1x/vG/tRDePnrAziJPLtx+4kE7izhvsq84/q7z3F/91Kc+xdAMQJawnuP7fv+BRwAEyE7Wc4wvXwF0AuBvZb5yyBoesLfwR8v3FnaawucXf5/6DKDz5ul3HjvqfH1d7UaSyboB4OGs9/he9NhAJuoEgPWxxmN88WcA+ex+vrP8zePc/qLz5ogue847KvBlvjoA0EHn+FYrCM5zx5zHfy8TtQLA2qGHw7q5z5vncd48AHbA8Q1gNxzjsG4esHz84fLlY+cN9QUzFQLAeuH4BrAbjnFYN8vfPAv3qQ+QPqVuL3zI9L5DIACQ3XB8A9gNxzismYKCgi87b4zD6sOiji2OX7/7mBroWDRCft557udM1goAa4PjG8BuOMYBAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAUsj/B36mynaUqbxAAAAAAElFTkSuQmCC\">"
+      ],
+      "text/plain": [
+       "<IPython.core.display.HTML object>"
+      ]
+     },
+     "metadata": {},
+     "output_type": "display_data"
+    }
+   ],
+   "source": [
+    "# Same for log-log scale, you can use the Figure.loglogplot() method\n",
+    "with replot.Figure() as figure:\n",
+    "    figure.loglogplot(lambda x: x**2, (0, 1))"
+   ]
+  },
   {
    "cell_type": "markdown",
    "metadata": {},
@@ -15885,7 +17465,7 @@
   },
   {
    "cell_type": "code",
-   "execution_count": 16,
+   "execution_count": 18,
    "metadata": {
     "collapsed": false
    },
@@ -16678,7 +18258,7 @@
   },
   {
    "cell_type": "code",
-   "execution_count": 17,
+   "execution_count": 19,
    "metadata": {
     "collapsed": false,
     "scrolled": false
@@ -17489,7 +19069,7 @@
   },
   {
    "cell_type": "code",
-   "execution_count": 18,
+   "execution_count": 20,
    "metadata": {
     "collapsed": false
    },
@@ -18280,7 +19860,7 @@
   },
   {
    "cell_type": "code",
-   "execution_count": 19,
+   "execution_count": 21,
    "metadata": {
     "collapsed": false
    },
@@ -19071,7 +20651,7 @@
   },
   {
    "cell_type": "code",
-   "execution_count": 20,
+   "execution_count": 22,
    "metadata": {
     "collapsed": false
    },
@@ -19863,7 +21443,7 @@
   },
   {
    "cell_type": "code",
-   "execution_count": 21,
+   "execution_count": 23,
    "metadata": {
     "collapsed": false
    },
@@ -20656,7 +22236,7 @@
   },
   {
    "cell_type": "code",
-   "execution_count": 22,
+   "execution_count": 24,
    "metadata": {
     "collapsed": false
    },
@@ -21453,7 +23033,7 @@
   },
   {
    "cell_type": "code",
-   "execution_count": 23,
+   "execution_count": 25,
    "metadata": {
     "collapsed": false
    },
@@ -22225,7 +23805,7 @@
     {
      "data": {
       "text/html": [
-       "<img src=\"data:image/png;base64,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\">"
+       "<img src=\"data:image/png;base64,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\">"
       ],
       "text/plain": [
        "<IPython.core.display.HTML object>"
@@ -22246,7 +23826,7 @@
   },
   {
    "cell_type": "code",
-   "execution_count": 24,
+   "execution_count": 26,
    "metadata": {
     "collapsed": false
    },
@@ -23041,7 +24621,7 @@
   },
   {
    "cell_type": "code",
-   "execution_count": 25,
+   "execution_count": 27,
    "metadata": {
     "collapsed": false
    },
@@ -23837,7 +25417,7 @@
   },
   {
    "cell_type": "code",
-   "execution_count": 26,
+   "execution_count": 28,
    "metadata": {
     "collapsed": false
    },
@@ -24630,7 +26210,7 @@
   },
   {
    "cell_type": "code",
-   "execution_count": 27,
+   "execution_count": 29,
    "metadata": {
     "collapsed": false
    },
@@ -26206,7 +27786,7 @@
   },
   {
    "cell_type": "code",
-   "execution_count": 28,
+   "execution_count": 30,
    "metadata": {
     "collapsed": false
    },
@@ -27004,7 +28584,7 @@
   },
   {
    "cell_type": "code",
-   "execution_count": 29,
+   "execution_count": 31,
    "metadata": {
     "collapsed": false
    },
@@ -27797,7 +29377,7 @@
   },
   {
    "cell_type": "code",
-   "execution_count": 30,
+   "execution_count": 32,
    "metadata": {
     "collapsed": false
    },
@@ -28590,7 +30170,7 @@
   },
   {
    "cell_type": "code",
-   "execution_count": 31,
+   "execution_count": 33,
    "metadata": {
     "collapsed": false
    },
@@ -29392,7 +30972,7 @@
   },
   {
    "cell_type": "code",
-   "execution_count": 32,
+   "execution_count": 34,
    "metadata": {
     "collapsed": false,
     "scrolled": false
@@ -30183,11 +31763,19 @@
   },
   {
    "cell_type": "code",
-   "execution_count": 33,
+   "execution_count": 35,
    "metadata": {
     "collapsed": false
    },
    "outputs": [
+    {
+     "name": "stderr",
+     "output_type": "stream",
+     "text": [
+      "/home/phyks/.local/share/virtualenvs/physique/lib/python3.5/site-packages/matplotlib/pyplot.py:516: RuntimeWarning: More than 40 figures have been opened. Figures created through the pyplot interface (`matplotlib.pyplot.figure`) are retained until explicitly closed and may consume too much memory. (To control this warning, see the rcParam `figure.max_open_warning`).\n",
+      "  max_open_warning, RuntimeWarning)\n"
+     ]
+    },
     {
      "data": {
       "application/javascript": [
@@ -30981,7 +32569,7 @@
   },
   {
    "cell_type": "code",
-   "execution_count": 34,
+   "execution_count": 36,
    "metadata": {
     "collapsed": false
    },
@@ -30993,9 +32581,9 @@
      "traceback": [
       "\u001b[1;31m---------------------------------------------------------------------------\u001b[0m",
       "\u001b[1;31mInvalidParameterError\u001b[0m                     Traceback (most recent call last)",
-      "\u001b[1;32m<ipython-input-34-810be42c9f1a>\u001b[0m in \u001b[0;36m<module>\u001b[1;34m()\u001b[0m\n\u001b[0;32m      1\u001b[0m \u001b[1;31m# Invalid interval for plotting a function\u001b[0m\u001b[1;33m\u001b[0m\u001b[1;33m\u001b[0m\u001b[0m\n\u001b[0;32m      2\u001b[0m \u001b[1;32mwith\u001b[0m \u001b[0mreplot\u001b[0m\u001b[1;33m.\u001b[0m\u001b[0mFigure\u001b[0m\u001b[1;33m(\u001b[0m\u001b[1;33m)\u001b[0m \u001b[1;32mas\u001b[0m \u001b[0mfigure\u001b[0m\u001b[1;33m:\u001b[0m\u001b[1;33m\u001b[0m\u001b[0m\n\u001b[1;32m----> 3\u001b[1;33m     \u001b[0mfigure\u001b[0m\u001b[1;33m.\u001b[0m\u001b[0mplot\u001b[0m\u001b[1;33m(\u001b[0m\u001b[0mnp\u001b[0m\u001b[1;33m.\u001b[0m\u001b[0msin\u001b[0m\u001b[1;33m,\u001b[0m \u001b[1;32mNone\u001b[0m\u001b[1;33m)\u001b[0m\u001b[1;33m\u001b[0m\u001b[0m\n\u001b[0m",
+      "\u001b[1;32m<ipython-input-36-810be42c9f1a>\u001b[0m in \u001b[0;36m<module>\u001b[1;34m()\u001b[0m\n\u001b[0;32m      1\u001b[0m \u001b[1;31m# Invalid interval for plotting a function\u001b[0m\u001b[1;33m\u001b[0m\u001b[1;33m\u001b[0m\u001b[0m\n\u001b[0;32m      2\u001b[0m \u001b[1;32mwith\u001b[0m \u001b[0mreplot\u001b[0m\u001b[1;33m.\u001b[0m\u001b[0mFigure\u001b[0m\u001b[1;33m(\u001b[0m\u001b[1;33m)\u001b[0m \u001b[1;32mas\u001b[0m \u001b[0mfigure\u001b[0m\u001b[1;33m:\u001b[0m\u001b[1;33m\u001b[0m\u001b[0m\n\u001b[1;32m----> 3\u001b[1;33m     \u001b[0mfigure\u001b[0m\u001b[1;33m.\u001b[0m\u001b[0mplot\u001b[0m\u001b[1;33m(\u001b[0m\u001b[0mnp\u001b[0m\u001b[1;33m.\u001b[0m\u001b[0msin\u001b[0m\u001b[1;33m,\u001b[0m \u001b[1;32mNone\u001b[0m\u001b[1;33m)\u001b[0m\u001b[1;33m\u001b[0m\u001b[0m\n\u001b[0m",
       "\u001b[1;32m/home/phyks/Code/replot/replot/__init__.py\u001b[0m in \u001b[0;36mplot\u001b[1;34m(self, *args, **kwargs)\u001b[0m\n\u001b[0;32m    314\u001b[0m         \u001b[1;32mif\u001b[0m \u001b[0mhasattr\u001b[0m\u001b[1;33m(\u001b[0m\u001b[0margs\u001b[0m\u001b[1;33m[\u001b[0m\u001b[1;36m0\u001b[0m\u001b[1;33m]\u001b[0m\u001b[1;33m,\u001b[0m \u001b[1;34m\"__call__\"\u001b[0m\u001b[1;33m)\u001b[0m\u001b[1;33m:\u001b[0m\u001b[1;33m\u001b[0m\u001b[0m\n\u001b[0;32m    315\u001b[0m             \u001b[1;31m# We want to plot a function\u001b[0m\u001b[1;33m\u001b[0m\u001b[1;33m\u001b[0m\u001b[0m\n\u001b[1;32m--> 316\u001b[1;33m             \u001b[0mplot_\u001b[0m \u001b[1;33m=\u001b[0m \u001b[0m_plot_function\u001b[0m\u001b[1;33m(\u001b[0m\u001b[0margs\u001b[0m\u001b[1;33m[\u001b[0m\u001b[1;36m0\u001b[0m\u001b[1;33m]\u001b[0m\u001b[1;33m,\u001b[0m \u001b[1;33m*\u001b[0m\u001b[1;33m(\u001b[0m\u001b[0margs\u001b[0m\u001b[1;33m[\u001b[0m\u001b[1;36m1\u001b[0m\u001b[1;33m:\u001b[0m\u001b[1;33m]\u001b[0m\u001b[1;33m)\u001b[0m\u001b[1;33m,\u001b[0m \u001b[1;33m**\u001b[0m\u001b[0mkwargs\u001b[0m\u001b[1;33m)\u001b[0m\u001b[1;33m\u001b[0m\u001b[0m\n\u001b[0m\u001b[0;32m    317\u001b[0m         \u001b[1;32melse\u001b[0m\u001b[1;33m:\u001b[0m\u001b[1;33m\u001b[0m\u001b[0m\n\u001b[0;32m    318\u001b[0m             \u001b[1;31m# Else, it is a point series, and we just have to store it for\u001b[0m\u001b[1;33m\u001b[0m\u001b[1;33m\u001b[0m\u001b[0m\n",
-      "\u001b[1;32m/home/phyks/Code/replot/replot/__init__.py\u001b[0m in \u001b[0;36m_plot_function\u001b[1;34m(data, *args, **kwargs)\u001b[0m\n\u001b[0;32m    744\u001b[0m         raise exc.InvalidParameterError(\n\u001b[0;32m    745\u001b[0m             \u001b[1;34m\"Second parameter in plot command should be a tuple \"\u001b[0m \u001b[1;33m+\u001b[0m\u001b[1;33m\u001b[0m\u001b[0m\n\u001b[1;32m--> 746\u001b[1;33m             \"specifying plotting interval.\")\n\u001b[0m\u001b[0;32m    747\u001b[0m     \u001b[1;32mreturn\u001b[0m \u001b[1;33m(\u001b[0m\u001b[1;33m(\u001b[0m\u001b[0mx_values\u001b[0m\u001b[1;33m,\u001b[0m \u001b[0my_values\u001b[0m\u001b[1;33m)\u001b[0m \u001b[1;33m+\u001b[0m \u001b[0margs\u001b[0m\u001b[1;33m[\u001b[0m\u001b[1;36m1\u001b[0m\u001b[1;33m:\u001b[0m\u001b[1;33m]\u001b[0m\u001b[1;33m,\u001b[0m \u001b[0mkwargs\u001b[0m\u001b[1;33m)\u001b[0m\u001b[1;33m\u001b[0m\u001b[0m\n\u001b[0;32m    748\u001b[0m \u001b[1;33m\u001b[0m\u001b[0m\n",
+      "\u001b[1;32m/home/phyks/Code/replot/replot/__init__.py\u001b[0m in \u001b[0;36m_plot_function\u001b[1;34m(data, *args, **kwargs)\u001b[0m\n\u001b[0;32m    780\u001b[0m         raise exc.InvalidParameterError(\n\u001b[0;32m    781\u001b[0m             \u001b[1;34m\"Second parameter in plot command should be a tuple \"\u001b[0m \u001b[1;33m+\u001b[0m\u001b[1;33m\u001b[0m\u001b[0m\n\u001b[1;32m--> 782\u001b[1;33m             \"specifying plotting interval.\")\n\u001b[0m\u001b[0;32m    783\u001b[0m     \u001b[1;32mreturn\u001b[0m \u001b[1;33m(\u001b[0m\u001b[1;33m(\u001b[0m\u001b[0mx_values\u001b[0m\u001b[1;33m,\u001b[0m \u001b[0my_values\u001b[0m\u001b[1;33m)\u001b[0m \u001b[1;33m+\u001b[0m \u001b[0margs\u001b[0m\u001b[1;33m[\u001b[0m\u001b[1;36m1\u001b[0m\u001b[1;33m:\u001b[0m\u001b[1;33m]\u001b[0m\u001b[1;33m,\u001b[0m \u001b[0mkwargs\u001b[0m\u001b[1;33m)\u001b[0m\u001b[1;33m\u001b[0m\u001b[0m\n\u001b[0;32m    784\u001b[0m \u001b[1;33m\u001b[0m\u001b[0m\n",
       "\u001b[1;31mInvalidParameterError\u001b[0m: Second parameter in plot command should be a tuple specifying plotting interval."
      ]
     }
@@ -31008,7 +32596,7 @@
   },
   {
    "cell_type": "code",
-   "execution_count": 35,
+   "execution_count": 37,
    "metadata": {
     "collapsed": false
    },
@@ -31020,7 +32608,7 @@
      "traceback": [
       "\u001b[1;31m---------------------------------------------------------------------------\u001b[0m",
       "\u001b[1;31mInvalidParameterError\u001b[0m                     Traceback (most recent call last)",
-      "\u001b[1;32m<ipython-input-35-bb8eaf706fb0>\u001b[0m in \u001b[0;36m<module>\u001b[1;34m()\u001b[0m\n\u001b[0;32m      1\u001b[0m \u001b[1;31m# Invalid plot call, no arguments given\u001b[0m\u001b[1;33m\u001b[0m\u001b[1;33m\u001b[0m\u001b[0m\n\u001b[0;32m      2\u001b[0m \u001b[1;32mwith\u001b[0m \u001b[0mreplot\u001b[0m\u001b[1;33m.\u001b[0m\u001b[0mFigure\u001b[0m\u001b[1;33m(\u001b[0m\u001b[1;33m)\u001b[0m \u001b[1;32mas\u001b[0m \u001b[0mfigure\u001b[0m\u001b[1;33m:\u001b[0m\u001b[1;33m\u001b[0m\u001b[0m\n\u001b[1;32m----> 3\u001b[1;33m     \u001b[0mfigure\u001b[0m\u001b[1;33m.\u001b[0m\u001b[0mplot\u001b[0m\u001b[1;33m(\u001b[0m\u001b[1;33m)\u001b[0m\u001b[1;33m\u001b[0m\u001b[0m\n\u001b[0m",
+      "\u001b[1;32m<ipython-input-37-bb8eaf706fb0>\u001b[0m in \u001b[0;36m<module>\u001b[1;34m()\u001b[0m\n\u001b[0;32m      1\u001b[0m \u001b[1;31m# Invalid plot call, no arguments given\u001b[0m\u001b[1;33m\u001b[0m\u001b[1;33m\u001b[0m\u001b[0m\n\u001b[0;32m      2\u001b[0m \u001b[1;32mwith\u001b[0m \u001b[0mreplot\u001b[0m\u001b[1;33m.\u001b[0m\u001b[0mFigure\u001b[0m\u001b[1;33m(\u001b[0m\u001b[1;33m)\u001b[0m \u001b[1;32mas\u001b[0m \u001b[0mfigure\u001b[0m\u001b[1;33m:\u001b[0m\u001b[1;33m\u001b[0m\u001b[0m\n\u001b[1;32m----> 3\u001b[1;33m     \u001b[0mfigure\u001b[0m\u001b[1;33m.\u001b[0m\u001b[0mplot\u001b[0m\u001b[1;33m(\u001b[0m\u001b[1;33m)\u001b[0m\u001b[1;33m\u001b[0m\u001b[0m\n\u001b[0m",
       "\u001b[1;32m/home/phyks/Code/replot/replot/__init__.py\u001b[0m in \u001b[0;36mplot\u001b[1;34m(self, *args, **kwargs)\u001b[0m\n\u001b[0;32m    303\u001b[0m         \u001b[1;32mif\u001b[0m \u001b[0mlen\u001b[0m\u001b[1;33m(\u001b[0m\u001b[0margs\u001b[0m\u001b[1;33m)\u001b[0m \u001b[1;33m==\u001b[0m \u001b[1;36m0\u001b[0m\u001b[1;33m:\u001b[0m\u001b[1;33m\u001b[0m\u001b[0m\n\u001b[0;32m    304\u001b[0m             raise exc.InvalidParameterError(\n\u001b[1;32m--> 305\u001b[1;33m                 \"You should pass at least one argument to this function.\")\n\u001b[0m\u001b[0;32m    306\u001b[0m \u001b[1;33m\u001b[0m\u001b[0m\n\u001b[0;32m    307\u001b[0m         \u001b[1;31m# Extract custom kwargs (the ones from replot but not matplotlib) from\u001b[0m\u001b[1;33m\u001b[0m\u001b[1;33m\u001b[0m\u001b[0m\n",
       "\u001b[1;31mInvalidParameterError\u001b[0m: You should pass at least one argument to this function."
      ]
@@ -31034,7 +32622,7 @@
   },
   {
    "cell_type": "code",
-   "execution_count": 36,
+   "execution_count": 38,
    "metadata": {
     "collapsed": false
    },
@@ -31046,9 +32634,9 @@
      "traceback": [
       "\u001b[1;31m---------------------------------------------------------------------------\u001b[0m",
       "\u001b[1;31mInvalidParameterError\u001b[0m                     Traceback (most recent call last)",
-      "\u001b[1;32m<ipython-input-36-8b04957bf3f0>\u001b[0m in \u001b[0;36m<module>\u001b[1;34m()\u001b[0m\n\u001b[0;32m      1\u001b[0m \u001b[1;31m# Invalid group argument, groups are one unicode character long\u001b[0m\u001b[1;33m\u001b[0m\u001b[1;33m\u001b[0m\u001b[0m\n\u001b[0;32m      2\u001b[0m \u001b[1;32mwith\u001b[0m \u001b[0mreplot\u001b[0m\u001b[1;33m.\u001b[0m\u001b[0mFigure\u001b[0m\u001b[1;33m(\u001b[0m\u001b[1;33m)\u001b[0m \u001b[1;32mas\u001b[0m \u001b[0mfigure\u001b[0m\u001b[1;33m:\u001b[0m\u001b[1;33m\u001b[0m\u001b[0m\n\u001b[1;32m----> 3\u001b[1;33m     \u001b[0mfigure\u001b[0m\u001b[1;33m.\u001b[0m\u001b[0mplot\u001b[0m\u001b[1;33m(\u001b[0m\u001b[0mnp\u001b[0m\u001b[1;33m.\u001b[0m\u001b[0mcos\u001b[0m\u001b[1;33m,\u001b[0m \u001b[1;33m(\u001b[0m\u001b[1;33m-\u001b[0m\u001b[1;36m10\u001b[0m\u001b[1;33m,\u001b[0m \u001b[1;36m10\u001b[0m\u001b[1;33m)\u001b[0m\u001b[1;33m,\u001b[0m \u001b[0mgroup\u001b[0m\u001b[1;33m=\u001b[0m\u001b[1;34m\"abc\"\u001b[0m\u001b[1;33m)\u001b[0m\u001b[1;33m\u001b[0m\u001b[0m\n\u001b[0m",
+      "\u001b[1;32m<ipython-input-38-8b04957bf3f0>\u001b[0m in \u001b[0;36m<module>\u001b[1;34m()\u001b[0m\n\u001b[0;32m      1\u001b[0m \u001b[1;31m# Invalid group argument, groups are one unicode character long\u001b[0m\u001b[1;33m\u001b[0m\u001b[1;33m\u001b[0m\u001b[0m\n\u001b[0;32m      2\u001b[0m \u001b[1;32mwith\u001b[0m \u001b[0mreplot\u001b[0m\u001b[1;33m.\u001b[0m\u001b[0mFigure\u001b[0m\u001b[1;33m(\u001b[0m\u001b[1;33m)\u001b[0m \u001b[1;32mas\u001b[0m \u001b[0mfigure\u001b[0m\u001b[1;33m:\u001b[0m\u001b[1;33m\u001b[0m\u001b[0m\n\u001b[1;32m----> 3\u001b[1;33m     \u001b[0mfigure\u001b[0m\u001b[1;33m.\u001b[0m\u001b[0mplot\u001b[0m\u001b[1;33m(\u001b[0m\u001b[0mnp\u001b[0m\u001b[1;33m.\u001b[0m\u001b[0mcos\u001b[0m\u001b[1;33m,\u001b[0m \u001b[1;33m(\u001b[0m\u001b[1;33m-\u001b[0m\u001b[1;36m10\u001b[0m\u001b[1;33m,\u001b[0m \u001b[1;36m10\u001b[0m\u001b[1;33m)\u001b[0m\u001b[1;33m,\u001b[0m \u001b[0mgroup\u001b[0m\u001b[1;33m=\u001b[0m\u001b[1;34m\"abc\"\u001b[0m\u001b[1;33m)\u001b[0m\u001b[1;33m\u001b[0m\u001b[0m\n\u001b[0m",
       "\u001b[1;32m/home/phyks/Code/replot/replot/__init__.py\u001b[0m in \u001b[0;36mplot\u001b[1;34m(self, *args, **kwargs)\u001b[0m\n\u001b[0;32m    308\u001b[0m         \u001b[1;31m# kwargs\u001b[0m\u001b[1;33m\u001b[0m\u001b[1;33m\u001b[0m\u001b[0m\n\u001b[0;32m    309\u001b[0m         \u001b[1;32mif\u001b[0m \u001b[0mkwargs\u001b[0m \u001b[1;32mis\u001b[0m \u001b[1;32mnot\u001b[0m \u001b[1;32mNone\u001b[0m\u001b[1;33m:\u001b[0m\u001b[1;33m\u001b[0m\u001b[0m\n\u001b[1;32m--> 310\u001b[1;33m             \u001b[0mkwargs\u001b[0m\u001b[1;33m,\u001b[0m \u001b[0mcustom_kwargs\u001b[0m \u001b[1;33m=\u001b[0m \u001b[0m_handle_custom_plot_arguments\u001b[0m\u001b[1;33m(\u001b[0m\u001b[0mkwargs\u001b[0m\u001b[1;33m)\u001b[0m\u001b[1;33m\u001b[0m\u001b[0m\n\u001b[0m\u001b[0;32m    311\u001b[0m         \u001b[1;32melse\u001b[0m\u001b[1;33m:\u001b[0m\u001b[1;33m\u001b[0m\u001b[0m\n\u001b[0;32m    312\u001b[0m             \u001b[0mcustom_kwargs\u001b[0m \u001b[1;33m=\u001b[0m \u001b[1;33m{\u001b[0m\u001b[1;33m}\u001b[0m\u001b[1;33m\u001b[0m\u001b[0m\n",
-      "\u001b[1;32m/home/phyks/Code/replot/replot/__init__.py\u001b[0m in \u001b[0;36m_handle_custom_plot_arguments\u001b[1;34m(kwargs)\u001b[0m\n\u001b[0;32m    697\u001b[0m         \u001b[1;32mif\u001b[0m \u001b[0mlen\u001b[0m\u001b[1;33m(\u001b[0m\u001b[0mkwargs\u001b[0m\u001b[1;33m[\u001b[0m\u001b[1;34m\"group\"\u001b[0m\u001b[1;33m]\u001b[0m\u001b[1;33m)\u001b[0m \u001b[1;33m>\u001b[0m \u001b[1;36m1\u001b[0m\u001b[1;33m:\u001b[0m\u001b[1;33m\u001b[0m\u001b[0m\n\u001b[0;32m    698\u001b[0m             raise exc.InvalidParameterError(\n\u001b[1;32m--> 699\u001b[1;33m                 \"Group name cannot be longer than one unicode character.\")\n\u001b[0m\u001b[0;32m    700\u001b[0m         \u001b[1;32melif\u001b[0m \u001b[0mkwargs\u001b[0m\u001b[1;33m[\u001b[0m\u001b[1;34m\"group\"\u001b[0m\u001b[1;33m]\u001b[0m \u001b[1;33m==\u001b[0m \u001b[0m_DEFAULT_GROUP\u001b[0m\u001b[1;33m:\u001b[0m\u001b[1;33m\u001b[0m\u001b[0m\n\u001b[0;32m    701\u001b[0m             raise exc.InvalidParameterError(\n",
+      "\u001b[1;32m/home/phyks/Code/replot/replot/__init__.py\u001b[0m in \u001b[0;36m_handle_custom_plot_arguments\u001b[1;34m(kwargs)\u001b[0m\n\u001b[0;32m    729\u001b[0m         \u001b[1;32mif\u001b[0m \u001b[0mlen\u001b[0m\u001b[1;33m(\u001b[0m\u001b[0mkwargs\u001b[0m\u001b[1;33m[\u001b[0m\u001b[1;34m\"group\"\u001b[0m\u001b[1;33m]\u001b[0m\u001b[1;33m)\u001b[0m \u001b[1;33m>\u001b[0m \u001b[1;36m1\u001b[0m\u001b[1;33m:\u001b[0m\u001b[1;33m\u001b[0m\u001b[0m\n\u001b[0;32m    730\u001b[0m             raise exc.InvalidParameterError(\n\u001b[1;32m--> 731\u001b[1;33m                 \"Group name cannot be longer than one unicode character.\")\n\u001b[0m\u001b[0;32m    732\u001b[0m         \u001b[1;32melif\u001b[0m \u001b[0mkwargs\u001b[0m\u001b[1;33m[\u001b[0m\u001b[1;34m\"group\"\u001b[0m\u001b[1;33m]\u001b[0m \u001b[1;33m==\u001b[0m \u001b[0m_DEFAULT_GROUP\u001b[0m\u001b[1;33m:\u001b[0m\u001b[1;33m\u001b[0m\u001b[0m\n\u001b[0;32m    733\u001b[0m             raise exc.InvalidParameterError(\n",
       "\u001b[1;31mInvalidParameterError\u001b[0m: Group name cannot be longer than one unicode character."
      ]
     }
@@ -31061,7 +32649,7 @@
   },
   {
    "cell_type": "code",
-   "execution_count": 37,
+   "execution_count": 39,
    "metadata": {
     "collapsed": false
    },
@@ -31073,7 +32661,7 @@
      "traceback": [
       "\u001b[1;31m---------------------------------------------------------------------------\u001b[0m",
       "\u001b[1;31mAttributeError\u001b[0m                            Traceback (most recent call last)",
-      "\u001b[1;32m<ipython-input-37-c89b5aaa14ef>\u001b[0m in \u001b[0;36m<module>\u001b[1;34m()\u001b[0m\n\u001b[0;32m      2\u001b[0m \u001b[1;32mwith\u001b[0m \u001b[0mreplot\u001b[0m\u001b[1;33m.\u001b[0m\u001b[0mFigure\u001b[0m\u001b[1;33m(\u001b[0m\u001b[1;33m)\u001b[0m \u001b[1;32mas\u001b[0m \u001b[0mfigure\u001b[0m\u001b[1;33m:\u001b[0m\u001b[1;33m\u001b[0m\u001b[0m\n\u001b[0;32m      3\u001b[0m     \u001b[0mfigure\u001b[0m\u001b[1;33m.\u001b[0m\u001b[0mplot\u001b[0m\u001b[1;33m(\u001b[0m\u001b[0mnp\u001b[0m\u001b[1;33m.\u001b[0m\u001b[0mcos\u001b[0m\u001b[1;33m,\u001b[0m \u001b[1;33m(\u001b[0m\u001b[1;33m-\u001b[0m\u001b[1;36m10\u001b[0m\u001b[1;33m,\u001b[0m \u001b[1;36m10\u001b[0m\u001b[1;33m)\u001b[0m\u001b[1;33m,\u001b[0m \u001b[0mgroup\u001b[0m\u001b[1;33m=\u001b[0m\u001b[1;34m\"a\"\u001b[0m\u001b[1;33m)\u001b[0m\u001b[1;33m\u001b[0m\u001b[0m\n\u001b[1;32m----> 4\u001b[1;33m     \u001b[0mfigure\u001b[0m\u001b[1;33m.\u001b[0m\u001b[0mapply_grid\u001b[0m\u001b[1;33m(\u001b[0m\u001b[1;33m[\u001b[0m\u001b[1;33m]\u001b[0m\u001b[1;33m)\u001b[0m\u001b[1;33m\u001b[0m\u001b[0m\n\u001b[0m",
+      "\u001b[1;32m<ipython-input-39-c89b5aaa14ef>\u001b[0m in \u001b[0;36m<module>\u001b[1;34m()\u001b[0m\n\u001b[0;32m      2\u001b[0m \u001b[1;32mwith\u001b[0m \u001b[0mreplot\u001b[0m\u001b[1;33m.\u001b[0m\u001b[0mFigure\u001b[0m\u001b[1;33m(\u001b[0m\u001b[1;33m)\u001b[0m \u001b[1;32mas\u001b[0m \u001b[0mfigure\u001b[0m\u001b[1;33m:\u001b[0m\u001b[1;33m\u001b[0m\u001b[0m\n\u001b[0;32m      3\u001b[0m     \u001b[0mfigure\u001b[0m\u001b[1;33m.\u001b[0m\u001b[0mplot\u001b[0m\u001b[1;33m(\u001b[0m\u001b[0mnp\u001b[0m\u001b[1;33m.\u001b[0m\u001b[0mcos\u001b[0m\u001b[1;33m,\u001b[0m \u001b[1;33m(\u001b[0m\u001b[1;33m-\u001b[0m\u001b[1;36m10\u001b[0m\u001b[1;33m,\u001b[0m \u001b[1;36m10\u001b[0m\u001b[1;33m)\u001b[0m\u001b[1;33m,\u001b[0m \u001b[0mgroup\u001b[0m\u001b[1;33m=\u001b[0m\u001b[1;34m\"a\"\u001b[0m\u001b[1;33m)\u001b[0m\u001b[1;33m\u001b[0m\u001b[0m\n\u001b[1;32m----> 4\u001b[1;33m     \u001b[0mfigure\u001b[0m\u001b[1;33m.\u001b[0m\u001b[0mapply_grid\u001b[0m\u001b[1;33m(\u001b[0m\u001b[1;33m[\u001b[0m\u001b[1;33m]\u001b[0m\u001b[1;33m)\u001b[0m\u001b[1;33m\u001b[0m\u001b[0m\n\u001b[0m",
       "\u001b[1;31mAttributeError\u001b[0m: 'Figure' object has no attribute 'apply_grid'"
      ]
     }
@@ -31087,7 +32675,7 @@
   },
   {
    "cell_type": "code",
-   "execution_count": 38,
+   "execution_count": 40,
    "metadata": {
     "collapsed": false
    },
@@ -31099,7 +32687,7 @@
      "traceback": [
       "\u001b[1;31m---------------------------------------------------------------------------\u001b[0m",
       "\u001b[1;31mAttributeError\u001b[0m                            Traceback (most recent call last)",
-      "\u001b[1;32m<ipython-input-38-c6ca6527d69a>\u001b[0m in \u001b[0;36m<module>\u001b[1;34m()\u001b[0m\n\u001b[0;32m      2\u001b[0m \u001b[1;32mwith\u001b[0m \u001b[0mreplot\u001b[0m\u001b[1;33m.\u001b[0m\u001b[0mFigure\u001b[0m\u001b[1;33m(\u001b[0m\u001b[1;33m)\u001b[0m \u001b[1;32mas\u001b[0m \u001b[0mfigure\u001b[0m\u001b[1;33m:\u001b[0m\u001b[1;33m\u001b[0m\u001b[0m\n\u001b[0;32m      3\u001b[0m     \u001b[0mfigure\u001b[0m\u001b[1;33m.\u001b[0m\u001b[0mplot\u001b[0m\u001b[1;33m(\u001b[0m\u001b[0mnp\u001b[0m\u001b[1;33m.\u001b[0m\u001b[0mcos\u001b[0m\u001b[1;33m,\u001b[0m \u001b[1;33m(\u001b[0m\u001b[1;33m-\u001b[0m\u001b[1;36m10\u001b[0m\u001b[1;33m,\u001b[0m \u001b[1;36m10\u001b[0m\u001b[1;33m)\u001b[0m\u001b[1;33m,\u001b[0m \u001b[0mgroup\u001b[0m\u001b[1;33m=\u001b[0m\u001b[1;34m\"a\"\u001b[0m\u001b[1;33m)\u001b[0m\u001b[1;33m\u001b[0m\u001b[0m\n\u001b[1;32m----> 4\u001b[1;33m     figure.apply_grid([\"a\",\n\u001b[0m\u001b[0;32m      5\u001b[0m                        \"ba\"])\n",
+      "\u001b[1;32m<ipython-input-40-c6ca6527d69a>\u001b[0m in \u001b[0;36m<module>\u001b[1;34m()\u001b[0m\n\u001b[0;32m      2\u001b[0m \u001b[1;32mwith\u001b[0m \u001b[0mreplot\u001b[0m\u001b[1;33m.\u001b[0m\u001b[0mFigure\u001b[0m\u001b[1;33m(\u001b[0m\u001b[1;33m)\u001b[0m \u001b[1;32mas\u001b[0m \u001b[0mfigure\u001b[0m\u001b[1;33m:\u001b[0m\u001b[1;33m\u001b[0m\u001b[0m\n\u001b[0;32m      3\u001b[0m     \u001b[0mfigure\u001b[0m\u001b[1;33m.\u001b[0m\u001b[0mplot\u001b[0m\u001b[1;33m(\u001b[0m\u001b[0mnp\u001b[0m\u001b[1;33m.\u001b[0m\u001b[0mcos\u001b[0m\u001b[1;33m,\u001b[0m \u001b[1;33m(\u001b[0m\u001b[1;33m-\u001b[0m\u001b[1;36m10\u001b[0m\u001b[1;33m,\u001b[0m \u001b[1;36m10\u001b[0m\u001b[1;33m)\u001b[0m\u001b[1;33m,\u001b[0m \u001b[0mgroup\u001b[0m\u001b[1;33m=\u001b[0m\u001b[1;34m\"a\"\u001b[0m\u001b[1;33m)\u001b[0m\u001b[1;33m\u001b[0m\u001b[0m\n\u001b[1;32m----> 4\u001b[1;33m     figure.apply_grid([\"a\",\n\u001b[0m\u001b[0;32m      5\u001b[0m                        \"ba\"])\n",
       "\u001b[1;31mAttributeError\u001b[0m: 'Figure' object has no attribute 'apply_grid'"
      ]
     }
diff --git a/README.md b/README.md
index 2d19c11..59203e6 100644
--- a/README.md
+++ b/README.md
@@ -74,6 +74,11 @@ design in the API, or required feature!
     compare them easily, but you do not want to waste time setting up a grid
     and placing your plots at the correct place? <code>replot</code> handles
     it for you out of the box!</dd>
+
+    <dt>Easy plotting in log scale</dt>
+    <dd><code>replot</code> defines <code>logplot</code> and
+    <code>loglogplot</code> shortcuts functions to plot in <em>log</em> scale
+    or <em>loglog</em> scale.</dd>
 </dl>
 
 
diff --git a/replot/__init__.py b/replot/__init__.py
index a095fc6..dc5e721 100644
--- a/replot/__init__.py
+++ b/replot/__init__.py
@@ -329,6 +329,9 @@ class Figure():
                     pass
             plot_ = (args, kwargs)
 
+        # Keep track of the custom kwargs
+        plot_ += (custom_kwargs,)
+
         # Add the plot to the correct group
         if "group" in custom_kwargs:
             self.plots[custom_kwargs["group"]].append(plot_)
@@ -340,6 +343,28 @@ class Figure():
         if "label" in kwargs and self.legend is None:
             self.legend = True
 
+    def logplot(self, *args, **kwargs):
+        """
+        Plot something on the :class:`Figure` object, in log scale.
+
+        .. note:: See :func:`replot.Figure.plot` for the full documentation.
+
+        >>> with replot.figure() as fig: fig.logplot(np.log, (-1, 1))
+        """
+        kwargs["logscale"] = "log"
+        self.plot(*args, **kwargs)
+
+    def loglogplot(self, *args, **kwargs):
+        """
+        Plot something on the :class:`Figure` object, in log-log scale.
+
+        .. note:: See :func:`replot.Figure.plot` for the full documentation.
+
+        >>> with replot.figure() as fig: fig.logplot(np.log, (-1, 1))
+        """
+        kwargs["logscale"] = "loglog"
+        self.plot(*args, **kwargs)
+
     def _legend(self, axis, overload_legend=None):
         """
         Helper function to handle ``legend`` attribute. It places the legend \
@@ -502,6 +527,13 @@ class Figure():
                 # Plot
                 for plot_ in self.plots[group_]:
                     tmp_plots = axis.plot(*(plot_[0]), **(plot_[1]))
+                    # Handle custom kwargs at plotting time
+                    if "logscale" in plot_[2]:
+                        if plot_[2]["logscale"] == "log":
+                            axis.set_xscale("log")
+                        elif plot_[2]["logscale"] == "loglog":
+                            axis.set_xscale("log")
+                            axis.set_yscale("log")
                     # Do not clip line at the axes boundaries to prevent
                     # extremas from being cropped.
                     for tmp_plot in tmp_plots:
@@ -704,10 +736,14 @@ def _handle_custom_plot_arguments(kwargs):
         del kwargs["group"]
     # Handle "line" argument
     if "line" in kwargs:
-        if not kwargs["line"]:
+        if not kwargs["line"]:  # If should not draw lines, set kwargs for it
             kwargs["linestyle"] = "None"
             kwargs["marker"] = "x"
         del kwargs["line"]
+    # Handle "logscale" argument
+    if "logscale" in kwargs:
+        custom_kwargs["logscale"] = kwargs["logscale"]
+        del kwargs["logscale"]
     return (kwargs, custom_kwargs)