08-Root-locus.ipynb

{
 "cells": [
  {
   "cell_type": "code",
   "execution_count": 1,
   "metadata": {},
   "outputs": [],
   "source": [
    "# Erasmus+ ICCT project (2018-1-SI01-KA203-047081)\n",
    "\n",
    "%matplotlib notebook\n",
    "import numpy as np\n",
    "import math\n",
    "import matplotlib.pyplot as plt\n",
    "from scipy import signal\n",
    "import ipywidgets as widgets"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 2,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "application/javascript": [
       "/* Put everything inside the global mpl namespace */\n",
       "window.mpl = {};\n",
       "\n",
       "\n",
       "mpl.get_websocket_type = function() {\n",
       "    if (typeof(WebSocket) !== 'undefined') {\n",
       "        return WebSocket;\n",
       "    } else if (typeof(MozWebSocket) !== 'undefined') {\n",
       "        return MozWebSocket;\n",
       "    } else {\n",
       "        alert('Your browser does not have WebSocket support.' +\n",
       "              'Please try Chrome, Safari or Firefox ≥ 6. ' +\n",
       "              'Firefox 4 and 5 are also supported but you ' +\n",
       "              'have to enable WebSockets in about:config.');\n",
       "    };\n",
       "}\n",
       "\n",
       "mpl.figure = function(figure_id, websocket, ondownload, parent_element) {\n",
       "    this.id = figure_id;\n",
       "\n",
       "    this.ws = websocket;\n",
       "\n",
       "    this.supports_binary = (this.ws.binaryType != undefined);\n",
       "\n",
       "    if (!this.supports_binary) {\n",
       "        var warnings = document.getElementById(\"mpl-warnings\");\n",
       "        if (warnings) {\n",
       "            warnings.style.display = 'block';\n",
       "            warnings.textContent = (\n",
       "                \"This browser does not support binary websocket messages. \" +\n",
       "                    \"Performance may be slow.\");\n",
       "        }\n",
       "    }\n",
       "\n",
       "    this.imageObj = new Image();\n",
       "\n",
       "    this.context = undefined;\n",
       "    this.message = undefined;\n",
       "    this.canvas = undefined;\n",
       "    this.rubberband_canvas = undefined;\n",
       "    this.rubberband_context = undefined;\n",
       "    this.format_dropdown = undefined;\n",
       "\n",
       "    this.image_mode = 'full';\n",
       "\n",
       "    this.root = $('<div/>');\n",
       "    this._root_extra_style(this.root)\n",
       "    this.root.attr('style', 'display: inline-block');\n",
       "\n",
       "    $(parent_element).append(this.root);\n",
       "\n",
       "    this._init_header(this);\n",
       "    this._init_canvas(this);\n",
       "    this._init_toolbar(this);\n",
       "\n",
       "    var fig = this;\n",
       "\n",
       "    this.waiting = false;\n",
       "\n",
       "    this.ws.onopen =  function () {\n",
       "            fig.send_message(\"supports_binary\", {value: fig.supports_binary});\n",
       "            fig.send_message(\"send_image_mode\", {});\n",
       "            if (mpl.ratio != 1) {\n",
       "                fig.send_message(\"set_dpi_ratio\", {'dpi_ratio': mpl.ratio});\n",
       "            }\n",
       "            fig.send_message(\"refresh\", {});\n",
       "        }\n",
       "\n",
       "    this.imageObj.onload = function() {\n",
       "            if (fig.image_mode == 'full') {\n",
       "                // Full images could contain transparency (where diff images\n",
       "                // almost always do), so we need to clear the canvas so that\n",
       "                // there is no ghosting.\n",
       "                fig.context.clearRect(0, 0, fig.canvas.width, fig.canvas.height);\n",
       "            }\n",
       "            fig.context.drawImage(fig.imageObj, 0, 0);\n",
       "        };\n",
       "\n",
       "    this.imageObj.onunload = function() {\n",
       "        fig.ws.close();\n",
       "    }\n",
       "\n",
       "    this.ws.onmessage = this._make_on_message_function(this);\n",
       "\n",
       "    this.ondownload = ondownload;\n",
       "}\n",
       "\n",
       "mpl.figure.prototype._init_header = function() {\n",
       "    var titlebar = $(\n",
       "        '<div class=\"ui-dialog-titlebar ui-widget-header ui-corner-all ' +\n",
       "        'ui-helper-clearfix\"/>');\n",
       "    var titletext = $(\n",
       "        '<div class=\"ui-dialog-title\" style=\"width: 100%; ' +\n",
       "        'text-align: center; padding: 3px;\"/>');\n",
       "    titlebar.append(titletext)\n",
       "    this.root.append(titlebar);\n",
       "    this.header = titletext[0];\n",
       "}\n",
       "\n",
       "\n",
       "\n",
       "mpl.figure.prototype._canvas_extra_style = function(canvas_div) {\n",
       "\n",
       "}\n",
       "\n",
       "\n",
       "mpl.figure.prototype._root_extra_style = function(canvas_div) {\n",
       "\n",
       "}\n",
       "\n",
       "mpl.figure.prototype._init_canvas = function() {\n",
       "    var fig = this;\n",
       "\n",
       "    var canvas_div = $('<div/>');\n",
       "\n",
       "    canvas_div.attr('style', 'position: relative; clear: both; outline: 0');\n",
       "\n",
       "    function canvas_keyboard_event(event) {\n",
       "        return fig.key_event(event, event['data']);\n",
       "    }\n",
       "\n",
       "    canvas_div.keydown('key_press', canvas_keyboard_event);\n",
       "    canvas_div.keyup('key_release', canvas_keyboard_event);\n",
       "    this.canvas_div = canvas_div\n",
       "    this._canvas_extra_style(canvas_div)\n",
       "    this.root.append(canvas_div);\n",
       "\n",
       "    var canvas = $('<canvas/>');\n",
       "    canvas.addClass('mpl-canvas');\n",
       "    canvas.attr('style', \"left: 0; top: 0; z-index: 0; outline: 0\")\n",
       "\n",
       "    this.canvas = canvas[0];\n",
       "    this.context = canvas[0].getContext(\"2d\");\n",
       "\n",
       "    var backingStore = this.context.backingStorePixelRatio ||\n",
       "\tthis.context.webkitBackingStorePixelRatio ||\n",
       "\tthis.context.mozBackingStorePixelRatio ||\n",
       "\tthis.context.msBackingStorePixelRatio ||\n",
       "\tthis.context.oBackingStorePixelRatio ||\n",
       "\tthis.context.backingStorePixelRatio || 1;\n",
       "\n",
       "    mpl.ratio = (window.devicePixelRatio || 1) / backingStore;\n",
       "\n",
       "    var rubberband = $('<canvas/>');\n",
       "    rubberband.attr('style', \"position: absolute; left: 0; top: 0; z-index: 1;\")\n",
       "\n",
       "    var pass_mouse_events = true;\n",
       "\n",
       "    canvas_div.resizable({\n",
       "        start: function(event, ui) {\n",
       "            pass_mouse_events = false;\n",
       "        },\n",
       "        resize: function(event, ui) {\n",
       "            fig.request_resize(ui.size.width, ui.size.height);\n",
       "        },\n",
       "        stop: function(event, ui) {\n",
       "            pass_mouse_events = true;\n",
       "            fig.request_resize(ui.size.width, ui.size.height);\n",
       "        },\n",
       "    });\n",
       "\n",
       "    function mouse_event_fn(event) {\n",
       "        if (pass_mouse_events)\n",
       "            return fig.mouse_event(event, event['data']);\n",
       "    }\n",
       "\n",
       "    rubberband.mousedown('button_press', mouse_event_fn);\n",
       "    rubberband.mouseup('button_release', mouse_event_fn);\n",
       "    // Throttle sequential mouse events to 1 every 20ms.\n",
       "    rubberband.mousemove('motion_notify', mouse_event_fn);\n",
       "\n",
       "    rubberband.mouseenter('figure_enter', mouse_event_fn);\n",
       "    rubberband.mouseleave('figure_leave', mouse_event_fn);\n",
       "\n",
       "    canvas_div.on(\"wheel\", function (event) {\n",
       "        event = event.originalEvent;\n",
       "        event['data'] = 'scroll'\n",
       "        if (event.deltaY < 0) {\n",
       "            event.step = 1;\n",
       "        } else {\n",
       "            event.step = -1;\n",
       "        }\n",
       "        mouse_event_fn(event);\n",
       "    });\n",
       "\n",
       "    canvas_div.append(canvas);\n",
       "    canvas_div.append(rubberband);\n",
       "\n",
       "    this.rubberband = rubberband;\n",
       "    this.rubberband_canvas = rubberband[0];\n",
       "    this.rubberband_context = rubberband[0].getContext(\"2d\");\n",
       "    this.rubberband_context.strokeStyle = \"#000000\";\n",
       "\n",
       "    this._resize_canvas = function(width, height) {\n",
       "        // Keep the size of the canvas, canvas container, and rubber band\n",
       "        // canvas in synch.\n",
       "        canvas_div.css('width', width)\n",
       "        canvas_div.css('height', height)\n",
       "\n",
       "        canvas.attr('width', width * mpl.ratio);\n",
       "        canvas.attr('height', height * mpl.ratio);\n",
       "        canvas.attr('style', 'width: ' + width + 'px; height: ' + height + 'px;');\n",
       "\n",
       "        rubberband.attr('width', width);\n",
       "        rubberband.attr('height', height);\n",
       "    }\n",
       "\n",
       "    // Set the figure to an initial 600x600px, this will subsequently be updated\n",
       "    // upon first draw.\n",
       "    this._resize_canvas(600, 600);\n",
       "\n",
       "    // Disable right mouse context menu.\n",
       "    $(this.rubberband_canvas).bind(\"contextmenu\",function(e){\n",
       "        return false;\n",
       "    });\n",
       "\n",
       "    function set_focus () {\n",
       "        canvas.focus();\n",
       "        canvas_div.focus();\n",
       "    }\n",
       "\n",
       "    window.setTimeout(set_focus, 100);\n",
       "}\n",
       "\n",
       "mpl.figure.prototype._init_toolbar = function() {\n",
       "    var fig = this;\n",
       "\n",
       "    var nav_element = $('<div/>')\n",
       "    nav_element.attr('style', 'width: 100%');\n",
       "    this.root.append(nav_element);\n",
       "\n",
       "    // Define a callback function for later on.\n",
       "    function toolbar_event(event) {\n",
       "        return fig.toolbar_button_onclick(event['data']);\n",
       "    }\n",
       "    function toolbar_mouse_event(event) {\n",
       "        return fig.toolbar_button_onmouseover(event['data']);\n",
       "    }\n",
       "\n",
       "    for(var toolbar_ind in mpl.toolbar_items) {\n",
       "        var name = mpl.toolbar_items[toolbar_ind][0];\n",
       "        var tooltip = mpl.toolbar_items[toolbar_ind][1];\n",
       "        var image = mpl.toolbar_items[toolbar_ind][2];\n",
       "        var method_name = mpl.toolbar_items[toolbar_ind][3];\n",
       "\n",
       "        if (!name) {\n",
       "            // put a spacer in here.\n",
       "            continue;\n",
       "        }\n",
       "        var button = $('<button/>');\n",
       "        button.addClass('ui-button ui-widget ui-state-default ui-corner-all ' +\n",
       "                        'ui-button-icon-only');\n",
       "        button.attr('role', 'button');\n",
       "        button.attr('aria-disabled', 'false');\n",
       "        button.click(method_name, toolbar_event);\n",
       "        button.mouseover(tooltip, toolbar_mouse_event);\n",
       "\n",
       "        var icon_img = $('<span/>');\n",
       "        icon_img.addClass('ui-button-icon-primary ui-icon');\n",
       "        icon_img.addClass(image);\n",
       "        icon_img.addClass('ui-corner-all');\n",
       "\n",
       "        var tooltip_span = $('<span/>');\n",
       "        tooltip_span.addClass('ui-button-text');\n",
       "        tooltip_span.html(tooltip);\n",
       "\n",
       "        button.append(icon_img);\n",
       "        button.append(tooltip_span);\n",
       "\n",
       "        nav_element.append(button);\n",
       "    }\n",
       "\n",
       "    var fmt_picker_span = $('<span/>');\n",
       "\n",
       "    var fmt_picker = $('<select/>');\n",
       "    fmt_picker.addClass('mpl-toolbar-option ui-widget ui-widget-content');\n",
       "    fmt_picker_span.append(fmt_picker);\n",
       "    nav_element.append(fmt_picker_span);\n",
       "    this.format_dropdown = fmt_picker[0];\n",
       "\n",
       "    for (var ind in mpl.extensions) {\n",
       "        var fmt = mpl.extensions[ind];\n",
       "        var option = $(\n",
       "            '<option/>', {selected: fmt === mpl.default_extension}).html(fmt);\n",
       "        fmt_picker.append(option)\n",
       "    }\n",
       "\n",
       "    // Add hover states to the ui-buttons\n",
       "    $( \".ui-button\" ).hover(\n",
       "        function() { $(this).addClass(\"ui-state-hover\");},\n",
       "        function() { $(this).removeClass(\"ui-state-hover\");}\n",
       "    );\n",
       "\n",
       "    var status_bar = $('<span class=\"mpl-message\"/>');\n",
       "    nav_element.append(status_bar);\n",
       "    this.message = status_bar[0];\n",
       "}\n",
       "\n",
       "mpl.figure.prototype.request_resize = function(x_pixels, y_pixels) {\n",
       "    // Request matplotlib to resize the figure. Matplotlib will then trigger a resize in the client,\n",
       "    // which will in turn request a refresh of the image.\n",
       "    this.send_message('resize', {'width': x_pixels, 'height': y_pixels});\n",
       "}\n",
       "\n",
       "mpl.figure.prototype.send_message = function(type, properties) {\n",
       "    properties['type'] = type;\n",
       "    properties['figure_id'] = this.id;\n",
       "    this.ws.send(JSON.stringify(properties));\n",
       "}\n",
       "\n",
       "mpl.figure.prototype.send_draw_message = function() {\n",
       "    if (!this.waiting) {\n",
       "        this.waiting = true;\n",
       "        this.ws.send(JSON.stringify({type: \"draw\", figure_id: this.id}));\n",
       "    }\n",
       "}\n",
       "\n",
       "\n",
       "mpl.figure.prototype.handle_save = function(fig, msg) {\n",
       "    var format_dropdown = fig.format_dropdown;\n",
       "    var format = format_dropdown.options[format_dropdown.selectedIndex].value;\n",
       "    fig.ondownload(fig, format);\n",
       "}\n",
       "\n",
       "\n",
       "mpl.figure.prototype.handle_resize = function(fig, msg) {\n",
       "    var size = msg['size'];\n",
       "    if (size[0] != fig.canvas.width || size[1] != fig.canvas.height) {\n",
       "        fig._resize_canvas(size[0], size[1]);\n",
       "        fig.send_message(\"refresh\", {});\n",
       "    };\n",
       "}\n",
       "\n",
       "mpl.figure.prototype.handle_rubberband = function(fig, msg) {\n",
       "    var x0 = msg['x0'] / mpl.ratio;\n",
       "    var y0 = (fig.canvas.height - msg['y0']) / mpl.ratio;\n",
       "    var x1 = msg['x1'] / mpl.ratio;\n",
       "    var y1 = (fig.canvas.height - msg['y1']) / mpl.ratio;\n",
       "    x0 = Math.floor(x0) + 0.5;\n",
       "    y0 = Math.floor(y0) + 0.5;\n",
       "    x1 = Math.floor(x1) + 0.5;\n",
       "    y1 = Math.floor(y1) + 0.5;\n",
       "    var min_x = Math.min(x0, x1);\n",
       "    var min_y = Math.min(y0, y1);\n",
       "    var width = Math.abs(x1 - x0);\n",
       "    var height = Math.abs(y1 - y0);\n",
       "\n",
       "    fig.rubberband_context.clearRect(\n",
       "        0, 0, fig.canvas.width, fig.canvas.height);\n",
       "\n",
       "    fig.rubberband_context.strokeRect(min_x, min_y, width, height);\n",
       "}\n",
       "\n",
       "mpl.figure.prototype.handle_figure_label = function(fig, msg) {\n",
       "    // Updates the figure title.\n",
       "    fig.header.textContent = msg['label'];\n",
       "}\n",
       "\n",
       "mpl.figure.prototype.handle_cursor = function(fig, msg) {\n",
       "    var cursor = msg['cursor'];\n",
       "    switch(cursor)\n",
       "    {\n",
       "    case 0:\n",
       "        cursor = 'pointer';\n",
       "        break;\n",
       "    case 1:\n",
       "        cursor = 'default';\n",
       "        break;\n",
       "    case 2:\n",
       "        cursor = 'crosshair';\n",
       "        break;\n",
       "    case 3:\n",
       "        cursor = 'move';\n",
       "        break;\n",
       "    }\n",
       "    fig.rubberband_canvas.style.cursor = cursor;\n",
       "}\n",
       "\n",
       "mpl.figure.prototype.handle_message = function(fig, msg) {\n",
       "    fig.message.textContent = msg['message'];\n",
       "}\n",
       "\n",
       "mpl.figure.prototype.handle_draw = function(fig, msg) {\n",
       "    // Request the server to send over a new figure.\n",
       "    fig.send_draw_message();\n",
       "}\n",
       "\n",
       "mpl.figure.prototype.handle_image_mode = function(fig, msg) {\n",
       "    fig.image_mode = msg['mode'];\n",
       "}\n",
       "\n",
       "mpl.figure.prototype.updated_canvas_event = function() {\n",
       "    // Called whenever the canvas gets updated.\n",
       "    this.send_message(\"ack\", {});\n",
       "}\n",
       "\n",
       "// A function to construct a web socket function for onmessage handling.\n",
       "// Called in the figure constructor.\n",
       "mpl.figure.prototype._make_on_message_function = function(fig) {\n",
       "    return function socket_on_message(evt) {\n",
       "        if (evt.data instanceof Blob) {\n",
       "            /* FIXME: We get \"Resource interpreted as Image but\n",
       "             * transferred with MIME type text/plain:\" errors on\n",
       "             * Chrome.  But how to set the MIME type?  It doesn't seem\n",
       "             * to be part of the websocket stream */\n",
       "            evt.data.type = \"image/png\";\n",
       "\n",
       "            /* Free the memory for the previous frames */\n",
       "            if (fig.imageObj.src) {\n",
       "                (window.URL || window.webkitURL).revokeObjectURL(\n",
       "                    fig.imageObj.src);\n",
       "            }\n",
       "\n",
       "            fig.imageObj.src = (window.URL || window.webkitURL).createObjectURL(\n",
       "                evt.data);\n",
       "            fig.updated_canvas_event();\n",
       "            fig.waiting = false;\n",
       "            return;\n",
       "        }\n",
       "        else if (typeof evt.data === 'string' && evt.data.slice(0, 21) == \"data:image/png;base64\") {\n",
       "            fig.imageObj.src = evt.data;\n",
       "            fig.updated_canvas_event();\n",
       "            fig.waiting = false;\n",
       "            return;\n",
       "        }\n",
       "\n",
       "        var msg = JSON.parse(evt.data);\n",
       "        var msg_type = msg['type'];\n",
       "\n",
       "        // Call the  \"handle_{type}\" callback, which takes\n",
       "        // the figure and JSON message as its only arguments.\n",
       "        try {\n",
       "            var callback = fig[\"handle_\" + msg_type];\n",
       "        } catch (e) {\n",
       "            console.log(\"No handler for the '\" + msg_type + \"' message type: \", msg);\n",
       "            return;\n",
       "        }\n",
       "\n",
       "        if (callback) {\n",
       "            try {\n",
       "                // console.log(\"Handling '\" + msg_type + \"' message: \", msg);\n",
       "                callback(fig, msg);\n",
       "            } catch (e) {\n",
       "                console.log(\"Exception inside the 'handler_\" + msg_type + \"' callback:\", e, e.stack, msg);\n",
       "            }\n",
       "        }\n",
       "    };\n",
       "}\n",
       "\n",
       "// from http://stackoverflow.com/questions/1114465/getting-mouse-location-in-canvas\n",
       "mpl.findpos = function(e) {\n",
       "    //this section is from http://www.quirksmode.org/js/events_properties.html\n",
       "    var targ;\n",
       "    if (!e)\n",
       "        e = window.event;\n",
       "    if (e.target)\n",
       "        targ = e.target;\n",
       "    else if (e.srcElement)\n",
       "        targ = e.srcElement;\n",
       "    if (targ.nodeType == 3) // defeat Safari bug\n",
       "        targ = targ.parentNode;\n",
       "\n",
       "    // jQuery normalizes the pageX and pageY\n",
       "    // pageX,Y are the mouse positions relative to the document\n",
       "    // offset() returns the position of the element relative to the document\n",
       "    var x = e.pageX - $(targ).offset().left;\n",
       "    var y = e.pageY - $(targ).offset().top;\n",
       "\n",
       "    return {\"x\": x, \"y\": y};\n",
       "};\n",
       "\n",
       "/*\n",
       " * return a copy of an object with only non-object keys\n",
       " * we need this to avoid circular references\n",
       " * http://stackoverflow.com/a/24161582/3208463\n",
       " */\n",
       "function simpleKeys (original) {\n",
       "  return Object.keys(original).reduce(function (obj, key) {\n",
       "    if (typeof original[key] !== 'object')\n",
       "        obj[key] = original[key]\n",
       "    return obj;\n",
       "  }, {});\n",
       "}\n",
       "\n",
       "mpl.figure.prototype.mouse_event = function(event, name) {\n",
       "    var canvas_pos = mpl.findpos(event)\n",
       "\n",
       "    if (name === 'button_press')\n",
       "    {\n",
       "        this.canvas.focus();\n",
       "        this.canvas_div.focus();\n",
       "    }\n",
       "\n",
       "    var x = canvas_pos.x * mpl.ratio;\n",
       "    var y = canvas_pos.y * mpl.ratio;\n",
       "\n",
       "    this.send_message(name, {x: x, y: y, button: event.button,\n",
       "                             step: event.step,\n",
       "                             guiEvent: simpleKeys(event)});\n",
       "\n",
       "    /* This prevents the web browser from automatically changing to\n",
       "     * the text insertion cursor when the button is pressed.  We want\n",
       "     * to control all of the cursor setting manually through the\n",
       "     * 'cursor' event from matplotlib */\n",
       "    event.preventDefault();\n",
       "    return false;\n",
       "}\n",
       "\n",
       "mpl.figure.prototype._key_event_extra = function(event, name) {\n",
       "    // Handle any extra behaviour associated with a key event\n",
       "}\n",
       "\n",
       "mpl.figure.prototype.key_event = function(event, name) {\n",
       "\n",
       "    // Prevent repeat events\n",
       "    if (name == 'key_press')\n",
       "    {\n",
       "        if (event.which === this._key)\n",
       "            return;\n",
       "        else\n",
       "            this._key = event.which;\n",
       "    }\n",
       "    if (name == 'key_release')\n",
       "        this._key = null;\n",
       "\n",
       "    var value = '';\n",
       "    if (event.ctrlKey && event.which != 17)\n",
       "        value += \"ctrl+\";\n",
       "    if (event.altKey && event.which != 18)\n",
       "        value += \"alt+\";\n",
       "    if (event.shiftKey && event.which != 16)\n",
       "        value += \"shift+\";\n",
       "\n",
       "    value += 'k';\n",
       "    value += event.which.toString();\n",
       "\n",
       "    this._key_event_extra(event, name);\n",
       "\n",
       "    this.send_message(name, {key: value,\n",
       "                             guiEvent: simpleKeys(event)});\n",
       "    return false;\n",
       "}\n",
       "\n",
       "mpl.figure.prototype.toolbar_button_onclick = function(name) {\n",
       "    if (name == 'download') {\n",
       "        this.handle_save(this, null);\n",
       "    } else {\n",
       "        this.send_message(\"toolbar_button\", {name: name});\n",
       "    }\n",
       "};\n",
       "\n",
       "mpl.figure.prototype.toolbar_button_onmouseover = function(tooltip) {\n",
       "    this.message.textContent = tooltip;\n",
       "};\n",
       "mpl.toolbar_items = [[\"Home\", \"Reset original view\", \"fa fa-home icon-home\", \"home\"], [\"Back\", \"Back to previous view\", \"fa fa-arrow-left icon-arrow-left\", \"back\"], [\"Forward\", \"Forward to next view\", \"fa fa-arrow-right icon-arrow-right\", \"forward\"], [\"\", \"\", \"\", \"\"], [\"Pan\", \"Pan axes with left mouse, zoom with right\", \"fa fa-arrows icon-move\", \"pan\"], [\"Zoom\", \"Zoom to rectangle\", \"fa fa-square-o icon-check-empty\", \"zoom\"], [\"\", \"\", \"\", \"\"], [\"Download\", \"Download plot\", \"fa fa-floppy-o icon-save\", \"download\"]];\n",
       "\n",
       "mpl.extensions = [\"eps\", \"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 overridden (by mpl) onmessage function.\n",
       "        ws.onmessage(msg['content']['data'])\n",
       "    });\n",
       "    return ws;\n",
       "}\n",
       "\n",
       "mpl.mpl_figure_comm = function(comm, msg) {\n",
       "    // This is the function which gets called when the mpl process\n",
       "    // starts-up an IPython Comm through the \"matplotlib\" channel.\n",
       "\n",
       "    var id = msg.content.data.id;\n",
       "    // Get hold of the div created by the display call when the Comm\n",
       "    // socket was opened in Python.\n",
       "    var element = $(\"#\" + id);\n",
       "    var ws_proxy = comm_websocket_adapter(comm)\n",
       "\n",
       "    function ondownload(figure, format) {\n",
       "        window.open(figure.imageObj.src);\n",
       "    }\n",
       "\n",
       "    var fig = new mpl.figure(id, ws_proxy,\n",
       "                           ondownload,\n",
       "                           element.get(0));\n",
       "\n",
       "    // Call onopen now - mpl needs it, as it is assuming we've passed it a real\n",
       "    // web socket which is closed, not our websocket->open comm proxy.\n",
       "    ws_proxy.onopen();\n",
       "\n",
       "    fig.parent_element = element.get(0);\n",
       "    fig.cell_info = mpl.find_output_cell(\"<div id='\" + id + \"'></div>\");\n",
       "    if (!fig.cell_info) {\n",
       "        console.error(\"Failed to find cell for figure\", id, fig);\n",
       "        return;\n",
       "    }\n",
       "\n",
       "    var output_index = fig.cell_info[2]\n",
       "    var cell = fig.cell_info[0];\n",
       "\n",
       "};\n",
       "\n",
       "mpl.figure.prototype.handle_close = function(fig, msg) {\n",
       "    var width = fig.canvas.width/mpl.ratio\n",
       "    fig.root.unbind('remove')\n",
       "\n",
       "    // Update the output cell to use the data from the current canvas.\n",
       "    fig.push_to_output();\n",
       "    var dataURL = fig.canvas.toDataURL();\n",
       "    // Re-enable the keyboard manager in IPython - without this line, in FF,\n",
       "    // the notebook keyboard shortcuts fail.\n",
       "    IPython.keyboard_manager.enable()\n",
       "    $(fig.parent_element).html('<img src=\"' + dataURL + '\" width=\"' + width + '\">');\n",
       "    fig.close_ws(fig, msg);\n",
       "}\n",
       "\n",
       "mpl.figure.prototype.close_ws = function(fig, msg){\n",
       "    fig.send_message('closing', msg);\n",
       "    // fig.ws.close()\n",
       "}\n",
       "\n",
       "mpl.figure.prototype.push_to_output = function(remove_interactive) {\n",
       "    // Turn the data on the canvas into data in the output cell.\n",
       "    var width = this.canvas.width/mpl.ratio\n",
       "    var dataURL = this.canvas.toDataURL();\n",
       "    this.cell_info[1]['text/html'] = '<img src=\"' + dataURL + '\" width=\"' + width + '\">';\n",
       "}\n",
       "\n",
       "mpl.figure.prototype.updated_canvas_event = function() {\n",
       "    // Tell IPython that the notebook contents must change.\n",
       "    IPython.notebook.set_dirty(true);\n",
       "    this.send_message(\"ack\", {});\n",
       "    var fig = this;\n",
       "    // Wait a second, then push the new image to the DOM so\n",
       "    // that it is saved nicely (might be nice to debounce this).\n",
       "    setTimeout(function () { fig.push_to_output() }, 1000);\n",
       "}\n",
       "\n",
       "mpl.figure.prototype._init_toolbar = function() {\n",
       "    var fig = this;\n",
       "\n",
       "    var nav_element = $('<div/>')\n",
       "    nav_element.attr('style', 'width: 100%');\n",
       "    this.root.append(nav_element);\n",
       "\n",
       "    // Define a callback function for later on.\n",
       "    function toolbar_event(event) {\n",
       "        return fig.toolbar_button_onclick(event['data']);\n",
       "    }\n",
       "    function toolbar_mouse_event(event) {\n",
       "        return fig.toolbar_button_onmouseover(event['data']);\n",
       "    }\n",
       "\n",
       "    for(var toolbar_ind in mpl.toolbar_items){\n",
       "        var name = mpl.toolbar_items[toolbar_ind][0];\n",
       "        var tooltip = mpl.toolbar_items[toolbar_ind][1];\n",
       "        var image = mpl.toolbar_items[toolbar_ind][2];\n",
       "        var method_name = mpl.toolbar_items[toolbar_ind][3];\n",
       "\n",
       "        if (!name) { continue; };\n",
       "\n",
       "        var button = $('<button class=\"btn btn-default\" href=\"#\" title=\"' + name + '\"><i class=\"fa ' + image + ' fa-lg\"></i></button>');\n",
       "        button.click(method_name, toolbar_event);\n",
       "        button.mouseover(tooltip, toolbar_mouse_event);\n",
       "        nav_element.append(button);\n",
       "    }\n",
       "\n",
       "    // Add the status bar.\n",
       "    var status_bar = $('<span class=\"mpl-message\" style=\"text-align:right; float: right;\"/>');\n",
       "    nav_element.append(status_bar);\n",
       "    this.message = status_bar[0];\n",
       "\n",
       "    // Add the close button to the window.\n",
       "    var buttongrp = $('<div class=\"btn-group inline pull-right\"></div>');\n",
       "    var button = $('<button class=\"btn btn-mini btn-primary\" href=\"#\" title=\"Stop Interaction\"><i class=\"fa fa-power-off icon-remove icon-large\"></i></button>');\n",
       "    button.click(function (evt) { fig.handle_close(fig, {}); } );\n",
       "    button.mouseover('Stop Interaction', toolbar_mouse_event);\n",
       "    buttongrp.append(button);\n",
       "    var titlebar = this.root.find($('.ui-dialog-titlebar'));\n",
       "    titlebar.prepend(buttongrp);\n",
       "}\n",
       "\n",
       "mpl.figure.prototype._root_extra_style = function(el){\n",
       "    var fig = this\n",
       "    el.on(\"remove\", function(){\n",
       "\tfig.close_ws(fig, {});\n",
       "    });\n",
       "}\n",
       "\n",
       "mpl.figure.prototype._canvas_extra_style = function(el){\n",
       "    // this is important to make the div 'focusable\n",
       "    el.attr('tabindex', 0)\n",
       "    // reach out to IPython and tell the keyboard manager to turn it's self\n",
       "    // off when our div gets focus\n",
       "\n",
       "    // location in version 3\n",
       "    if (IPython.notebook.keyboard_manager) {\n",
       "        IPython.notebook.keyboard_manager.register_events(el);\n",
       "    }\n",
       "    else {\n",
       "        // location in version 2\n",
       "        IPython.keyboard_manager.register_events(el);\n",
       "    }\n",
       "\n",
       "}\n",
       "\n",
       "mpl.figure.prototype._key_event_extra = function(event, name) {\n",
       "    var manager = IPython.notebook.keyboard_manager;\n",
       "    if (!manager)\n",
       "        manager = IPython.keyboard_manager;\n",
       "\n",
       "    // Check for shift+enter\n",
       "    if (event.shiftKey && event.which == 13) {\n",
       "        this.canvas_div.blur();\n",
       "        event.shiftKey = false;\n",
       "        // Send a \"J\" for go to next cell\n",
       "        event.which = 74;\n",
       "        event.keyCode = 74;\n",
       "        manager.command_mode();\n",
       "        manager.handle_keydown(event);\n",
       "    }\n",
       "}\n",
       "\n",
       "mpl.figure.prototype.handle_save = function(fig, msg) {\n",
       "    fig.ondownload(fig, null);\n",
       "}\n",
       "\n",
       "\n",
       "mpl.find_output_cell = function(html_output) {\n",
       "    // Return the cell and output element which can be found *uniquely* in the notebook.\n",
       "    // Note - this is a bit hacky, but it is done because the \"notebook_saving.Notebook\"\n",
       "    // IPython event is triggered only after the cells have been serialised, which for\n",
       "    // our purposes (turning an active figure into a static one), is too late.\n",
       "    var cells = IPython.notebook.get_cells();\n",
       "    var ncells = cells.length;\n",
       "    for (var i=0; i<ncells; i++) {\n",
       "        var cell = cells[i];\n",
       "        if (cell.cell_type === 'code'){\n",
       "            for (var j=0; j<cell.output_area.outputs.length; j++) {\n",
       "                var data = cell.output_area.outputs[j];\n",
       "                if (data.data) {\n",
       "                    // IPython >= 3 moved mimebundle to data attribute of output\n",
       "                    data = data.data;\n",
       "                }\n",
       "                if (data['text/html'] == html_output) {\n",
       "                    return [cell, data, j];\n",
       "                }\n",
       "            }\n",
       "        }\n",
       "    }\n",
       "}\n",
       "\n",
       "// Register the function which deals with the matplotlib target/channel.\n",
       "// The kernel may be null if the page has been refreshed.\n",
       "if (IPython.notebook.kernel != null) {\n",
       "    IPython.notebook.kernel.comm_manager.register_target('matplotlib', mpl.mpl_figure_comm);\n",
       "}\n"
      ],
      "text/plain": [
       "<IPython.core.display.Javascript object>"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    },
    {
     "data": {
      "text/html": [
       "<img src=\"data:image/png;base64,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\" width=\"900\">"
      ],
      "text/plain": [
       "<IPython.core.display.HTML object>"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    },
    {
     "data": {
      "application/vnd.jupyter.widget-view+json": {
       "model_id": "f078139c5f284c008ac67d1c00788c11",
       "version_major": 2,
       "version_minor": 0
      },
      "text/plain": [
       "HBox(children=(VBox(children=(Button(button_style='info', description='Add pole', style=ButtonStyle(), tooltip…"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    }
   ],
   "source": [
    "x_axis = [[-10, 10], [0, 0]] #lists of ploted axes [[x-data], [y-data]]\n",
    "y_axis = [[0, 0], [-10, 10]]\n",
    "\n",
    "poles = [] # list of coordinates of poles\n",
    "zeros = [] # list of coordinates of zeros\n",
    "doublepoles = []\n",
    "doublezeros = []\n",
    "\n",
    "drag = False # variable for mouse drag, which on a list is dragged\n",
    "dragged = False # flag which is dragged (pole or zero)\n",
    "\n",
    "fig = plt.figure(figsize=(9, 4)) # figure, where to plot\n",
    "\n",
    "root = fig.add_subplot(121) #axes for root locus plot\n",
    "root.set_xlabel('$Re$')\n",
    "root.set_ylabel('$Im$')\n",
    "root.plot(x_axis[0], x_axis[1], 'k', lw=.5)\n",
    "root.plot(y_axis[0], y_axis[1], 'k', lw=.5)\n",
    "root.set_xlim([-10,10])\n",
    "root.set_ylim([-10,10])\n",
    "root.set_aspect('equal', adjustable='datalim')\n",
    "\n",
    "\n",
    "step_plot = fig.add_subplot(122) # axes for step plot\n",
    "step_plot.set_xlabel('$time$')\n",
    "step_plot.set_ylabel('$response$')\n",
    "\n",
    "# points, which appear at start of program\n",
    "poles.append([-7, 0])\n",
    "zeros.append([0, 0])\n",
    "\n",
    "# computing init step response data\n",
    "sig = signal.ZerosPolesGain([zeros[0][0]], [poles[0][0]], 1) # Close loop transfer function (ZerosPolesGain)\n",
    "timep, stepr = signal.step(sig, T=np.linspace(0,10,100))\n",
    "\n",
    "# plotting init plot\n",
    "poles_plot, = root.plot(poles[0][0], poles[0][1], 'xg')\n",
    "zeros_plot, = root.plot(zeros[0][0], zeros[0][1], 'og')\n",
    "doublepoles_plot, = root.plot([], [], 'xr', lw=2)\n",
    "doublezeros_plot, = root.plot([], [], 'or', lw=2)\n",
    "#for plotting colored , which are dragged\n",
    "dragged_plot_poles, = root.plot([],[],'bx')\n",
    "dragged_plot_zeros, = root.plot([],[],'bo')\n",
    "\n",
    "step_ax, = step_plot.plot(timep, stepr, 'b', lw=1.5)\n",
    "\n",
    "plt.show()\n",
    "\n",
    "# FIRST PART, for manipulating zeros and poles on matplotlib plot\n",
    "def check_point_clicked(xdata, ydata):\n",
    "    global poles, zeros, poles_plot, zeros_plot, dragged, drag\n",
    "    global doublepoles, doublezeros, doublezeros_plot, doublepoles_plot\n",
    "    tolerance = .3\n",
    "    for i in range(len(poles)):\n",
    "        pole = poles[i]\n",
    "        if ((xdata-pole[0])**2 + (ydata-pole[1])**2)**0.5 < tolerance: # check if pole near (xdata, ydata)\n",
    "            drag = i\n",
    "            dragged_plot_poles.set_data([poles[drag][0]],[poles[drag][1]])\n",
    "            dragged_plot_poles.set_marker('x')\n",
    "            dragged_plot_poles.set_visible(True)\n",
    "            dragged = 'pole'\n",
    "            return\n",
    "    for i in range(len(zeros)):\n",
    "        zero = zeros[i]\n",
    "        if ((xdata-zero[0])**2 + (ydata-zero[1])**2)**0.5 < tolerance:\n",
    "            drag = i\n",
    "            dragged_plot_zeros.set_data([zeros[drag][0]],[zeros[drag][1]])\n",
    "            dragged_plot_zeros.set_visible(True)\n",
    "            dragged = 'zero'\n",
    "            return\n",
    "    #check also in doublepoles/doublezeros lists\n",
    "    for i in range(len(doublepoles)):\n",
    "        doublepole = doublepoles[i]\n",
    "        if ((xdata-doublepole[0])**2 + (ydata-doublepole[1])**2)**0.5 < tolerance: # check if doublepole near (xdata, ydata)\n",
    "            dragged = 'doublepole'\n",
    "            drag = i\n",
    "            if i%2 == 0:\n",
    "                dragged_plot_poles.set_data([doublepoles[drag][0],doublepoles[drag+1][0]],[doublepoles[drag][1],doublepoles[drag+1][1]])\n",
    "            if i%2 == 1:\n",
    "                dragged_plot_poles.set_data([doublepoles[drag-1][0],doublepoles[drag][0]],[doublepoles[drag-1][1],doublepoles[drag][1]])\n",
    "            dragged_plot_poles.set_visible(True)\n",
    "            return\n",
    "    for i in range(len(doublezeros)):\n",
    "        doublezero = doublezeros[i]\n",
    "        if ((xdata-doublezero[0])**2 + (ydata-doublezero[1])**2)**0.5 < tolerance:\n",
    "            dragged = 'doublezero'\n",
    "            drag = i\n",
    "            if i%2 == 0:\n",
    "                dragged_plot_zeros.set_data([doublezeros[drag][0],doublezeros[drag+1][0]],[doublezeros[drag][1],doublezeros[drag+1][1]])\n",
    "            if i%2 == 1:\n",
    "                dragged_plot_zeros.set_data([doublezeros[drag-1][0],doublezeros[drag][0]],[doublezeros[drag-1][1],doublezeros[drag][1]])\n",
    "            dragged_plot_zeros.set_visible(True)\n",
    "            return\n",
    "\n",
    "# when click on left mouse button\n",
    "def onclick(event):\n",
    "    mouse_coordx, mouse_coordy = event.xdata, event.ydata #extract location of mouse cursor\n",
    "    check_point_clicked(mouse_coordx, mouse_coordy) # which point is dragged\n",
    "\n",
    "def onrelease(event):\n",
    "    global poles_plot, zeros_plot, dragged, drag, poles, zeros\n",
    "    global doublepoles_plot, doublezeros_plot, doublepoles, doublezeros\n",
    "    mouse_coordx, mouse_coordy = event.xdata, event.ydata\n",
    "    if dragged == 'pole':\n",
    "        poles[drag][0] = mouse_coordx\n",
    "        poles_plot.set_data([poles[i][0] for i in range(len(poles))], [poles[j][1] for j in range(len(poles))])\n",
    "        dragged_plot_poles.set_visible(False)\n",
    "    if dragged == 'zero':\n",
    "        zeros[drag][0] = mouse_coordx\n",
    "        zeros_plot.set_data([zeros[i][0] for i in range(len(zeros))], [zeros[j][1] for j in range(len(zeros))])\n",
    "        dragged_plot_zeros.set_visible(False)\n",
    "    if dragged == 'doublepole':\n",
    "        doublepoles[drag] = [mouse_coordx, mouse_coordy]\n",
    "        if drag%2 == 0:\n",
    "            doublepoles[drag+1] = [mouse_coordx, -mouse_coordy]\n",
    "        else:\n",
    "            doublepoles[drag-1] = [mouse_coordx, -mouse_coordy]\n",
    "        doublepoles_plot.set_data([doublepoles[i][0] for i in range(len(doublepoles))],\n",
    "                                  [doublepoles[j][1] for j in range(len(doublepoles))])\n",
    "        dragged_plot_poles.set_visible(False)\n",
    "    if dragged == 'doublezero':\n",
    "        doublezeros[drag] = [mouse_coordx, mouse_coordy]\n",
    "        if drag%2 == 0:\n",
    "            doublezeros[drag+1] = [mouse_coordx, -mouse_coordy]\n",
    "        else:\n",
    "            doublezeros[drag-1] = [mouse_coordx, -mouse_coordy]\n",
    "        doublezeros_plot.set_data([doublezeros[i][0] for i in range(len(doublezeros))],\n",
    "                                  [doublezeros[j][1] for j in range(len(doublezeros))])\n",
    "        dragged_plot_zeros.set_visible(False)\n",
    "    \n",
    "    sig = signal.ZerosPolesGain([zero[0]+zero[1]*1j for zero in zeros + doublezeros], # zeros\n",
    "                                [pole[0]+pole[1]*1j for pole in poles + doublepoles], # poles\n",
    "                                1)  # gain\n",
    "    timep, stepr = signal.step(sig, T=np.linspace(0,10,100))\n",
    "\n",
    "    #update step plots\n",
    "    step_ax.set_data(timep, stepr)\n",
    "    step_plot.set_ylim([min(stepr), max(stepr)])\n",
    "    \n",
    "    drag = False\n",
    "    dragged = False\n",
    "\n",
    "t = 0 # variable for plotting motion faster\n",
    "fastRat = 7 # how much times faster\n",
    "def onmotion(event):\n",
    "    global t, poles_plot, zeros_plot, dragged, poles, zeros, drag\n",
    "    global doublepoles, doublezeros, doublepoles_plot, doublezeros_plot\n",
    "    if dragged:\n",
    "        mouse_coordx = event.xdata\n",
    "        mouse_coordy = event.ydata\n",
    "        if t%fastRat == fastRat-1:# for faster plotting in jupyter notebook\n",
    "            if dragged == 'pole':\n",
    "                poles[drag][0] = mouse_coordx\n",
    "                poles_plot.set_data([poles[i][0] for i in range(len(poles))], [poles[j][1] for j in range(len(poles))])\n",
    "                dragged_plot_poles.set_data([poles[drag][0]],[poles[drag][1]])\n",
    "            if dragged == 'zero':\n",
    "                zeros[drag][0] = mouse_coordx\n",
    "                zeros_plot.set_data([zeros[i][0] for i in range(len(zeros))], [zeros[j][1] for j in range(len(zeros))])\n",
    "                dragged_plot_zeros.set_data([zeros[drag][0]],[zeros[drag][1]])\n",
    "            if dragged == 'doublepole':\n",
    "                doublepoles[drag] = [mouse_coordx, mouse_coordy]\n",
    "                if drag%2 == 0:\n",
    "                    doublepoles[drag+1] = [mouse_coordx, -mouse_coordy]\n",
    "                elif drag%2 == 1:\n",
    "                    doublepoles[drag-1] = [mouse_coordx, -mouse_coordy]\n",
    "                else:\n",
    "                    raise Exception\n",
    "                doublepoles_plot.set_data([doublepoles[i][0] for i in range(len(doublepoles))],\n",
    "                                          [doublepoles[j][1] for j in range(len(doublepoles))])\n",
    "                if drag%2 == 0:\n",
    "                    dragged_plot_poles.set_data([doublepoles[drag][0],doublepoles[drag+1][0]],[doublepoles[drag][1],doublepoles[drag+1][1]])\n",
    "                elif drag%2 == 1:\n",
    "                    dragged_plot_poles.set_data([doublepoles[drag-1][0],doublepoles[drag][0]],[doublepoles[drag-1][1],doublepoles[drag][1]])\n",
    "            if dragged == 'doublezero':\n",
    "                doublezeros[drag] = [mouse_coordx, mouse_coordy]\n",
    "                if drag%2 == 0:\n",
    "                    doublezeros[drag+1] = [mouse_coordx, -mouse_coordy]\n",
    "                elif drag%2 == 1:\n",
    "                    doublezeros[drag-1] = [mouse_coordx, -mouse_coordy]\n",
    "                doublezeros_plot.set_data([doublezeros[i][0] for i in range(len(doublezeros))],\n",
    "                                          [doublezeros[j][1] for j in range(len(doublezeros))])\n",
    "                if drag%2 == 0:\n",
    "                    dragged_plot_zeros.set_data([doublezeros[drag][0],doublezeros[drag+1][0]],[doublezeros[drag][1],doublezeros[drag+1][1]])\n",
    "                elif drag%2 == 1:\n",
    "                    dragged_plot_zeros.set_data([doublezeros[drag-1][0],doublezeros[drag][0]],[doublezeros[drag-1][1],doublezeros[drag][1]])\n",
    "\n",
    "    t = t + 1\n",
    "    # for t not to become too large\n",
    "    if t >= 1000*fastRat:\n",
    "        t = 0\n",
    "\n",
    "# mouse events for interactive plot\n",
    "press_event = fig.canvas.mpl_connect('button_press_event', onclick)\n",
    "motion_event = fig.canvas.mpl_connect('motion_notify_event', onmotion)\n",
    "release_event = fig.canvas.mpl_connect('button_release_event', onrelease)\n",
    "\n",
    "# SECOND PART, for adding and taking poles and zeros:\n",
    "\n",
    "def check_improper_function():\n",
    "    if len(poles+doublepoles) >= len(zeros+doublezeros)+2:\n",
    "        TsinglePole.disabled=False\n",
    "        TdoublePole.disabled=False\n",
    "        AsingleZero.disabled=False\n",
    "        AdoubleZero.disabled=False\n",
    "    if len(poles+doublepoles) == len(zeros+doublezeros)+1:\n",
    "        TsinglePole.disabled=False\n",
    "        TdoublePole.disabled=True\n",
    "        AsingleZero.disabled=False\n",
    "        AdoubleZero.disabled=True\n",
    "    if len(poles+doublepoles) == len(zeros+doublezeros):\n",
    "        TsinglePole.disabled=True\n",
    "        TdoublePole.disabled=True\n",
    "        AsingleZero.disabled=True\n",
    "        AdoubleZero.disabled=True\n",
    "    if len(poles+doublepoles) < len(zeros+doublezeros):\n",
    "        raise Exception('System error, improper transfer function')\n",
    "    if len(poles)<=1 and len(doublepoles)==0 or len(poles)==0 and len(doublepoles)<=2:\n",
    "        TsinglePole.disabled=True\n",
    "        TdoublePole.disabled=True\n",
    "    \n",
    "def update_plot():\n",
    "    sig = signal.ZerosPolesGain([zero[0]+zero[1]*1j for zero in zeros + doublezeros], # zeros\n",
    "                                [pole[0]+pole[1]*1j for pole in poles + doublepoles], # poles\n",
    "                                1)  # gain\n",
    "    timep, stepr = signal.step(sig, T=np.linspace(0,10,100))\n",
    "    #update step plots\n",
    "    step_ax.set_data(timep, stepr)\n",
    "    step_plot.set_ylim([min(stepr), max(stepr)])\n",
    "    \n",
    "    \n",
    "# functions for event buttons \n",
    "def AsinglePole_clicked(event):\n",
    "    if len(poles) <= 10:\n",
    "        poles.append([0, 0])\n",
    "        poles_plot.set_data([poles[i][0] for i in range(len(poles))], [poles[j][1] for j in range(len(poles))])\n",
    "        check_improper_function()\n",
    "        update_plot()\n",
    "def TsinglePole_clicked(event):\n",
    "    if len(poles) >= 1:\n",
    "        poles.pop(-1)\n",
    "        poles_plot.set_data([poles[i][0] for i in range(len(poles))], [poles[j][1] for j in range(len(poles))])\n",
    "        check_improper_function()\n",
    "        update_plot()\n",
    "\n",
    "def AdoublePole_clicked(event):\n",
    "    if len(doublepoles) <= 10:\n",
    "        doublepoles.append([0, 1])\n",
    "        doublepoles.append([0, -1])\n",
    "        doublepoles_plot.set_data([doublepoles[i][0] for i in range(len(doublepoles))],\n",
    "                                  [doublepoles[j][1] for j in range(len(doublepoles))])\n",
    "        check_improper_function()\n",
    "        update_plot()\n",
    "def TdoublePole_clicked(event):\n",
    "    if len(doublepoles) >= 2:\n",
    "        doublepoles.pop(-1)\n",
    "        doublepoles.pop(-1)\n",
    "        doublepoles_plot.set_data([doublepoles[i][0] for i in range(len(doublepoles))],\n",
    "                                    [doublepoles[j][1] for j in range(len(doublepoles))])\n",
    "        check_improper_function()\n",
    "        update_plot()\n",
    "\n",
    "def AsingleZero_clicked(event):\n",
    "    if len(zeros) <= 10:\n",
    "        zeros.append([0, 0])\n",
    "        zeros_plot.set_data([zeros[i][0] for i in range(len(zeros))], [zeros[j][1] for j in range(len(zeros))])\n",
    "        check_improper_function()\n",
    "        update_plot()\n",
    "def TsingleZero_clicked(event):\n",
    "    if len(zeros) >= 1:\n",
    "        zeros.pop(-1)\n",
    "        zeros_plot.set_data([zeros[i][0] for i in range(len(zeros))], [zeros[j][1] for j in range(len(zeros))])\n",
    "        check_improper_function()\n",
    "        update_plot()\n",
    "    \n",
    "def AdoubleZero_clicked(event):\n",
    "    if len(doublezeros) <= 10:\n",
    "        doublezeros.append([0, 1])\n",
    "        doublezeros.append([0, -1])\n",
    "        doublezeros_plot.set_data([doublezeros[i][0] for i in range(len(doublezeros))],\n",
    "                                  [doublezeros[j][1] for j in range(len(doublezeros))])\n",
    "        check_improper_function()\n",
    "        update_plot()\n",
    "def TdoubleZero_clicked(event):\n",
    "    if len(doublezeros)>=2:\n",
    "        doublezeros.pop(-1)\n",
    "        doublezeros.pop(-1)\n",
    "        doublezeros_plot.set_data([doublezeros[i][0] for i in range(len(doublezeros))],\n",
    "                                  [doublezeros[j][1] for j in range(len(doublezeros))])\n",
    "        check_improper_function()\n",
    "        update_plot()\n",
    "\n",
    "# defined buttons for adding or taking poles and zeros\n",
    "\n",
    "AsinglePole = widgets.Button(description='Add pole', disabled=False, button_style='info', tooltip='Click me', icon='')\n",
    "AdoublePole = widgets.Button(description='Add double pole', disabled=False, button_style='info', tooltip='Click me', icon='')\n",
    "\n",
    "AsingleZero = widgets.Button(description='Add zero', disabled=False, button_style='info', tooltip='Click me', icon='')\n",
    "AdoubleZero = widgets.Button(description='Add double zero', disabled=False, button_style='info', tooltip='Click me', icon='')\n",
    "\n",
    "TsinglePole = widgets.Button(description='Remove pole', disabled=False, button_style='info', tooltip='Click me', icon='')\n",
    "TdoublePole = widgets.Button(description='Rewmove double pole', disabled=False, button_style='info', tooltip='Click me', icon='')\n",
    "\n",
    "TsingleZero = widgets.Button(description='Remove zero', disabled=False, button_style='info', tooltip='Click me', icon='')\n",
    "TdoubleZero = widgets.Button(description='Remove double zero', disabled=False, button_style='info', tooltip='Click me', icon='')\n",
    "\n",
    "# make layout\n",
    "column1 = widgets.VBox([AsinglePole, AdoublePole, AsingleZero, AdoubleZero])\n",
    "column2 = widgets.VBox([TsinglePole, TdoublePole, TsingleZero, TdoubleZero])\n",
    "both_columns = widgets.HBox([column1, column2])\n",
    "display(both_columns)\n",
    "\n",
    "# defined events\n",
    "AsinglePole.on_click(AsinglePole_clicked)\n",
    "AdoublePole.on_click(AdoublePole_clicked)\n",
    "AsingleZero.on_click(AsingleZero_clicked)\n",
    "AdoubleZero.on_click(AdoubleZero_clicked)\n",
    "\n",
    "TsinglePole.on_click(TsinglePole_clicked)\n",
    "TdoublePole.on_click(TdoublePole_clicked)\n",
    "TsingleZero.on_click(TsingleZero_clicked)\n",
    "TdoubleZero.on_click(TdoubleZero_clicked)\n",
    "\n",
    "check_improper_function()"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": []
  }
 ],
 "metadata": {
  "kernelspec": {
   "display_name": "Python 3",
   "language": "python",
   "name": "python3"
  },
  "language_info": {
   "codemirror_mode": {
    "name": "ipython",
    "version": 3
   },
   "file_extension": ".py",
   "mimetype": "text/x-python",
   "name": "python",
   "nbconvert_exporter": "python",
   "pygments_lexer": "ipython3",
   "version": "3.7.1"
  }
 },
 "nbformat": 4,
 "nbformat_minor": 2
}