diff --git a/Interpolation.ipynb b/Interpolation.ipynb
index 96e8317..6fd479f 100644
--- a/Interpolation.ipynb
+++ b/Interpolation.ipynb
@@ -570,7 +570,7 @@
    "name": "python",
    "nbconvert_exporter": "python",
    "pygments_lexer": "ipython3",
-   "version": "3.6.7"
+   "version": "3.6.8"
   }
  },
  "nbformat": 4,
diff --git a/Kullback_Leibler.ipynb b/Kullback_Leibler.ipynb
index 8f8054f..6b1e452 100644
--- a/Kullback_Leibler.ipynb
+++ b/Kullback_Leibler.ipynb
@@ -260,21 +260,21 @@
  ],
  "metadata": {
   "kernelspec": {
-   "display_name": "Python 2",
+   "display_name": "Python 3",
    "language": "python",
-   "name": "python2"
+   "name": "python3"
   },
   "language_info": {
    "codemirror_mode": {
     "name": "ipython",
-    "version": 2
+    "version": 3
    },
    "file_extension": ".py",
    "mimetype": "text/x-python",
    "name": "python",
    "nbconvert_exporter": "python",
-   "pygments_lexer": "ipython2",
-   "version": "2.7.14"
+   "pygments_lexer": "ipython3",
+   "version": "3.6.8"
   }
  },
  "nbformat": 4,
