efficient.ipynb

{
 "cells": [
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "# Efficient programming for parallel computing"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Timing and profiling: `timeit` and `line_profiler`"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "* Timing your code"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 1,
   "metadata": {
    "collapsed": false
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Overwriting timing.py\n"
     ]
    }
   ],
   "source": [
    "%%file timing.py\n",
    "\"\"\"\n",
    "some simple things to time\n",
    "\"\"\"\n",
    "import time\n",
    "\n",
    "\n",
    "def _list_comprehension(N):\n",
    "    return [x*x for x in xrange(N)]\n",
    "\n",
    "\n",
    "def _for_append(N):\n",
    "    L = []\n",
    "    for x in xrange(N):\n",
    "        L.append(x*x)\n",
    "    return L\n",
    "\n",
    "\n",
    "def _for_setitem(N):\n",
    "    L = [None]*N\n",
    "    for x in xrange(N):\n",
    "        L[x] = x*x\n",
    "    return L\n",
    "\n",
    "\n",
    "def timed(f):\n",
    "    def dec(*args, **kwds):\n",
    "        start = time.time()\n",
    "        res = f(*args, **kwds) \n",
    "        dec.__time__[f.__name__] = time.time() - start\n",
    "        return res\n",
    "    def get_time():\n",
    "        return dec.__time__.values()[0]\n",
    "    dec.__time__ = {}\n",
    "    dec.timed = get_time\n",
    "    return dec\n",
    "\n",
    "\n",
    "def compare(f1, f2, N, M=1000):\n",
    "    t1 = 0; t2 = 0\n",
    "    for i in xrange(M):\n",
    "        f1(N)\n",
    "        t1 += f1.timed()\n",
    "    for i in xrange(M):\n",
    "        f2(N)\n",
    "        t2 += f2.timed()\n",
    "    print \"ratio: %s\" % (t1/t2)\n",
    "\n",
    "\n",
    "\n",
    "if __name__ == '__main__':\n",
    "    N = 10000\n",
    "    \n",
    "    print(\"size = %s\" % N)\n",
    "    start = time.time()\n",
    "    _list_comprehension(N)\n",
    "    end = time.time() - start\n",
    "    print(\"%s: list comp\" % end)\n",
    "    \n",
    "    start = time.time()\n",
    "    _for_append(N)\n",
    "    end = time.time() - start\n",
    "    print(\"%s: for append\" % end)\n",
    "    \n",
    "    start = time.time()\n",
    "    _for_setitem(N)\n",
    "    end = time.time() - start\n",
    "    print(\"%s: for setitem\" % end)\n",
    "\n",
    "\n",
    "# EOF"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 2,
   "metadata": {
    "collapsed": false
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "size = 10000\r\n",
      "0.000709056854248: list comp\r\n",
      "0.00122308731079: for append\r\n",
      "0.00180315971375: for setitem\r\n"
     ]
    }
   ],
   "source": [
    "!python2.7 timing.py"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 3,
   "metadata": {
    "collapsed": false
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "result: 40425\n",
      "time: 1.09672546387e-05\n"
     ]
    }
   ],
   "source": [
    "import timing\n",
    "\n",
    "@timing.timed\n",
    "def sum_squared(x):\n",
    "    return sum(i*i for i in x)\n",
    "\n",
    "print \"result: %s\" % sum_squared(xrange(50))\n",
    "print \"time: %s\" % sum_squared.timed()"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 4,
   "metadata": {
    "collapsed": false
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "100000 loops, best of 3: 5.17 µs per loop\n"
     ]
    }
   ],
   "source": [
    "def sum_squared(x):\n",
    "    return sum(i*i for i in x)\n",
    "\n",
    "%timeit sum_squared(xrange(50))"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Profiling your code"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 5,
   "metadata": {
    "collapsed": false
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Overwriting profiling.py\n"
     ]
    }
   ],
   "source": [
    "%%file profiling.py\n",
    "\"\"\"some simple things to profile\n",
    "\"\"\"\n",
    "    \n",
    "GLOBAL = 1\n",
    "\n",
    "\n",
    "def _repeat(counter):\n",
    "    \"\"\"Using the GLOBAL value directly.\n",
    "    \"\"\"\n",
    "    for count in xrange(counter):\n",
    "        GLOBAL\n",
    "\n",
    "\n",
    "def _repeat_local(counter):\n",
    "    \"\"\"Making GLOBAL a local variable.\n",
    "    \"\"\"\n",
    "    local = GLOBAL\n",
    "    for count in xrange(counter):\n",
    "        local\n",
    "\n",
    "\n",
    "def _repeat_2(counter):\n",
    "    \"\"\"Using the built-in `True` in a loop.\n",
    "    \"\"\"\n",
    "    for count in xrange(counter):\n",
    "        True\n",
    "\n",
    "\n",
    "def _repeat_local_2(counter):\n",
    "    \"\"\"Making `True` a local variable.\n",
    "    \"\"\"\n",
    "    true = True\n",
    "    for count in xrange(counter):\n",
    "        true\n",
    "\n",
    "        \n",
    "def _test(counter):\n",
    "    \"\"\"Call all functions.\n",
    "    \"\"\"\n",
    "    _repeat(counter)\n",
    "    _repeat_local(counter)\n",
    "    _repeat_2(counter)\n",
    "    _repeat_local_2(counter)\n",
    "\n",
    "\n",
    "def profile(code_string):\n",
    "    \"\"\"Check the run times.\n",
    "    \"\"\"\n",
    "    import cProfile\n",
    "    profiler = cProfile.Profile()\n",
    "    profiler.run(code_string)\n",
    "    profiler.print_stats()   \n",
    "    \n",
    "\n",
    "    \n",
    "if __name__ == '__main__':\n",
    "    profile('_test(int(1e8))')\n",
    "\n",
    "\n",
    "# EOF"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 19,
   "metadata": {
    "collapsed": false
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "         7 function calls in 13.129 seconds\r\n",
      "\r\n",
      "   Ordered by: standard name\r\n",
      "\r\n",
      "   ncalls  tottime  percall  cumtime  percall filename:lineno(function)\r\n",
      "        1    0.000    0.000   13.129   13.129 <string>:1(<module>)\r\n",
      "        1    2.896    2.896    2.896    2.896 profiling.py:14(_repeat_local)\r\n",
      "        1    3.873    3.873    3.873    3.873 profiling.py:22(_repeat_2)\r\n",
      "        1    2.902    2.902    2.902    2.902 profiling.py:29(_repeat_local_2)\r\n",
      "        1    0.000    0.000   13.129   13.129 profiling.py:37(_test)\r\n",
      "        1    3.458    3.458    3.458    3.458 profiling.py:7(_repeat)\r\n",
      "        1    0.000    0.000    0.000    0.000 {method 'disable' of '_lsprof.Profiler' objects}\r\n",
      "\r\n",
      "\r\n"
     ]
    }
   ],
   "source": [
    "!python profiling.py"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 6,
   "metadata": {
    "collapsed": false
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Overwriting http_search.py\n"
     ]
    }
   ],
   "source": [
    "%%file http_search.py\n",
    "\"\"\"http pattern search\n",
    "\"\"\"\n",
    "\n",
    "import re\n",
    "\n",
    "PATTERN = r\"https?:\\/\\/[\\w\\-_]+(\\.[\\w\\-_]+)+([\\w\\-\\.,@?^=%&amp;:/~\\+#]*[\\w\\-\\@?^=%&amp;/~\\+#])?\"\n",
    "\n",
    "@profile\n",
    "def scan_for_http(f):\n",
    "    addresses = []\n",
    "    for line in f:\n",
    "        result = re.search(PATTERN, line)\n",
    "        if result:\n",
    "            addresses.append(result.group(0))\n",
    "    return addresses\n",
    "\n",
    "\n",
    "if __name__ == \"__main__\":\n",
    "    import sys\n",
    "    f = open(sys.argv[1], 'r')\n",
    "    addresses = scan_for_http(f)\n",
    "    for address in addresses:\n",
    "        pass\n",
    "       #print(address)\n",
    "\n",
    "\n",
    "# EOF"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 37,
   "metadata": {
    "collapsed": false
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Wrote profile results to http_search.py.lprof\n",
      "Timer unit: 1e-06 s\n",
      "\n",
      "Total time: 0.009604 s\n",
      "File: http_search.py\n",
      "Function: scan_for_http at line 8\n",
      "\n",
      "Line #      Hits         Time  Per Hit   % Time  Line Contents\n",
      "==============================================================\n",
      "     8                                           @profile\n",
      "     9                                           def scan_for_http(f):\n",
      "    10         1            2      2.0      0.0      addresses = []\n",
      "    11      1350          778      0.6      8.1      for line in f:\n",
      "    12      1349         8242      6.1     85.8          result = re.search(PATTERN, line)\n",
      "    13      1349          543      0.4      5.7          if result:\n",
      "    14        39           39      1.0      0.4              addresses.append(result.group(0))\n",
      "    15         1            0      0.0      0.0      return addresses\n",
      "\n"
     ]
    }
   ],
   "source": [
    "%%bash\n",
    "kernprof -lv http_search.py sample.html"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 7,
   "metadata": {
    "collapsed": false
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Overwriting http_search.py\n"
     ]
    }
   ],
   "source": [
    "%%file http_search.py\n",
    "\"\"\"http pattern search\n",
    "\"\"\"\n",
    "\n",
    "import re\n",
    "\n",
    "PATTERN = r\"https?:\\/\\/[\\w\\-_]+(\\.[\\w\\-_]+)+([\\w\\-\\.,@?^=%&amp;:/~\\+#]*[\\w\\-\\@?^=%&amp;/~\\+#])?\"\n",
    "\n",
    "@profile\n",
    "def scan_for_http(f):\n",
    "    addresses = []\n",
    "    pat = re.compile(PATTERN) # <-- NOTE\n",
    "    for line in f:\n",
    "        result = pat.search(line)\n",
    "        if result:\n",
    "            addresses.append(result.group(0))\n",
    "    return addresses\n",
    "\n",
    "\n",
    "if __name__ == \"__main__\":\n",
    "    import sys\n",
    "    f = open(sys.argv[1], 'r')\n",
    "    addresses = scan_for_http(f)\n",
    "    for address in addresses:\n",
    "        pass\n",
    "       #print(address)\n",
    "\n",
    "\n",
    "# EOF"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 39,
   "metadata": {
    "collapsed": false
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Wrote profile results to http_search.py.lprof\n",
      "Timer unit: 1e-06 s\n",
      "\n",
      "Total time: 0.004025 s\n",
      "File: http_search.py\n",
      "Function: scan_for_http at line 8\n",
      "\n",
      "Line #      Hits         Time  Per Hit   % Time  Line Contents\n",
      "==============================================================\n",
      "     8                                           @profile\n",
      "     9                                           def scan_for_http(f):\n",
      "    10         1            2      2.0      0.0      addresses = []\n",
      "    11         1         1667   1667.0     41.4      pat = re.compile(PATTERN) # <-- NOTE\n",
      "    12      1350          705      0.5     17.5      for line in f:\n",
      "    13      1349         1150      0.9     28.6          result = pat.search(line)\n",
      "    14      1349          466      0.3     11.6          if result:\n",
      "    15        39           34      0.9      0.8              addresses.append(result.group(0))\n",
      "    16         1            1      1.0      0.0      return addresses\n",
      "\n"
     ]
    }
   ],
   "source": [
    "%%bash\n",
    "kernprof -lv http_search.py sample.html"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Not covered: memory profiling. See `guppy` and `pympler`"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Also see: http://pynash.org/2013/03/06/timing-and-profiling/"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Efficiency in language patterns"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "* Global versus local"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "* Staying native"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 15,
   "metadata": {
    "collapsed": false
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "for 100, ON:O1 = 2.01408450704\n",
      "for 100, O1:list = 0.0597014925373\n",
      "for 1000, ON:O1 = 4.36685288641\n",
      "for 1000, O1:list = 0.0243902439024\n",
      "for 10000, ON:O1 = 23.2021516571\n",
      "for 10000, O1:list = 0.022230965965\n"
     ]
    }
   ],
   "source": [
    "import timing\n",
    "\n",
    "@timing.timed\n",
    "def use_ON(iterable):\n",
    "    result = []\n",
    "    for item in iterable:\n",
    "        result.insert(0, item)\n",
    "    return result\n",
    "\n",
    "\n",
    "@timing.timed\n",
    "def use_O1(iterable):\n",
    "    result = []\n",
    "    for item in iterable:\n",
    "        result.append(item)\n",
    "    result.reverse()\n",
    "    return result\n",
    "\n",
    "\n",
    "@timing.timed\n",
    "def use_list(iterable):\n",
    "    result = list(iterable)\n",
    "    result.reverse()\n",
    "    return result\n",
    "\n",
    "\n",
    "def compare_ON_O1(N):\n",
    "    r1 = use_ON(range(N))\n",
    "    r2 = use_O1(range(N))\n",
    "    print use_ON.timed() / use_O1.timed()\n",
    "\n",
    "    \n",
    "def compare_O1_list(N):\n",
    "    r1 = use_list(range(N))\n",
    "    r2 = use_O1(range(N))\n",
    "    print use_list.timed() / use_O1.timed()\n",
    "\n",
    "    \n",
    "for i in [100,1000,10000]:\n",
    "    print \"for %s, ON:O1 =\" % i,\n",
    "    compare_ON_O1(i)\n",
    "    print \"for %s, O1:list =\" % i,\n",
    "    compare_O1_list(i)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "* Pointers versus copies"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 16,
   "metadata": {
    "collapsed": false
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "N=100 ratio: 0.911269430052\n",
      "N=1000 ratio: 0.752598695878\n",
      "N=10000 ratio: 0.66382711874\n"
     ]
    }
   ],
   "source": [
    "import timing\n",
    "\n",
    "@timing.timed\n",
    "def double_extend(N):\n",
    "    x = range(N)\n",
    "    x.extend(x)\n",
    "    return x\n",
    "\n",
    "@timing.timed\n",
    "def double_concatenate(N):\n",
    "    x = range(N)\n",
    "    return x+x\n",
    "\n",
    "for i in [100,1000,10000]:\n",
    "    print \"N=%s\" % i,\n",
    "    timing.compare(double_extend, double_concatenate, N=i)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "* Choosing the right container"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 17,
   "metadata": {
    "collapsed": false
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "M=10, N=1000 ratio: 0.924845269673\n",
      "M=10, N=10000 ratio: 0.821234487793\n",
      "M=10, N=100000 ratio: 0.614927891245\n",
      "M=100, N=1000 ratio: 1.07002729444\n",
      "M=100, N=10000 ratio: 0.959192717797\n",
      "M=100, N=100000 ratio: 0.739521890806\n",
      "M=1000, N=1000 ratio: 0.998064452741\n",
      "M=1000, N=10000 ratio: 0.893941558453\n",
      "M=1000, N=100000 ratio: 0.724139481948\n"
     ]
    }
   ],
   "source": [
    "import timing\n",
    "\n",
    "@timing.timed\n",
    "def search_list(N):\n",
    "    x = list(xrange(N))\n",
    "    return N in x\n",
    "\n",
    "@timing.timed\n",
    "def search_set(N):\n",
    "    x = set(xrange(N))\n",
    "    return N in x\n",
    "\n",
    "\n",
    "for j in [10,100,1000]:\n",
    "    for i in [1000,10000,100000]:\n",
    "        print \"M=%s, N=%s\" % (j, i),\n",
    "        timing.compare(search_list, search_set, N=i, M=j)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 17,
   "metadata": {
    "collapsed": false
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "The slowest run took 29.05 times longer than the fastest. This could mean that an intermediate result is being cached \n",
      "10000000 loops, best of 3: 73.9 ns per loop\n",
      "10000 loops, best of 3: 144 µs per loop\n"
     ]
    }
   ],
   "source": [
    "N = 10000\n",
    "x = set(xrange(N))\n",
    "%timeit N in x\n",
    "x = list(xrange(N))\n",
    "%timeit N in x"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "* Looping constructs"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "**EXERCISE:** Write test code that calculates the sum of all squares of the numbers from zero to one million. Use a for loop that directly adds with `+=`, a list comprehension, and also generator comprehension. Try it with `range` and `xrange`. Use different numbers, e.g. smaller and larger than one million.  How do they compare?"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 24,
   "metadata": {
    "collapsed": false
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Overwriting looping.py\n"
     ]
    }
   ],
   "source": [
    "%%file looping.py\n",
    "\"\"\"test some looping constructs\n",
    "\"\"\"\n",
    "\n",
    "def generator(N):\n",
    "    return sum(i*i for i in xrange(N))\n",
    "\n",
    "def list_comp(N):\n",
    "    return sum([i*i for i in xrange(N)])\n",
    "\n",
    "def for_loop(N):\n",
    "    sum = 0\n",
    "    for i in xrange(N):\n",
    "        sum += i*i\n",
    "    return sum\n",
    "\n",
    "\n",
    "for N in [100,1000,10000,1000000]:\n",
    "    print \"N = %s\" % N\n",
    "    %timeit generator(N)\n",
    "    %timeit list_comp(N)\n",
    "    %timeit for_loop(N)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 23,
   "metadata": {
    "collapsed": false
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "N = 100\n",
      "100000 loops, best of 3: 9.61 µs per loop\n",
      "100000 loops, best of 3: 8.52 µs per loop\n",
      "100000 loops, best of 3: 7.14 µs per loop\n",
      "N = 1000\n",
      "10000 loops, best of 3: 90.5 µs per loop\n",
      "10000 loops, best of 3: 66.6 µs per loop\n",
      "10000 loops, best of 3: 81.8 µs per loop\n",
      "N = 10000\n",
      "1000 loops, best of 3: 897 µs per loop\n",
      "1000 loops, best of 3: 635 µs per loop\n",
      "1000 loops, best of 3: 843 µs per loop\n",
      "N = 1000000\n",
      "10 loops, best of 3: 89.6 ms per loop\n",
      "10 loops, best of 3: 71.8 ms per loop\n",
      "10 loops, best of 3: 85 ms per loop\n"
     ]
    }
   ],
   "source": [
    "# %load looping.py\n",
    "\"\"\"test some looping constructs\n",
    "\"\"\"\n",
    "\n",
    "def generator(N):\n",
    "    return sum(i*i for i in xrange(N))\n",
    "\n",
    "def list_comp(N):\n",
    "    return sum([i*i for i in xrange(N)])\n",
    "\n",
    "def for_loop(N):\n",
    "    sum = 0\n",
    "    for i in xrange(N):\n",
    "        sum += i*i\n",
    "    return sum\n",
    "\n",
    "\n",
    "for N in [100,1000,10000,1000000]:\n",
    "    print \"N = %s\" % N\n",
    "    %timeit generator(N)\n",
    "    %timeit list_comp(N)\n",
    "    %timeit for_loop(N)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Vector programming: `numpy`"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "* `numpy` basics"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 39,
   "metadata": {
    "collapsed": false
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "[ 6  8 10 12]\n",
      "[ 5 12 21 32]\n",
      "[-8 -7 -4  1]\n"
     ]
    }
   ],
   "source": [
    "import numpy as np\n",
    "a = np.array([1,2,3,4])\n",
    "b = np.array([5,6,7,8])\n",
    "\n",
    "print a+b\n",
    "print a*b\n",
    "print a**2 - 2*b + 1"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 44,
   "metadata": {
    "collapsed": false
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "[ 0.84147098  0.90929743  0.14112001 -0.7568025 ]\n",
      "4\n"
     ]
    }
   ],
   "source": [
    "print np.sin(a)\n",
    "print np.max(a)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 49,
   "metadata": {
    "collapsed": false
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "[1 2 3 4 5 6 7 8]\n",
      "[ 6  8 10 12]\n",
      "[ 1  3  6 10]\n"
     ]
    }
   ],
   "source": [
    "print np.hstack((a,b))\n",
    "print np.add(a,b)\n",
    "print np.add.accumulate(a)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 54,
   "metadata": {
    "collapsed": false
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "[0 2 4 6]\n",
      "[0]\n",
      "[0 4]\n",
      "[ 0  4 16]\n",
      "[ 0  4 16 36]\n"
     ]
    }
   ],
   "source": [
    "c = np.arange(0,8,2)\n",
    "print c\n",
    "d = np.empty(c.shape, dtype=int)\n",
    "for i,j in enumerate(c):\n",
    "    d[i] = j**2\n",
    "    print d[:i+1]"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 62,
   "metadata": {
    "collapsed": false
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "[[1 2 3 4]\n",
      " [5 6 7 8]]\n"
     ]
    }
   ],
   "source": [
    "e = np.vstack((a,b))\n",
    "print e"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "* Pointers versus copies"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 64,
   "metadata": {
    "collapsed": false
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "(2, 4)\n",
      "[[1 2 3 4 5 6 7 8]]\n",
      "[[1 2]\n",
      " [3 4]\n",
      " [5 6]\n",
      " [7 8]]\n"
     ]
    }
   ],
   "source": [
    "print e.shape\n",
    "e.shape = (-1,8)\n",
    "print e\n",
    "c = e.reshape((4,2))\n",
    "print c"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 66,
   "metadata": {
    "collapsed": false
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "[[-1  3  5  7]\n",
      " [ 2  4  6  8]]\n",
      "[-1  3  5  7  2  4  6  8]\n"
     ]
    }
   ],
   "source": [
    "d = c.T\n",
    "print d\n",
    "b = d.flatten()\n",
    "print b"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 67,
   "metadata": {
    "collapsed": false
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "[[-1  3  5  7]\n",
      " [ 2  4  6  8]]\n"
     ]
    }
   ],
   "source": [
    "c[0,0] = -1\n",
    "b[-1] = 10\n",
    "print d"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "* `slice` versus `where`"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 71,
   "metadata": {
    "collapsed": false
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "[[11 13 15 17]\n",
      " [ 2  4  6  8]]\n"
     ]
    }
   ],
   "source": [
    "d[0,:2] = [11,13]\n",
    "c[2:,0] = [15,17]\n",
    "print d"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 72,
   "metadata": {
    "collapsed": false
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "[11 15]\n",
      "[1 5]\n",
      "[[ 1 13  5 17]\n",
      " [ 2  4  6  8]]\n"
     ]
    }
   ],
   "source": [
    "b = d[0,::2]\n",
    "print b\n",
    "np.add(b,-10,b)\n",
    "print b\n",
    "print d"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 77,
   "metadata": {
    "collapsed": false
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "The slowest run took 25.41 times longer than the fastest. This could mean that an intermediate result is being cached \n",
      "10000000 loops, best of 3: 159 ns per loop\n",
      "The slowest run took 15.04 times longer than the fastest. This could mean that an intermediate result is being cached \n",
      "1000000 loops, best of 3: 270 ns per loop\n",
      "The slowest run took 18.78 times longer than the fastest. This could mean that an intermediate result is being cached \n",
      "1000000 loops, best of 3: 698 ns per loop\n"
     ]
    }
   ],
   "source": [
    "x = np.arange(1e8)\n",
    "%timeit x.T\n",
    "%timeit y = x[1::2]\n",
    "%timeit np.add(c,d.T)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 113,
   "metadata": {
    "collapsed": false
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "[ 0  2  4  6  9 11 13 16]\n",
      "(array([5, 6, 7]),)\n",
      "[11 13 16]\n",
      "[11 13 16]\n"
     ]
    }
   ],
   "source": [
    "x = np.linspace(0,16,8, dtype=int)\n",
    "print x\n",
    "print np.where(x >= 10)\n",
    "print x[np.where(x >= 10)]\n",
    "print x[x >= 10]"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 114,
   "metadata": {
    "collapsed": false
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "[ 0  2  4  6  8 10 12 16]\n"
     ]
    }
   ],
   "source": [
    "x[x % 2 != 0] = x[x % 2 != 0] - 1\n",
    "print x"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "* Vector programming versus looping"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 115,
   "metadata": {
    "collapsed": false
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "[[ 0.84147098  0.03232054 -0.19178485 -0.05655279]\n",
      " [ 0.45464871 -0.18920062 -0.04656925  0.12366978]]\n"
     ]
    }
   ],
   "source": [
    "def _sinc(x):\n",
    "    if x == 0.0:\n",
    "        return 1.0\n",
    "    return np.sin(x)/x\n",
    "\n",
    "sinc = np.vectorize(_sinc)  # could use as a decorator\n",
    "\n",
    "print sinc(d)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 116,
   "metadata": {
    "collapsed": false
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "10000 loops, best of 3: 34.6 µs per loop\n",
      "10000 loops, best of 3: 43.1 µs per loop\n",
      "100000 loops, best of 3: 10.3 µs per loop\n"
     ]
    }
   ],
   "source": [
    "%timeit map(_sinc, x)\n",
    "%timeit sinc(x)\n",
    "%timeit np.sinc(x)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "**EXERCISE:** Profile the functions in `roll.py`, `strategy.py`, and `trials.py`.  Where are the hot spots?  Can you make any significant improvements?  Try converting to vectorized versions of the code in those three files where it seems appropriate.  Can you make any gains?  (Don't touch the code in `optimize.py` for now.)  Note that some functions don't vectorize well, so make sure to retain the original verions of the code -- especially since some other techniques for speeding up code may prefer non-vector versions."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "See: ['solution'](premature.ipynb)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Programming efficency: testing and error handling"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "* Functional programming as a gateway to parallel"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 118,
   "metadata": {
    "collapsed": false
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "[25, 9, 1, 1, 9, 25, 49, 81, 121, 169, 225]\n",
      "[25, 9, 1, 1, 9, 25, 49, 81, 121, 169, 225]\n",
      "100000 loops, best of 3: 5.94 µs per loop\n",
      "100000 loops, best of 3: 3.91 µs per loop\n"
     ]
    }
   ],
   "source": [
    "x = range(11)\n",
    "y = range(-5,6)\n",
    "\n",
    "def add(x,y):\n",
    "    return x+y\n",
    "\n",
    "def squared(x):\n",
    "    return x*x \n",
    "\n",
    "print [squared(i) for i in (add(j,k) for j,k in zip(x,y))]\n",
    "print map(squared, map(add, x, y))\n",
    "\n",
    "%timeit [squared(i) for i in (add(j,k) for j,k in zip(x,y))]\n",
    "%timeit map(squared, map(add, x, y))"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 119,
   "metadata": {
    "collapsed": false
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "100000 loops, best of 3: 2.33 µs per loop\n",
      "1000 loops, best of 3: 855 µs per loop\n"
     ]
    }
   ],
   "source": [
    "from multiprocessing.dummy import Pool\n",
    "tmap = Pool().map\n",
    "%timeit map(squared, range(10))\n",
    "%timeit tmap(squared, range(10))"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 120,
   "metadata": {
    "collapsed": false
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "1 loops, best of 3: 1.01 s per loop\n",
      "1 loops, best of 3: 202 ms per loop\n"
     ]
    }
   ],
   "source": [
    "def sleepy_squared(x):\n",
    "    import time\n",
    "    time.sleep(.1)\n",
    "    return x*x\n",
    "\n",
    "%timeit map(sleepy_squared, range(10))\n",
    "%timeit tmap(sleepy_squared, range(10))"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "* Not covered: `nose` and saving your validation code"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 121,
   "metadata": {
    "collapsed": false
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Writing test_squared_map.py\n"
     ]
    }
   ],
   "source": [
    "%%file test_squared_map.py\n",
    "\"\"\"sanity check for our parallel maps\n",
    "\"\"\"\n",
    "from multiprocessing.dummy import Pool\n",
    "tmap = Pool().map\n",
    "\n",
    "x = range(11)\n",
    "\n",
    "def squared(x):\n",
    "    return x*x\n",
    "\n",
    "def test_squared():\n",
    "    assert map(squared, x) == tmap(squared, x)\n",
    "\n",
    "\n",
    "# EOF"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 122,
   "metadata": {
    "collapsed": false
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      ".\r\n",
      "----------------------------------------------------------------------\r\n",
      "Ran 1 test in 0.001s\r\n",
      "\r\n",
      "OK\r\n"
     ]
    }
   ],
   "source": [
    "!nosetests test_squared_map.py"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "See: https://nose.readthedocs.org/en/latest/"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "* Errors and error handling"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 127,
   "metadata": {
    "collapsed": false
   },
   "outputs": [
    {
     "ename": "ImportError",
     "evalue": "No module named sleep",
     "output_type": "error",
     "traceback": [
      "\u001b[0;31m---------------------------------------------------------------------------\u001b[0m",
      "\u001b[0;31mImportError\u001b[0m                               Traceback (most recent call last)",
      "\u001b[0;32m<ipython-input-127-6c3719217f06>\u001b[0m in \u001b[0;36m<module>\u001b[0;34m()\u001b[0m\n\u001b[1;32m      4\u001b[0m     \u001b[0;32mreturn\u001b[0m \u001b[0mx\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[1;32m      5\u001b[0m \u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0;32m----> 6\u001b[0;31m \u001b[0;32mprint\u001b[0m \u001b[0mmap\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0mbad\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0mrange\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0;36m2\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0m",
      "\u001b[0;32m<ipython-input-127-6c3719217f06>\u001b[0m in \u001b[0;36mbad\u001b[0;34m(x)\u001b[0m\n\u001b[1;32m      1\u001b[0m \u001b[0;32mdef\u001b[0m \u001b[0mbad\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0mx\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m:\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0;32m----> 2\u001b[0;31m     \u001b[0;32mimport\u001b[0m \u001b[0msleep\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0m\u001b[1;32m      3\u001b[0m     \u001b[0msleep\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0mx\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[1;32m      4\u001b[0m     \u001b[0;32mreturn\u001b[0m \u001b[0mx\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[1;32m      5\u001b[0m \u001b[0;34m\u001b[0m\u001b[0m\n",
      "\u001b[0;31mImportError\u001b[0m: No module named sleep"
     ]
    }
   ],
   "source": [
    "def bad(x):\n",
    "    import sleep\n",
    "    sleep(x)\n",
    "    return x\n",
    "\n",
    "print map(bad, range(2))"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 128,
   "metadata": {
    "collapsed": false
   },
   "outputs": [
    {
     "data": {
      "text/plain": [
       "[None, None]"
      ]
     },
     "execution_count": 128,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "def less_bad(x):\n",
    "    try:\n",
    "        import sleep\n",
    "    except ImportError:\n",
    "        return None\n",
    "    sleep(x)\n",
    "    return x\n",
    "\n",
    "map(less_bad, range(2))"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "* Sanity checking with `pyflakes` and `pep8`"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 126,
   "metadata": {
    "collapsed": false
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "test_squared_map.py:8:1: E302 expected 2 blank lines, found 1\n",
      "test_squared_map.py:11:1: E302 expected 2 blank lines, found 1\n",
      "test_squared_map.py:15:6: W292 no newline at end of file\n"
     ]
    }
   ],
   "source": [
    "%%bash\n",
    "pyflakes-2.7 test_squared_map.py\n",
    "pep8-2.7 test_squared_map.py"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "* Serialization and code encapsulation"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 135,
   "metadata": {
    "collapsed": false
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Writing state.py\n"
     ]
    }
   ],
   "source": [
    "%%file state.py\n",
    "\"\"\"some good state utilities\n",
    "\"\"\"\n",
    "\n",
    "def check_pickle(x):\n",
    "    \"checks the pickle across a subprocess\"\n",
    "    import pickle\n",
    "    import subprocess\n",
    "    fail = True\n",
    "    try:\n",
    "        _x = pickle.dumps(x)\n",
    "        fail = False\n",
    "    finally:\n",
    "        if fail:\n",
    "            print \"DUMP FAILED\"\n",
    "    msg = \"python -c import pickle; print pickle.loads(%s)\" % repr(_x)\n",
    "    print \"SUCCESS\" if not subprocess.call(msg.split(None,2)) else \"LOAD FAILED\"\n",
    "\n",
    "\n",
    "# EOF"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 136,
   "metadata": {
    "collapsed": false
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "(lp0\n",
      "I1\n",
      "aI2\n",
      "aI3\n",
      "a.\n"
     ]
    }
   ],
   "source": [
    "import pickle\n",
    "print pickle.dumps([1,2,3])"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 137,
   "metadata": {
    "collapsed": false
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "c__main__\n",
      "squared\n",
      "p0\n",
      ".\n"
     ]
    }
   ],
   "source": [
    "print pickle.dumps(squared)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 138,
   "metadata": {
    "collapsed": false
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "SUCCESS\n"
     ]
    }
   ],
   "source": [
    "import state\n",
    "state.check_pickle([1,2,3])"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 139,
   "metadata": {
    "collapsed": false
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "LOAD FAILED\n"
     ]
    }
   ],
   "source": [
    "state.check_pickle(squared)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 140,
   "metadata": {
    "collapsed": false
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Writing sleepy.py\n"
     ]
    }
   ],
   "source": [
    "%%file sleepy.py\n",
    "'''test file for pickling \n",
    "'''\n",
    "def sleepy_squared(x):\n",
    "    import time\n",
    "    time.sleep(.1)\n",
    "    return x*x\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 141,
   "metadata": {
    "collapsed": false
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "SUCCESS\n"
     ]
    }
   ],
   "source": [
    "import sleepy\n",
    "state.check_pickle(sleepy.sleepy_squared)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Let's look at going parallel with [multiprocessing](multiprocessing.ipynb)..."
   ]
  }
 ],
 "metadata": {
  "kernelspec": {
   "display_name": "Python 2",
   "language": "python",
   "name": "python2"
  },
  "language_info": {
   "codemirror_mode": {
    "name": "ipython",
    "version": 2
   },
   "file_extension": ".py",
   "mimetype": "text/x-python",
   "name": "python",
   "nbconvert_exporter": "python",
   "pygments_lexer": "ipython2",
   "version": "2.7.10"
  }
 },
 "nbformat": 4,
 "nbformat_minor": 0
}