02_Speeding_Python.ipynb

{
 "metadata": {
  "name": "02_Speeding_Python"
 },
 "nbformat": 3,
 "nbformat_minor": 0,
 "worksheets": [
  {
   "cells": [
    {
     "cell_type": "markdown",
     "metadata": {},
     "source": [
      "<style>\n",
      "    h1{\n",
      "        text-align:center;\n",
      "    }\n",
      "    h2{\n",
      "        text-align:center;\n",
      "        font-variant:small-caps;\n",
      "    }\n",
      "</style>\n",
      "# Speeding Python\n",
      "# Python in HPC\n",
      "\n",
      "## Supercomputing 2012\n",
      "\n",
      "Presenters: \n",
      "\n",
      "Andy R. Terrel, PhD  \n",
      "Texas Advanced Computing Center  \n",
      "University of Texas at Austin  \n",
      "\n",
      "Travis Oliphant, PhD  \n",
      "Continuum Analytics \n",
      "\n",
      "Aron Ahmadia, PhD  \n",
      "Supercomputing Laboratory  \n",
      "King Abdullah University of Science and Technoglogy \n",
      "\n",
      "[![Creative Commons License](/files/figures/creative_commons_logo.png)](http://creativecommons.org/licenses/by/3.0/deed.en_US)  \n",
      "\n",
      "![TACC Logo](/files/figures/TACC_logo.png)\n",
      "![Continuum Logo](/files/figures/continuum.png)\n",
      "![KAUST Logo](/files/figures/kaust.png)\n",
      "\n",
      "<script>\n",
      "var bind_remote = function(selector){\n",
      "    var cc = $('<input/>')\n",
      "        .attr('id','azerty')\n",
      "        .fadeTo(0.2,0)\n",
      "        .keydown(\n",
      "        function(event){\n",
      "                if(event.which == IPython.utils.keycodes.LEFT_ARROW){\n",
      "                    console.log('go left');\n",
      "                    IPython.slideshow.prev();\n",
      "                }\n",
      "                else if(event.which == IPython.utils.keycodes.RIGHT_ARROW){\n",
      "                    console.log('go right')\n",
      "                    IPython.slideshow.next();   \n",
      "                }\n",
      "            event.preventDefault();\n",
      "            return false;\n",
      "            })\n",
      "            .focusin(function(){$('#qwerty').button('option','label','Slide Mode Enabled')})\n",
      "            .focusout(function(){$('#qwerty').button('option','label','Enable Slide Mode')})\n",
      "        \n",
      "        var dd = $('<div/>')\n",
      "            .attr('id','qwerty')\n",
      "            .button({label:'slide control'})\n",
      "            .attr('style','float:right')\n",
      "            .click(\n",
      "                function(){\n",
      "                    $('#azerty').focus();\n",
      "                    console.log('...');\n",
      "                })\n",
      "            .keydown(\n",
      "                function(event){\n",
      "                    console.log('event append',event);\n",
      "                event.preventDefault();\n",
      "                return false;\n",
      "                })\n",
      "    var hin = function(){$(selector).fadeTo('slow',1);}\n",
      "    var hout= function(){$(selector).fadeTo('slow',0.3);}        \n",
      "    $(selector)\n",
      "        .append(cc)\n",
      "        .append(dd)\n",
      "        .fadeTo('slow',0.3)\n",
      "    .hover(hin,hout)\n",
      "     \n",
      "}\n",
      "</script>   "
     ]
    },
    {
     "cell_type": "markdown",
     "metadata": {},
     "source": [
      "---\n",
      "\n",
      "## About This Tutorial\n",
      "\n",
      "### PyHPC Tutorial on GitHub\n",
      "\n",
      "These presentation materials are part of a continuously updated tutorial on Python for High Performance Computing.  To get the presentation materials as they were delivered today, please use the SC2012 tag on github.  Future versions of this presentation will be found at:\n",
      "\n",
      "https://github.com/pyhpc/pyhpc-tutorial\n",
      "\n",
      "Please set all permanent bookmarks to this URL.\n",
      "\n",
      "### Direct download of this SC2012 presentation\n",
      "You can download a zip or tar ball from the [github SC2012 tag](https://github.com/pyHPC/pyhpc-tutorial/tags):\n",
      "\n",
      "```\n",
      "wget --no-check-certificate https://github.com/pyhpc/pyhpc-tutorial/zipball/SC2012\n",
      "wget --no-check-certificate https://github.com/pyhpc/pyhpc-tutorial/tarball/SC2012\n",
      "```\n",
      "\n",
      "### \n",
      "2) Checkout from git\n",
      "\n",
      "```\n",
      "git clone https://github.com/pyhpc/pyhpc-tutorial.git\n",
      "```\n",
      "\n",
      "### Viewing the read-only version of this presentation on nbviewer: \n",
      "\n",
      "* http://nbviewer.ipython.org/urls/raw.github.com/pyhpc/pyhpc-tutorial/master/02_Speeding_Python.ipynb"
     ]
    },
    {
     "cell_type": "markdown",
     "metadata": {},
     "source": [
      "--- \n",
      "\n",
      "## Using the Texas Advanced Computing Center IPython Notebooks\n",
      "\n",
      "You will need a modern web browser to interact with the TACC nodes, there are no other requirements.\n",
      "\n",
      "### TACC IPython Notebooks\n",
      "* http://pyhpc01.tacc.utexas.edu/\n",
      "* http://pyhpc02.tacc.utexas.edu/\n",
      "* http://pyhpc03.tacc.utexas.edu/\n",
      "* http://pyhpc04.tacc.utexas.edu/\n",
      "* http://pyhpc05.tacc.utexas.edu/\n",
      "* http://pyhpc06.tacc.utexas.edu/\n",
      "* http://pyhpc07.tacc.utexas.edu/\n",
      "* http://pyhpc08.tacc.utexas.edu/\n",
      "* http://pyhpc09.tacc.utexas.edu/\n",
      "* http://pyhpc10.tacc.utexas.edu/\n",
      "\n",
      "The TACC nodes will not be available after this workshop, please contact the presenters for more permanent hosting solutions."
     ]
    },
    {
     "cell_type": "markdown",
     "metadata": {},
     "source": [
      "---\n",
      "\n",
      "## Interacting with the Tutorial Slides\n",
      "\n",
      "This tutorial is an interactive worksheet designed to encourage you to try out the lessons during the demonstration.  If you are looking at the PDF version of these slides, we encourage you to download the updated version (see previous slide) and try the interactive version.\n",
      "\n",
      "To run the interactive version of this notebook, you will need a Python 2.7 environment including: \n",
      "\n",
      "* IPython version >= 13.0\n",
      "* numpy version >= 1.6\n",
      "* scipy >= 0.10\n",
      "* matplotlib >= 1.0.0\n",
      "\n",
      "Move to the directory containing the tarball and execute:\n",
      "\n",
      "    $ ipython notebook --pylab=inline\n",
      "\n",
      "If you are installing the packages yourself, Continuum Analytics (disclaimer, Travis Oliphant is CEO of this company) provides both free community as well as professional versions of the Anaconda installer, which provides all the packages you will need for this portion of the tutorial. The installer is available from the [Anaconda download page at Continuum Analytics](https://store.continuum.io/cshop/anaconda).\n",
      "\n",
      "You are also welcome to use Enthought's Python Distribution (free for Academic users), available from the [EPD download page at Enthought](http://www.enthought.com/products/epd.php).\n",
      "\n",
      "Unfortunately, you will need to upgrade your EPD's IPython to 0.13 if you go this route, and this may be non-trivial, please see the [Enthought discussion thread here](https://mail.enthought.com/pipermail/epd-users/2012-August/000800.html)."
     ]
    },
    {
     "cell_type": "markdown",
     "metadata": {},
     "source": [
      "---\n",
      "## Presentation mode\n",
      "The slideshow mode is only supported by an IPython development branch version. If you would like to write your own slideshows (the notebooks will work regardless of slideshow capabilities), you will need to install Matthias Bussonnier's slideshow_metadata branch.  Here are some sample command-line instructions.\n",
      "\n",
      "    #!/bin/bash\n",
      "    git clone carreau git://github.com/Carreau/ipython.git # Matthias' IPython fork\n",
      "    git checkout origin/slideshow_metadata                 # Select the right branch\n",
      "    python setup.py develop                                # Install the development version\n",
      "    ipython notebook                                       # Check out the slideshows!"
     ]
    },
    {
     "cell_type": "markdown",
     "metadata": {},
     "source": [
      "---\n",
      "## Slideshow Setup Code"
     ]
    },
    {
     "cell_type": "code",
     "collapsed": false,
     "input": [
      "# The below command starts pylab inline mode, which simplifies syntax for many common \n",
      "# scientific computing commands.  All commands starting with % are IPython extensions.\n",
      "%pylab inline\n",
      "\n",
      "import numpy as np\n",
      "import scipy as sp\n",
      "\n",
      "# The following two lines of code load the slideshow extension and start it,\n",
      "# you only need to run these if you are writing or running your own slideshow\n",
      "\n",
      "%load_ext slidemode\n",
      "%slideshow_mode"
     ],
     "language": "python",
     "metadata": {},
     "outputs": [
      {
       "output_type": "stream",
       "stream": "stdout",
       "text": [
        "\n",
        "Welcome to pylab, a matplotlib-based Python environment [backend: module://IPython.zmq.pylab.backend_inline].\n",
        "For more information, type 'help(pylab)'.\n"
       ]
      },
      {
       "javascript": [
        "\n",
        "var bind_remote = function(selector){\n",
        "    var cc = $('<input/>')\n",
        "        .attr('id','azerty')\n",
        "        .fadeTo(0.2,0)\n",
        "        .keydown(\n",
        "        function(event){\n",
        "                if(event.which == IPython.utils.keycodes.LEFT_ARROW){\n",
        "                    console.log('go left');\n",
        "                    IPython.slideshow.prev();\n",
        "                }\n",
        "                else if(event.which == IPython.utils.keycodes.RIGHT_ARROW){\n",
        "                    console.log('go right')\n",
        "                    IPython.slideshow.next();   \n",
        "                }\n",
        "            event.preventDefault();\n",
        "            return false;\n",
        "            })\n",
        "            .focusin(function(){$('#qwerty').button('option','label','Slide Control Enabled')})\n",
        "            .focusout(function(){$('#qwerty').button('option','label','Enable Slide Control')})\n",
        "        \n",
        "        var dd = $('<div/>')\n",
        "            .attr('id','qwerty')\n",
        "            .button({label:'Enable Slide Control'})\n",
        "            .attr('style','float:right')\n",
        "            .click(\n",
        "                function(){\n",
        "                    $('#azerty').focus();\n",
        "                    console.log('...');\n",
        "                })\n",
        "            .keydown(\n",
        "                function(event){\n",
        "                    console.log('event append',event);\n",
        "                event.preventDefault();\n",
        "                return false;\n",
        "                })\n",
        "    var hin = function(){$(selector).fadeTo('slow',1);}\n",
        "    var hout= function(){$(selector).fadeTo('slow',0.3);}        \n",
        "    $(selector)\n",
        "        .append(cc)\n",
        "        .append(dd)\n",
        "        .fadeTo('slow',0.3)\n",
        "    .hover(hin,hout)\n",
        "     \n",
        "}\n",
        "    \n",
        "var show_line = function(cell,line_number){\n",
        "    cell.code_mirror.showLine(cell.code_mirror.getLineHandle(line_number-1))    }\n",
        "\n",
        "    IPython = (function(IPython) {\n",
        "    \n",
        "    var Presentation = function(){\n",
        "          this.ccell = 0;\n",
        "      }\n",
        "\n",
        "      var is_marked_cell = function(cell){\n",
        "          return (cell.code_mirror.getValue().match(/(\\n)?(<!--|#)?====(-->)?(\\n)?/) != null)\n",
        "      }\n",
        "      Presentation.prototype.create_toolbar = function(){\n",
        "            var pt = $('<div/>').attr('id','toolbar_present').addClass('toolbar');\n",
        "            var that = this;\n",
        "            this.avc = $('<div/>').button({label:that.eta()});\n",
        "            pt.append(this.avc);\n",
        "\n",
        "            $('#toolbar').after(pt);\n",
        "            var ptoolbar = new IPython.ToolBar('#toolbar_present');\n",
        "            IPython.ptoolbar = ptoolbar;\n",
        "            ptoolbar.addButtonsGroup([{label:'Stop', icon:'ui-icon-stop', callback:function(){that.stop()}}])\n",
        "            ptoolbar.addButtonsGroup([\n",
        "                     {label:'Restart from 0', icon:'ui-icon-arrowthickstop-1-w', callback:function(){that.stop(); that.restart(); that.start()}}\n",
        "                     ])\n",
        "            ptoolbar.addButtonsGroup([\n",
        "                     {label:'Prev Slide', icon:'ui-icon-seek-prev', callback:function(){that.prev_group()}},\n",
        "                     {label:'Next Slide', icon:'ui-icon-seek-next', callback:function(){that.next_group()}},\n",
        "                                    ])\n",
        "            ptoolbar.addButtonsGroup([\n",
        "                     {label:'Step Next', icon:'ui-icon-play', callback:function(){that.next()}}\n",
        "                     ])\n",
        "            bind_remote('#toolbar_present');\n",
        "\n",
        "      }\n",
        "\n",
        "      Presentation.prototype.remove_toolbar = function(){\n",
        "          $('#toolbar_present').remove();\n",
        "      }\n",
        "\n",
        "      Presentation.prototype.ngroups = function(){\n",
        "          var cells = IPython.notebook.get_cells();\n",
        "          var cnt =0\n",
        "          for( var i=0; i< cells.length;i++)\n",
        "              if(is_marked_cell(cells[i])) cnt++;\n",
        "          return cnt\n",
        "      }\n",
        "\n",
        "      Presentation.prototype.cgroups = function(){\n",
        "          var cells = IPython.notebook.get_cells();\n",
        "          var cnt =0\n",
        "          for( var i=0; i<= this.ccell ;i++)\n",
        "              if(is_marked_cell(cells[i])) cnt++;\n",
        "          return cnt\n",
        "      }\n",
        "\n",
        "      Presentation.prototype.eta = function(){\n",
        "          return this.cgroups()+'/'+this.ngroups()\n",
        "          }\n",
        "\n",
        "      Presentation.prototype.next_marked_cell_n = function()\n",
        "      {\n",
        "          for(var i=this.ccell+1; i< $('.cell').length; i++)\n",
        "          {\n",
        "              if(is_marked_cell(IPython.notebook.get_cell(i)))\n",
        "                { return i; }\n",
        "          }\n",
        "          return null;\n",
        "      }\n",
        "\n",
        "      Presentation.prototype.prev_marked_cell_n = function()\n",
        "      {\n",
        "          for(var i=this.ccell-1; i> 0; i--)\n",
        "          {\n",
        "              if(is_marked_cell(IPython.notebook.get_cell(i))){\n",
        "                 return i\n",
        "              }\n",
        "          }\n",
        "          return 0;\n",
        "      }\n",
        "\n",
        "      Presentation.prototype.start = function(){\n",
        "          this.restart();\n",
        "          this.resume();\n",
        "      }\n",
        "\n",
        "      Presentation.prototype.restart = function(){\n",
        "          this.ccell = 0;\n",
        "          $(this.avc).remove();\n",
        "          delete this.avc;\n",
        "      }\n",
        "\n",
        "      Presentation.prototype.resume = function(){\n",
        "          this.create_toolbar();\n",
        "          $('#menubar, #pager_splitter, #pager, #header,#toolbar').addClass('pmode');\n",
        "          $('.cell').fadeOut();\n",
        "          if(this.current_is_marked()){\n",
        "              $('.cell:nth('+this.ccell+')').fadeIn();\n",
        "          } else {\n",
        "              for( var i=this.prev_marked_cell_n() ; i<= this.ccell; i++){\n",
        "                  $('.cell:nth('+i+')').fadeIn();\n",
        "              }\n",
        "          }\n",
        "          var that=this;\n",
        "          if(this.avc != undefined)\n",
        "            $(this.avc).button('option','label',that.eta())\n",
        "          return this;\n",
        "      }\n",
        "\n",
        "      Presentation.prototype.stop = function(){\n",
        "          $('.cell').fadeIn();\n",
        "          $('.pmode').removeClass('pmode');\n",
        "          $('div#notebook').removeClass('pove');\n",
        "          this.remove_toolbar();\n",
        "      }\n",
        "\n",
        "      Presentation.prototype.next = function(){\n",
        "          this.ccell = this.ccell+1;\n",
        "          var that = this;\n",
        "          if(this.ccell >= $('.cell').length ){\n",
        "              this.restart();\n",
        "              this.stop();\n",
        "              return;\n",
        "          }\n",
        "          var nnext = this.ccell;\n",
        "          var ncell = IPython.notebook.get_cell(nnext)\n",
        "\n",
        "          if(is_marked_cell(ncell)){\n",
        "              $('.cell').fadeOut(500);\n",
        "              setTimeout(function(){$('.cell:nth('+nnext+')').fadeIn(500)},600);\n",
        "          } else {\n",
        "              setTimeout(function(){$('.cell:nth('+nnext+')').fadeIn(500)},0);\n",
        "          }\n",
        "          $(this.avc).button('option','label',that.eta())\n",
        "          return this;\n",
        "      }\n",
        "\n",
        "      Presentation.prototype.next_group = function(){\n",
        "          this.ccell = this.next_marked_cell_n();\n",
        "          var that = this;\n",
        "          $('.cell').fadeOut(500);\n",
        "          setTimeout(function(){\n",
        "              $('.cell:nth('+that.ccell+')').fadeIn(500)\n",
        "                  },600);\n",
        "          $(this.avc).button('option','label',that.eta())\n",
        "      }\n",
        "\n",
        "      Presentation.prototype.prev_group = function(){\n",
        "          this.ccell = this.prev_marked_cell_n();\n",
        "          var that = this\n",
        "          $('.cell').fadeOut(500);\n",
        "          setTimeout(function(){$('.cell:nth('+that.ccell+')').fadeIn(500)},600);\n",
        "          $(this.avc).button('option','label',that.eta())\n",
        "      }\n",
        "\n",
        "      Presentation.prototype.is_n_marked = function(n){\n",
        "          return is_marked_cell(IPython.notebook.get_cell(n))\n",
        "      }\n",
        "\n",
        "      Presentation.prototype.current_is_marked = function(n){\n",
        "          return is_marked_cell(IPython.notebook.get_cell(this.ccell));\n",
        "      }\n",
        "\n",
        "      Presentation.prototype.prev = function(){\n",
        "          if(is_marked_cell(IPython.notebook.get_cell(this.ccell))){\n",
        "              var pmcell = this.prev_marked_cell_n();\n",
        "              $('.cell').fadeOut(500);\n",
        "              for( var i=pmcell; i< this.ccell ; i++ ){\n",
        "                  (function(val){\n",
        "                      return function(){\n",
        "                                  setTimeout( function(){\n",
        "                                      $('.cell:nth('+val+')').fadeIn(500)\n",
        "                                      },600);\n",
        "                      }\n",
        "                   })(i)();\n",
        "              }\n",
        "          } else {\n",
        "              $('.cell:nth('+this.ccell+')').fadeOut(500);\n",
        "          }\n",
        "          this.ccell = this.ccell -1;\n",
        "          return this;\n",
        "      }\n",
        "\n",
        "      IPython.Presentation = Presentation;\n",
        "      return IPython;\n",
        "\n",
        "    })(IPython);\n",
        "\n",
        "    $('body').append($('<style/>').text('.pmode{ display: none !important }'));\n",
        "    IPython.slideshow = new IPython.Presentation();\n",
        "\n",
        "    var sid = 'start_pmode'\n",
        "    if(($('#'+sid)).length == 0) {\n",
        "          IPython.toolbar.addButtonsGroup([\n",
        "                  {'label'  :'Start Slideshow',\n",
        "                    'icon'  :'ui-icon-image',\n",
        "                    'callback':function(){IPython.slideshow.resume()},'id':sid},\n",
        "              ])\n",
        "         }\n"
       ],
       "output_type": "display_data",
       "text": [
        "<IPython.core.display.Javascript at 0x2b255d0>"
       ]
      }
     ],
     "prompt_number": 1
    },
    {
     "cell_type": "markdown",
     "metadata": {},
     "source": [
      "---\n",
      "## How Slow is Python\n",
      "<!--====-->\n",
      "\n",
      "Let's add one to a million number"
     ]
    },
    {
     "cell_type": "code",
     "collapsed": false,
     "input": [
      "lst = range(1000000) # A pure Python list\n",
      "%timeit [i + 1 for i in lst] # A Python list comprehension (iteration happens in C but with PyObjects)"
     ],
     "language": "python",
     "metadata": {},
     "outputs": [
      {
       "output_type": "stream",
       "stream": "stdout",
       "text": [
        "10 loops, best of 3: 60.8 ms per loop\n"
       ]
      }
     ],
     "prompt_number": 2
    },
    {
     "cell_type": "markdown",
     "metadata": {},
     "source": [
      "---\n",
      "##Why is Python Slow?\n",
      "<!--====-->\n",
      "\n",
      "Dynamic typing requires lots of metadata around variable. \n",
      "\n",
      "* Python uses heavy frame objects during iteration\n",
      "\n",
      "### Solution:\n",
      "* Make an object that has a single type and continuous storage.\n",
      "* Implement common functionality into that object to iterate in C."
     ]
    },
    {
     "cell_type": "code",
     "collapsed": false,
     "input": [
      "arr = np.arange(1000000) # A NumPy list of integers\n",
      "%timeit arr + 1 # Use operator overloading for nice syntax, now iteration is in C with ints"
     ],
     "language": "python",
     "metadata": {},
     "outputs": [
      {
       "output_type": "stream",
       "stream": "stdout",
       "text": [
        "100 loops, best of 3: 2.06 ms per loop\n"
       ]
      }
     ],
     "prompt_number": 3
    },
    {
     "cell_type": "markdown",
     "metadata": {},
     "source": [
      "---\n",
      "## What makes NumPy so much faster?\n",
      "<!--====-->\n",
      "\n",
      "* Data layout\n",
      "  * homogenous: every item takes up the same size block of memory\n",
      "  * single data-type objects\n",
      "  * powerful array scalar types\n",
      "\n",
      "* universal function (ufuncs)\n",
      "  * function that operates on ndarrays in an element-by-element fashion\n",
      "  * vectorized wrapper for a function\n",
      "  * built-in functions are implemented in compiled C code"
     ]
    },
    {
     "cell_type": "markdown",
     "metadata": {},
     "source": [
      "---\n",
      "## Numpy Data layout\n",
      "<!--====-->\n",
      "\n",
      "* homogenous: every item takes up the same size block of memory\n",
      "* single data-type objects\n",
      "* powerful array scalar types\n",
      "\n",
      "![three fundamental](/files/figures/numpy/threefundamental.png)\n",
      "\n"
     ]
    },
    {
     "cell_type": "markdown",
     "metadata": {},
     "source": [
      "---\n",
      "## Numpy Universal Functions (ufuncs)\n",
      "<!--====-->\n",
      "\n",
      "* function that operates on ndarrays in an element-by-element fashion\n",
      "* vectorized wrapper for a function\n",
      "* built-in functions are implemented in compiled C code"
     ]
    },
    {
     "cell_type": "code",
     "collapsed": false,
     "input": [
      "%timeit [sin(i)**2 for i in arr]\n"
     ],
     "language": "python",
     "metadata": {},
     "outputs": [
      {
       "output_type": "stream",
       "stream": "stdout",
       "text": [
        "1 loops, best of 3: 4.39 s per loop\n"
       ]
      }
     ],
     "prompt_number": 4
    },
    {
     "cell_type": "code",
     "collapsed": false,
     "input": [
      "%timeit np.sin(arr)**2"
     ],
     "language": "python",
     "metadata": {},
     "outputs": [
      {
       "output_type": "stream",
       "stream": "stdout",
       "text": [
        "10 loops, best of 3: 54.9 ms per loop\n"
       ]
      }
     ],
     "prompt_number": 5
    },
    {
     "cell_type": "markdown",
     "metadata": {},
     "source": [
      "---\n",
      "## Other Numpy Features to be aware of\n",
      "<!--====-->\n",
      "\n",
      "* Reshaping"
     ]
    },
    {
     "cell_type": "code",
     "collapsed": false,
     "input": [
      "arr2 = arr.reshape((10,100000))\n",
      "print(arr2)"
     ],
     "language": "python",
     "metadata": {},
     "outputs": [
      {
       "output_type": "stream",
       "stream": "stdout",
       "text": [
        "[[     0      1      2 ...,  99997  99998  99999]\n",
        " [100000 100001 100002 ..., 199997 199998 199999]\n",
        " [200000 200001 200002 ..., 299997 299998 299999]\n",
        " ..., \n",
        " [700000 700001 700002 ..., 799997 799998 799999]\n",
        " [800000 800001 800002 ..., 899997 899998 899999]\n",
        " [900000 900001 900002 ..., 999997 999998 999999]]\n"
       ]
      }
     ],
     "prompt_number": 6
    },
    {
     "cell_type": "markdown",
     "metadata": {},
     "source": [
      "* Memory Views"
     ]
    },
    {
     "cell_type": "code",
     "collapsed": false,
     "input": [
      "arr2.view?"
     ],
     "language": "python",
     "metadata": {},
     "outputs": [],
     "prompt_number": 7
    },
    {
     "cell_type": "markdown",
     "metadata": {},
     "source": [
      "* Index Slicing"
     ]
    },
    {
     "cell_type": "code",
     "collapsed": false,
     "input": [
      "x = np.arange(0, 20, 2); y = x**2\n",
      "((y[1:] - y[:-1]) / (x[1:] - x[:-1])) # dy/dx"
     ],
     "language": "python",
     "metadata": {},
     "outputs": [
      {
       "output_type": "pyout",
       "prompt_number": 8,
       "text": [
        "array([ 2,  6, 10, 14, 18, 22, 26, 30, 34])"
       ]
      }
     ],
     "prompt_number": 8
    },
    {
     "cell_type": "markdown",
     "metadata": {},
     "source": [
      "* Fancy Indexing"
     ]
    },
    {
     "cell_type": "code",
     "collapsed": false,
     "input": [
      "evens = arr[arr%2 == 0]\n",
      "print(evens)"
     ],
     "language": "python",
     "metadata": {},
     "outputs": [
      {
       "output_type": "stream",
       "stream": "stdout",
       "text": [
        "[     0      2      4 ..., 999994 999996 999998]\n"
       ]
      }
     ],
     "prompt_number": 9
    },
    {
     "cell_type": "markdown",
     "metadata": {},
     "source": [
      "---\n",
      "## Compiling to C\n",
      "<!--====-->\n",
      "\n",
      "C is faster, and Python is easier to write.  We want both!\n",
      "\n",
      "## Cython\n",
      "* a programming language based on Python\n",
      "* uses extra syntax allowing for optional static type declarations\n",
      "* source code gets translated into optimized C/C++ code and compiled as Python extension modules\n"
     ]
    },
    {
     "cell_type": "markdown",
     "metadata": {},
     "source": [
      "---\n",
      "## Using Cython in IPython\n",
      "<!--====-->\n",
      "\n",
      "In IPython we can make any cell call out to Cython via the cell magic\n",
      "\n",
      "First load the extension"
     ]
    },
    {
     "cell_type": "code",
     "collapsed": false,
     "input": [
      "%load_ext cythonmagic"
     ],
     "language": "python",
     "metadata": {},
     "outputs": [],
     "prompt_number": 10
    },
    {
     "cell_type": "markdown",
     "metadata": {},
     "source": [
      "Now use `%%cython` at the begining of a code cell to call out to Cython."
     ]
    },
    {
     "cell_type": "code",
     "collapsed": false,
     "input": [
      "%%cython\n",
      "def f_cython(int i):\n",
      "    return i**4 + 3*i**2 + 10"
     ],
     "language": "python",
     "metadata": {},
     "outputs": [],
     "prompt_number": 11
    },
    {
     "cell_type": "markdown",
     "metadata": {},
     "source": [
      "Now use Cython function in code:"
     ]
    },
    {
     "cell_type": "code",
     "collapsed": false,
     "input": [
      "f_cython(100)"
     ],
     "language": "python",
     "metadata": {},
     "outputs": [
      {
       "output_type": "pyout",
       "prompt_number": 12,
       "text": [
        "100030010"
       ]
      }
     ],
     "prompt_number": 12
    },
    {
     "cell_type": "markdown",
     "metadata": {},
     "source": [
      "---\n",
      "\n",
      "## How much faster is Cython?\n",
      "<!--====-->\n",
      "\n",
      "The more you are able to provide type information the better the compile. For example f without type information:"
     ]
    },
    {
     "cell_type": "code",
     "collapsed": false,
     "input": [
      "%%cython\n",
      "def f_slow(i):\n",
      "    return i**4 + 3*i**2 + 10"
     ],
     "language": "python",
     "metadata": {},
     "outputs": [],
     "prompt_number": 13
    },
    {
     "cell_type": "code",
     "collapsed": false,
     "input": [
      "%timeit f_slow(100)"
     ],
     "language": "python",
     "metadata": {},
     "outputs": [
      {
       "output_type": "stream",
       "stream": "stdout",
       "text": [
        "1000000 loops, best of 3: 230 ns per loop\n"
       ]
      }
     ],
     "prompt_number": 14
    },
    {
     "cell_type": "code",
     "collapsed": false,
     "input": [
      "%timeit f_cython(100)"
     ],
     "language": "python",
     "metadata": {},
     "outputs": [
      {
       "output_type": "stream",
       "stream": "stdout",
       "text": [
        "10000000 loops, best of 3: 79.9 ns per loop\n"
       ]
      }
     ],
     "prompt_number": 15
    },
    {
     "cell_type": "markdown",
     "metadata": {},
     "source": [
      "---\n",
      "## Declaring Cython variables for C level\n",
      "<!--====-->\n",
      "\n",
      "If you use a variable or function only at the Cython level you can keep it in C via `cdef`:"
     ]
    },
    {
     "cell_type": "code",
     "collapsed": false,
     "input": [
      "%%cython\n",
      "cdef f(double x):\n",
      "    return x**2-x\n",
      "\n",
      "def integrate_f(double a, double b, int N):\n",
      "    cdef int i\n",
      "    cdef double s, dx\n",
      "    s = 0\n",
      "    dx = (b-a)/N\n",
      "    for i in range(N):\n",
      "        s += f(a+i*dx)\n",
      "    return s * dx"
     ],
     "language": "python",
     "metadata": {},
     "outputs": [],
     "prompt_number": 16
    },
    {
     "cell_type": "code",
     "collapsed": false,
     "input": [
      "%timeit integrate_f(1.0, 2.0, 1000)"
     ],
     "language": "python",
     "metadata": {},
     "outputs": [
      {
       "output_type": "stream",
       "stream": "stdout",
       "text": [
        "10000 loops, best of 3: 40.2 us per loop\n"
       ]
      }
     ],
     "prompt_number": 17
    },
    {
     "cell_type": "markdown",
     "metadata": {},
     "source": [
      "The pure Python version:"
     ]
    },
    {
     "cell_type": "code",
     "collapsed": false,
     "input": [
      "def f(x):\n",
      "    return x**2-x\n",
      "\n",
      "def integrate_f(a, b, N):\n",
      "    s = 0\n",
      "    dx = (b-a)/N\n",
      "    for i in range(N):\n",
      "        s += f(a+i*dx)\n",
      "    return s * dx"
     ],
     "language": "python",
     "metadata": {},
     "outputs": [],
     "prompt_number": 18
    },
    {
     "cell_type": "code",
     "collapsed": false,
     "input": [
      "%timeit integrate_f(1.0, 2.0, 1000)"
     ],
     "language": "python",
     "metadata": {},
     "outputs": [
      {
       "output_type": "stream",
       "stream": "stdout",
       "text": [
        "1000 loops, best of 3: 404 us per loop\n"
       ]
      }
     ],
     "prompt_number": 19
    },
    {
     "cell_type": "markdown",
     "metadata": {},
     "source": [
      "---\n",
      "## Using NumPy with Cython\n",
      "<!--====-->\n",
      "\n",
      "You can also use fast accessors to NumPy arrays from Cython:"
     ]
    },
    {
     "cell_type": "code",
     "collapsed": false,
     "input": [
      "%%cython\n",
      "import numpy as np\n",
      "# \"cimport\" is used to import special compile-time information\n",
      "# about the numpy module (this is stored in a file numpy.pxd which is\n",
      "# currently part of the Cython distribution).\n",
      "cimport numpy as np\n",
      "# We now need to fix a datatype for our arrays. I've used the variable\n",
      "# DTYPE for this, which is assigned to the usual NumPy runtime\n",
      "# type info object.\n",
      "DTYPE = np.int\n",
      "# \"ctypedef\" assigns a corresponding compile-time type to DTYPE_t. For\n",
      "# every type in the numpy module there's a corresponding compile-time\n",
      "# type with a _t-suffix.\n",
      "ctypedef np.int_t DTYPE_t\n",
      "# \"def\" can type its arguments but not have a return type. The type of the\n",
      "# arguments for a \"def\" function is checked at run-time when entering the\n",
      "# function.\n",
      "#\n",
      "# The arrays f, g and h is typed as \"np.ndarray\" instances. The only effect\n",
      "# this has is to a) insert checks that the function arguments really are\n",
      "# NumPy arrays, and b) make some attribute access like f.shape[0] much\n",
      "# more efficient. (In this example this doesn't matter though.)\n",
      "def naive_convolve(np.ndarray f, np.ndarray g):\n",
      "    if g.shape[0] % 2 != 1 or g.shape[1] % 2 != 1:\n",
      "        raise ValueError(\"Only odd dimensions on filter supported\")\n",
      "    assert f.dtype == DTYPE and g.dtype == DTYPE\n",
      "    # The \"cdef\" keyword is also used within functions to type variables. It\n",
      "    # can only be used at the top indendation level (there are non-trivial\n",
      "    # problems with allowing them in other places, though we'd love to see\n",
      "    # good and thought out proposals for it).\n",
      "    #\n",
      "    # For the indices, the \"int\" type is used. This corresponds to a C int,\n",
      "    # other C types (like \"unsigned int\") could have been used instead.\n",
      "    # Purists could use \"Py_ssize_t\" which is the proper Python type for\n",
      "    # array indices.\n",
      "    cdef int vmax = f.shape[0]\n",
      "    cdef int wmax = f.shape[1]\n",
      "    cdef int smax = g.shape[0]\n",
      "    cdef int tmax = g.shape[1]\n",
      "    cdef int smid = smax // 2\n",
      "    cdef int tmid = tmax // 2\n",
      "    cdef int xmax = vmax + 2*smid\n",
      "    cdef int ymax = wmax + 2*tmid\n",
      "    cdef np.ndarray h = np.zeros([xmax, ymax], dtype=DTYPE)\n",
      "    cdef int x, y, s, t, v, w\n",
      "    # It is very important to type ALL your variables. You do not get any\n",
      "    # warnings if not, only much slower code (they are implicitly typed as\n",
      "    # Python objects).\n",
      "    cdef int s_from, s_to, t_from, t_to\n",
      "    # For the value variable, we want to use the same data type as is\n",
      "    # stored in the array, so we use \"DTYPE_t\" as defined above.\n",
      "    # NB! An important side-effect of this is that if \"value\" overflows its\n",
      "    # datatype size, it will simply wrap around like in C, rather than raise\n",
      "    # an error like in Python.\n",
      "    cdef DTYPE_t value\n",
      "    for x in range(xmax):\n",
      "        for y in range(ymax):\n",
      "            s_from = max(smid - x, -smid)\n",
      "            s_to = min((xmax - x) - smid, smid + 1)\n",
      "            t_from = max(tmid - y, -tmid)\n",
      "            t_to = min((ymax - y) - tmid, tmid + 1)\n",
      "            value = 0\n",
      "            for s in range(s_from, s_to):\n",
      "                for t in range(t_from, t_to):\n",
      "                    v = x - smid + s\n",
      "                    w = y - tmid + t\n",
      "                    value += g[smid - s, tmid - t] * f[v, w]\n",
      "            h[x, y] = value\n",
      "    return h"
     ],
     "language": "python",
     "metadata": {},
     "outputs": [],
     "prompt_number": 20
    },
    {
     "cell_type": "code",
     "collapsed": false,
     "input": [
      "N=100\n",
      "f = np.arange(N*N, dtype=np.int).reshape((N,N))\n",
      "g = np.arange(81, dtype=np.int).reshape((9, 9))\n",
      "%timeit -n2 -r3 naive_convolve(f, g)"
     ],
     "language": "python",
     "metadata": {},
     "outputs": [
      {
       "output_type": "stream",
       "stream": "stdout",
       "text": [
        "2 loops, best of 3: 1.16 s per loop\n"
       ]
      }
     ],
     "prompt_number": 21
    },
    {
     "cell_type": "markdown",
     "metadata": {},
     "source": [
      "---\n",
      "# Numba -- A Python Compiler for Numpy arrays\n",
      "<!--===-->\n",
      "\n"
     ]
    },
    {
     "cell_type": "code",
     "collapsed": false,
     "input": [
      "import numpy as np\n",
      "from numba import autojit, jit, double"
     ],
     "language": "python",
     "metadata": {},
     "outputs": [],
     "prompt_number": 2
    },
    {
     "cell_type": "markdown",
     "metadata": {},
     "source": [
      "Numba provides two major decorators:  `jit` and `autojit`.  \n",
      "\n",
      "The `jit` decorator returns a compiled version of the function using the input types and the output types of the function.   You can specify the type using `out_type(in_type, ...)` syntax.  Array inputs can be specified using `[:,:]` appended to the type.  \n",
      "\n",
      "The `autojit` decorator does not require you to specify any types.  It watches for what types you call the function with and infers the type of the return.  If there is a previously compiled version of the code available it uses it, if not it generates machine code for the function and then executes that code. "
     ]
    },
    {
     "cell_type": "code",
     "collapsed": false,
     "input": [
      "def sum(arr):\n",
      "    M, N = arr.shape\n",
      "    sum = 0.0\n",
      "    for i in range(M):\n",
      "        for j in range(N):\n",
      "            sum += arr[i,j]\n",
      "    return sum\n",
      "fastsum = jit('f8(f8[:,:])')(sum)\n",
      "flexsum = autojit(sum)"
     ],
     "language": "python",
     "metadata": {},
     "outputs": [],
     "prompt_number": 23
    },
    {
     "cell_type": "code",
     "collapsed": false,
     "input": [
      "arr2d = np.arange(600,dtype=float).reshape(20,30)\n",
      "print sum(arr2d)\n",
      "print fastsum(arr2d)\n",
      "print flexsum(arr2d)\n",
      "print flexsum(arr2d.astype(int))"
     ],
     "language": "python",
     "metadata": {},
     "outputs": [
      {
       "output_type": "stream",
       "stream": "stdout",
       "text": [
        "179700.0\n",
        "179700.0\n",
        "179700.0\n",
        "179700.0\n"
       ]
      }
     ],
     "prompt_number": 24
    },
    {
     "cell_type": "code",
     "collapsed": false,
     "input": [
      "%timeit sum(arr2d)"
     ],
     "language": "python",
     "metadata": {},
     "outputs": [
      {
       "output_type": "stream",
       "stream": "stdout",
       "text": [
        "1000 loops, best of 3: 320 us per loop\n"
       ]
      }
     ],
     "prompt_number": 25
    },
    {
     "cell_type": "code",
     "collapsed": false,
     "input": [
      "%timeit fastsum(arr2d)"
     ],
     "language": "python",
     "metadata": {},
     "outputs": [
      {
       "output_type": "stream",
       "stream": "stdout",
       "text": [
        "100000 loops, best of 3: 2.24 us per loop\n"
       ]
      }
     ],
     "prompt_number": 26
    },
    {
     "cell_type": "code",
     "collapsed": false,
     "input": [
      "321 / 2.26 # speedup"
     ],
     "language": "python",
     "metadata": {},
     "outputs": [
      {
       "output_type": "pyout",
       "prompt_number": 27,
       "text": [
        "142.0353982300885"
       ]
      }
     ],
     "prompt_number": 27
    },
    {
     "cell_type": "code",
     "collapsed": false,
     "input": [
      "%timeit arr2d.sum() "
     ],
     "language": "python",
     "metadata": {},
     "outputs": [
      {
       "output_type": "stream",
       "stream": "stdout",
       "text": [
        "100000 loops, best of 3: 7.14 us per loop\n"
       ]
      }
     ],
     "prompt_number": 28
    },
    {
     "cell_type": "code",
     "collapsed": false,
     "input": [
      "6.61 / 2.26 # even provides a speedup over general-purpose NumPy surm"
     ],
     "language": "python",
     "metadata": {},
     "outputs": [
      {
       "output_type": "pyout",
       "prompt_number": 29,
       "text": [
        "2.924778761061947"
       ]
      }
     ],
     "prompt_number": 29
    },
    {
     "cell_type": "markdown",
     "metadata": {},
     "source": [
      "The speed-up is even more pronounced the more inner loops in the code.   Here is an image processing example:"
     ]
    },
    {
     "cell_type": "code",
     "collapsed": false,
     "input": [
      "@jit('void(f8[:,:],f8[:,:],f8[:,:])')\n",
      "def filter(image, filt, output):\n",
      "    M, N = image.shape\n",
      "    m, n = filt.shape\n",
      "    for i in range(m//2, M-m//2):\n",
      "        for j in range(n//2, N-n//2):\n",
      "            result = 0.0\n",
      "            for k in range(m):\n",
      "                for l in range(n):\n",
      "                    result += image[i+k-m//2,j+l-n//2]*filt[k, l]\n",
      "            output[i,j] = result\n",
      "\n",
      "from scipy.misc import lena\n",
      "import time\n",
      "image = lena().astype('double')\n",
      "filt = np.ones((15,15),dtype='double')\n",
      "filt /= filt.sum()\n",
      "output = image.copy()\n",
      "filter(image, filt, output)\n",
      "gray()\n",
      "imshow(output)\n",
      "start = time.time()\n",
      "filter(image[:100,:100], filt, output[:100,:100])\n",
      "fast = time.time() - start\n",
      "start = time.time()\n",
      "filter.py_func(image[:100,:100], filt, output[:100,:100])\n",
      "slow = time.time() - start\n",
      "print \"Python: %f s; Numba: %f ms; Speed up is %f\" % (slow, fast*1000, slow / fast)"
     ],
     "language": "python",
     "metadata": {},
     "outputs": [
      {
       "output_type": "stream",
       "stream": "stdout",
       "text": [
        "Python: 2.039625 s; Numba: 6.991148 ms; Speed up is 291.743921\n"
       ]
      },
      {
       "output_type": "display_data",
       "png": "iVBORw0KGgoAAAANSUhEUgAAAQcAAAD9CAYAAACx1bJsAAAABHNCSVQICAgIfAhkiAAAAAlwSFlz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\n"
      }
     ],
     "prompt_number": "*"
    },
    {
     "cell_type": "markdown",
     "metadata": {},
     "source": [
      "You can call Numba-created functions from other Numba-created functions"
     ]
    },
    {
     "cell_type": "code",
     "collapsed": false,
     "input": [
      "@autojit\n",
      "def mandel(x, y, max_iters):\n",
      "    \"\"\"\n",
      "    Given the real and imaginary parts of a complex number,\n",
      "    determine if it is a candidate for membership in the Mandelbrot\n",
      "    set given a fixed number of iterations.\n",
      "    \"\"\"\n",
      "    i = 0\n",
      "    c = complex(x, y)\n",
      "    z = 0.0j\n",
      "    for i in range(max_iters):\n",
      "        z = z**2 + c\n",
      "        if abs(z)**2 >= 4:\n",
      "            return i\n",
      "\n",
      "    return 255\n",
      "\n",
      "@autojit\n",
      "def create_fractal(min_x, max_x, min_y, max_y, image, iters):\n",
      "    height = image.shape[0]\n",
      "    width = image.shape[1]\n",
      "\n",
      "    pixel_size_x = (max_x - min_x) / width\n",
      "    pixel_size_y = (max_y - min_y) / height\n",
      "    for x in range(width):\n",
      "        real = min_x + x * pixel_size_x\n",
      "        for y in range(height):\n",
      "            imag = min_y + y * pixel_size_y\n",
      "            color = mandel(real, imag, iters)\n",
      "            image[y, x] = color\n",
      "\n",
      "    return image\n",
      "\n",
      "image = np.zeros((500, 750), dtype=np.uint8)\n",
      "imshow(create_fractal(-2.0, 1.0, -1.0, 1.0, image, 20))"
     ],
     "language": "python",
     "metadata": {},
     "outputs": [],
     "prompt_number": "*"
    },
    {
     "cell_type": "code",
     "collapsed": false,
     "input": [
      "%timeit create_fractal(-2.0, 1.0, -1.0, 1.0, image, 20)"
     ],
     "language": "python",
     "metadata": {},
     "outputs": [],
     "prompt_number": "*"
    },
    {
     "cell_type": "code",
     "collapsed": false,
     "input": [
      "%timeit create_fractal.py_func(-2.0, 1.0, -1.0, 1.0, image, 20)"
     ],
     "language": "python",
     "metadata": {},
     "outputs": [],
     "prompt_number": "*"
    },
    {
     "cell_type": "code",
     "collapsed": false,
     "input": [
      "18.9/ 1.28 # speedup of compiling outer-loop (inner-loop mandel call is still optimized)"
     ],
     "language": "python",
     "metadata": {},
     "outputs": [],
     "prompt_number": "*"
    },
    {
     "cell_type": "markdown",
     "metadata": {},
     "source": [
      "Numba works very well for numerical calculations and infers types for variables.  You can over-ride this inference by passing in a locals dictionary to the autojit decorator.   Notice how the code below shows both Python object manipulation and native manipulation"
     ]
    },
    {
     "cell_type": "code",
     "collapsed": false,
     "input": [
      "class MyClass(object):\n",
      "    def mymethod(self, arg):\n",
      "        return arg * 2\n",
      "    \n",
      "@autojit(locals=dict(mydouble=double)) # specify types for local variables\n",
      "def call_method(obj):\n",
      "    print obj.mymethod(\"hello\")   # object result\n",
      "    mydouble = obj.mymethod(10.2) # native double\n",
      "    print mydouble * 2            # native multiplication\n",
      "    \n",
      "call_method(MyClass())"
     ],
     "language": "python",
     "metadata": {},
     "outputs": [
      {
       "output_type": "stream",
       "stream": "stdout",
       "text": [
        "hellohello\n",
        "40.8\n"
       ]
      }
     ],
     "prompt_number": 3
    },
    {
     "cell_type": "markdown",
     "metadata": {},
     "source": [
      "Complex support is available as well."
     ]
    },
    {
     "cell_type": "code",
     "collapsed": false,
     "input": [
      "@autojit\n",
      "def complex_support(real, imag):\n",
      "    c = complex(real, imag)\n",
      "    return (c ** 2).conjugate()\n",
      "\n",
      "c = 2.0 + 4.0j\n",
      "complex_support(c.real, c.imag), (c**2).conjugate()"
     ],
     "language": "python",
     "metadata": {},
     "outputs": [],
     "prompt_number": "*"
    },
    {
     "cell_type": "markdown",
     "metadata": {},
     "source": [
      "We can even create a function that takes a structured array as input."
     ]
    },
    {
     "cell_type": "code",
     "collapsed": false,
     "input": [
      "from numba import struct, jit2\n",
      "record_type = struct([('x', double), ('y', double)])\n",
      "record_dtype = record_type.get_dtype()\n",
      "a = np.array([(1.0, 2.0), (3.0, 4.0)], dtype=record_dtype)\n",
      "\n",
      "@jit2(argtypes=[record_type[:]])\n",
      "def pyth(data):\n",
      "    result = np.empty_like(data, dtype=np.float64) # return types of numpy functions are inferred\n",
      "    for i in range(data.shape[0]):\n",
      "        result[i] = np.sqrt(data[i].x ** 2 + data[i].y ** 2)\n",
      "\n",
      "    return result\n",
      "\n",
      "print pyth(a)"
     ],
     "language": "python",
     "metadata": {},
     "outputs": [
      {
       "output_type": "stream",
       "stream": "stdout",
       "text": [
        "[ 2.23606798  5.        ]\n"
       ]
      }
     ],
     "prompt_number": 4
    },
    {
     "cell_type": "code",
     "collapsed": false,
     "input": [
      "print pyth.signature # inspect function signature, note inferred return type"
     ],
     "language": "python",
     "metadata": {},
     "outputs": [
      {
       "output_type": "stream",
       "stream": "stdout",
       "text": [
        "double[:] (*)(struct { double x, double y }[:])\n"
       ]
      }
     ],
     "prompt_number": 5
    },
    {
     "cell_type": "code",
     "collapsed": false,
     "input": [
      "[line for line in str(pyth.lfunc).splitlines() if 'sqrt' in line] # note native math calls"
     ],
     "language": "python",
     "metadata": {},
     "outputs": [
      {
       "output_type": "pyout",
       "prompt_number": 6,
       "text": [
        "['  %51 = call double @llvm.sqrt.f64(double %50)']"
       ]
      }
     ],
     "prompt_number": 6
    },
    {
     "cell_type": "markdown",
     "metadata": {},
     "source": [
      "The roadmap for Numba includes better error-handling, support for almost all Python syntax which gets compiled to code that either uses machine instructions or else the Python library run-time, improved support for basic types, and the ability to create objects easily. "
     ]
    },
    {
     "cell_type": "markdown",
     "metadata": {},
     "source": [
      "The commercial product NumbaPro includes additional features:\n",
      "\n",
      "* ability to create ufuncs (fast-vectorize)\n",
      "* ability to target the GPU via CUDA\n",
      "* ability to target multiple-cores  \n",
      "* array-expressions (ability to write NumPy-like code that gets compiled)"
     ]
    }
   ],
   "metadata": {}
  }
 ]
}