diff --git a/data/Convolution.pdf b/data/Convolution.pdf
new file mode 100644
index 0000000..4adaf8f
Binary files /dev/null and b/data/Convolution.pdf differ
diff --git a/gradient_descent.ipynb b/gradient_descent.ipynb
new file mode 100644
index 0000000..6979fb5
--- /dev/null
+++ b/gradient_descent.ipynb
@@ -0,0 +1,990 @@
+{
+ "cells": [
+  {
+   "cell_type": "markdown",
+   "metadata": {},
+   "source": [
+    "# Gradient descent\n",
+    "\n",
+    "$\\alpha$ parameter regulates the size of the step.\n",
+    "We multiple alpha by the value of the derivative in the given point.\n",
+    "The derivative in a point tells us how steep in the curve at the point.\n",
+    "\n",
+    "**Question**: Why can't we just set alpha and only use the sign of the derivative? Since we just need to know in which direction to move?\n",
+    "\n",
+    "In this case, we succeded only if we get the step correctly. In the example below, the only value for $\\alpha$ that works in this case is $\\alpha = 0.5$, since we start at $-2.0$. In all other cases, how ever small they are we are most likely to never reach the minimum.\n",
+    "\n",
+    "**Question**: Why should $\\alpha \\in (0,1)$?\n",
+    "\n",
+    "If $\\alpha <= 1$ the process diverges (in case of symmetric quadratic function) and we can't reach minimum ever."
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 1,
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "\n",
+    "import numpy as np\n",
+    "\n",
+    "def f(x):\n",
+    "    return np.square(x);\n",
+    "\n",
+    "def jacobian(x):\n",
+    "    ## jacobians for x^2\n",
+    "    return 2*x;\n",
+    "\n",
+    "x = np.arange(-2.0,2.0,0.1)\n",
+    "\n",
+    "alpha = 0.1;\n",
+    "error = 1000;\n",
+    "x_prev = -2.0;\n",
+    "opt_way = []\n",
+    "numOfIter =0;\n",
+    "while error >1e-05:\n",
+    "#     print(\"Step is: \", alpha *jacobian(x_prev))\n",
+    "#     x_opt = x_prev - alpha *np.sign(jacobian(x_prev)); # just using sign of the derivative\n",
+    "    x_opt = x_prev - alpha *jacobian(x_prev); # using value of the derivative\n",
+    "    error  = abs(x_prev -x_opt);\n",
+    "    x_prev = x_opt;\n",
+    "    opt_way.append(x_opt)\n",
+    "    numOfIter+=1;\n"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 3,
+   "metadata": {},
+   "outputs": [
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      "Converged with  49 iterations\n",
+      "\n"
+     ]
+    },
+    {
+     "data": {
+      "image/png": "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\n",
+      "text/plain": [
+       "<Figure size 432x288 with 1 Axes>"
+      ]
+     },
+     "metadata": {
+      "needs_background": "light"
+     },
+     "output_type": "display_data"
+    }
+   ],
+   "source": [
+    "import matplotlib.pyplot as plt\n",
+    "\n",
+    "print(\"Converged with \", numOfIter, \"iterations\\n\")\n",
+    "\n",
+    "plt.figure(1)\n",
+    "plt.plot(x, f(x))\n",
+    "y = np.zeros((len(opt_way),1))\n",
+    "plt.plot(opt_way,y, 'r*')\n",
+    "plt.plot(opt_way, f(opt_way), 'g*-')\n",
+    "\n",
+    "plt.show()"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "metadata": {},
+   "source": [
+    "TODO; two dimensional variant"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 32,
+   "metadata": {},
+   "outputs": [
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      "Converged with  51 iterations\n",
+      "\n"
+     ]
+    }
+   ],
+   "source": [
+    "# Very sloppy functions and derivatives\n",
+    "def f(x,y):\n",
+    "    return np.square(x) + np.square(y);\n",
+    "\n",
+    "def jacobian(x,y):\n",
+    "    return np.array([2*x, 2*y])\n",
+    "\n",
+    "\n",
+    "\n",
+    "alpha = 0.1;\n",
+    "error = 1000;\n",
+    "x_prev = [-2.0, 2.0];\n",
+    "opt_way = []\n",
+    "numOfIter =0;\n",
+    "while error >1e-05:\n",
+    "#     print(\"Step is: \", alpha *jacobian(x_prev))\n",
+    "#     x_opt = x_prev - alpha *np.sign(jacobian(x_prev)); # just using sign of the derivative\n",
+    "    x_opt = x_prev - alpha *jacobian(x_prev[0], x_prev[1]); # using value of the derivative\n",
+    "    error  = np.linalg.norm(x_prev -x_opt);\n",
+    "    x_prev = x_opt;\n",
+    "    opt_way.append(x_opt)\n",
+    "    numOfIter+=1;\n",
+    "print(\"Converged with \", numOfIter, \"iterations\\n\")\n",
+    "opt_way = np.array(opt_way)\n",
+    "# print(opt_way)"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 33,
+   "metadata": {},
+   "outputs": [
+    {
+     "data": {
+      "application/javascript": [
+       "/* Put everything inside the global mpl namespace */\n",
+       "window.mpl = {};\n",
+       "\n",
+       "\n",
+       "mpl.get_websocket_type = function() {\n",
+       "    if (typeof(WebSocket) !== 'undefined') {\n",
+       "        return WebSocket;\n",
+       "    } else if (typeof(MozWebSocket) !== 'undefined') {\n",
+       "        return MozWebSocket;\n",
+       "    } else {\n",
+       "        alert('Your browser does not have WebSocket support.' +\n",
+       "              'Please try Chrome, Safari or Firefox ≥ 6. ' +\n",
+       "              'Firefox 4 and 5 are also supported but you ' +\n",
+       "              'have to enable WebSockets in about:config.');\n",
+       "    };\n",
+       "}\n",
+       "\n",
+       "mpl.figure = function(figure_id, websocket, ondownload, parent_element) {\n",
+       "    this.id = figure_id;\n",
+       "\n",
+       "    this.ws = websocket;\n",
+       "\n",
+       "    this.supports_binary = (this.ws.binaryType != undefined);\n",
+       "\n",
+       "    if (!this.supports_binary) {\n",
+       "        var warnings = document.getElementById(\"mpl-warnings\");\n",
+       "        if (warnings) {\n",
+       "            warnings.style.display = 'block';\n",
+       "            warnings.textContent = (\n",
+       "                \"This browser does not support binary websocket messages. \" +\n",
+       "                    \"Performance may be slow.\");\n",
+       "        }\n",
+       "    }\n",
+       "\n",
+       "    this.imageObj = new Image();\n",
+       "\n",
+       "    this.context = undefined;\n",
+       "    this.message = undefined;\n",
+       "    this.canvas = undefined;\n",
+       "    this.rubberband_canvas = undefined;\n",
+       "    this.rubberband_context = undefined;\n",
+       "    this.format_dropdown = undefined;\n",
+       "\n",
+       "    this.image_mode = 'full';\n",
+       "\n",
+       "    this.root = $('<div/>');\n",
+       "    this._root_extra_style(this.root)\n",
+       "    this.root.attr('style', 'display: inline-block');\n",
+       "\n",
+       "    $(parent_element).append(this.root);\n",
+       "\n",
+       "    this._init_header(this);\n",
+       "    this._init_canvas(this);\n",
+       "    this._init_toolbar(this);\n",
+       "\n",
+       "    var fig = this;\n",
+       "\n",
+       "    this.waiting = false;\n",
+       "\n",
+       "    this.ws.onopen =  function () {\n",
+       "            fig.send_message(\"supports_binary\", {value: fig.supports_binary});\n",
+       "            fig.send_message(\"send_image_mode\", {});\n",
+       "            if (mpl.ratio != 1) {\n",
+       "                fig.send_message(\"set_dpi_ratio\", {'dpi_ratio': mpl.ratio});\n",
+       "            }\n",
+       "            fig.send_message(\"refresh\", {});\n",
+       "        }\n",
+       "\n",
+       "    this.imageObj.onload = function() {\n",
+       "            if (fig.image_mode == 'full') {\n",
+       "                // Full images could contain transparency (where diff images\n",
+       "                // almost always do), so we need to clear the canvas so that\n",
+       "                // there is no ghosting.\n",
+       "                fig.context.clearRect(0, 0, fig.canvas.width, fig.canvas.height);\n",
+       "            }\n",
+       "            fig.context.drawImage(fig.imageObj, 0, 0);\n",
+       "        };\n",
+       "\n",
+       "    this.imageObj.onunload = function() {\n",
+       "        fig.ws.close();\n",
+       "    }\n",
+       "\n",
+       "    this.ws.onmessage = this._make_on_message_function(this);\n",
+       "\n",
+       "    this.ondownload = ondownload;\n",
+       "}\n",
+       "\n",
+       "mpl.figure.prototype._init_header = function() {\n",
+       "    var titlebar = $(\n",
+       "        '<div class=\"ui-dialog-titlebar ui-widget-header ui-corner-all ' +\n",
+       "        'ui-helper-clearfix\"/>');\n",
+       "    var titletext = $(\n",
+       "        '<div class=\"ui-dialog-title\" style=\"width: 100%; ' +\n",
+       "        'text-align: center; padding: 3px;\"/>');\n",
+       "    titlebar.append(titletext)\n",
+       "    this.root.append(titlebar);\n",
+       "    this.header = titletext[0];\n",
+       "}\n",
+       "\n",
+       "\n",
+       "\n",
+       "mpl.figure.prototype._canvas_extra_style = function(canvas_div) {\n",
+       "\n",
+       "}\n",
+       "\n",
+       "\n",
+       "mpl.figure.prototype._root_extra_style = function(canvas_div) {\n",
+       "\n",
+       "}\n",
+       "\n",
+       "mpl.figure.prototype._init_canvas = function() {\n",
+       "    var fig = this;\n",
+       "\n",
+       "    var canvas_div = $('<div/>');\n",
+       "\n",
+       "    canvas_div.attr('style', 'position: relative; clear: both; outline: 0');\n",
+       "\n",
+       "    function canvas_keyboard_event(event) {\n",
+       "        return fig.key_event(event, event['data']);\n",
+       "    }\n",
+       "\n",
+       "    canvas_div.keydown('key_press', canvas_keyboard_event);\n",
+       "    canvas_div.keyup('key_release', canvas_keyboard_event);\n",
+       "    this.canvas_div = canvas_div\n",
+       "    this._canvas_extra_style(canvas_div)\n",
+       "    this.root.append(canvas_div);\n",
+       "\n",
+       "    var canvas = $('<canvas/>');\n",
+       "    canvas.addClass('mpl-canvas');\n",
+       "    canvas.attr('style', \"left: 0; top: 0; z-index: 0; outline: 0\")\n",
+       "\n",
+       "    this.canvas = canvas[0];\n",
+       "    this.context = canvas[0].getContext(\"2d\");\n",
+       "\n",
+       "    var backingStore = this.context.backingStorePixelRatio ||\n",
+       "\tthis.context.webkitBackingStorePixelRatio ||\n",
+       "\tthis.context.mozBackingStorePixelRatio ||\n",
+       "\tthis.context.msBackingStorePixelRatio ||\n",
+       "\tthis.context.oBackingStorePixelRatio ||\n",
+       "\tthis.context.backingStorePixelRatio || 1;\n",
+       "\n",
+       "    mpl.ratio = (window.devicePixelRatio || 1) / backingStore;\n",
+       "\n",
+       "    var rubberband = $('<canvas/>');\n",
+       "    rubberband.attr('style', \"position: absolute; left: 0; top: 0; z-index: 1;\")\n",
+       "\n",
+       "    var pass_mouse_events = true;\n",
+       "\n",
+       "    canvas_div.resizable({\n",
+       "        start: function(event, ui) {\n",
+       "            pass_mouse_events = false;\n",
+       "        },\n",
+       "        resize: function(event, ui) {\n",
+       "            fig.request_resize(ui.size.width, ui.size.height);\n",
+       "        },\n",
+       "        stop: function(event, ui) {\n",
+       "            pass_mouse_events = true;\n",
+       "            fig.request_resize(ui.size.width, ui.size.height);\n",
+       "        },\n",
+       "    });\n",
+       "\n",
+       "    function mouse_event_fn(event) {\n",
+       "        if (pass_mouse_events)\n",
+       "            return fig.mouse_event(event, event['data']);\n",
+       "    }\n",
+       "\n",
+       "    rubberband.mousedown('button_press', mouse_event_fn);\n",
+       "    rubberband.mouseup('button_release', mouse_event_fn);\n",
+       "    // Throttle sequential mouse events to 1 every 20ms.\n",
+       "    rubberband.mousemove('motion_notify', mouse_event_fn);\n",
+       "\n",
+       "    rubberband.mouseenter('figure_enter', mouse_event_fn);\n",
+       "    rubberband.mouseleave('figure_leave', mouse_event_fn);\n",
+       "\n",
+       "    canvas_div.on(\"wheel\", function (event) {\n",
+       "        event = event.originalEvent;\n",
+       "        event['data'] = 'scroll'\n",
+       "        if (event.deltaY < 0) {\n",
+       "            event.step = 1;\n",
+       "        } else {\n",
+       "            event.step = -1;\n",
+       "        }\n",
+       "        mouse_event_fn(event);\n",
+       "    });\n",
+       "\n",
+       "    canvas_div.append(canvas);\n",
+       "    canvas_div.append(rubberband);\n",
+       "\n",
+       "    this.rubberband = rubberband;\n",
+       "    this.rubberband_canvas = rubberband[0];\n",
+       "    this.rubberband_context = rubberband[0].getContext(\"2d\");\n",
+       "    this.rubberband_context.strokeStyle = \"#000000\";\n",
+       "\n",
+       "    this._resize_canvas = function(width, height) {\n",
+       "        // Keep the size of the canvas, canvas container, and rubber band\n",
+       "        // canvas in synch.\n",
+       "        canvas_div.css('width', width)\n",
+       "        canvas_div.css('height', height)\n",
+       "\n",
+       "        canvas.attr('width', width * mpl.ratio);\n",
+       "        canvas.attr('height', height * mpl.ratio);\n",
+       "        canvas.attr('style', 'width: ' + width + 'px; height: ' + height + 'px;');\n",
+       "\n",
+       "        rubberband.attr('width', width);\n",
+       "        rubberband.attr('height', height);\n",
+       "    }\n",
+       "\n",
+       "    // Set the figure to an initial 600x600px, this will subsequently be updated\n",
+       "    // upon first draw.\n",
+       "    this._resize_canvas(600, 600);\n",
+       "\n",
+       "    // Disable right mouse context menu.\n",
+       "    $(this.rubberband_canvas).bind(\"contextmenu\",function(e){\n",
+       "        return false;\n",
+       "    });\n",
+       "\n",
+       "    function set_focus () {\n",
+       "        canvas.focus();\n",
+       "        canvas_div.focus();\n",
+       "    }\n",
+       "\n",
+       "    window.setTimeout(set_focus, 100);\n",
+       "}\n",
+       "\n",
+       "mpl.figure.prototype._init_toolbar = function() {\n",
+       "    var fig = this;\n",
+       "\n",
+       "    var nav_element = $('<div/>')\n",
+       "    nav_element.attr('style', 'width: 100%');\n",
+       "    this.root.append(nav_element);\n",
+       "\n",
+       "    // Define a callback function for later on.\n",
+       "    function toolbar_event(event) {\n",
+       "        return fig.toolbar_button_onclick(event['data']);\n",
+       "    }\n",
+       "    function toolbar_mouse_event(event) {\n",
+       "        return fig.toolbar_button_onmouseover(event['data']);\n",
+       "    }\n",
+       "\n",
+       "    for(var toolbar_ind in mpl.toolbar_items) {\n",
+       "        var name = mpl.toolbar_items[toolbar_ind][0];\n",
+       "        var tooltip = mpl.toolbar_items[toolbar_ind][1];\n",
+       "        var image = mpl.toolbar_items[toolbar_ind][2];\n",
+       "        var method_name = mpl.toolbar_items[toolbar_ind][3];\n",
+       "\n",
+       "        if (!name) {\n",
+       "            // put a spacer in here.\n",
+       "            continue;\n",
+       "        }\n",
+       "        var button = $('<button/>');\n",
+       "        button.addClass('ui-button ui-widget ui-state-default ui-corner-all ' +\n",
+       "                        'ui-button-icon-only');\n",
+       "        button.attr('role', 'button');\n",
+       "        button.attr('aria-disabled', 'false');\n",
+       "        button.click(method_name, toolbar_event);\n",
+       "        button.mouseover(tooltip, toolbar_mouse_event);\n",
+       "\n",
+       "        var icon_img = $('<span/>');\n",
+       "        icon_img.addClass('ui-button-icon-primary ui-icon');\n",
+       "        icon_img.addClass(image);\n",
+       "        icon_img.addClass('ui-corner-all');\n",
+       "\n",
+       "        var tooltip_span = $('<span/>');\n",
+       "        tooltip_span.addClass('ui-button-text');\n",
+       "        tooltip_span.html(tooltip);\n",
+       "\n",
+       "        button.append(icon_img);\n",
+       "        button.append(tooltip_span);\n",
+       "\n",
+       "        nav_element.append(button);\n",
+       "    }\n",
+       "\n",
+       "    var fmt_picker_span = $('<span/>');\n",
+       "\n",
+       "    var fmt_picker = $('<select/>');\n",
+       "    fmt_picker.addClass('mpl-toolbar-option ui-widget ui-widget-content');\n",
+       "    fmt_picker_span.append(fmt_picker);\n",
+       "    nav_element.append(fmt_picker_span);\n",
+       "    this.format_dropdown = fmt_picker[0];\n",
+       "\n",
+       "    for (var ind in mpl.extensions) {\n",
+       "        var fmt = mpl.extensions[ind];\n",
+       "        var option = $(\n",
+       "            '<option/>', {selected: fmt === mpl.default_extension}).html(fmt);\n",
+       "        fmt_picker.append(option)\n",
+       "    }\n",
+       "\n",
+       "    // Add hover states to the ui-buttons\n",
+       "    $( \".ui-button\" ).hover(\n",
+       "        function() { $(this).addClass(\"ui-state-hover\");},\n",
+       "        function() { $(this).removeClass(\"ui-state-hover\");}\n",
+       "    );\n",
+       "\n",
+       "    var status_bar = $('<span class=\"mpl-message\"/>');\n",
+       "    nav_element.append(status_bar);\n",
+       "    this.message = status_bar[0];\n",
+       "}\n",
+       "\n",
+       "mpl.figure.prototype.request_resize = function(x_pixels, y_pixels) {\n",
+       "    // Request matplotlib to resize the figure. Matplotlib will then trigger a resize in the client,\n",
+       "    // which will in turn request a refresh of the image.\n",
+       "    this.send_message('resize', {'width': x_pixels, 'height': y_pixels});\n",
+       "}\n",
+       "\n",
+       "mpl.figure.prototype.send_message = function(type, properties) {\n",
+       "    properties['type'] = type;\n",
+       "    properties['figure_id'] = this.id;\n",
+       "    this.ws.send(JSON.stringify(properties));\n",
+       "}\n",
+       "\n",
+       "mpl.figure.prototype.send_draw_message = function() {\n",
+       "    if (!this.waiting) {\n",
+       "        this.waiting = true;\n",
+       "        this.ws.send(JSON.stringify({type: \"draw\", figure_id: this.id}));\n",
+       "    }\n",
+       "}\n",
+       "\n",
+       "\n",
+       "mpl.figure.prototype.handle_save = function(fig, msg) {\n",
+       "    var format_dropdown = fig.format_dropdown;\n",
+       "    var format = format_dropdown.options[format_dropdown.selectedIndex].value;\n",
+       "    fig.ondownload(fig, format);\n",
+       "}\n",
+       "\n",
+       "\n",
+       "mpl.figure.prototype.handle_resize = function(fig, msg) {\n",
+       "    var size = msg['size'];\n",
+       "    if (size[0] != fig.canvas.width || size[1] != fig.canvas.height) {\n",
+       "        fig._resize_canvas(size[0], size[1]);\n",
+       "        fig.send_message(\"refresh\", {});\n",
+       "    };\n",
+       "}\n",
+       "\n",
+       "mpl.figure.prototype.handle_rubberband = function(fig, msg) {\n",
+       "    var x0 = msg['x0'] / mpl.ratio;\n",
+       "    var y0 = (fig.canvas.height - msg['y0']) / mpl.ratio;\n",
+       "    var x1 = msg['x1'] / mpl.ratio;\n",
+       "    var y1 = (fig.canvas.height - msg['y1']) / mpl.ratio;\n",
+       "    x0 = Math.floor(x0) + 0.5;\n",
+       "    y0 = Math.floor(y0) + 0.5;\n",
+       "    x1 = Math.floor(x1) + 0.5;\n",
+       "    y1 = Math.floor(y1) + 0.5;\n",
+       "    var min_x = Math.min(x0, x1);\n",
+       "    var min_y = Math.min(y0, y1);\n",
+       "    var width = Math.abs(x1 - x0);\n",
+       "    var height = Math.abs(y1 - y0);\n",
+       "\n",
+       "    fig.rubberband_context.clearRect(\n",
+       "        0, 0, fig.canvas.width, fig.canvas.height);\n",
+       "\n",
+       "    fig.rubberband_context.strokeRect(min_x, min_y, width, height);\n",
+       "}\n",
+       "\n",
+       "mpl.figure.prototype.handle_figure_label = function(fig, msg) {\n",
+       "    // Updates the figure title.\n",
+       "    fig.header.textContent = msg['label'];\n",
+       "}\n",
+       "\n",
+       "mpl.figure.prototype.handle_cursor = function(fig, msg) {\n",
+       "    var cursor = msg['cursor'];\n",
+       "    switch(cursor)\n",
+       "    {\n",
+       "    case 0:\n",
+       "        cursor = 'pointer';\n",
+       "        break;\n",
+       "    case 1:\n",
+       "        cursor = 'default';\n",
+       "        break;\n",
+       "    case 2:\n",
+       "        cursor = 'crosshair';\n",
+       "        break;\n",
+       "    case 3:\n",
+       "        cursor = 'move';\n",
+       "        break;\n",
+       "    }\n",
+       "    fig.rubberband_canvas.style.cursor = cursor;\n",
+       "}\n",
+       "\n",
+       "mpl.figure.prototype.handle_message = function(fig, msg) {\n",
+       "    fig.message.textContent = msg['message'];\n",
+       "}\n",
+       "\n",
+       "mpl.figure.prototype.handle_draw = function(fig, msg) {\n",
+       "    // Request the server to send over a new figure.\n",
+       "    fig.send_draw_message();\n",
+       "}\n",
+       "\n",
+       "mpl.figure.prototype.handle_image_mode = function(fig, msg) {\n",
+       "    fig.image_mode = msg['mode'];\n",
+       "}\n",
+       "\n",
+       "mpl.figure.prototype.updated_canvas_event = function() {\n",
+       "    // Called whenever the canvas gets updated.\n",
+       "    this.send_message(\"ack\", {});\n",
+       "}\n",
+       "\n",
+       "// A function to construct a web socket function for onmessage handling.\n",
+       "// Called in the figure constructor.\n",
+       "mpl.figure.prototype._make_on_message_function = function(fig) {\n",
+       "    return function socket_on_message(evt) {\n",
+       "        if (evt.data instanceof Blob) {\n",
+       "            /* FIXME: We get \"Resource interpreted as Image but\n",
+       "             * transferred with MIME type text/plain:\" errors on\n",
+       "             * Chrome.  But how to set the MIME type?  It doesn't seem\n",
+       "             * to be part of the websocket stream */\n",
+       "            evt.data.type = \"image/png\";\n",
+       "\n",
+       "            /* Free the memory for the previous frames */\n",
+       "            if (fig.imageObj.src) {\n",
+       "                (window.URL || window.webkitURL).revokeObjectURL(\n",
+       "                    fig.imageObj.src);\n",
+       "            }\n",
+       "\n",
+       "            fig.imageObj.src = (window.URL || window.webkitURL).createObjectURL(\n",
+       "                evt.data);\n",
+       "            fig.updated_canvas_event();\n",
+       "            fig.waiting = false;\n",
+       "            return;\n",
+       "        }\n",
+       "        else if (typeof evt.data === 'string' && evt.data.slice(0, 21) == \"data:image/png;base64\") {\n",
+       "            fig.imageObj.src = evt.data;\n",
+       "            fig.updated_canvas_event();\n",
+       "            fig.waiting = false;\n",
+       "            return;\n",
+       "        }\n",
+       "\n",
+       "        var msg = JSON.parse(evt.data);\n",
+       "        var msg_type = msg['type'];\n",
+       "\n",
+       "        // Call the  \"handle_{type}\" callback, which takes\n",
+       "        // the figure and JSON message as its only arguments.\n",
+       "        try {\n",
+       "            var callback = fig[\"handle_\" + msg_type];\n",
+       "        } catch (e) {\n",
+       "            console.log(\"No handler for the '\" + msg_type + \"' message type: \", msg);\n",
+       "            return;\n",
+       "        }\n",
+       "\n",
+       "        if (callback) {\n",
+       "            try {\n",
+       "                // console.log(\"Handling '\" + msg_type + \"' message: \", msg);\n",
+       "                callback(fig, msg);\n",
+       "            } catch (e) {\n",
+       "                console.log(\"Exception inside the 'handler_\" + msg_type + \"' callback:\", e, e.stack, msg);\n",
+       "            }\n",
+       "        }\n",
+       "    };\n",
+       "}\n",
+       "\n",
+       "// from http://stackoverflow.com/questions/1114465/getting-mouse-location-in-canvas\n",
+       "mpl.findpos = function(e) {\n",
+       "    //this section is from http://www.quirksmode.org/js/events_properties.html\n",
+       "    var targ;\n",
+       "    if (!e)\n",
+       "        e = window.event;\n",
+       "    if (e.target)\n",
+       "        targ = e.target;\n",
+       "    else if (e.srcElement)\n",
+       "        targ = e.srcElement;\n",
+       "    if (targ.nodeType == 3) // defeat Safari bug\n",
+       "        targ = targ.parentNode;\n",
+       "\n",
+       "    // jQuery normalizes the pageX and pageY\n",
+       "    // pageX,Y are the mouse positions relative to the document\n",
+       "    // offset() returns the position of the element relative to the document\n",
+       "    var x = e.pageX - $(targ).offset().left;\n",
+       "    var y = e.pageY - $(targ).offset().top;\n",
+       "\n",
+       "    return {\"x\": x, \"y\": y};\n",
+       "};\n",
+       "\n",
+       "/*\n",
+       " * return a copy of an object with only non-object keys\n",
+       " * we need this to avoid circular references\n",
+       " * http://stackoverflow.com/a/24161582/3208463\n",
+       " */\n",
+       "function simpleKeys (original) {\n",
+       "  return Object.keys(original).reduce(function (obj, key) {\n",
+       "    if (typeof original[key] !== 'object')\n",
+       "        obj[key] = original[key]\n",
+       "    return obj;\n",
+       "  }, {});\n",
+       "}\n",
+       "\n",
+       "mpl.figure.prototype.mouse_event = function(event, name) {\n",
+       "    var canvas_pos = mpl.findpos(event)\n",
+       "\n",
+       "    if (name === 'button_press')\n",
+       "    {\n",
+       "        this.canvas.focus();\n",
+       "        this.canvas_div.focus();\n",
+       "    }\n",
+       "\n",
+       "    var x = canvas_pos.x * mpl.ratio;\n",
+       "    var y = canvas_pos.y * mpl.ratio;\n",
+       "\n",
+       "    this.send_message(name, {x: x, y: y, button: event.button,\n",
+       "                             step: event.step,\n",
+       "                             guiEvent: simpleKeys(event)});\n",
+       "\n",
+       "    /* This prevents the web browser from automatically changing to\n",
+       "     * the text insertion cursor when the button is pressed.  We want\n",
+       "     * to control all of the cursor setting manually through the\n",
+       "     * 'cursor' event from matplotlib */\n",
+       "    event.preventDefault();\n",
+       "    return false;\n",
+       "}\n",
+       "\n",
+       "mpl.figure.prototype._key_event_extra = function(event, name) {\n",
+       "    // Handle any extra behaviour associated with a key event\n",
+       "}\n",
+       "\n",
+       "mpl.figure.prototype.key_event = function(event, name) {\n",
+       "\n",
+       "    // Prevent repeat events\n",
+       "    if (name == 'key_press')\n",
+       "    {\n",
+       "        if (event.which === this._key)\n",
+       "            return;\n",
+       "        else\n",
+       "            this._key = event.which;\n",
+       "    }\n",
+       "    if (name == 'key_release')\n",
+       "        this._key = null;\n",
+       "\n",
+       "    var value = '';\n",
+       "    if (event.ctrlKey && event.which != 17)\n",
+       "        value += \"ctrl+\";\n",
+       "    if (event.altKey && event.which != 18)\n",
+       "        value += \"alt+\";\n",
+       "    if (event.shiftKey && event.which != 16)\n",
+       "        value += \"shift+\";\n",
+       "\n",
+       "    value += 'k';\n",
+       "    value += event.which.toString();\n",
+       "\n",
+       "    this._key_event_extra(event, name);\n",
+       "\n",
+       "    this.send_message(name, {key: value,\n",
+       "                             guiEvent: simpleKeys(event)});\n",
+       "    return false;\n",
+       "}\n",
+       "\n",
+       "mpl.figure.prototype.toolbar_button_onclick = function(name) {\n",
+       "    if (name == 'download') {\n",
+       "        this.handle_save(this, null);\n",
+       "    } else {\n",
+       "        this.send_message(\"toolbar_button\", {name: name});\n",
+       "    }\n",
+       "};\n",
+       "\n",
+       "mpl.figure.prototype.toolbar_button_onmouseover = function(tooltip) {\n",
+       "    this.message.textContent = tooltip;\n",
+       "};\n",
+       "mpl.toolbar_items = [[\"Home\", \"Reset original view\", \"fa fa-home icon-home\", \"home\"], [\"Back\", \"Back to previous view\", \"fa fa-arrow-left icon-arrow-left\", \"back\"], [\"Forward\", \"Forward to next view\", \"fa fa-arrow-right icon-arrow-right\", \"forward\"], [\"\", \"\", \"\", \"\"], [\"Pan\", \"Pan axes with left mouse, zoom with right\", \"fa fa-arrows icon-move\", \"pan\"], [\"Zoom\", \"Zoom to rectangle\", \"fa fa-square-o icon-check-empty\", \"zoom\"], [\"\", \"\", \"\", \"\"], [\"Download\", \"Download plot\", \"fa fa-floppy-o icon-save\", \"download\"]];\n",
+       "\n",
+       "mpl.extensions = [\"eps\", \"jpeg\", \"pdf\", \"png\", \"ps\", \"raw\", \"svg\", \"tif\"];\n",
+       "\n",
+       "mpl.default_extension = \"png\";var comm_websocket_adapter = function(comm) {\n",
+       "    // Create a \"websocket\"-like object which calls the given IPython comm\n",
+       "    // object with the appropriate methods. Currently this is a non binary\n",
+       "    // socket, so there is still some room for performance tuning.\n",
+       "    var ws = {};\n",
+       "\n",
+       "    ws.close = function() {\n",
+       "        comm.close()\n",
+       "    };\n",
+       "    ws.send = function(m) {\n",
+       "        //console.log('sending', m);\n",
+       "        comm.send(m);\n",
+       "    };\n",
+       "    // Register the callback with on_msg.\n",
+       "    comm.on_msg(function(msg) {\n",
+       "        //console.log('receiving', msg['content']['data'], msg);\n",
+       "        // Pass the mpl event to the overridden (by mpl) onmessage function.\n",
+       "        ws.onmessage(msg['content']['data'])\n",
+       "    });\n",
+       "    return ws;\n",
+       "}\n",
+       "\n",
+       "mpl.mpl_figure_comm = function(comm, msg) {\n",
+       "    // This is the function which gets called when the mpl process\n",
+       "    // starts-up an IPython Comm through the \"matplotlib\" channel.\n",
+       "\n",
+       "    var id = msg.content.data.id;\n",
+       "    // Get hold of the div created by the display call when the Comm\n",
+       "    // socket was opened in Python.\n",
+       "    var element = $(\"#\" + id);\n",
+       "    var ws_proxy = comm_websocket_adapter(comm)\n",
+       "\n",
+       "    function ondownload(figure, format) {\n",
+       "        window.open(figure.imageObj.src);\n",
+       "    }\n",
+       "\n",
+       "    var fig = new mpl.figure(id, ws_proxy,\n",
+       "                           ondownload,\n",
+       "                           element.get(0));\n",
+       "\n",
+       "    // Call onopen now - mpl needs it, as it is assuming we've passed it a real\n",
+       "    // web socket which is closed, not our websocket->open comm proxy.\n",
+       "    ws_proxy.onopen();\n",
+       "\n",
+       "    fig.parent_element = element.get(0);\n",
+       "    fig.cell_info = mpl.find_output_cell(\"<div id='\" + id + \"'></div>\");\n",
+       "    if (!fig.cell_info) {\n",
+       "        console.error(\"Failed to find cell for figure\", id, fig);\n",
+       "        return;\n",
+       "    }\n",
+       "\n",
+       "    var output_index = fig.cell_info[2]\n",
+       "    var cell = fig.cell_info[0];\n",
+       "\n",
+       "};\n",
+       "\n",
+       "mpl.figure.prototype.handle_close = function(fig, msg) {\n",
+       "    var width = fig.canvas.width/mpl.ratio\n",
+       "    fig.root.unbind('remove')\n",
+       "\n",
+       "    // Update the output cell to use the data from the current canvas.\n",
+       "    fig.push_to_output();\n",
+       "    var dataURL = fig.canvas.toDataURL();\n",
+       "    // Re-enable the keyboard manager in IPython - without this line, in FF,\n",
+       "    // the notebook keyboard shortcuts fail.\n",
+       "    IPython.keyboard_manager.enable()\n",
+       "    $(fig.parent_element).html('<img src=\"' + dataURL + '\" width=\"' + width + '\">');\n",
+       "    fig.close_ws(fig, msg);\n",
+       "}\n",
+       "\n",
+       "mpl.figure.prototype.close_ws = function(fig, msg){\n",
+       "    fig.send_message('closing', msg);\n",
+       "    // fig.ws.close()\n",
+       "}\n",
+       "\n",
+       "mpl.figure.prototype.push_to_output = function(remove_interactive) {\n",
+       "    // Turn the data on the canvas into data in the output cell.\n",
+       "    var width = this.canvas.width/mpl.ratio\n",
+       "    var dataURL = this.canvas.toDataURL();\n",
+       "    this.cell_info[1]['text/html'] = '<img src=\"' + dataURL + '\" width=\"' + width + '\">';\n",
+       "}\n",
+       "\n",
+       "mpl.figure.prototype.updated_canvas_event = function() {\n",
+       "    // Tell IPython that the notebook contents must change.\n",
+       "    IPython.notebook.set_dirty(true);\n",
+       "    this.send_message(\"ack\", {});\n",
+       "    var fig = this;\n",
+       "    // Wait a second, then push the new image to the DOM so\n",
+       "    // that it is saved nicely (might be nice to debounce this).\n",
+       "    setTimeout(function () { fig.push_to_output() }, 1000);\n",
+       "}\n",
+       "\n",
+       "mpl.figure.prototype._init_toolbar = function() {\n",
+       "    var fig = this;\n",
+       "\n",
+       "    var nav_element = $('<div/>')\n",
+       "    nav_element.attr('style', 'width: 100%');\n",
+       "    this.root.append(nav_element);\n",
+       "\n",
+       "    // Define a callback function for later on.\n",
+       "    function toolbar_event(event) {\n",
+       "        return fig.toolbar_button_onclick(event['data']);\n",
+       "    }\n",
+       "    function toolbar_mouse_event(event) {\n",
+       "        return fig.toolbar_button_onmouseover(event['data']);\n",
+       "    }\n",
+       "\n",
+       "    for(var toolbar_ind in mpl.toolbar_items){\n",
+       "        var name = mpl.toolbar_items[toolbar_ind][0];\n",
+       "        var tooltip = mpl.toolbar_items[toolbar_ind][1];\n",
+       "        var image = mpl.toolbar_items[toolbar_ind][2];\n",
+       "        var method_name = mpl.toolbar_items[toolbar_ind][3];\n",
+       "\n",
+       "        if (!name) { continue; };\n",
+       "\n",
+       "        var button = $('<button class=\"btn btn-default\" href=\"#\" title=\"' + name + '\"><i class=\"fa ' + image + ' fa-lg\"></i></button>');\n",
+       "        button.click(method_name, toolbar_event);\n",
+       "        button.mouseover(tooltip, toolbar_mouse_event);\n",
+       "        nav_element.append(button);\n",
+       "    }\n",
+       "\n",
+       "    // Add the status bar.\n",
+       "    var status_bar = $('<span class=\"mpl-message\" style=\"text-align:right; float: right;\"/>');\n",
+       "    nav_element.append(status_bar);\n",
+       "    this.message = status_bar[0];\n",
+       "\n",
+       "    // Add the close button to the window.\n",
+       "    var buttongrp = $('<div class=\"btn-group inline pull-right\"></div>');\n",
+       "    var button = $('<button class=\"btn btn-mini btn-primary\" href=\"#\" title=\"Stop Interaction\"><i class=\"fa fa-power-off icon-remove icon-large\"></i></button>');\n",
+       "    button.click(function (evt) { fig.handle_close(fig, {}); } );\n",
+       "    button.mouseover('Stop Interaction', toolbar_mouse_event);\n",
+       "    buttongrp.append(button);\n",
+       "    var titlebar = this.root.find($('.ui-dialog-titlebar'));\n",
+       "    titlebar.prepend(buttongrp);\n",
+       "}\n",
+       "\n",
+       "mpl.figure.prototype._root_extra_style = function(el){\n",
+       "    var fig = this\n",
+       "    el.on(\"remove\", function(){\n",
+       "\tfig.close_ws(fig, {});\n",
+       "    });\n",
+       "}\n",
+       "\n",
+       "mpl.figure.prototype._canvas_extra_style = function(el){\n",
+       "    // this is important to make the div 'focusable\n",
+       "    el.attr('tabindex', 0)\n",
+       "    // reach out to IPython and tell the keyboard manager to turn it's self\n",
+       "    // off when our div gets focus\n",
+       "\n",
+       "    // location in version 3\n",
+       "    if (IPython.notebook.keyboard_manager) {\n",
+       "        IPython.notebook.keyboard_manager.register_events(el);\n",
+       "    }\n",
+       "    else {\n",
+       "        // location in version 2\n",
+       "        IPython.keyboard_manager.register_events(el);\n",
+       "    }\n",
+       "\n",
+       "}\n",
+       "\n",
+       "mpl.figure.prototype._key_event_extra = function(event, name) {\n",
+       "    var manager = IPython.notebook.keyboard_manager;\n",
+       "    if (!manager)\n",
+       "        manager = IPython.keyboard_manager;\n",
+       "\n",
+       "    // Check for shift+enter\n",
+       "    if (event.shiftKey && event.which == 13) {\n",
+       "        this.canvas_div.blur();\n",
+       "        event.shiftKey = false;\n",
+       "        // Send a \"J\" for go to next cell\n",
+       "        event.which = 74;\n",
+       "        event.keyCode = 74;\n",
+       "        manager.command_mode();\n",
+       "        manager.handle_keydown(event);\n",
+       "    }\n",
+       "}\n",
+       "\n",
+       "mpl.figure.prototype.handle_save = function(fig, msg) {\n",
+       "    fig.ondownload(fig, null);\n",
+       "}\n",
+       "\n",
+       "\n",
+       "mpl.find_output_cell = function(html_output) {\n",
+       "    // Return the cell and output element which can be found *uniquely* in the notebook.\n",
+       "    // Note - this is a bit hacky, but it is done because the \"notebook_saving.Notebook\"\n",
+       "    // IPython event is triggered only after the cells have been serialised, which for\n",
+       "    // our purposes (turning an active figure into a static one), is too late.\n",
+       "    var cells = IPython.notebook.get_cells();\n",
+       "    var ncells = cells.length;\n",
+       "    for (var i=0; i<ncells; i++) {\n",
+       "        var cell = cells[i];\n",
+       "        if (cell.cell_type === 'code'){\n",
+       "            for (var j=0; j<cell.output_area.outputs.length; j++) {\n",
+       "                var data = cell.output_area.outputs[j];\n",
+       "                if (data.data) {\n",
+       "                    // IPython >= 3 moved mimebundle to data attribute of output\n",
+       "                    data = data.data;\n",
+       "                }\n",
+       "                if (data['text/html'] == html_output) {\n",
+       "                    return [cell, data, j];\n",
+       "                }\n",
+       "            }\n",
+       "        }\n",
+       "    }\n",
+       "}\n",
+       "\n",
+       "// Register the function which deals with the matplotlib target/channel.\n",
+       "// The kernel may be null if the page has been refreshed.\n",
+       "if (IPython.notebook.kernel != null) {\n",
+       "    IPython.notebook.kernel.comm_manager.register_target('matplotlib', mpl.mpl_figure_comm);\n",
+       "}\n"
+      ],
+      "text/plain": [
+       "<IPython.core.display.Javascript object>"
+      ]
+     },
+     "metadata": {},
+     "output_type": "display_data"
+    },
+    {
+     "data": {
+      "text/html": [
+       "<img src=\"data:image/png;base64,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\" width=\"800\">"
+      ],
+      "text/plain": [
+       "<IPython.core.display.HTML object>"
+      ]
+     },
+     "metadata": {},
+     "output_type": "display_data"
+    }
+   ],
+   "source": [
+    "%matplotlib notebook\n",
+    "from mpl_toolkits.mplot3d import Axes3D\n",
+    "\n",
+    "fig = plt.figure(figsize=(8,6))\n",
+    "# fig = plt.figure(2)\n",
+    "ax = fig.gca(projection='3d')\n",
+    "\n",
+    "x, y = np.meshgrid(np.linspace(np.min(-2.0), np.max(2.0), 10), np.linspace(np.min(-2.0),np.max(2.0), 10))\n",
+    "# ax.plot_surface(x, y, f(x,y), cmap='plasma')\n",
+    "ax.plot_wireframe(x, y, f(x,y),cmap='plasma')\n",
+    "ax.scatter(opt_way[:,0], opt_way[:,1], f(opt_way[:,0], opt_way[:,1]), color='g', s=100)\n",
+    "# ax.plot(opt_way[:,0], opt_way[:,1], f(opt_way[:,0], opt_way[:,1]), color='g')\n",
+    "x = np.arange(-2.0,2.0,0.1)\n",
+    "y = np.arange(-2.0,2.0,0.1)\n",
+    "\n",
+    "plt.show()"
+   ]
+  },
+  {
+   "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.6.8"
+  }
+ },
+ "nbformat": 4,
+ "nbformat_minor": 2
+}
diff --git a/homogeneous_coords.ipynb b/homogeneous_coords.ipynb
index eea99da..f544ef4 100644
--- a/homogeneous_coords.ipynb
+++ b/homogeneous_coords.ipynb
@@ -201,7 +201,7 @@
    "name": "python",
    "nbconvert_exporter": "python",
    "pygments_lexer": "ipython3",
