information-entropy-3D-TODO.ipynb

{
 "cells": [
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Trying to figure out the shape of information entropy in 3D.\n",
    "\n",
    "2D case is clear as seen in https://en.wikipedia.org/wiki/Entropy_(information_theory)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 1,
   "metadata": {
    "collapsed": true
   },
   "outputs": [],
   "source": [
    "'''\n",
    "======================\n",
    "3D surface (color map)\n",
    "======================\n",
    "\n",
    "Demonstrates plotting a 3D surface colored with the coolwarm color map.\n",
    "The surface is made opaque by using antialiased=False.\n",
    "\n",
    "Also demonstrates using the LinearLocator and custom formatting for the\n",
    "z axis tick labels.\n",
    "'''\n",
    "\n",
    "from mpl_toolkits.mplot3d import Axes3D\n",
    "import matplotlib.pyplot as plt\n",
    "from matplotlib import cm\n",
    "from matplotlib.ticker import LinearLocator, FormatStrFormatter\n",
    "import numpy as np\n",
    "\n",
    "%matplotlib notebook"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 4,
   "metadata": {
    "collapsed": false
   },
   "outputs": [
    {
     "data": {
      "application/javascript": [
       "/* Put everything inside the global mpl namespace */\n",
       "window.mpl = {};\n",
       "\n",
       "\n",
       "mpl.get_websocket_type = function() {\n",
       "    if (typeof(WebSocket) !== 'undefined') {\n",
       "        return WebSocket;\n",
       "    } else if (typeof(MozWebSocket) !== 'undefined') {\n",
       "        return MozWebSocket;\n",
       "    } else {\n",
       "        alert('Your browser does not have WebSocket support.' +\n",
       "              'Please try Chrome, Safari or Firefox ≥ 6. ' +\n",
       "              'Firefox 4 and 5 are also supported but you ' +\n",
       "              'have to enable WebSockets in about:config.');\n",
       "    };\n",
       "}\n",
       "\n",
       "mpl.figure = function(figure_id, websocket, ondownload, parent_element) {\n",
       "    this.id = figure_id;\n",
       "\n",
       "    this.ws = websocket;\n",
       "\n",
       "    this.supports_binary = (this.ws.binaryType != undefined);\n",
       "\n",
       "    if (!this.supports_binary) {\n",
       "        var warnings = document.getElementById(\"mpl-warnings\");\n",
       "        if (warnings) {\n",
       "            warnings.style.display = 'block';\n",
       "            warnings.textContent = (\n",
       "                \"This browser does not support binary websocket messages. \" +\n",
       "                    \"Performance may be slow.\");\n",
       "        }\n",
       "    }\n",
       "\n",
       "    this.imageObj = new Image();\n",
       "\n",
       "    this.context = undefined;\n",
       "    this.message = undefined;\n",
       "    this.canvas = undefined;\n",
       "    this.rubberband_canvas = undefined;\n",
       "    this.rubberband_context = undefined;\n",
       "    this.format_dropdown = undefined;\n",
       "\n",
       "    this.image_mode = 'full';\n",
       "\n",
       "    this.root = $('<div/>');\n",
       "    this._root_extra_style(this.root)\n",
       "    this.root.attr('style', 'display: inline-block');\n",
       "\n",
       "    $(parent_element).append(this.root);\n",
       "\n",
       "    this._init_header(this);\n",
       "    this._init_canvas(this);\n",
       "    this._init_toolbar(this);\n",
       "\n",
       "    var fig = this;\n",
       "\n",
       "    this.waiting = false;\n",
       "\n",
       "    this.ws.onopen =  function () {\n",
       "            fig.send_message(\"supports_binary\", {value: fig.supports_binary});\n",
       "            fig.send_message(\"send_image_mode\", {});\n",
       "            if (mpl.ratio != 1) {\n",
       "                fig.send_message(\"set_dpi_ratio\", {'dpi_ratio': mpl.ratio});\n",
       "            }\n",
       "            fig.send_message(\"refresh\", {});\n",
       "        }\n",
       "\n",
       "    this.imageObj.onload = function() {\n",
       "            if (fig.image_mode == 'full') {\n",
       "                // Full images could contain transparency (where diff images\n",
       "                // almost always do), so we need to clear the canvas so that\n",
       "                // there is no ghosting.\n",
       "                fig.context.clearRect(0, 0, fig.canvas.width, fig.canvas.height);\n",
       "            }\n",
       "            fig.context.drawImage(fig.imageObj, 0, 0);\n",
       "        };\n",
       "\n",
       "    this.imageObj.onunload = function() {\n",
       "        this.ws.close();\n",
       "    }\n",
       "\n",
       "    this.ws.onmessage = this._make_on_message_function(this);\n",
       "\n",
       "    this.ondownload = ondownload;\n",
       "}\n",
       "\n",
       "mpl.figure.prototype._init_header = function() {\n",
       "    var titlebar = $(\n",
       "        '<div class=\"ui-dialog-titlebar ui-widget-header ui-corner-all ' +\n",
       "        'ui-helper-clearfix\"/>');\n",
       "    var titletext = $(\n",
       "        '<div class=\"ui-dialog-title\" style=\"width: 100%; ' +\n",
       "        'text-align: center; padding: 3px;\"/>');\n",
       "    titlebar.append(titletext)\n",
       "    this.root.append(titlebar);\n",
       "    this.header = titletext[0];\n",
       "}\n",
       "\n",
       "\n",
       "\n",
       "mpl.figure.prototype._canvas_extra_style = function(canvas_div) {\n",
       "\n",
       "}\n",
       "\n",
       "\n",
       "mpl.figure.prototype._root_extra_style = function(canvas_div) {\n",
       "\n",
       "}\n",
       "\n",
       "mpl.figure.prototype._init_canvas = function() {\n",
       "    var fig = this;\n",
       "\n",
       "    var canvas_div = $('<div/>');\n",
       "\n",
       "    canvas_div.attr('style', 'position: relative; clear: both; outline: 0');\n",
       "\n",
       "    function canvas_keyboard_event(event) {\n",
       "        return fig.key_event(event, event['data']);\n",
       "    }\n",
       "\n",
       "    canvas_div.keydown('key_press', canvas_keyboard_event);\n",
       "    canvas_div.keyup('key_release', canvas_keyboard_event);\n",
       "    this.canvas_div = canvas_div\n",
       "    this._canvas_extra_style(canvas_div)\n",
       "    this.root.append(canvas_div);\n",
       "\n",
       "    var canvas = $('<canvas/>');\n",
       "    canvas.addClass('mpl-canvas');\n",
       "    canvas.attr('style', \"left: 0; top: 0; z-index: 0; outline: 0\")\n",
       "\n",
       "    this.canvas = canvas[0];\n",
       "    this.context = canvas[0].getContext(\"2d\");\n",
       "\n",
       "    var backingStore = this.context.backingStorePixelRatio ||\n",
       "\tthis.context.webkitBackingStorePixelRatio ||\n",
       "\tthis.context.mozBackingStorePixelRatio ||\n",
       "\tthis.context.msBackingStorePixelRatio ||\n",
       "\tthis.context.oBackingStorePixelRatio ||\n",
       "\tthis.context.backingStorePixelRatio || 1;\n",
       "\n",
       "    mpl.ratio = (window.devicePixelRatio || 1) / backingStore;\n",
       "\n",
       "    var rubberband = $('<canvas/>');\n",
       "    rubberband.attr('style', \"position: absolute; left: 0; top: 0; z-index: 1;\")\n",
       "\n",
       "    var pass_mouse_events = true;\n",
       "\n",
       "    canvas_div.resizable({\n",
       "        start: function(event, ui) {\n",
       "            pass_mouse_events = false;\n",
       "        },\n",
       "        resize: function(event, ui) {\n",
       "            fig.request_resize(ui.size.width, ui.size.height);\n",
       "        },\n",
       "        stop: function(event, ui) {\n",
       "            pass_mouse_events = true;\n",
       "            fig.request_resize(ui.size.width, ui.size.height);\n",
       "        },\n",
       "    });\n",
       "\n",
       "    function mouse_event_fn(event) {\n",
       "        if (pass_mouse_events)\n",
       "            return fig.mouse_event(event, event['data']);\n",
       "    }\n",
       "\n",
       "    rubberband.mousedown('button_press', mouse_event_fn);\n",
       "    rubberband.mouseup('button_release', mouse_event_fn);\n",
       "    // Throttle sequential mouse events to 1 every 20ms.\n",
       "    rubberband.mousemove('motion_notify', mouse_event_fn);\n",
       "\n",
       "    rubberband.mouseenter('figure_enter', mouse_event_fn);\n",
       "    rubberband.mouseleave('figure_leave', mouse_event_fn);\n",
       "\n",
       "    canvas_div.on(\"wheel\", function (event) {\n",
       "        event = event.originalEvent;\n",
       "        event['data'] = 'scroll'\n",
       "        if (event.deltaY < 0) {\n",
       "            event.step = 1;\n",
       "        } else {\n",
       "            event.step = -1;\n",
       "        }\n",
       "        mouse_event_fn(event);\n",
       "    });\n",
       "\n",
       "    canvas_div.append(canvas);\n",
       "    canvas_div.append(rubberband);\n",
       "\n",
       "    this.rubberband = rubberband;\n",
       "    this.rubberband_canvas = rubberband[0];\n",
       "    this.rubberband_context = rubberband[0].getContext(\"2d\");\n",
       "    this.rubberband_context.strokeStyle = \"#000000\";\n",
       "\n",
       "    this._resize_canvas = function(width, height) {\n",
       "        // Keep the size of the canvas, canvas container, and rubber band\n",
       "        // canvas in synch.\n",
       "        canvas_div.css('width', width)\n",
       "        canvas_div.css('height', height)\n",
       "\n",
       "        canvas.attr('width', width * mpl.ratio);\n",
       "        canvas.attr('height', height * mpl.ratio);\n",
       "        canvas.attr('style', 'width: ' + width + 'px; height: ' + height + 'px;');\n",
       "\n",
       "        rubberband.attr('width', width);\n",
       "        rubberband.attr('height', height);\n",
       "    }\n",
       "\n",
       "    // Set the figure to an initial 600x600px, this will subsequently be updated\n",
       "    // upon first draw.\n",
       "    this._resize_canvas(600, 600);\n",
       "\n",
       "    // Disable right mouse context menu.\n",
       "    $(this.rubberband_canvas).bind(\"contextmenu\",function(e){\n",
       "        return false;\n",
       "    });\n",
       "\n",
       "    function set_focus () {\n",
       "        canvas.focus();\n",
       "        canvas_div.focus();\n",
       "    }\n",
       "\n",
       "    window.setTimeout(set_focus, 100);\n",
       "}\n",
       "\n",
       "mpl.figure.prototype._init_toolbar = function() {\n",
       "    var fig = this;\n",
       "\n",
       "    var nav_element = $('<div/>')\n",
       "    nav_element.attr('style', 'width: 100%');\n",
       "    this.root.append(nav_element);\n",
       "\n",
       "    // Define a callback function for later on.\n",
       "    function toolbar_event(event) {\n",
       "        return fig.toolbar_button_onclick(event['data']);\n",
       "    }\n",
       "    function toolbar_mouse_event(event) {\n",
       "        return fig.toolbar_button_onmouseover(event['data']);\n",
       "    }\n",
       "\n",
       "    for(var toolbar_ind in mpl.toolbar_items) {\n",
       "        var name = mpl.toolbar_items[toolbar_ind][0];\n",
       "        var tooltip = mpl.toolbar_items[toolbar_ind][1];\n",
       "        var image = mpl.toolbar_items[toolbar_ind][2];\n",
       "        var method_name = mpl.toolbar_items[toolbar_ind][3];\n",
       "\n",
       "        if (!name) {\n",
       "            // put a spacer in here.\n",
       "            continue;\n",
       "        }\n",
       "        var button = $('<button/>');\n",
       "        button.addClass('ui-button ui-widget ui-state-default ui-corner-all ' +\n",
       "                        'ui-button-icon-only');\n",
       "        button.attr('role', 'button');\n",
       "        button.attr('aria-disabled', 'false');\n",
       "        button.click(method_name, toolbar_event);\n",
       "        button.mouseover(tooltip, toolbar_mouse_event);\n",
       "\n",
       "        var icon_img = $('<span/>');\n",
       "        icon_img.addClass('ui-button-icon-primary ui-icon');\n",
       "        icon_img.addClass(image);\n",
       "        icon_img.addClass('ui-corner-all');\n",
       "\n",
       "        var tooltip_span = $('<span/>');\n",
       "        tooltip_span.addClass('ui-button-text');\n",
       "        tooltip_span.html(tooltip);\n",
       "\n",
       "        button.append(icon_img);\n",
       "        button.append(tooltip_span);\n",
       "\n",
       "        nav_element.append(button);\n",
       "    }\n",
       "\n",
       "    var fmt_picker_span = $('<span/>');\n",
       "\n",
       "    var fmt_picker = $('<select/>');\n",
       "    fmt_picker.addClass('mpl-toolbar-option ui-widget ui-widget-content');\n",
       "    fmt_picker_span.append(fmt_picker);\n",
       "    nav_element.append(fmt_picker_span);\n",
       "    this.format_dropdown = fmt_picker[0];\n",
       "\n",
       "    for (var ind in mpl.extensions) {\n",
       "        var fmt = mpl.extensions[ind];\n",
       "        var option = $(\n",
       "            '<option/>', {selected: fmt === mpl.default_extension}).html(fmt);\n",
       "        fmt_picker.append(option)\n",
       "    }\n",
       "\n",
       "    // Add hover states to the ui-buttons\n",
       "    $( \".ui-button\" ).hover(\n",
       "        function() { $(this).addClass(\"ui-state-hover\");},\n",
       "        function() { $(this).removeClass(\"ui-state-hover\");}\n",
       "    );\n",
       "\n",
       "    var status_bar = $('<span class=\"mpl-message\"/>');\n",
       "    nav_element.append(status_bar);\n",
       "    this.message = status_bar[0];\n",
       "}\n",
       "\n",
       "mpl.figure.prototype.request_resize = function(x_pixels, y_pixels) {\n",
       "    // Request matplotlib to resize the figure. Matplotlib will then trigger a resize in the client,\n",
       "    // which will in turn request a refresh of the image.\n",
       "    this.send_message('resize', {'width': x_pixels, 'height': y_pixels});\n",
       "}\n",
       "\n",
       "mpl.figure.prototype.send_message = function(type, properties) {\n",
       "    properties['type'] = type;\n",
       "    properties['figure_id'] = this.id;\n",
       "    this.ws.send(JSON.stringify(properties));\n",
       "}\n",
       "\n",
       "mpl.figure.prototype.send_draw_message = function() {\n",
       "    if (!this.waiting) {\n",
       "        this.waiting = true;\n",
       "        this.ws.send(JSON.stringify({type: \"draw\", figure_id: this.id}));\n",
       "    }\n",
       "}\n",
       "\n",
       "\n",
       "mpl.figure.prototype.handle_save = function(fig, msg) {\n",
       "    var format_dropdown = fig.format_dropdown;\n",
       "    var format = format_dropdown.options[format_dropdown.selectedIndex].value;\n",
       "    fig.ondownload(fig, format);\n",
       "}\n",
       "\n",
       "\n",
       "mpl.figure.prototype.handle_resize = function(fig, msg) {\n",
       "    var size = msg['size'];\n",
       "    if (size[0] != fig.canvas.width || size[1] != fig.canvas.height) {\n",
       "        fig._resize_canvas(size[0], size[1]);\n",
       "        fig.send_message(\"refresh\", {});\n",
       "    };\n",
       "}\n",
       "\n",
       "mpl.figure.prototype.handle_rubberband = function(fig, msg) {\n",
       "    var x0 = msg['x0'] / mpl.ratio;\n",
       "    var y0 = (fig.canvas.height - msg['y0']) / mpl.ratio;\n",
       "    var x1 = msg['x1'] / mpl.ratio;\n",
       "    var y1 = (fig.canvas.height - msg['y1']) / mpl.ratio;\n",
       "    x0 = Math.floor(x0) + 0.5;\n",
       "    y0 = Math.floor(y0) + 0.5;\n",
       "    x1 = Math.floor(x1) + 0.5;\n",
       "    y1 = Math.floor(y1) + 0.5;\n",
       "    var min_x = Math.min(x0, x1);\n",
       "    var min_y = Math.min(y0, y1);\n",
       "    var width = Math.abs(x1 - x0);\n",
       "    var height = Math.abs(y1 - y0);\n",
       "\n",
       "    fig.rubberband_context.clearRect(\n",
       "        0, 0, fig.canvas.width, fig.canvas.height);\n",
       "\n",
       "    fig.rubberband_context.strokeRect(min_x, min_y, width, height);\n",
       "}\n",
       "\n",
       "mpl.figure.prototype.handle_figure_label = function(fig, msg) {\n",
       "    // Updates the figure title.\n",
       "    fig.header.textContent = msg['label'];\n",
       "}\n",
       "\n",
       "mpl.figure.prototype.handle_cursor = function(fig, msg) {\n",
       "    var cursor = msg['cursor'];\n",
       "    switch(cursor)\n",
       "    {\n",
       "    case 0:\n",
       "        cursor = 'pointer';\n",
       "        break;\n",
       "    case 1:\n",
       "        cursor = 'default';\n",
       "        break;\n",
       "    case 2:\n",
       "        cursor = 'crosshair';\n",
       "        break;\n",
       "    case 3:\n",
       "        cursor = 'move';\n",
       "        break;\n",
       "    }\n",
       "    fig.rubberband_canvas.style.cursor = cursor;\n",
       "}\n",
       "\n",
       "mpl.figure.prototype.handle_message = function(fig, msg) {\n",
       "    fig.message.textContent = msg['message'];\n",
       "}\n",
       "\n",
       "mpl.figure.prototype.handle_draw = function(fig, msg) {\n",
       "    // Request the server to send over a new figure.\n",
       "    fig.send_draw_message();\n",
       "}\n",
       "\n",
       "mpl.figure.prototype.handle_image_mode = function(fig, msg) {\n",
       "    fig.image_mode = msg['mode'];\n",
       "}\n",
       "\n",
       "mpl.figure.prototype.updated_canvas_event = function() {\n",
       "    // Called whenever the canvas gets updated.\n",
       "    this.send_message(\"ack\", {});\n",
       "}\n",
       "\n",
       "// A function to construct a web socket function for onmessage handling.\n",
       "// Called in the figure constructor.\n",
       "mpl.figure.prototype._make_on_message_function = function(fig) {\n",
       "    return function socket_on_message(evt) {\n",
       "        if (evt.data instanceof Blob) {\n",
       "            /* FIXME: We get \"Resource interpreted as Image but\n",
       "             * transferred with MIME type text/plain:\" errors on\n",
       "             * Chrome.  But how to set the MIME type?  It doesn't seem\n",
       "             * to be part of the websocket stream */\n",
       "            evt.data.type = \"image/png\";\n",
       "\n",
       "            /* Free the memory for the previous frames */\n",
       "            if (fig.imageObj.src) {\n",
       "                (window.URL || window.webkitURL).revokeObjectURL(\n",
       "                    fig.imageObj.src);\n",
       "            }\n",
       "\n",
       "            fig.imageObj.src = (window.URL || window.webkitURL).createObjectURL(\n",
       "                evt.data);\n",
       "            fig.updated_canvas_event();\n",
       "            fig.waiting = false;\n",
       "            return;\n",
       "        }\n",
       "        else if (typeof evt.data === 'string' && evt.data.slice(0, 21) == \"data:image/png;base64\") {\n",
       "            fig.imageObj.src = evt.data;\n",
       "            fig.updated_canvas_event();\n",
       "            fig.waiting = false;\n",
       "            return;\n",
       "        }\n",
       "\n",
       "        var msg = JSON.parse(evt.data);\n",
       "        var msg_type = msg['type'];\n",
       "\n",
       "        // Call the  \"handle_{type}\" callback, which takes\n",
       "        // the figure and JSON message as its only arguments.\n",
       "        try {\n",
       "            var callback = fig[\"handle_\" + msg_type];\n",
       "        } catch (e) {\n",
       "            console.log(\"No handler for the '\" + msg_type + \"' message type: \", msg);\n",
       "            return;\n",
       "        }\n",
       "\n",
       "        if (callback) {\n",
       "            try {\n",
       "                // console.log(\"Handling '\" + msg_type + \"' message: \", msg);\n",
       "                callback(fig, msg);\n",
       "            } catch (e) {\n",
       "                console.log(\"Exception inside the 'handler_\" + msg_type + \"' callback:\", e, e.stack, msg);\n",
       "            }\n",
       "        }\n",
       "    };\n",
       "}\n",
       "\n",
       "// from http://stackoverflow.com/questions/1114465/getting-mouse-location-in-canvas\n",
       "mpl.findpos = function(e) {\n",
       "    //this section is from http://www.quirksmode.org/js/events_properties.html\n",
       "    var targ;\n",
       "    if (!e)\n",
       "        e = window.event;\n",
       "    if (e.target)\n",
       "        targ = e.target;\n",
       "    else if (e.srcElement)\n",
       "        targ = e.srcElement;\n",
       "    if (targ.nodeType == 3) // defeat Safari bug\n",
       "        targ = targ.parentNode;\n",
       "\n",
       "    // jQuery normalizes the pageX and pageY\n",
       "    // pageX,Y are the mouse positions relative to the document\n",
       "    // offset() returns the position of the element relative to the document\n",
       "    var x = e.pageX - $(targ).offset().left;\n",
       "    var y = e.pageY - $(targ).offset().top;\n",
       "\n",
       "    return {\"x\": x, \"y\": y};\n",
       "};\n",
       "\n",
       "/*\n",
       " * return a copy of an object with only non-object keys\n",
       " * we need this to avoid circular references\n",
       " * http://stackoverflow.com/a/24161582/3208463\n",
       " */\n",
       "function simpleKeys (original) {\n",
       "  return Object.keys(original).reduce(function (obj, key) {\n",
       "    if (typeof original[key] !== 'object')\n",
       "        obj[key] = original[key]\n",
       "    return obj;\n",
       "  }, {});\n",
       "}\n",
       "\n",
       "mpl.figure.prototype.mouse_event = function(event, name) {\n",
       "    var canvas_pos = mpl.findpos(event)\n",
       "\n",
       "    if (name === 'button_press')\n",
       "    {\n",
       "        this.canvas.focus();\n",
       "        this.canvas_div.focus();\n",
       "    }\n",
       "\n",
       "    var x = canvas_pos.x * mpl.ratio;\n",
       "    var y = canvas_pos.y * mpl.ratio;\n",
       "\n",
       "    this.send_message(name, {x: x, y: y, button: event.button,\n",
       "                             step: event.step,\n",
       "                             guiEvent: simpleKeys(event)});\n",
       "\n",
       "    /* This prevents the web browser from automatically changing to\n",
       "     * the text insertion cursor when the button is pressed.  We want\n",
       "     * to control all of the cursor setting manually through the\n",
       "     * 'cursor' event from matplotlib */\n",
       "    event.preventDefault();\n",
       "    return false;\n",
       "}\n",
       "\n",
       "mpl.figure.prototype._key_event_extra = function(event, name) {\n",
       "    // Handle any extra behaviour associated with a key event\n",
       "}\n",
       "\n",
       "mpl.figure.prototype.key_event = function(event, name) {\n",
       "\n",
       "    // Prevent repeat events\n",
       "    if (name == 'key_press')\n",
       "    {\n",
       "        if (event.which === this._key)\n",
       "            return;\n",
       "        else\n",
       "            this._key = event.which;\n",
       "    }\n",
       "    if (name == 'key_release')\n",
       "        this._key = null;\n",
       "\n",
       "    var value = '';\n",
       "    if (event.ctrlKey && event.which != 17)\n",
       "        value += \"ctrl+\";\n",
       "    if (event.altKey && event.which != 18)\n",
       "        value += \"alt+\";\n",
       "    if (event.shiftKey && event.which != 16)\n",
       "        value += \"shift+\";\n",
       "\n",
       "    value += 'k';\n",
       "    value += event.which.toString();\n",
       "\n",
       "    this._key_event_extra(event, name);\n",
       "\n",
       "    this.send_message(name, {key: value,\n",
       "                             guiEvent: simpleKeys(event)});\n",
       "    return false;\n",
       "}\n",
       "\n",
       "mpl.figure.prototype.toolbar_button_onclick = function(name) {\n",
       "    if (name == 'download') {\n",
       "        this.handle_save(this, null);\n",
       "    } else {\n",
       "        this.send_message(\"toolbar_button\", {name: name});\n",
       "    }\n",
       "};\n",
       "\n",
       "mpl.figure.prototype.toolbar_button_onmouseover = function(tooltip) {\n",
       "    this.message.textContent = tooltip;\n",
       "};\n",
       "mpl.toolbar_items = [[\"Home\", \"Reset original view\", \"fa fa-home icon-home\", \"home\"], [\"Back\", \"Back to  previous view\", \"fa fa-arrow-left icon-arrow-left\", \"back\"], [\"Forward\", \"Forward to next view\", \"fa fa-arrow-right icon-arrow-right\", \"forward\"], [\"\", \"\", \"\", \"\"], [\"Pan\", \"Pan axes with left mouse, zoom with right\", \"fa fa-arrows icon-move\", \"pan\"], [\"Zoom\", \"Zoom to rectangle\", \"fa fa-square-o icon-check-empty\", \"zoom\"], [\"\", \"\", \"\", \"\"], [\"Download\", \"Download plot\", \"fa fa-floppy-o icon-save\", \"download\"]];\n",
       "\n",
       "mpl.extensions = [\"eps\", \"jpeg\", \"pdf\", \"png\", \"ps\", \"raw\", \"svg\", \"tif\"];\n",
       "\n",
       "mpl.default_extension = \"png\";var comm_websocket_adapter = function(comm) {\n",
       "    // Create a \"websocket\"-like object which calls the given IPython comm\n",
       "    // object with the appropriate methods. Currently this is a non binary\n",
       "    // socket, so there is still some room for performance tuning.\n",
       "    var ws = {};\n",
       "\n",
       "    ws.close = function() {\n",
       "        comm.close()\n",
       "    };\n",
       "    ws.send = function(m) {\n",
       "        //console.log('sending', m);\n",
       "        comm.send(m);\n",
       "    };\n",
       "    // Register the callback with on_msg.\n",
       "    comm.on_msg(function(msg) {\n",
       "        //console.log('receiving', msg['content']['data'], msg);\n",
       "        // Pass the mpl event to the overriden (by mpl) onmessage function.\n",
       "        ws.onmessage(msg['content']['data'])\n",
       "    });\n",
       "    return ws;\n",
       "}\n",
       "\n",
       "mpl.mpl_figure_comm = function(comm, msg) {\n",
       "    // This is the function which gets called when the mpl process\n",
       "    // starts-up an IPython Comm through the \"matplotlib\" channel.\n",
       "\n",
       "    var id = msg.content.data.id;\n",
       "    // Get hold of the div created by the display call when the Comm\n",
       "    // socket was opened in Python.\n",
       "    var element = $(\"#\" + id);\n",
       "    var ws_proxy = comm_websocket_adapter(comm)\n",
       "\n",
       "    function ondownload(figure, format) {\n",
       "        window.open(figure.imageObj.src);\n",
       "    }\n",
       "\n",
       "    var fig = new mpl.figure(id, ws_proxy,\n",
       "                           ondownload,\n",
       "                           element.get(0));\n",
       "\n",
       "    // Call onopen now - mpl needs it, as it is assuming we've passed it a real\n",
       "    // web socket which is closed, not our websocket->open comm proxy.\n",
       "    ws_proxy.onopen();\n",
       "\n",
       "    fig.parent_element = element.get(0);\n",
       "    fig.cell_info = mpl.find_output_cell(\"<div id='\" + id + \"'></div>\");\n",
       "    if (!fig.cell_info) {\n",
       "        console.error(\"Failed to find cell for figure\", id, fig);\n",
       "        return;\n",
       "    }\n",
       "\n",
       "    var output_index = fig.cell_info[2]\n",
       "    var cell = fig.cell_info[0];\n",
       "\n",
       "};\n",
       "\n",
       "mpl.figure.prototype.handle_close = function(fig, msg) {\n",
       "    var width = fig.canvas.width/mpl.ratio\n",
       "    fig.root.unbind('remove')\n",
       "\n",
       "    // Update the output cell to use the data from the current canvas.\n",
       "    fig.push_to_output();\n",
       "    var dataURL = fig.canvas.toDataURL();\n",
       "    // Re-enable the keyboard manager in IPython - without this line, in FF,\n",
       "    // the notebook keyboard shortcuts fail.\n",
       "    IPython.keyboard_manager.enable()\n",
       "    $(fig.parent_element).html('<img src=\"' + dataURL + '\" width=\"' + width + '\">');\n",
       "    fig.close_ws(fig, msg);\n",
       "}\n",
       "\n",
       "mpl.figure.prototype.close_ws = function(fig, msg){\n",
       "    fig.send_message('closing', msg);\n",
       "    // fig.ws.close()\n",
       "}\n",
       "\n",
       "mpl.figure.prototype.push_to_output = function(remove_interactive) {\n",
       "    // Turn the data on the canvas into data in the output cell.\n",
       "    var width = this.canvas.width/mpl.ratio\n",
       "    var dataURL = this.canvas.toDataURL();\n",
       "    this.cell_info[1]['text/html'] = '<img src=\"' + dataURL + '\" width=\"' + width + '\">';\n",
       "}\n",
       "\n",
       "mpl.figure.prototype.updated_canvas_event = function() {\n",
       "    // Tell IPython that the notebook contents must change.\n",
       "    IPython.notebook.set_dirty(true);\n",
       "    this.send_message(\"ack\", {});\n",
       "    var fig = this;\n",
       "    // Wait a second, then push the new image to the DOM so\n",
       "    // that it is saved nicely (might be nice to debounce this).\n",
       "    setTimeout(function () { fig.push_to_output() }, 1000);\n",
       "}\n",
       "\n",
       "mpl.figure.prototype._init_toolbar = function() {\n",
       "    var fig = this;\n",
       "\n",
       "    var nav_element = $('<div/>')\n",
       "    nav_element.attr('style', 'width: 100%');\n",
       "    this.root.append(nav_element);\n",
       "\n",
       "    // Define a callback function for later on.\n",
       "    function toolbar_event(event) {\n",
       "        return fig.toolbar_button_onclick(event['data']);\n",
       "    }\n",
       "    function toolbar_mouse_event(event) {\n",
       "        return fig.toolbar_button_onmouseover(event['data']);\n",
       "    }\n",
       "\n",
       "    for(var toolbar_ind in mpl.toolbar_items){\n",
       "        var name = mpl.toolbar_items[toolbar_ind][0];\n",
       "        var tooltip = mpl.toolbar_items[toolbar_ind][1];\n",
       "        var image = mpl.toolbar_items[toolbar_ind][2];\n",
       "        var method_name = mpl.toolbar_items[toolbar_ind][3];\n",
       "\n",
       "        if (!name) { continue; };\n",
       "\n",
       "        var button = $('<button class=\"btn btn-default\" href=\"#\" title=\"' + name + '\"><i class=\"fa ' + image + ' fa-lg\"></i></button>');\n",
       "        button.click(method_name, toolbar_event);\n",
       "        button.mouseover(tooltip, toolbar_mouse_event);\n",
       "        nav_element.append(button);\n",
       "    }\n",
       "\n",
       "    // Add the status bar.\n",
       "    var status_bar = $('<span class=\"mpl-message\" style=\"text-align:right; float: right;\"/>');\n",
       "    nav_element.append(status_bar);\n",
       "    this.message = status_bar[0];\n",
       "\n",
       "    // Add the close button to the window.\n",
       "    var buttongrp = $('<div class=\"btn-group inline pull-right\"></div>');\n",
       "    var button = $('<button class=\"btn btn-mini btn-primary\" href=\"#\" title=\"Stop Interaction\"><i class=\"fa fa-power-off icon-remove icon-large\"></i></button>');\n",
       "    button.click(function (evt) { fig.handle_close(fig, {}); } );\n",
       "    button.mouseover('Stop Interaction', toolbar_mouse_event);\n",
       "    buttongrp.append(button);\n",
       "    var titlebar = this.root.find($('.ui-dialog-titlebar'));\n",
       "    titlebar.prepend(buttongrp);\n",
       "}\n",
       "\n",
       "mpl.figure.prototype._root_extra_style = function(el){\n",
       "    var fig = this\n",
       "    el.on(\"remove\", function(){\n",
       "\tfig.close_ws(fig, {});\n",
       "    });\n",
       "}\n",
       "\n",
       "mpl.figure.prototype._canvas_extra_style = function(el){\n",
       "    // this is important to make the div 'focusable\n",
       "    el.attr('tabindex', 0)\n",
       "    // reach out to IPython and tell the keyboard manager to turn it's self\n",
       "    // off when our div gets focus\n",
       "\n",
       "    // location in version 3\n",
       "    if (IPython.notebook.keyboard_manager) {\n",
       "        IPython.notebook.keyboard_manager.register_events(el);\n",
       "    }\n",
       "    else {\n",
       "        // location in version 2\n",
       "        IPython.keyboard_manager.register_events(el);\n",
       "    }\n",
       "\n",
       "}\n",
       "\n",
       "mpl.figure.prototype._key_event_extra = function(event, name) {\n",
       "    var manager = IPython.notebook.keyboard_manager;\n",
       "    if (!manager)\n",
       "        manager = IPython.keyboard_manager;\n",
       "\n",
       "    // Check for shift+enter\n",
       "    if (event.shiftKey && event.which == 13) {\n",
       "        this.canvas_div.blur();\n",
       "        // select the cell after this one\n",
       "        var index = IPython.notebook.find_cell_index(this.cell_info[0]);\n",
       "        IPython.notebook.select(index + 1);\n",
       "    }\n",
       "}\n",
       "\n",
       "mpl.figure.prototype.handle_save = function(fig, msg) {\n",
       "    fig.ondownload(fig, null);\n",
       "}\n",
       "\n",
       "\n",
       "mpl.find_output_cell = function(html_output) {\n",
       "    // Return the cell and output element which can be found *uniquely* in the notebook.\n",
       "    // Note - this is a bit hacky, but it is done because the \"notebook_saving.Notebook\"\n",
       "    // IPython event is triggered only after the cells have been serialised, which for\n",
       "    // our purposes (turning an active figure into a static one), is too late.\n",
       "    var cells = IPython.notebook.get_cells();\n",
       "    var ncells = cells.length;\n",
       "    for (var i=0; i<ncells; i++) {\n",
       "        var cell = cells[i];\n",
       "        if (cell.cell_type === 'code'){\n",
       "            for (var j=0; j<cell.output_area.outputs.length; j++) {\n",
       "                var data = cell.output_area.outputs[j];\n",
       "                if (data.data) {\n",
       "                    // IPython >= 3 moved mimebundle to data attribute of output\n",
       "                    data = data.data;\n",
       "                }\n",
       "                if (data['text/html'] == html_output) {\n",
       "                    return [cell, data, j];\n",
       "                }\n",
       "            }\n",
       "        }\n",
       "    }\n",
       "}\n",
       "\n",
       "// Register the function which deals with the matplotlib target/channel.\n",
       "// The kernel may be null if the page has been refreshed.\n",
       "if (IPython.notebook.kernel != null) {\n",
       "    IPython.notebook.kernel.comm_manager.register_target('matplotlib', mpl.mpl_figure_comm);\n",
       "}\n"
      ],
      "text/plain": [
       "<IPython.core.display.Javascript object>"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    },
    {
     "data": {
      "text/html": [
       "<img src=\"data:image/png;base64,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\" width=\"640\">"
      ],
      "text/plain": [
       "<IPython.core.display.HTML object>"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    },
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      "/projects/btl2/zxue/miniconda3/envs/ml/lib/python3.5/site-packages/ipykernel/__main__.py:10: RuntimeWarning: divide by zero encountered in log\n",
      "/projects/btl2/zxue/miniconda3/envs/ml/lib/python3.5/site-packages/ipykernel/__main__.py:10: RuntimeWarning: invalid value encountered in log\n",
      "/projects/btl2/zxue/miniconda3/envs/ml/lib/python3.5/site-packages/ipykernel/__main__.py:10: RuntimeWarning: invalid value encountered in multiply\n"
     ]
    },
    {
     "data": {
      "text/plain": [
       "<matplotlib.contour.QuadContourSet at 0x7f29692f2160>"
      ]
     },
     "execution_count": 4,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "fig = plt.figure()\n",
    "ax = fig.gca(projection='3d')\n",
    "\n",
    "\n",
    "Xs = np.arange(0.01, 1, 0.01)\n",
    "Ys = np.arange(0.01, 1, 0.01)\n",
    "\n",
    "Xs, Ys = np.meshgrid(Xs, Ys)\n",
    "\n",
    "Z = - (Xs * np.log(Xs) + Ys * np.log(Ys) + (1 - Xs - Ys) * np.log(1 - Xs - Ys))\n",
    "\n",
    "ax.contour(Xs, Ys, Z)\n",
    "# ax.plot_surface(Xs, Ys, Z, cmap=cm.coolwarm, linewidth=0, antialiased=False)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "collapsed": true
   },
   "outputs": [],
   "source": []
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "collapsed": true
   },
   "outputs": [],
   "source": []
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "collapsed": true
   },
   "outputs": [],
   "source": []
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "collapsed": true
   },
   "outputs": [],
   "source": []
  },
  {
   "cell_type": "code",
   "execution_count": 14,
   "metadata": {
    "collapsed": false
   },
   "outputs": [
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      "/projects/btl2/zxue/miniconda3/envs/ml/lib/python3.5/site-packages/ipykernel/__main__.py:30: RuntimeWarning: divide by zero encountered in log\n",
      "/projects/btl2/zxue/miniconda3/envs/ml/lib/python3.5/site-packages/ipykernel/__main__.py:30: RuntimeWarning: invalid value encountered in double_scalars\n"
     ]
    }
   ],
   "source": [
    "res = []\n",
    "p1s = []\n",
    "p2s = []\n",
    "zs = []\n",
    "for p1 in np.arange(0.01, 1, 0.01):\n",
    "    for p2 in np.arange(0.01, 1 - p1, 0.01):\n",
    "        p3 = 1 - p1 - p2\n",
    "        z = - np.sum(p1 * np.log(p1) + p2 * np.log(p2) + p3 * np.log(p3))\n",
    "        p1s.append(p1)\n",
    "        p2s.append(p2)\n",
    "        zs.append(z)\n",
    "\n",
    "p1s = np.array(p1s)\n",
    "p2s = np.array(p2s)\n",
    "zs = np.array(zs)\n",
    "# Y = np.arange(0, X, 0.01)\n",
    "# X, Y = np.meshgrid(X, Y)\n",
    "# Z = np.sum(X * np.log(X) + Y * np.log(Y) + (1 - X - Y) * np.log(1 - X - Y))\n",
    "\n",
    "# # Plot the surface.\n",
    "# surf = ax.plot_surface(X, Y, Z, cmap=cm.coolwarm,\n",
    "#                        linewidth=0, antialiased=False)\n",
    "\n",
    "# # Customize the z axis.\n",
    "# ax.set_zlim(-1.01, 1.01)\n",
    "# ax.zaxis.set_major_locator(LinearLocator(10))\n",
    "# ax.zaxis.set_major_formatter(FormatStrFormatter('%.02f'))\n",
    "\n",
    "# # Add a color bar which maps values to colors.\n",
    "# fig.colorbar(surf, shrink=0.5, aspect=5)\n",
    "\n",
    "# plt.show()"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 15,
   "metadata": {
    "collapsed": false
   },
   "outputs": [
    {
     "data": {
      "text/plain": [
       "(4856,)"
      ]
     },
     "execution_count": 15,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "p1s.shape"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 16,
   "metadata": {
    "collapsed": false
   },
   "outputs": [
    {
     "data": {
      "text/plain": [
       "(4856,)"
      ]
     },
     "execution_count": 16,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "p2s.shape"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 17,
   "metadata": {
    "collapsed": false
   },
   "outputs": [
    {
     "data": {
      "text/plain": [
       "(4856,)"
      ]
     },
     "execution_count": 17,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "zs.shape"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 18,
   "metadata": {
    "collapsed": true
   },
   "outputs": [],
   "source": [
    "X, Y = np.meshgrid(p1s, p2s)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 19,
   "metadata": {
    "collapsed": false
   },
   "outputs": [
    {
     "data": {
      "text/plain": [
       "(4856, 4856)"
      ]
     },
     "execution_count": 19,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "X.shape"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 31,
   "metadata": {
    "collapsed": false
   },
   "outputs": [
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      "/projects/btl2/zxue/miniconda3/envs/ml/lib/python3.5/site-packages/ipykernel/__main__.py:6: RuntimeWarning: divide by zero encountered in log\n",
      "/projects/btl2/zxue/miniconda3/envs/ml/lib/python3.5/site-packages/ipykernel/__main__.py:6: RuntimeWarning: invalid value encountered in multiply\n"
     ]
    },
    {
     "data": {
      "text/plain": [
       "<mpl_toolkits.mplot3d.art3d.Poly3DCollection at 0x7fc448ccbf28>"
      ]
     },
     "execution_count": 31,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": []
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "collapsed": true
   },
   "outputs": [],
   "source": []
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "collapsed": true
   },
   "outputs": [],
   "source": []
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "collapsed": true
   },
   "outputs": [],
   "source": []
  },
  {
   "cell_type": "code",
   "execution_count": 20,
   "metadata": {
    "collapsed": false
   },
   "outputs": [
    {
     "data": {
      "text/plain": [
       "[array([[1, 2],\n",
       "        [1, 2]]), array([[3, 3],\n",
       "        [4, 4]])]"
      ]
     },
     "execution_count": 20,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "np.meshgrid([1, 2], [3, 4])"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "collapsed": true
   },
   "outputs": [],
   "source": []
  }
 ],
 "metadata": {
  "anaconda-cloud": {},
  "kernelspec": {
   "display_name": "Python [default]",
   "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.5.3"
  }
 },
 "nbformat": 4,
 "nbformat_minor": 2
}