13_Optimising_2.ipynb

{
 "metadata": {
  "celltoolbar": "Slideshow",
  "name": "",
  "signature": "sha256:bdd39cce86ec973476a3b7cb941850ff9734245f3269aad0f64b386e60778e63"
 },
 "nbformat": 3,
 "nbformat_minor": 0,
 "worksheets": [
  {
   "cells": [
    {
     "cell_type": "markdown",
     "metadata": {
      "slideshow": {
       "slide_type": "slide"
      }
     },
     "source": [
      "More optimisation\n",
      "================="
     ]
    },
    {
     "cell_type": "markdown",
     "metadata": {
      "slideshow": {
       "slide_type": "slide"
      }
     },
     "source": [
      "Our number crunching is often the most expensive part of the calculation, and often speeding up a single function can boost overall performance. In this case study we show that, sometimes, what we expect might be slower can end up much fatser and vice versa, and that knowledge of implementation can help identifying speed ups."
     ]
    },
    {
     "cell_type": "markdown",
     "metadata": {
      "slideshow": {
       "slide_type": "slide"
      }
     },
     "source": [
      "Dot product\n",
      "-----------"
     ]
    },
    {
     "cell_type": "code",
     "collapsed": false,
     "input": [
      "import operator\n",
      "import numpy as np\n",
      "from itertools import imap\n",
      "from operator import mul\n",
      "\n",
      "def dot_indexed(a, b):\n",
      "    return a[0]*b[0] + a[1]*b[1] + a[2]*b[2]\n",
      "\n",
      "def dot_sum_index(a, b):\n",
      "    return sum(a[i]*b[i] for i in xrange(len(a)))\n",
      "\n",
      "def dot_zip(a, b):\n",
      "    return sum(x*y for x, y in zip(a, b))\n",
      "\n",
      "def dot_sum_map(a, b):\n",
      "    return sum(map(mul, a, b))\n",
      "\n",
      "def dot_itertools(vec1, vec2, sum=sum, imap=imap, mul=operator.mul):\n",
      "    return sum(imap(mul, vec1, vec2))"
     ],
     "language": "python",
     "metadata": {},
     "outputs": [],
     "prompt_number": 1
    },
    {
     "cell_type": "code",
     "collapsed": false,
     "input": [
      "from random import random\n",
      "# our tests are typical 3d vectors, but we don't\n",
      "# want to be limited to that so have a long one too\n",
      "short_vector = [random() for _i in range(3)]\n",
      "long_vector = [random() for _i in range(2000)]"
     ],
     "language": "python",
     "metadata": {
      "slideshow": {
       "slide_type": "slide"
      }
     },
     "outputs": [],
     "prompt_number": 2
    },
    {
     "cell_type": "markdown",
     "metadata": {
      "slideshow": {
       "slide_type": "slide"
      }
     },
     "source": [
      "Short vector\n",
      "------------"
     ]
    },
    {
     "cell_type": "code",
     "collapsed": false,
     "input": [
      "%timeit dot_indexed(short_vector, short_vector)"
     ],
     "language": "python",
     "metadata": {},
     "outputs": [
      {
       "output_type": "stream",
       "stream": "stdout",
       "text": [
        "1000000 loops, best of 3: 631 ns per loop\n"
       ]
      }
     ],
     "prompt_number": 3
    },
    {
     "cell_type": "code",
     "collapsed": false,
     "input": [
      "%timeit dot_sum_index(short_vector, short_vector)"
     ],
     "language": "python",
     "metadata": {},
     "outputs": [
      {
       "output_type": "stream",
       "stream": "stdout",
       "text": [
        "100000 loops, best of 3: 2.31 \u00b5s per loop\n"
       ]
      }
     ],
     "prompt_number": 4
    },
    {
     "cell_type": "code",
     "collapsed": false,
     "input": [
      "%timeit dot_zip(short_vector, short_vector)"
     ],
     "language": "python",
     "metadata": {},
     "outputs": [
      {
       "output_type": "stream",
       "stream": "stdout",
       "text": [
        "100000 loops, best of 3: 2.08 \u00b5s per loop\n"
       ]
      }
     ],
     "prompt_number": 5
    },
    {
     "cell_type": "code",
     "collapsed": false,
     "input": [
      "%timeit dot_sum_map(short_vector, short_vector)"
     ],
     "language": "python",
     "metadata": {},
     "outputs": [
      {
       "output_type": "stream",
       "stream": "stdout",
       "text": [
        "1000000 loops, best of 3: 1.47 \u00b5s per loop\n"
       ]
      }
     ],
     "prompt_number": 6
    },
    {
     "cell_type": "code",
     "collapsed": false,
     "input": [
      "%timeit dot_itertools(short_vector, short_vector)"
     ],
     "language": "python",
     "metadata": {},
     "outputs": [
      {
       "output_type": "stream",
       "stream": "stdout",
       "text": [
        "1000000 loops, best of 3: 1.23 \u00b5s per loop\n"
       ]
      }
     ],
     "prompt_number": 7
    },
    {
     "cell_type": "code",
     "collapsed": false,
     "input": [
      "%timeit np.dot(short_vector, short_vector)"
     ],
     "language": "python",
     "metadata": {},
     "outputs": [
      {
       "output_type": "stream",
       "stream": "stdout",
       "text": [
        "100000 loops, best of 3: 5.28 \u00b5s per loop\n"
       ]
      }
     ],
     "prompt_number": 8
    },
    {
     "cell_type": "markdown",
     "metadata": {},
     "source": [
      "Interestingly, a very simple expression is twice as fast as the next best and ten times faster than NumPy. Since NumPy is supposed to be able to do calculations as if it was written in C, clearly something is going on."
     ]
    },
    {
     "cell_type": "markdown",
     "metadata": {
      "slideshow": {
       "slide_type": "slide"
      }
     },
     "source": [
      "Long vector\n",
      "-----------"
     ]
    },
    {
     "cell_type": "code",
     "collapsed": false,
     "input": [
      "%timeit dot_indexed(long_vector, long_vector)"
     ],
     "language": "python",
     "metadata": {},
     "outputs": [
      {
       "output_type": "stream",
       "stream": "stdout",
       "text": [
        "1000000 loops, best of 3: 637 ns per loop\n"
       ]
      }
     ],
     "prompt_number": 9
    },
    {
     "cell_type": "code",
     "collapsed": false,
     "input": [
      "%timeit dot_sum_index(long_vector, long_vector)"
     ],
     "language": "python",
     "metadata": {},
     "outputs": [
      {
       "output_type": "stream",
       "stream": "stdout",
       "text": [
        "1000 loops, best of 3: 441 \u00b5s per loop\n"
       ]
      }
     ],
     "prompt_number": 10
    },
    {
     "cell_type": "code",
     "collapsed": false,
     "input": [
      "%timeit dot_zip(long_vector, long_vector)"
     ],
     "language": "python",
     "metadata": {},
     "outputs": [
      {
       "output_type": "stream",
       "stream": "stdout",
       "text": [
        "1000 loops, best of 3: 439 \u00b5s per loop\n"
       ]
      }
     ],
     "prompt_number": 11
    },
    {
     "cell_type": "code",
     "collapsed": false,
     "input": [
      "%timeit dot_sum_map(long_vector, long_vector)"
     ],
     "language": "python",
     "metadata": {},
     "outputs": [
      {
       "output_type": "stream",
       "stream": "stdout",
       "text": [
        "1000 loops, best of 3: 298 \u00b5s per loop\n"
       ]
      }
     ],
     "prompt_number": 12
    },
    {
     "cell_type": "code",
     "collapsed": false,
     "input": [
      "%timeit dot_itertools(long_vector, long_vector)"
     ],
     "language": "python",
     "metadata": {},
     "outputs": [
      {
       "output_type": "stream",
       "stream": "stdout",
       "text": [
        "1000 loops, best of 3: 262 \u00b5s per loop\n"
       ]
      }
     ],
     "prompt_number": 13
    },
    {
     "cell_type": "code",
     "collapsed": false,
     "input": [
      "%timeit np.dot(long_vector, long_vector)"
     ],
     "language": "python",
     "metadata": {},
     "outputs": [
      {
       "output_type": "stream",
       "stream": "stdout",
       "text": [
        "1000 loops, best of 3: 567 \u00b5s per loop\n"
       ]
      }
     ],
     "prompt_number": 14
    },
    {
     "cell_type": "markdown",
     "metadata": {},
     "source": [
      "Even though the indexed case wins out here, bear in mind that it is giving the *incorrect answer*. Always test that your optimised functions are doing the correct thing! Now the 'highly optimised' itertools case is giving the best performance, but NumPy is doing terribly!"
     ]
    },
    {
     "cell_type": "markdown",
     "metadata": {
      "slideshow": {
       "slide_type": "slide"
      }
     },
     "source": [
      "Numpy\n",
      "-----"
     ]
    },
    {
     "cell_type": "markdown",
     "metadata": {},
     "source": [
      "NumPy is a numerical computing library that is built around a very fast `array` datatype and implemented in C. What happens if we use those arrays"
     ]
    },
    {
     "cell_type": "code",
     "collapsed": false,
     "input": [
      "short_array = np.array(short_vector)\n",
      "%timeit np.dot(short_array, short_array)\n",
      "long_array = np.array(long_vector)\n",
      "%timeit np.dot(long_array, long_array)"
     ],
     "language": "python",
     "metadata": {},
     "outputs": [
      {
       "output_type": "stream",
       "stream": "stdout",
       "text": [
        "1000000 loops, best of 3: 1.75 \u00b5s per loop\n",
        "100000 loops, best of 3: 4.41 \u00b5s per loop"
       ]
      },
      {
       "output_type": "stream",
       "stream": "stdout",
       "text": [
        "\n"
       ]
      }
     ],
     "prompt_number": 15
    },
    {
     "cell_type": "markdown",
     "metadata": {},
     "source": [
      "By using ndarrays as arguments we are able to get massive speedups. In this case there is an implicit conversion to a numpy array (and the result we get is an array) to use the numpy functions. If we keep everything as ndarrays we can benefit from large speed boosts, as long as we don't cast to and from the Python built in types too often."
     ]
    },
    {
     "cell_type": "code",
     "collapsed": false,
     "input": [
      "%timeit long_array = np.array(long_vector)"
     ],
     "language": "python",
     "metadata": {},
     "outputs": [
      {
       "output_type": "stream",
       "stream": "stdout",
       "text": [
        "10000 loops, best of 3: 195 \u00b5s per loop\n"
       ]
      }
     ],
     "prompt_number": 16
    },
    {
     "cell_type": "markdown",
     "metadata": {
      "slideshow": {
       "slide_type": "slide"
      }
     },
     "source": [
      "Thinking outside Python\n",
      "-----------------------\n",
      "\n",
      "NumPy shows us the speed gains that we can achieve by taking computationally expensive bits of code to the C level. Even Guido himself has said that if you need the speed and you can't get there by refactoring, the route to go is to start rewriting the hotspots in C. \n",
      "\n",
      "+ [\"It is quite easy to add new built-in modules to Python, if you know how to program in C.\"](http://docs.python.org/2.7/extending/extending.html)\n",
      "+ Often we just want to rewrite the slow bit, not a whole module\n",
      "+ Several solutions depending on how deep you want to get into the code: \n",
      "\n",
      "    + PyPy: a different implementation of Python with a just-in-time (JIT) compiler (lacks full scientific library support)\n",
      "    + ctypes: standard library utilities for linking with arbritary C libraries\n",
      "    + **f2py**: easily compile Fortran to importable code\n",
      "    + **cython**: compile of Python and Python-like code to C\n",
      "    + Numba: a Python to LLVM bytecode converter\n",
      "    + Python C API: directly write C modules\n",
      "    + SWIG: the Simplified Wrapper Interface Generator,generate wrappers from low-level languages to many high-level languages.\n",
      "    + **weave**: included in SciPy, include C snippets within a Python program.\n"
     ]
    },
    {
     "cell_type": "markdown",
     "metadata": {
      "slideshow": {
       "slide_type": "slide"
      }
     },
     "source": [
      "Cython\n",
      "------\n",
      "\n",
      "+ Cython translates Python into C (language complete).\n",
      "+ Offers opportunistic optimisation on the produced C code.\n",
      "+ Lowers overheads associated with the Python virtual machine and function calls.\n",
      "+ Can include static type inference to greatly increase speed (breaks language compatibility).\n",
      "+ Popular in scientific community (SciPy now contains a lot of Cython)"
     ]
    },
    {
     "cell_type": "code",
     "collapsed": false,
     "input": [
      "%%file cy_dot.pyx\n",
      "# Just write normal Python, but put it in a .pyx file\n",
      "\n",
      "def dot_zip_cython(a, b):\n",
      "    return sum(x*y for x, y in zip(a, b))"
     ],
     "language": "python",
     "metadata": {
      "slideshow": {
       "slide_type": "slide"
      }
     },
     "outputs": [
      {
       "output_type": "stream",
       "stream": "stdout",
       "text": [
        "Overwriting cy_dot.pyx\n"
       ]
      }
     ],
     "prompt_number": 17
    },
    {
     "cell_type": "code",
     "collapsed": false,
     "input": [
      "# this is the simple method to build and include Cython at runtime. When\n",
      "# distributing code, pyx files are compiled during install (see cythonize)\n",
      "import pyximport\n",
      "pyximport.install()\n",
      "\n",
      "# because of pyximport, this gets compiled automatically\n",
      "import cy_dot"
     ],
     "language": "python",
     "metadata": {
      "slideshow": {
       "slide_type": "slide"
      }
     },
     "outputs": [],
     "prompt_number": 18
    },
    {
     "cell_type": "code",
     "collapsed": false,
     "input": [
      "# this shows us the compiled shared object file\n",
      "cy_dot.__file__"
     ],
     "language": "python",
     "metadata": {},
     "outputs": [
      {
       "metadata": {},
       "output_type": "pyout",
       "prompt_number": 19,
       "text": [
        "'/home/tdaff/.pyxbld/lib.linux-x86_64-2.7/cy_dot.so'"
       ]
      }
     ],
     "prompt_number": 19
    },
    {
     "cell_type": "code",
     "collapsed": true,
     "input": [
      "%timeit cy_dot.dot_zip_cython(short_vector, short_vector)"
     ],
     "language": "python",
     "metadata": {},
     "outputs": [
      {
       "output_type": "stream",
       "stream": "stdout",
       "text": [
        "100000 loops, best of 3: 2.78 \u00b5s per loop\n"
       ]
      }
     ],
     "prompt_number": 20
    },
    {
     "cell_type": "markdown",
     "metadata": {},
     "source": [
      "The compiled code is usually only a few percent faster. It may not seem worth it, but we can improve on that!"
     ]
    },
    {
     "cell_type": "markdown",
     "metadata": {
      "slideshow": {
       "slide_type": "slide"
      }
     },
     "source": [
      "Type annotations\n",
      "----------------\n",
      "\n",
      "Most of the slowness of Python is because objects are so malleable and must be constantly type checked. If we tell Cython what _types_ to expect, it will streamline the code to stop doing type checks and run much faster. We lose some finesse of pure Python, but a couple of annotations can boost speed in the most important places."
     ]
    },
    {
     "cell_type": "code",
     "collapsed": false,
     "input": [
      "%%file cy_fib.pyx\n",
      "\n",
      "# Standard python:\n",
      "def py_fibonacci(n):\n",
      "    a, b = 0, 1\n",
      "    for i in range(n):\n",
      "        b, a = a + b, b\n",
      "    return a\n",
      "\n",
      "# Type annotated:\n",
      "def cy_fibonacci(int n):\n",
      "    cdef int a = 0\n",
      "    cdef int b = 1\n",
      "    for i in range(n):  # cython knows common idioms\n",
      "        b, a = a + b, b\n",
      "    return a"
     ],
     "language": "python",
     "metadata": {
      "slideshow": {
       "slide_type": "slide"
      }
     },
     "outputs": [
      {
       "output_type": "stream",
       "stream": "stdout",
       "text": [
        "Overwriting cy_fib.pyx\n"
       ]
      }
     ],
     "prompt_number": 21
    },
    {
     "cell_type": "code",
     "collapsed": false,
     "input": [
      "import cy_fib"
     ],
     "language": "python",
     "metadata": {
      "slideshow": {
       "slide_type": "slide"
      }
     },
     "outputs": [],
     "prompt_number": 22
    },
    {
     "cell_type": "code",
     "collapsed": false,
     "input": [
      "%timeit cy_fib.py_fibonacci(1000)\n",
      "%timeit cy_fib.cy_fibonacci(1000)"
     ],
     "language": "python",
     "metadata": {},
     "outputs": [
      {
       "output_type": "stream",
       "stream": "stdout",
       "text": [
        "10000 loops, best of 3: 111 \u00b5s per loop\n",
        "100000 loops, best of 3: 5.38 \u00b5s per loop"
       ]
      },
      {
       "output_type": "stream",
       "stream": "stdout",
       "text": [
        "\n"
       ]
      }
     ],
     "prompt_number": 23
    },
    {
     "cell_type": "markdown",
     "metadata": {},
     "source": [
      "Telling Cython that the function expects an integer, so it can skip type checks, makes it orders of magnitude faster."
     ]
    },
    {
     "cell_type": "markdown",
     "metadata": {
      "slideshow": {
       "slide_type": "slide"
      }
     },
     "source": [
      "Cython and NumPy\n",
      "----------------\n",
      "\n",
      "Python lists, like `long_vector` don't cythonize very well as they are complex containers of pretty much anything. However, Cython works well with NumPy arrays which have uniform types, so we can use that to optimise our dot product."
     ]
    },
    {
     "cell_type": "code",
     "collapsed": false,
     "input": [
      "# we can use cython directly in the notebooks for convenience\n",
      "%load_ext cythonmagic"
     ],
     "language": "python",
     "metadata": {
      "slideshow": {
       "slide_type": "slide"
      }
     },
     "outputs": [],
     "prompt_number": 24
    },
    {
     "cell_type": "code",
     "collapsed": false,
     "input": [
      "%%cython\n",
      "\n",
      "cimport cython\n",
      "cimport numpy\n",
      "\n",
      "@cython.boundscheck(False)\n",
      "@cython.wraparound(False)\n",
      "def dot_cython_typed(numpy.ndarray[numpy.float64_t, ndim=1] a, \n",
      "                     numpy.ndarray[numpy.float64_t, ndim=1] b):\n",
      "    cdef int i\n",
      "    cdef n = len(a)\n",
      "    cdef double result = 0.0\n",
      "    for i in range(n):\n",
      "        result += a[i]*b[i]\n",
      "    return result"
     ],
     "language": "python",
     "metadata": {},
     "outputs": [],
     "prompt_number": 25
    },
    {
     "cell_type": "code",
     "collapsed": false,
     "input": [
      "%timeit dot_cython_typed(short_array, short_array)\n",
      "%timeit dot_cython_typed(long_array, long_array)"
     ],
     "language": "python",
     "metadata": {
      "slideshow": {
       "slide_type": "slide"
      }
     },
     "outputs": [
      {
       "output_type": "stream",
       "stream": "stdout",
       "text": [
        "1000000 loops, best of 3: 1.72 \u00b5s per loop\n",
        "10000 loops, best of 3: 20.6 \u00b5s per loop"
       ]
      },
      {
       "output_type": "stream",
       "stream": "stdout",
       "text": [
        "\n"
       ]
      }
     ],
     "prompt_number": 26
    },
    {
     "cell_type": "markdown",
     "metadata": {},
     "source": [
      "Our naive implementation is almost as fast as the optimised NumPy implementation. These small annotations can clearly be useful for a speed boost in more complex code!"
     ]
    },
    {
     "cell_type": "markdown",
     "metadata": {
      "slideshow": {
       "slide_type": "slide"
      }
     },
     "source": [
      "Weave\n",
      "-----\n",
      "\n",
      "Weave is a module in SciPy that can help to integrate C/C++ snippets directly in your code. While generally considered superceeded by Cython, it offers simplicity for directly including verbatim C code makes it useful in some circumstances.\n",
      "\n",
      "Like Cython it takes care of all the interfacing and boilerplate of the C codes so we only need to provide the bare C implementation. Docs are found at [http://docs.scipy.org/doc/scipy/reference/tutorial/weave.html](http://docs.scipy.org/doc/scipy/reference/tutorial/weave.html)"
     ]
    },
    {
     "cell_type": "code",
     "collapsed": false,
     "input": [
      "from scipy import weave\n",
      "from scipy.weave import converters"
     ],
     "language": "python",
     "metadata": {
      "slideshow": {
       "slide_type": "slide"
      }
     },
     "outputs": [],
     "prompt_number": 27
    },
    {
     "cell_type": "code",
     "collapsed": false,
     "input": [
      "def dot_weave(one, two):\n",
      "    \"\"\"A dot product with inlined C.\"\"\"\n",
      "    N = len(one)  # need to get the size first\n",
      "\n",
      "    # C/C++ code just written as a string\n",
      "    code = \"\"\"\n",
      "    double result = 0.0;\n",
      "    for(int i=0; i < N; i++)\n",
      "    {\n",
      "        result += one(i)*two(i);\n",
      "    }\n",
      "    return_val = result;\n",
      "    \"\"\" \n",
      "    # inline does the compilation using the local environment\n",
      "    result = weave.inline(code, ['one', 'two', 'N'],\n",
      "                          type_converters=converters.blitz)\n",
      "    return result"
     ],
     "language": "python",
     "metadata": {},
     "outputs": [],
     "prompt_number": 28
    },
    {
     "cell_type": "markdown",
     "metadata": {},
     "source": [
      "All we need to do is pass our code to the `inline()` function and it will take care of tall the compilation and linking in the code. The second argument is all the arguments from our environment that will be passed in and the `type_converters` means that we don't have to worry about declaring specific Python types within our C code and things like numpy arrays work seamlessly."
     ]
    },
    {
     "cell_type": "code",
     "collapsed": false,
     "input": [
      "# The first time the function runs there is a delay as it is compiled.\n",
      "dot_weave(short_array, short_array)"
     ],
     "language": "python",
     "metadata": {
      "slideshow": {
       "slide_type": "slide"
      }
     },
     "outputs": [
      {
       "metadata": {},
       "output_type": "pyout",
       "prompt_number": 29,
       "text": [
        "1.2242968541427075"
       ]
      }
     ],
     "prompt_number": 29
    },
    {
     "cell_type": "code",
     "collapsed": false,
     "input": [
      "%timeit dot_weave(short_array, short_array)\n",
      "%timeit dot_weave(long_array, long_array)"
     ],
     "language": "python",
     "metadata": {},
     "outputs": [
      {
       "output_type": "stream",
       "stream": "stdout",
       "text": [
        "100000 loops, best of 3: 7.02 \u00b5s per loop\n",
        "10000 loops, best of 3: 65.3 \u00b5s per loop"
       ]
      },
      {
       "output_type": "stream",
       "stream": "stdout",
       "text": [
        "\n"
       ]
      }
     ],
     "prompt_number": 30
    },
    {
     "cell_type": "markdown",
     "metadata": {},
     "source": [
      "It's faster than pure Python, but the overhead of the `inline` and the Python function setup make this slow for this simple case, and Cython wins overall. "
     ]
    },
    {
     "cell_type": "markdown",
     "metadata": {
      "slideshow": {
       "slide_type": "slide"
      }
     },
     "source": [
      "Weave still offers some conveniences, such as being able to convert various Python types and interact with local and global environments. Mutable types are passed through to the C environment and any changes you make in that environment are reflected in the Python variable."
     ]
    },
    {
     "cell_type": "code",
     "collapsed": false,
     "input": [
      "mutate = np.array([1, 2, 3])\n",
      "# blitz converts numpy to fast numeric types in C\n",
      "weave.inline('mutate(1) = 7;', ['mutate'], \n",
      "             type_converters=converters.blitz)\n",
      "# mutate array in C and also changes in the Python environment\n",
      "mutate"
     ],
     "language": "python",
     "metadata": {},
     "outputs": [
      {
       "metadata": {},
       "output_type": "pyout",
       "prompt_number": 31,
       "text": [
        "array([1, 7, 3])"
       ]
      }
     ],
     "prompt_number": 31
    },
    {
     "cell_type": "markdown",
     "metadata": {
      "slideshow": {
       "slide_type": "slide"
      }
     },
     "source": [
      "Fortran and Python\n",
      "------------------\n",
      "\n",
      "Probably the next easiest interface mechanism is `f2py`. As the name suggests it takes standard fortan code and makes it accessible from python as if it were a standard module."
     ]
    },
    {
     "cell_type": "code",
     "collapsed": false,
     "input": [
      "%%file f90_dot.f90\n",
      "\n",
      "subroutine dot_fortran(a, b, n, result)\n",
      "\n",
      "! Calculate the dot product with the\n",
      "! intrinsic fortran function\n",
      "\n",
      "integer n\n",
      "real(8), intent(in) :: a(n), b(n)\n",
      "real(8), intent(out) :: result\n",
      "result = DOT_PRODUCT(a, b)\n",
      "end"
     ],
     "language": "python",
     "metadata": {},
     "outputs": [
      {
       "output_type": "stream",
       "stream": "stdout",
       "text": [
        "Overwriting f90_dot.f90\n"
       ]
      }
     ],
     "prompt_number": 32
    },
    {
     "cell_type": "markdown",
     "metadata": {},
     "source": [
      "The `intent(in)` directives notify the compiler what the arguments of the function are, and `intent(out)` identifies the return value. If more than one output is given they are returned as a tuple. Since `f2py` is a part of NumPy, functions that take arrays expect NumPy arrays."
     ]
    },
    {
     "cell_type": "code",
     "collapsed": false,
     "input": [
      "# Build the code with the `f2py` command.\n",
      "# The `-m` argument compiles code to a module that can be imported.\n",
      "!f2py -c -m f90_dot f90_dot.f90 > build.log"
     ],
     "language": "python",
     "metadata": {
      "slideshow": {
       "slide_type": "slide"
      }
     },
     "outputs": [],
     "prompt_number": 33
    },
    {
     "cell_type": "code",
     "collapsed": false,
     "input": [
      "import f90_dot\n",
      "from f90_dot import dot_fortran"
     ],
     "language": "python",
     "metadata": {},
     "outputs": [],
     "prompt_number": 34
    },
    {
     "cell_type": "code",
     "collapsed": false,
     "input": [
      "print(dot_fortran.__doc__)"
     ],
     "language": "python",
     "metadata": {},
     "outputs": [
      {
       "output_type": "stream",
       "stream": "stdout",
       "text": [
        "result = dot_fortran(a,b,[n])\n",
        "\n",
        "Wrapper for ``dot_fortran``.\n",
        "\n",
        "Parameters\n",
        "----------\n",
        "a : input rank-1 array('d') with bounds (n)\n",
        "b : input rank-1 array('d') with bounds (n)\n",
        "\n",
        "Other Parameters\n",
        "----------------\n",
        "n : input int, optional\n",
        "    Default: len(a)\n",
        "\n",
        "Returns\n",
        "-------\n",
        "result : float\n",
        "\n"
       ]
      }
     ],
     "prompt_number": 35
    },
    {
     "cell_type": "code",
     "collapsed": false,
     "input": [
      "dot_fortran(short_array, short_array)"
     ],
     "language": "python",
     "metadata": {
      "slideshow": {
       "slide_type": "slide"
      }
     },
     "outputs": [
      {
       "metadata": {},
       "output_type": "pyout",
       "prompt_number": 36,
       "text": [
        "1.2242968541427075"
       ]
      }
     ],
     "prompt_number": 36
    },
    {
     "cell_type": "code",
     "collapsed": false,
     "input": [
      "%timeit dot_fortran(short_array, short_array)\n",
      "%timeit dot_fortran(long_array, long_array)"
     ],
     "language": "python",
     "metadata": {},
     "outputs": [
      {
       "output_type": "stream",
       "stream": "stdout",
       "text": [
        "1000000 loops, best of 3: 444 ns per loop\n",
        "100000 loops, best of 3: 3.03 \u00b5s per loop"
       ]
      },
      {
       "output_type": "stream",
       "stream": "stdout",
       "text": [
        "\n"
       ]
      }
     ],
     "prompt_number": 37
    },
    {
     "cell_type": "markdown",
     "metadata": {},
     "source": [
      "By interfacing with Fortran we have made the fastest solution."
     ]
    },
    {
     "cell_type": "markdown",
     "metadata": {
      "slideshow": {
       "slide_type": "slide"
      }
     },
     "source": [
      "Summary\n",
      "-------\n",
      "\n",
      "These are _very brief_ introductions to interfacing with other languages.\n",
      "\n",
      "Whereas Python offeres many benefits, these are roads to directly address some of the speed issues that are a common complaint of the Python programmer.\n",
      "\n",
      "Be aware that as soon as you start mixing languages you sacrifice:\n",
      "\n",
      "+ portability that allows people to just download and run your code;\n",
      "+ simplicity of not having to deal with compilers;\n",
      "+ tesre and descriptive, readable code;\n",
      "+ dynamic language features;\n",
      "+ high-level data;\n",
      "+ rapid prototyping\n",
      "+ ..."
     ]
    }
   ],
   "metadata": {}
  }
 ]
}