-   "version": "3.6.7"
+   "version": "3.6.8"
   }
  },
  "nbformat": 4,
diff --git a/Hidden_markov_model.ipynb b/in_progress/Hidden_markov_model.ipynb
similarity index 100%
rename from Hidden_markov_model.ipynb
rename to in_progress/Hidden_markov_model.ipynb
diff --git a/icp_cov_estimation.ipynb b/in_progress/icp_cov_estimation.ipynb
similarity index 100%
rename from icp_cov_estimation.ipynb
rename to in_progress/icp_cov_estimation.ipynb
diff --git a/local_image_operators.ipynb b/local_image_operators.ipynb
index c3641a8..cbfe6db 100644
--- a/local_image_operators.ipynb
+++ b/local_image_operators.ipynb
@@ -568,7 +568,7 @@
    "name": "python",
    "nbconvert_exporter": "python",
    "pygments_lexer": "ipython3",
-   "version": "3.6.7"
+   "version": "3.6.8"
   }
  },
  "nbformat": 4,
diff --git a/ml_regression.ipynb b/ml_regression.ipynb
index 74de8d0..2cc2e6f 100644
--- a/ml_regression.ipynb
+++ b/ml_regression.ipynb
@@ -38,7 +38,8 @@
     "$$\\frac{\\partial L}{\\partial a} = \\sum(y_i - ax_i -b)(-x_i)$$\n",
     "$$\\frac{\\partial L}{\\partial b} = \\sum(y_i - ax_i -b)(-1)$$\n",
     "\n",
