cython_test.ipynb

{
 "metadata": {
  "name": "cython_test"
 },
 "nbformat": 3,
 "nbformat_minor": 0,
 "worksheets": [
  {
   "cells": [
    {
     "cell_type": "markdown",
     "metadata": {},
     "source": [
      "Cython magic example is here: <http://nbviewer.ipython.org/urls/raw.github.com/ipython/ipython/3607712653c66d63e0d7f13f073bde8c0f209ba8/docs/examples/notebooks/cython_extension.ipynb>\n",
      "\n",
      "Other Cython references I used are:\n",
      "\n",
      "1. <http://cython.org/>\n",
      "1. <http://wiki.cython.org/InstallingOnWindows>\n",
      "1. <http://conference.scipy.org/proceedings/SciPy2009/paper_1/full_text.pdf>\n",
      "1. <http://simula.no/research/sc/publications/Simula.SC.578/simula_pdf_file>\n",
      "1. <http://conference.scipy.org/proceedings/SciPy2009/paper_2/full_text.pdf>"
     ]
    },
    {
     "cell_type": "code",
     "collapsed": false,
     "input": [
      "cd d:\\workspace\\cython_test"
     ],
     "language": "python",
     "metadata": {},
     "outputs": [
      {
       "output_type": "stream",
       "stream": "stdout",
       "text": [
        "d:\\workspace\\cython_test\n"
       ]
      }
     ],
     "prompt_number": 127
    },
    {
     "cell_type": "code",
     "collapsed": false,
     "input": [
      "from numpy.random import multinomial\n",
      "from numpy import ndarray, float32"
     ],
     "language": "python",
     "metadata": {},
     "outputs": [],
     "prompt_number": 166
    },
    {
     "cell_type": "code",
     "collapsed": false,
     "input": [
      "pop_size = 10**6\n",
      "num_classes = 10**3\n",
      "def create_population():\n",
      "\treturn multinomial(pop_size, [1.0/num_classes]*num_classes)"
     ],
     "language": "python",
     "metadata": {},
     "outputs": [],
     "prompt_number": 214
    },
    {
     "cell_type": "markdown",
     "metadata": {},
     "source": [
      "# Drift"
     ]
    },
    {
     "cell_type": "code",
     "collapsed": false,
     "input": [
      "def drift_python(population):\n",
      "\tpop_size = float(sum(population))\n",
      "\tp = [x/pop_size for x  in population]\n",
      "\tpopulation = multinomial(pop_size, p).tolist()\n",
      "\treturn population"
     ],
     "language": "python",
     "metadata": {},
     "outputs": [],
     "prompt_number": 215
    },
    {
     "cell_type": "code",
     "collapsed": false,
     "input": [
      "population = create_population().tolist()\n",
      "print 'drift_python'\n",
      "%timeit -n 10000 drift_python(population)"
     ],
     "language": "python",
     "metadata": {},
     "outputs": [
      {
       "output_type": "stream",
       "stream": "stdout",
       "text": [
        "drift_python\n",
        "1000 loops, best of 3: 956 us per loop"
       ]
      },
      {
       "output_type": "stream",
       "stream": "stdout",
       "text": [
        "\n"
       ]
      }
     ],
     "prompt_number": 219
    },
    {
     "cell_type": "code",
     "collapsed": false,
     "input": [
      "def drift_numpy(population):\n",
      "\tpop_size = float32(population.sum())\n",
      "\tp = population/pop_size\n",
      "\tpopulation = multinomial(pop_size, p)\n",
      "\treturn population"
     ],
     "language": "python",
     "metadata": {},
     "outputs": [],
     "prompt_number": 220
    },
    {
     "cell_type": "code",
     "collapsed": false,
     "input": [
      "population = create_population()\n",
      "print 'drift_numpy'\n",
      "%timeit -n 10000 drift_numpy(population)"
     ],
     "language": "python",
     "metadata": {},
     "outputs": [
      {
       "output_type": "stream",
       "stream": "stdout",
       "text": [
        "drift_numpy\n",
        "1000 loops, best of 3: 444 us per loop"
       ]
      },
      {
       "output_type": "stream",
       "stream": "stdout",
       "text": [
        "\n"
       ]
      }
     ],
     "prompt_number": 259
    },
    {
     "cell_type": "code",
     "collapsed": false,
     "input": [
      "%load_ext cythonmagic"
     ],
     "language": "python",
     "metadata": {},
     "outputs": [],
     "prompt_number": 223
    },
    {
     "cell_type": "code",
     "collapsed": false,
     "input": [
      "%%cython\n",
      "from numpy.random import multinomial\n",
      "def drift_python_cython(population):\n",
      "\tpop_size = float(sum(population))\n",
      "\tp = [x/pop_size for x  in population]\n",
      "\tpopulation = multinomial(pop_size, p).tolist()\n",
      "\treturn population"
     ],
     "language": "python",
     "metadata": {},
     "outputs": [],
     "prompt_number": 224
    },
    {
     "cell_type": "code",
     "collapsed": false,
     "input": [
      "population = create_population().tolist()\n",
      "print 'drift_python_cython'\n",
      "%timeit  -n 10000 drift_python_cython(population)"
     ],
     "language": "python",
     "metadata": {},
     "outputs": [
      {
       "output_type": "stream",
       "stream": "stdout",
       "text": [
        "drift_python_cython\n",
        "1000 loops, best of 3: 917 us per loop"
       ]
      },
      {
       "output_type": "stream",
       "stream": "stdout",
       "text": [
        "\n"
       ]
      }
     ],
     "prompt_number": 225
    },
    {
     "cell_type": "code",
     "collapsed": false,
     "input": [
      "%%cython\n",
      "from numpy.random import multinomial\n",
      "from numpy import array, float32\n",
      "def drift_numpy_cython(population):\n",
      "\tpop_size = float32(population.sum())\n",
      "\tp = population/pop_size\n",
      "\tpopulation = multinomial(pop_size, p)\n",
      "\treturn population"
     ],
     "language": "python",
     "metadata": {},
     "outputs": [],
     "prompt_number": 232
    },
    {
     "cell_type": "code",
     "collapsed": false,
     "input": [
      "population = create_population()\n",
      "print 'drift_numpy_cython'\n",
      "%timeit -n 10000 drift_numpy_cython(population)"
     ],
     "language": "python",
     "metadata": {},
     "outputs": [
      {
       "output_type": "stream",
       "stream": "stdout",
       "text": [
        "drift_numpy_cython\n",
        "10000 loops, best of 3: 189 us per loop"
       ]
      },
      {
       "output_type": "stream",
       "stream": "stdout",
       "text": [
        "\n",
        "drift_numpy\n",
        "10000 loops, best of 3: 190 us per loop"
       ]
      },
      {
       "output_type": "stream",
       "stream": "stdout",
       "text": [
        "\n"
       ]
      }
     ],
     "prompt_number": 267
    },
    {
     "cell_type": "code",
     "collapsed": false,
     "input": [
      "%%cython\n",
      "from numpy.random import multinomial\n",
      "cimport numpy as np\n",
      "import numpy as np\n",
      "\n",
      "def drift_numpy_cython_cdef(np.ndarray[np.int32_t, ndim=1] population):\n",
      "    cdef float pop_size\n",
      "    pop_size = population.sum()\n",
      "    cdef np.ndarray[double] p\n",
      "    p = population/pop_size\n",
      "    population = multinomial(pop_size, p)\n",
      "    return population"
     ],
     "language": "python",
     "metadata": {},
     "outputs": [],
     "prompt_number": 246
    },
    {
     "cell_type": "code",
     "collapsed": false,
     "input": [
      "population = create_population()\n",
      "print 'drift_numpy_cython_cdef'\n",
      "%timeit -n 10000 drift_numpy_cython_cdef(population)"
     ],
     "language": "python",
     "metadata": {},
     "outputs": [
      {
       "output_type": "stream",
       "stream": "stdout",
       "text": [
        "drift_numpy_cython_cdef\n",
        "1000 loops, best of 3: 481 us per loop"
       ]
      },
      {
       "output_type": "stream",
       "stream": "stdout",
       "text": [
        "\n"
       ]
      }
     ],
     "prompt_number": 247
    },
    {
     "cell_type": "code",
     "collapsed": false,
     "input": [
      "%%cython\n",
      "from numpy.random import multinomial\n",
      "cimport numpy as np\n",
      "import numpy as np\n",
      "\n",
      "cpdef np.ndarray[np.int32_t, ndim=1] drift_numpy_cython_cpdef(np.ndarray[np.int32_t] population):\n",
      "    cdef float pop_size\n",
      "    pop_size = population.sum()\n",
      "    cdef np.ndarray[double] p\n",
      "    p = population/pop_size\n",
      "    population[:] = multinomial(pop_size, p)\n",
      "    return population"
     ],
     "language": "python",
     "metadata": {},
     "outputs": [],
     "prompt_number": 277
    },
    {
     "cell_type": "code",
     "collapsed": false,
     "input": [
      "population = create_population()\n",
      "print 'drift_numpy_cython_cpdef'\n",
      "%timeit -n 10000 drift_numpy_cython_cpdef(population)"
     ],
     "language": "python",
     "metadata": {},
     "outputs": [
      {
       "output_type": "stream",
       "stream": "stdout",
       "text": [
        "drift_numpy_cython_cpdef\n",
        "10000 loops, best of 3: 108 us per loop"
       ]
      },
      {
       "output_type": "stream",
       "stream": "stdout",
       "text": [
        "\n"
       ]
      }
     ],
     "prompt_number": 278
    },
    {
     "cell_type": "code",
     "collapsed": false,
     "input": [
      "%%cython\n",
      "cimport cython\n",
      "from numpy.random import multinomial\n",
      "cimport numpy as np\n",
      "import numpy as np\n",
      "\n",
      "@cython.boundscheck(False)\n",
      "@cython.wraparound(False)\n",
      "@cython.nonecheck(False)\n",
      "def drift_numpy_cython_decorators(np.ndarray[np.int32_t] population):\n",
      "    cdef float pop_size\n",
      "    pop_size = population.sum()\n",
      "    cdef np.ndarray[double] p\n",
      "    p = population/pop_size\n",
      "    population = multinomial(pop_size, p)\n",
      "    return population"
     ],
     "language": "python",
     "metadata": {},
     "outputs": [],
     "prompt_number": 254
    },
    {
     "cell_type": "code",
     "collapsed": false,
     "input": [
      "population = create_population()\n",
      "print 'drift_numpy_cython_decorators'\n",
      "%timeit -n 10000 drift_numpy_cython_decorators(population)"
     ],
     "language": "python",
     "metadata": {},
     "outputs": [
      {
       "output_type": "stream",
       "stream": "stdout",
       "text": [
        "drift_numpy_cython_decorators\n",
        "1000 loops, best of 3: 523 us per loop"
       ]
      },
      {
       "output_type": "stream",
       "stream": "stdout",
       "text": [
        "\n"
       ]
      }
     ],
     "prompt_number": 255
    },
    {
     "cell_type": "code",
     "collapsed": false,
     "input": [
      "%%cython\n",
      "cimport cython\n",
      "from numpy.random import multinomial\n",
      "cimport numpy as np\n",
      "import numpy as np\n",
      "\n",
      "@cython.boundscheck(False)\n",
      "@cython.wraparound(False)\n",
      "@cython.nonecheck(False)\n",
      "def drift_numpy_cython_forsum(np.ndarray[np.int32_t] population):\n",
      "    cdef int pop_size = 0\n",
      "    cdef Py_ssize_t i\n",
      "    for i in range(1000):\n",
      "        pop_size = pop_size + population[i]\n",
      "    cdef np.ndarray[double] p\n",
      "    p = population/float(pop_size)\n",
      "    population = multinomial(pop_size, p)\n",
      "    return population"
     ],
     "language": "python",
     "metadata": {},
     "outputs": [],
     "prompt_number": 252
    },
    {
     "cell_type": "code",
     "collapsed": false,
     "input": [
      "population = create_population()\n",
      "print 'drift_numpy_cython_forsum'\n",
      "%timeit -n 10000 drift_numpy_cython_forsum(population)"
     ],
     "language": "python",
     "metadata": {},
     "outputs": [
      {
       "output_type": "stream",
       "stream": "stdout",
       "text": [
        "drift_numpy_cython_forsum\n",
        "1000 loops, best of 3: 480 us per loop"
       ]
      },
      {
       "output_type": "stream",
       "stream": "stdout",
       "text": [
        "\n"
       ]
      }
     ],
     "prompt_number": 253
    },
    {
     "cell_type": "code",
     "collapsed": false,
     "input": [
      "def drift_numpy_dots(population):\n",
      "\tpop_size = float32(population.sum())\n",
      "\tp = population/pop_size\n",
      "\tpopulation[:] = multinomial(pop_size, p)\n",
      "\treturn population"
     ],
     "language": "python",
     "metadata": {},
     "outputs": [],
     "prompt_number": 256
    },
    {
     "cell_type": "code",
     "collapsed": false,
     "input": [
      "population = create_population()\n",
      "print 'drift_numpy'\n",
      "%timeit -n 10000 drift_numpy(population)"
     ],
     "language": "python",
     "metadata": {},
     "outputs": [
      {
       "output_type": "stream",
       "stream": "stdout",
       "text": [
        "drift_numpy\n",
        "10000 loops, best of 3: 343 us per loop"
       ]
      },
      {
       "output_type": "stream",
       "stream": "stdout",
       "text": [
        "\n"
       ]
      }
     ],
     "prompt_number": 347
    },
    {
     "cell_type": "code",
     "collapsed": false,
     "input": [
      "population = create_population()\n",
      "print 'drift_numpy_dots'\n",
      "%timeit -n 10000 drift_numpy_dots(population)"
     ],
     "language": "python",
     "metadata": {},
     "outputs": [
      {
       "output_type": "stream",
       "stream": "stdout",
       "text": [
        "drift_numpy_dots\n",
        "10000 loops, best of 3: 64.7 us per loop"
       ]
      },
      {
       "output_type": "stream",
       "stream": "stdout",
       "text": [
        "\n"
       ]
      }
     ],
     "prompt_number": 348
    },
    {
     "cell_type": "code",
     "collapsed": false,
     "input": [
      "def drift_numpy_dots_no_return(population):\n",
      "\tpop_size = float32(population.sum())\n",
      "\tp = population/pop_size\n",
      "\tpopulation[:] = multinomial(pop_size, p)"
     ],
     "language": "python",
     "metadata": {},
     "outputs": [],
     "prompt_number": 342
    },
    {
     "cell_type": "code",
     "collapsed": false,
     "input": [
      "population = create_population()\n",
      "print 'drift_numpy_dots_no_return'\n",
      "%timeit -n 10000 drift_numpy_dots_no_return(population)"
     ],
     "language": "python",
     "metadata": {},
     "outputs": [
      {
       "output_type": "stream",
       "stream": "stdout",
       "text": [
        "drift_numpy_dots_no_return\n",
        "10000 loops, best of 3: 63.5 us per loop"
       ]
      },
      {
       "output_type": "stream",
       "stream": "stdout",
       "text": [
        "\n"
       ]
      }
     ],
     "prompt_number": 349
    },
    {
     "cell_type": "markdown",
     "metadata": {},
     "source": [
      "## Winner is... drift_numpy_dots"
     ]
    },
    {
     "cell_type": "markdown",
     "metadata": {},
     "source": [
      "# Selection"
     ]
    },
    {
     "cell_type": "code",
     "collapsed": false,
     "input": [
      "def create_fitness():\n",
      "    return array( [ (1-0.1)**x for x in range(num_classes) ] )"
     ],
     "language": "python",
     "metadata": {},
     "outputs": [],
     "prompt_number": 285
    },
    {
     "cell_type": "code",
     "collapsed": false,
     "input": [
      "def selection_python(population, fitness):\n",
      "    pop_size = float(sum(population))\n",
      "    p = [population[i]*fitness[i]/pop_size for i in range(len(population))]\n",
      "    population = multinomial(pop_size, p).tolist()\n",
      "    return population"
     ],
     "language": "python",
     "metadata": {},
     "outputs": [],
     "prompt_number": 287
    },
    {
     "cell_type": "code",
     "collapsed": false,
     "input": [
      "population = create_population().tolist()\n",
      "fitness = create_fitness().tolist()\n",
      "print 'selection_python'\n",
      "%timeit -n 10000 selection_python(population, fitness)"
     ],
     "language": "python",
     "metadata": {},
     "outputs": [
      {
       "output_type": "stream",
       "stream": "stdout",
       "text": [
        "selection_python\n",
        "10000 loops, best of 3: 875 us per loop"
       ]
      },
      {
       "output_type": "stream",
       "stream": "stdout",
       "text": [
        "\n"
       ]
      }
     ],
     "prompt_number": 292
    },
    {
     "cell_type": "code",
     "collapsed": false,
     "input": [
      "def selection_numpy(population, fitness):\n",
      "\tpop_size = float32(population.sum())\n",
      "\tp = population*fitness/pop_size\n",
      "\tpopulation[:] = multinomial(pop_size, p)\n",
      "\treturn population"
     ],
     "language": "python",
     "metadata": {},
     "outputs": [],
     "prompt_number": 303
    },
    {
     "cell_type": "code",
     "collapsed": false,
     "input": [
      "population = create_population()\n",
      "fitness = create_fitness()\n",
      "print 'selection_numpy'\n",
      "%timeit -n 10000 selection_numpy(population, fitness)"
     ],
     "language": "python",
     "metadata": {},
     "outputs": [
      {
       "output_type": "stream",
       "stream": "stdout",
       "text": [
        "selection_numpy\n",
        "10000 loops, best of 3: 111 us per loop"
       ]
      },
      {
       "output_type": "stream",
       "stream": "stdout",
       "text": [
        "\n"
       ]
      }
     ],
     "prompt_number": 315
    },
    {
     "cell_type": "code",
     "collapsed": false,
     "input": [
      "%%cython\n",
      "cimport cython\n",
      "from numpy.random import multinomial\n",
      "cimport numpy as np\n",
      "import numpy as np\n",
      "\n",
      "@cython.boundscheck(False)\n",
      "@cython.wraparound(False)\n",
      "@cython.nonecheck(False)\n",
      "def drift_numpy_cython_forsum(np.ndarray[np.int32_t] population, np.ndarray[double] fitness):\n",
      "    cdef int pop_size = 0\n",
      "    cdef Py_ssize_t i\n",
      "    for i in range(1000):\n",
      "        pop_size = pop_size + population[i]\n",
      "    cdef float pop_size_f = float(pop_size)\n",
      "    cdef np.ndarray[double] p\n",
      "    p = np.empty(1000)\n",
      "    for i in range(1000):\n",
      "        p[i] = population[i]*fitness[i]/pop_size_f\n",
      "    population = multinomial(pop_size, p)\n",
      "    return population"
     ],
     "language": "python",
     "metadata": {},
     "outputs": [],
     "prompt_number": 310
    },
    {
     "cell_type": "code",
     "collapsed": false,
     "input": [
      "population = create_population()\n",
      "fitness = create_fitness()\n",
      "print 'drift_numpy_cython_forsum'\n",
      "%timeit -n 10000 drift_numpy_cython_forsum(population, fitness)"
     ],
     "language": "python",
     "metadata": {},
     "outputs": [
      {
       "output_type": "stream",
       "stream": "stdout",
       "text": [
        "drift_numpy_cython_forsum\n",
        "10000 loops, best of 3: 224 us per loop"
       ]
      },
      {
       "output_type": "stream",
       "stream": "stdout",
       "text": [
        "\n"
       ]
      }
     ],
     "prompt_number": 314
    },
    {
     "cell_type": "markdown",
     "metadata": {},
     "source": [
      "## The winner is... selection_numpy!"
     ]
    },
    {
     "cell_type": "markdown",
     "metadata": {},
     "source": [
      "# Mutation"
     ]
    },
    {
     "cell_type": "code",
     "collapsed": false,
     "input": [
      "from numpy.random import poisson"
     ],
     "language": "python",
     "metadata": {},
     "outputs": [],
     "prompt_number": 316
    },
    {
     "cell_type": "code",
     "collapsed": false,
     "input": [
      "def mutation_numpy(population, mutation_rates):\n",
      "    mutations = poisson(population*mutation_rates)\n",
      "    for i in range(len(mutations)-1):\n",
      "        population[i] -= mutations[i]\n",
      "        population[i+1] += mutations[i]   \n",
      "    return population"
     ],
     "language": "python",
     "metadata": {},
     "outputs": [],
     "prompt_number": 384
    },
    {
     "cell_type": "code",
     "collapsed": false,
     "input": [
      "population = create_population()\n",
      "mutation_rates = array( [0.003]*len(population) )\n",
      "print 'mutation_numpy'\n",
      "%timeit -n 1000 mutation_numpy(population, mutation_rates);"
     ],
     "language": "python",
     "metadata": {},
     "outputs": [
      {
       "output_type": "stream",
       "stream": "stdout",
       "text": [
        "mutation_numpy\n",
        "1000 loops, best of 3: 1.53 ms per loop"
       ]
      },
      {
       "output_type": "stream",
       "stream": "stdout",
       "text": [
        "\n"
       ]
      }
     ],
     "prompt_number": 385
    },
    {
     "cell_type": "code",
     "collapsed": false,
     "input": [
      "%load_ext cythonmagic"
     ],
     "language": "python",
     "metadata": {},
     "outputs": [],
     "prompt_number": 367
    },
    {
     "cell_type": "code",
     "collapsed": false,
     "input": [
      "%%cython\n",
      "from numpy.random import poisson\n",
      "\n",
      "def mutation_cython(population, mutation_rates):\n",
      "    mutations = poisson(population*mutation_rates)\n",
      "    for i in range(population.shape[0]-1):\n",
      "        population[i] -= mutations[i]\n",
      "        population[i+1] += mutations[i]   \n",
      "    return population"
     ],
     "language": "python",
     "metadata": {},
     "outputs": [],
     "prompt_number": 398
    },
    {
     "cell_type": "code",
     "collapsed": false,
     "input": [
      "population = create_population()\n",
      "mutation_rates = array( [0.003]*len(population) )\n",
      "print 'mutation_cython'\n",
      "%timeit -n 1000 mutation_cython(population, mutation_rates)"
     ],
     "language": "python",
     "metadata": {},
     "outputs": [
      {
       "output_type": "stream",
       "stream": "stdout",
       "text": [
        "mutation_cython\n",
        "1000 loops, best of 3: 1.41 ms per loop"
       ]
      },
      {
       "output_type": "stream",
       "stream": "stdout",
       "text": [
        "\n"
       ]
      }
     ],
     "prompt_number": 399
    },
    {
     "cell_type": "code",
     "collapsed": false,
     "input": [
      "%%cython\n",
      "from numpy.random import poisson\n",
      "import numpy as np\n",
      "cimport numpy as np\n",
      "\n",
      "def mutation_cython_cdef(np.ndarray[np.int32_t] population, np.ndarray[double] mutation_rates):\n",
      "    cdef np.ndarray[np.int32_t] mutations\n",
      "    mutations = poisson(population*mutation_rates)\n",
      "    cdef Py_ssize_t i\n",
      "    for i in range(population.shape[0]-1):\n",
      "        population[i] -= mutations[i]\n",
      "        population[i+1] += mutations[i]   \n",
      "    return population"
     ],
     "language": "python",
     "metadata": {},
     "outputs": [],
     "prompt_number": 404
    },
    {
     "cell_type": "code",
     "collapsed": false,
     "input": [
      "population = create_population()\n",
      "mutation_rates = array( [0.003]*len(population) )\n",
      "print 'mutation_cython_cdef'\n",
      "%timeit -n 10000 mutation_cython_cdef(population, mutation_rates)"
     ],
     "language": "python",
     "metadata": {},
     "outputs": [
      {
       "output_type": "stream",
       "stream": "stdout",
       "text": [
        "mutation_cython_cdef\n",
        "10000 loops, best of 3: 222 us per loop"
       ]
      },
      {
       "output_type": "stream",
       "stream": "stdout",
       "text": [
        "\n"
       ]
      }
     ],
     "prompt_number": 412
    },
    {
     "cell_type": "code",
     "collapsed": false,
     "input": [
      "%%cython\n",
      "cimport cython\n",
      "from numpy.random import poisson\n",
      "import numpy as np\n",
      "cimport numpy as np\n",
      "\n",
      "@cython.boundscheck(False)\n",
      "@cython.wraparound(False)\n",
      "@cython.nonecheck(False)\n",
      "def mutation_cython_decorators(np.ndarray[np.int32_t] population, np.ndarray[double] mutation_rates):\n",
      "    cdef np.ndarray[np.int32_t] mutations\n",
      "    mutations = poisson(population*mutation_rates)\n",
      "    cdef Py_ssize_t i\n",
      "    for i in range(population.shape[0]-1):\n",
      "        population[i] -= mutations[i]\n",
      "        population[i+1] += mutations[i]   \n",
      "    return population"
     ],
     "language": "python",
     "metadata": {},
     "outputs": [],
     "prompt_number": 400
    },
    {
     "cell_type": "code",
     "collapsed": false,
     "input": [
      "population = create_population()\n",
      "mutation_rates = array( [0.003]*len(population) )\n",
      "print 'mutation_cython_decorators'\n",
      "%timeit -n 10000 mutation_cython_decorators(population, mutation_rates)"
     ],
     "language": "python",
     "metadata": {},
     "outputs": []
    },
    {
     "cell_type": "code",
     "collapsed": false,
     "input": [
      "%%cython\n",
      "from numpy.random import poisson\n",
      "import numpy as np\n",
      "cimport numpy as np\n",
      "\n",
      "cpdef np.ndarray[np.int32_t] mutation_cython_cpdef(np.ndarray[np.int32_t] population, np.ndarray[double] mutation_rates):\n",
      "    cdef np.ndarray[np.int32_t] mutations\n",
      "    mutations = poisson(population*mutation_rates)\n",
      "    cdef Py_ssize_t i\n",
      "    for i in range(population.shape[0]-1):\n",
      "        population[i] -= mutations[i]\n",
      "        population[i+1] += mutations[i]   \n",
      "    return population"
     ],
     "language": "python",
     "metadata": {},
     "outputs": [],
     "prompt_number": 406
    },
    {
     "cell_type": "code",
     "collapsed": false,
     "input": [
      "population = create_population()\n",
      "mutation_rates = array( [0.003]*len(population) )\n",
      "print 'mutation_cython_cpdef'\n",
      "%timeit -n 10000 mutation_cython_cpdef(population, mutation_rates)"
     ],
     "language": "python",
     "metadata": {},
     "outputs": [
      {
       "output_type": "stream",
       "stream": "stdout",
       "text": [
        "mutation_cython_cpdef\n",
        "10000 loops, best of 3: 261 us per loop"
       ]
      },
      {
       "output_type": "stream",
       "stream": "stdout",
       "text": [
        "\n"
       ]
      }
     ],
     "prompt_number": 411
    },
    {
     "cell_type": "code",
     "collapsed": false,
     "input": [
      "(1.41/1000)/(261.0/1000000)"
     ],
     "language": "python",
     "metadata": {},
     "outputs": [
      {
       "output_type": "pyout",
       "prompt_number": 413,
       "text": [
        "5.402298850574713"
       ]
      }
     ],
     "prompt_number": 413
    },
    {
     "cell_type": "markdown",
     "metadata": {},
     "source": [
      "## And the winnder is... mutation_cython_cdef"
     ]
    }
   ],
   "metadata": {}
  }
 ]
}