Chapter 3 - Functions and Branching.ipynb

{
 "cells": [
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "# 3.1 Functions"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## 3.1.2 Understanding the Program Flow"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "http://www.pythontutor.com"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 1,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "-30.0 -22.0\n",
      "-20.0  -4.0\n",
      "-10.0  14.0\n",
      "  0.0  32.0\n",
      " 10.0  50.0\n",
      " 20.0  68.0\n",
      " 30.0  86.0\n",
      " 40.0 104.0\n",
      " 50.0 122.0\n"
     ]
    }
   ],
   "source": [
    "def F(C):\n",
    "    F = 9./5*C + 32\n",
    "    return F\n",
    "\n",
    "dC = 10\n",
    "C = -30\n",
    "while C <= 50:\n",
    "    print(\"%5.1f %5.1f\" % (C, F(C))) \n",
    "    C += dC"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## 3.1.3 Local and Global Variables"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 2,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Inside F3: C=21 F_value=69.80000000000001 r=21\n"
     ]
    }
   ],
   "source": [
    "def F3(C):\n",
    "    F_value = (9.0/5)*C + 32\n",
    "    print(\"Inside F3: C=%s F_value=%s r=%s\" % (C, F_value, r))\n",
    "    return \"%.1f degrees Celsius corresponds to %.1f degrees Fahrenheit\" % (C, F_value)\n",
    "\n",
    "C = 60     # make a global variable C\n",
    "r = 21     # another global variable\n",
    "s3 = F3(r)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 3,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "'21.0 degrees Celsius corresponds to 69.8 degrees Fahrenheit'"
      ]
     },
     "execution_count": 3,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "s3"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 4,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "60"
      ]
     },
     "execution_count": 4,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "C"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 5,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "<built-in function sum>\n",
      "500\n",
      "3\n",
      "4\n"
     ]
    }
   ],
   "source": [
    "sum_ = sum\n",
    "print(sum) # sum is a built-in Python function\n",
    "sum = 500 # rebind the name sum to an int\n",
    "print(sum) # sum is a global variable\n",
    "def myfunc(n):\n",
    "    sum = n + 1\n",
    "    print(sum) # sum is a local variable\n",
    "    return sum\n",
    "sum = myfunc(2) + 1 # new value in global variable sum\n",
    "print(sum)\n",
    "sum = sum_"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 6,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "20\n",
      "20\n",
      "21\n"
     ]
    }
   ],
   "source": [
    "a = 20; b = -2.5     # global variables\n",
    "\n",
    "def f1(x):\n",
    "    a = 21     # this is a new local variable\n",
    "    return a*x + b\n",
    "\n",
    "print(a)     # yields 20\n",
    "\n",
    "def f2(x):\n",
    "    global a\n",
    "    a = 21     # the global a is changed\n",
    "    return a*x + b\n",
    "\n",
    "f1(3); print(a)     # 20 is printed\n",
    "f2(3); print(a)     # 21 is printed"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## 3.1.4 Multiple Arguments"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 7,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "0.55095"
      ]
     },
     "execution_count": 7,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "def yfunc(t, v0):\n",
    "    g = 9.81\n",
    "    return v0*t - (0.5 * g * t**2)\n",
    "\n",
    "y = yfunc(0.1, 6)\n",
    "y = yfunc(0.1, v0=6)\n",
    "y = yfunc(t=0.1, v0=6)\n",
    "y = yfunc(v0=6, t=0.1)\n",
    "# illegal: y = yfunc(t=0.1, 6)\n",
    "y"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 8,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "0.55095"
      ]
     },
     "execution_count": 8,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "def yfunc(t):\n",
    "    g = 9.81\n",
    "    return v0*t - 0.5*g*t**2\n",
    "\n",
    "v0 = 6\n",
    "y = yfunc(0.1)\n",
    "y"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## 3.1.6 Beyond Mathematical Functions"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 9,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "[0, 0.2, 0.4, 0.6000000000000001, 0.8, 1.0, 1.2, 1.4, 1.5999999999999999, 1.7999999999999998, 1.9999999999999998, 2.1999999999999997, 2.4, 2.6, 2.8000000000000003, 3.0000000000000004, 3.2000000000000006, 3.400000000000001, 3.600000000000001, 3.800000000000001, 4.000000000000001, 4.200000000000001, 4.400000000000001, 4.600000000000001, 4.800000000000002, 5.000000000000002, 5.200000000000002, 5.400000000000002, 5.600000000000002, 5.8000000000000025, 6.000000000000003, 6.200000000000003, 6.400000000000003, 6.600000000000003, 6.800000000000003, 7.0000000000000036, 7.200000000000004, 7.400000000000004, 7.600000000000004, 7.800000000000004, 8.000000000000004, 8.200000000000003, 8.400000000000002, 8.600000000000001, 8.8, 9.0, 9.2, 9.399999999999999, 9.599999999999998, 9.799999999999997, 9.999999999999996]\n"
     ]
    }
   ],
   "source": [
    "def makelist(start, stop, inc):\n",
    "    value = start\n",
    "    result = []\n",
    "    while value <= stop:\n",
    "        result.append(value)\n",
    "        value = value + inc\n",
    "    return result\n",
    "\n",
    "mylist = makelist(0, 10, 0.2)\n",
    "print(mylist)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## 3.1.7 Multiple Return Values"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 10,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "t=0          position=0          velocity=5         \n",
      "t=0.05       position=0.237737   velocity=4.5095    \n",
      "t=0.1        position=0.45095    velocity=4.019     \n",
      "t=0.15       position=0.639638   velocity=3.5285    \n",
      "t=0.2        position=0.8038     velocity=3.038     \n",
      "t=0.25       position=0.943437   velocity=2.5475    \n",
      "t=0.3        position=1.05855    velocity=2.057     \n",
      "t=0.35       position=1.14914    velocity=1.5665    \n",
      "t=0.4        position=1.2152     velocity=1.076     \n",
      "t=0.45       position=1.25674    velocity=0.5855    \n"
     ]
    }
   ],
   "source": [
    "def yfunc(t, v0):\n",
    "    g = 9.81\n",
    "    y = v0*t - 0.5*g*t**2\n",
    "    dydt = v0 - g*t\n",
    "    return y, dydt    # returning a tuple.\n",
    "\n",
    "\n",
    "t_values = [0.05*i for i in range(10)]\n",
    "\n",
    "for t in t_values:\n",
    "    position, velocity = yfunc(t, v0=5)\n",
    "    print(\"t=%-10g position=%-10g velocity=%-10g\" % (t, position, velocity))"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## 3.1.8 Computing Sums"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 11,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "1.3862943611198895"
      ]
     },
     "execution_count": 11,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "def L(x, n):\n",
    "    s = 0\n",
    "    for i in range(1, n+1):\n",
    "        s += 1.0 / i * (x / (1.0 + x))**i\n",
    "    return s\n",
    "\n",
    "L(3, 500)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 12,
   "metadata": {
    "collapsed": true
   },
   "outputs": [],
   "source": [
    "def L2(x, n):\n",
    "    s = 0\n",
    "    for i in range(1, n+1):\n",
    "        s += (1.0/i)*(x/(1.0+x))**i\n",
    "    value_of_sum = s\n",
    "    first_neglected_term = (1.0/(n+1))*(x/(1.0+x))**(n+1)\n",
    "    from math import log\n",
    "    exact_error = log(1+x) - value_of_sum\n",
    "    return value_of_sum, first_neglected_term, exact_error"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## 3.1.9 Functions with No Return Values"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 13,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "\n",
      "x=10, ln(1+x)=2.3979\n",
      "n=1    0.909091   (next term: 4.13e-01 error: 1.49e+00)\n",
      "n=2    1.32231    (next term: 2.50e-01 error: 1.08e+00)\n",
      "n=10   2.17907    (next term: 3.19e-02 error: 2.19e-01)\n",
      "n=100  2.39789    (next term: 6.53e-07 error: 6.59e-06)\n",
      "n=500  2.3979     (next term: 3.65e-24 error: 6.22e-15)\n",
      "\n",
      "x=1000, ln(1+x)=6.90875\n",
      "n=1    0.999001   (next term: 4.99e-01 error: 5.91e+00)\n",
      "n=2    1.498      (next term: 3.32e-01 error: 5.41e+00)\n",
      "n=10   2.919      (next term: 8.99e-02 error: 3.99e+00)\n",
      "n=100  5.08989    (next term: 8.95e-03 error: 1.82e+00)\n",
      "n=500  6.34928    (next term: 1.21e-03 error: 5.59e-01)\n"
     ]
    }
   ],
   "source": [
    "from math import log\n",
    "\n",
    "def table(x):\n",
    "    print(\"\\nx=%g, ln(1+x)=%g\" % (x, log(1+x)))\n",
    "    for n in [1, 2, 10, 100, 500]:\n",
    "        value, next, error = L2(x, n)\n",
    "        print(\"n=%-4d %-10g (next term: %8.2e error: %8.2e)\" % (n, value, next, error))\n",
    "        \n",
    "table(10)\n",
    "table(1000)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## 3.1.10 Keyword Arguments"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 14,
   "metadata": {
    "collapsed": true
   },
   "outputs": [],
   "source": [
    "def somefunc(arg1, arg2, kwarg1=True, kwarg2=0):\n",
    "    print(arg1, arg2, kwarg1, kwarg2)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 15,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Hello [1, 2] True 0\n",
      "Hello [1, 2] Hi 0\n",
      "Hello [1, 2] True Hi\n",
      "Hello [1, 2] 6 Hi\n",
      "Hi [1, 2] 6 Hello\n",
      "Hello Hi 6 [1, 2]\n"
     ]
    }
   ],
   "source": [
    "somefunc(\"Hello\", [1,2])\n",
    "somefunc(\"Hello\", [1,2], kwarg1=\"Hi\")\n",
    "somefunc(\"Hello\", [1,2], kwarg2=\"Hi\")\n",
    "somefunc(\"Hello\", [1,2], kwarg2=\"Hi\", kwarg1=6)\n",
    "somefunc(kwarg2=\"Hello\", arg1=\"Hi\", kwarg1=6, arg2=[1,2],)\n",
    "somefunc(\"Hello\", \"Hi\", 6, [1,2])"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Example"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 16,
   "metadata": {
    "collapsed": true
   },
   "outputs": [],
   "source": [
    "from math import pi, exp, sin\n",
    "\n",
    "def f(t, A=1, a=1, omega=2*pi):\n",
    "    return A*exp(-a*t)*sin(omega*t)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 17,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "0.778659217806053 0.16265669081533915 3.167131721310066e-20 0.00490099254970159 0.08132834540766957\n"
     ]
    }
   ],
   "source": [
    "v1 = f(0.2)\n",
    "v2 = f(0.2, omega=1)\n",
    "v3 = f(1, A=5, omega=pi, a=pi**2)\n",
    "v4 = f(A=5, a=2, t=0.01, omega=0.1)\n",
    "v5 = f(0.2, 0.5, 1, 1)\n",
    "print(v1, v2, v3, v4, v5)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 18,
   "metadata": {
    "collapsed": true
   },
   "outputs": [],
   "source": [
    "def L3(x, ε=1.0E-6):\n",
    "    x = float(x)\n",
    "    i = 1\n",
    "    term = (1.0/i)*(x/(1+x))**i\n",
    "    s = term\n",
    "    while abs(term) > ε:\n",
    "        i += 1\n",
    "        term = (1.0/i)*(x/(1+x))**i\n",
    "        s += term\n",
    "    return s, i"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 19,
   "metadata": {
    "collapsed": true
   },
   "outputs": [],
   "source": [
    "def table2(x):\n",
    "    from math import log\n",
    "    for k in range(4, 14, 2):\n",
    "        epsilon = 10**(-k)\n",
    "        approx, n = L3(x, ε=epsilon)\n",
    "        exact = log(1+x)\n",
    "        exact_error = exact - approx\n",
    "        print(f\"epsilon: {epsilon:.0e}, exact error: {exact_error:.2e}, n={n}\")"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 20,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "epsilon: 1e-04, exact error: 8.18e-04, n=55\n",
      "epsilon: 1e-06, exact error: 9.02e-06, n=97\n",
      "epsilon: 1e-08, exact error: 8.70e-08, n=142\n",
      "epsilon: 1e-10, exact error: 9.20e-10, n=187\n",
      "epsilon: 1e-12, exact error: 9.31e-12, n=233\n"
     ]
    }
   ],
   "source": [
    "table2(10)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## 3.1.11 Doc Strings"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 21,
   "metadata": {
    "collapsed": true
   },
   "outputs": [],
   "source": [
    "def line(x0, y0, x1, y1):\n",
    "    \"\"\"\n",
    "    Compute the coefficients a and b in the mathematical\n",
    "    expression for a straight line y = a*x + b that goes\n",
    "    through two points (x0,y0) and (x1,y1).\n",
    "    x0, y0: a point on the line (float).\n",
    "    x1, y1: another point on the line (float).\n",
    "    return: coefficients a, b (floats) for the line (y=a*x+b).\n",
    "    Example:\n",
    "    >>> a, b = line(1, -1, 4, 3)\n",
    "    >>> a\n",
    "    1.3333333333333333\n",
    "    >>> b\n",
    "    -2.333333333333333\n",
    "    \"\"\"\n",
    "    a = (y1 - y0)/float(x1 - x0)\n",
    "    b = y0 - a*x0\n",
    "    return a, b"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 22,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "'\\n    Compute the coefficients a and b in the mathematical\\n    expression for a straight line y = a*x + b that goes\\n    through two points (x0,y0) and (x1,y1).\\n    x0, y0: a point on the line (float).\\n    x1, y1: another point on the line (float).\\n    return: coefficients a, b (floats) for the line (y=a*x+b).\\n    Example:\\n    >>> a, b = line(1, -1, 4, 3)\\n    >>> a\\n    1.3333333333333333\\n    >>> b\\n    -2.333333333333333\\n    '"
      ]
     },
     "execution_count": 22,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "line.__doc__"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## 3.1.12 Functions as Arguments to Functions"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 23,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "g''(1.200000)=9.767798\n"
     ]
    }
   ],
   "source": [
    "def diff2nd(f, x, h=1E-6):\n",
    "    r = (f(x-h) - 2*f(x) + f(x+h))/float(h*h)\n",
    "    return r\n",
    "\n",
    "def g(t):\n",
    "    return t**(-6)\n",
    "\n",
    "t = 1.2\n",
    "d2g = diff2nd(g, t)\n",
    "\n",
    "print(\"g''(%f)=%f\" % (t, d2g))"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 24,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "h=1e-01: 44.61504\n",
      "h=1e-02: 42.02521\n",
      "h=1e-03: 42.00025\n",
      "h=1e-04: 42.00000\n",
      "h=1e-05: 41.99999\n",
      "h=1e-06: 42.00074\n",
      "h=1e-07: 41.94423\n",
      "h=1e-08: 47.73959\n",
      "h=1e-09: -666.13381\n",
      "h=1e-10: 0.00000\n",
      "h=1e-11: 0.00000\n",
      "h=1e-12: -666133814.77509\n",
      "h=1e-13: 66613381477.50939\n",
      "h=1e-14: 0.00000\n"
     ]
    }
   ],
   "source": [
    "# float precision! -> use \"decimal\" or sympy\n",
    "for k in range(1,15):\n",
    "    h = 10**(-k)\n",
    "    d2g = diff2nd(g, 1, h)\n",
    "    print(\"h=%.0e: %.5f\" % (h, d2g))"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## 3.1.14 Lambda Functions"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 25,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "13\n",
      "13\n"
     ]
    }
   ],
   "source": [
    "f = lambda x: x**2 + 4\n",
    "print(f(3))\n",
    "\n",
    "# equivalent to:\n",
    "def f(x):\n",
    "    return x**2 + 4\n",
    "print(f(3))"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 26,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "0.9112710586123285"
      ]
     },
     "execution_count": 26,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "d2 = diff2nd(lambda t, A=1, a=0.5: -a*2*t*A*exp(-a*t**2), 1.2)\n",
    "d2"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "# 3.2 Branching"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## 3.2.2 Inline if Tests"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 27,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "0.9092974268256817"
      ]
     },
     "execution_count": 27,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "f = lambda x: sin(x) if 0 <= x <= 2*pi else 0\n",
    "f(2)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "# 3.3 Mixing Loops, Branching, and Functions in Bioinformatics Examples"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## 3.3.1 Counting Letters in DNA Strings"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 28,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "['A', 'T', 'G', 'C', 'G', 'G', 'A', 'C', 'C', 'T', 'A', 'T']"
      ]
     },
     "execution_count": 28,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "dna = \"ATGCGGACCTAT\"\n",
    "list(dna)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 29,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "C appears 3 times in ATGCGGACCTAT\n"
     ]
    }
   ],
   "source": [
    "def count(dna, base):\n",
    "    # dna = list(dna)  -> convert string to list (unnecessary, python can iterate over strings)\n",
    "    i = 0              # counter\n",
    "    for c in dna:\n",
    "        if c == base:\n",
    "            i += 1\n",
    "    return i\n",
    "\n",
    "base = 'C'\n",
    "n = count(dna, base)\n",
    "\n",
    "print(f\"{base} appears {n} times in {dna}\")"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 30,
   "metadata": {
    "collapsed": true
   },
   "outputs": [],
   "source": [
    "def count2(dna, base):\n",
    "    i = 0 # counter\n",
    "    for j in range(len(dna)):\n",
    "        if dna[j] == base:\n",
    "            i += 1\n",
    "    return i\n",
    "\n",
    "def count3(dna, base):\n",
    "    i = 0 # counter\n",
    "    j = 0 # string index\n",
    "    while j < len(dna):\n",
    "        if dna[j] == base:\n",
    "            i += 1\n",
    "        j += 1\n",
    "    return i\n",
    "\n",
    "def count4(dna, base):\n",
    "    m = [] # matches for base in dna: m[i]=True if dna[i]==base\n",
    "    for c in dna:\n",
    "        if c == base:\n",
    "            m.append(True)\n",
    "        else:\n",
    "            m.append(False)\n",
    "    return sum(m)    # True: 1, False: 0\n",
    "\n",
    "def count5(dna, base):\n",
    "    m = [] # matches for base in dna: m[i]=True if dna[i]==base\n",
    "    for c in dna:\n",
    "        m.append(c == base) # m.append(True if c == base else False)\n",
    "    return sum(m)\n",
    "\n",
    "def count6(dna, base):\n",
    "    m = [c == base for c in dna]\n",
    "    return sum(m)\n",
    "\n",
    "def count7(dna, base):\n",
    "    return sum([c == base for c in dna])\n",
    "\n",
    "def count8(dna, base):\n",
    "    return sum(c == base for c in dna)    # sum iterator, no need to create a list.\n",
    "\n",
    "def count9(dna, base):\n",
    "    return len([i for i in range(len(dna)) if dna[i] == base])\n",
    "\n",
    "def count10(dna, base):\n",
    "    return dna.count(base)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## 3.3.2 Efficiency Assessment"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 31,
   "metadata": {
    "collapsed": true
   },
   "outputs": [],
   "source": [
    "N = 1000000\n",
    "dna = 'A' * N    # lamo\n",
    "\n",
    "# more exciting:\n",
    "import random\n",
    "alphabet = list(\"ATGC\")\n",
    "dna = [random.choice(alphabet) for i in range(N)]\n",
    "dna = ''.join(dna)    # join the list elements to a string\n",
    "\n",
    "import random\n",
    "\n",
    "def generate_string(N, alphabet=\"ATGC\"):\n",
    "    return ''.join([random.choice(alphabet) for i in range(N)])\n",
    "\n",
    "dna = generate_string(600000)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Measuring CPU time"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 32,
   "metadata": {
    "collapsed": true
   },
   "outputs": [],
   "source": [
    "import time\n",
    "\n",
    "functions = [count, count2, count3, count4,\n",
    "             count5, count6, count7, count8,\n",
    "             count9, count10]\n",
    "timings = []     # timings[i] holds CPU time for functions[i]\n",
    "\n",
    "for function in functions:\n",
    "    t0 = time.clock()\n",
    "    function(dna, 'A')\n",
    "    t1 = time.clock()\n",
    "    cpu_time = t1 - t0\n",
    "    timings.append(cpu_time)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 33,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "count    : 0.04 s\n",
      "count2   : 0.06 s\n",
      "count3   : 0.16 s\n",
      "count4   : 0.14 s\n",
      "count5   : 0.13 s\n",
      "count6   : 0.09 s\n",
      "count7   : 0.09 s\n",
      "count8   : 0.09 s\n",
      "count9   : 0.07 s\n",
      "count10  : 0.00 s\n"
     ]
    }
   ],
   "source": [
    "for cpu_time, function in zip(timings, functions):\n",
    "    print(f\"{function.__name__:<9s}: {cpu_time:.2f} s\")"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## 3.3.3 Verifying the Implementations"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 34,
   "metadata": {
    "collapsed": true
   },
   "outputs": [],
   "source": [
    "dna = \"ATTTGCGGTCCAAA\"\n",
    "exact = dna.count('A')\n",
    "for f in functions:\n",
    "    if f(dna, 'A') != exact:\n",
    "        print(f.__name__, \"failed\")"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 35,
   "metadata": {
    "collapsed": true
   },
   "outputs": [],
   "source": [
    "def test_count_all():\n",
    "    dna = \"ATTTGCGGTCCAAA\"\n",
    "    expected = dna.count('A')\n",
    "    functions = [count, count2, count3, count4,\n",
    "                 count5, count6, count7, count8,\n",
    "                 count9, count10]\n",
    "    for f in functions:\n",
    "        success = f(dna, 'A') == expected\n",
    "        msg = \"%s failed\" % f.__name__\n",
    "        assert success, msg"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 36,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "30.3 µs ± 1.43 µs per loop (mean ± std. dev. of 7 runs, 10000 loops each)\n"
     ]
    }
   ],
   "source": [
    "%timeit test_count_all()"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "# 3.4 Summary"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## 3.4.2 Example: Numerical Integration"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 37,
   "metadata": {
    "collapsed": true
   },
   "outputs": [],
   "source": [
    "def Simpson(f, a, b, n=500):\n",
    "    h = (b - a) / n\n",
    "    return h / 3 * (f(a) + f(b) + 4*sum(f(a + (2*i - 1)*h) for i in range(1, n//2 + 1)) + 2*sum(f(a + 2*i*h) for i in range(1, n//2)))\n",
    "\n",
    "def test_Simpson():\n",
    "    from math import sin, pi\n",
    "    eps = 1e-10\n",
    "    G = lambda x: x**3 - (3.5 * x**2) + 2.5*x\n",
    "    exact = G(2) - G(3/2)\n",
    "    success = abs(Simpson(lambda x: (3 * x**2) - 7*x + 2.5, 3/2, 2) - exact) < eps\n",
    "    assert success"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 38,
   "metadata": {
    "collapsed": true
   },
   "outputs": [],
   "source": [
    "test_Simpson()"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 39,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "approximation: 0.0000000000000000, error=2.000e+00, n=1\n",
      "approximation: 1.9988995863942782, error=1.100e-03, n=10\n",
      "approximation: 1.9999984341019419, error=1.566e-06, n=50\n",
      "approximation: 1.9999999024763504, error=9.752e-08, n=100\n",
      "approximation: 1.9999999999902591, error=9.741e-12, n=1000\n"
     ]
    }
   ],
   "source": [
    "from math import sin, pi\n",
    "\n",
    "for n in (1, 10, 50, 100, 1000):\n",
    "    f = lambda x: 3 / 2 * sin(x)**3\n",
    "    approx = Simpson(f, 0, pi, n)\n",
    "    error = abs(2 - approx)\n",
    "    print(f\"approximation: {approx:.16f}, error={error:.3e}, n={n}\")"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 40,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "approximation: -0.1250000000000000, error=1.250e-01, n=1\n",
      "approximation: -0.2499999999999999, error=5.551e-17, n=10\n",
      "approximation: -0.2500000000000000, error=0.000e+00, n=50\n",
      "approximation: -0.2500000000000000, error=2.776e-17, n=100\n",
      "approximation: -0.2499999999999997, error=3.053e-16, n=1000\n"
     ]
    }
   ],
   "source": [
    "for n in (1, 10, 50, 100, 1000):\n",
    "    f = lambda x: (3 * x**2) - 7*x + 2.5\n",
    "    approx = Simpson(f, 3/2, 2, n)\n",
    "    G = lambda x: x**3 - (3.5 * x**2) + 2.5*x\n",
    "    exact = G(2) - G(3/2)\n",
    "    error = abs(exact - approx)\n",
    "    print(f\"approximation: {approx:19.16f}, error={error:.3e}, n={n}\")"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 41,
   "metadata": {
    "collapsed": true
   },
   "outputs": [],
   "source": [
    "# hpl\n",
    "def Simpson(f, a, b, n=500):\n",
    "    \"\"\"\n",
    "    Return the approximation of the integral of f\n",
    "    from a to b using Simpson’s rule with n intervals.\n",
    "    \"\"\"\n",
    "    \n",
    "    if a > b:\n",
    "        print('Error: a=%g > b=%g' % (a, b))\n",
    "        return None\n",
    "    \n",
    "    # check that n is even:\n",
    "    if n % 2 != 0:\n",
    "        print('Error: n=%d is not an even integer!' % n)\n",
    "        n = n+1 # make n even\n",
    "    \n",
    "    h = (b - a)/float(n)\n",
    "    \n",
    "    sum1 = 0\n",
    "    for i in range(1, n//2 + 1):\n",
    "        sum1 += f(a + (2*i-1)*h)\n",
    " \n",
    "    sum2 = 0   \n",
    "    for i in range(1, n//2):\n",
    "        sum2 += f(a + 2*i*h)\n",
    "    \n",
    "    integral = (b-a)/(3*n)*(f(a) + f(b) + 4*sum1 + 2*sum2)\n",
    "    \n",
    "    return integral\n",
    "    \n",
    "def test_Simpson():\n",
    "    \"\"\"Test exact integration of quadratic polynomials.\"\"\"\n",
    "    a = 1.5\n",
    "    b = 2.0\n",
    "    n = 8\n",
    "    g = lambda x: 3*x**2 - 7*x + 2.5 # test integrand\n",
    "    G = lambda x: x**3 - 3.5*x**2 + 2.5*x # integral of g\n",
    "    exact = G(b) - G(a)\n",
    "    approx = Simpson(g, a, b, n)\n",
    "    success = abs(exact - approx)<1E-14\n",
    "    msg = 'Simpson: %g, exact: %g' % (approx, exact)\n",
    "    assert success, msg\n",
    "    \n",
    "test_Simpson()"
   ]
  }
 ],
 "metadata": {
  "kernelspec": {
   "display_name": "Python 3",
   "language": "python",
   "name": "python3"
  },
  "language_info": {
   "codemirror_mode": {
    "name": "ipython",
    "version": 3
   },
   "file_extension": ".py",
   "mimetype": "text/x-python",
   "name": "python",
   "nbconvert_exporter": "python",
   "pygments_lexer": "ipython3",
   "version": "3.6.2"
  }
 },
 "nbformat": 4,
 "nbformat_minor": 2
}