AM18_ex1.ipynb

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