-    "After some manipulations we can get the system of linear equation.\n\n",
+    "After some manipulations we can get the system of linear equation.\n",
+    "\n",
     "$$\n",
     "\\begin{pmatrix}\n",
     "    \\sum x_i^2 & \\sum x_i\\\\\n",
@@ -54,7 +55,8 @@
     "    \\sum y_i\n",
     "\\end{pmatrix}\n",
     "$$\n",
-    "\n\n",
+    "\n",
+    "\n",
     "** Elegant solution **\n",
     "\n",
     "Consider $y = (y_1, .., y_n)$ be a vector and $x = [[x_1, 1], [x_2, 1], ..., [x_n, 1]]$ $nx2$ a matrix and $\\theta = (a,b)^T$ line parameters. Then given the fact that we fit a line, we minimize the following likelihood $ L = || y - x\\theta ||_{\\sum_i} $. Taken into account gaussian noise assumption\n",
@@ -176,21 +178,21 @@
  ],
  "metadata": {
   "kernelspec": {
-   "display_name": "Python 2",
+   "display_name": "Python 3",
    "language": "python",
-   "name": "python2"
+   "name": "python3"
   },
   "language_info": {
    "codemirror_mode": {
     "name": "ipython",
-    "version": 2
+    "version": 3
    },
    "file_extension": ".py",
    "mimetype": "text/x-python",
    "name": "python",
    "nbconvert_exporter": "python",
-   "pygments_lexer": "ipython2",
-   "version": "2.7.14"
+   "pygments_lexer": "ipython3",
+   "version": "3.6.8"
   }
  },
  "nbformat": 4,
diff --git a/topological_sorting.ipynb b/topological_sorting.ipynb
index ebebc08..3ec46ff 100644
--- a/topological_sorting.ipynb
+++ b/topological_sorting.ipynb
@@ -250,7 +250,7 @@
    "name": "python",
    "nbconvert_exporter": "python",
    "pygments_lexer": "ipython3",
-   "version": "3.6.5"
+   "version": "3.6.8"
   }
  },
  "nbformat": 4,