day2_reading_journal.ipynb

{
 "cells": [
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "# Day 2 Reading Journal\n",
    "\n",
    "This journal includes several required exercises, but it is meant to encourage active reading more generally.  You should use the journal to take detailed notes, catalog questions, and explore the content from Think Python deeply.\n",
    "\n",
    "Reading: Think Python Chapter 6.1-6.4, 7\n",
    "\n",
    "**Due: Tuesday, January 24 at 12 noon**\n",
    "\n"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## [Chapter 6.1-6.4](http://greenteapress.com/thinkpython2/html/thinkpython2007.html)\n",
    "\n",
    "Note: the exercise numbers below match up with the reading for ease of cross referencing."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "**Quick check:** What is a _fruitful function_?"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "The function that actually returns the value.  "
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Chapter 6.1 \n",
    "Write a `compare` function that returns `1` if `x > y`, `0` if `x == y`, and `-1` if `x < y`."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 6,
   "metadata": {
    "collapsed": false
   },
   "outputs": [
    {
     "data": {
      "text/plain": [
       "1"
      ]
     },
     "execution_count": 6,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "def comparison(x,y):\n",
    "    if x>y:\n",
    "        return 1\n",
    "    elif x == y:\n",
    "        return 0\n",
    "    else:\n",
    "        return -1\n",
    "\n",
    "comparison(5,3)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 8,
   "metadata": {
    "collapsed": false
   },
   "outputs": [
    {
     "data": {
      "text/plain": [
       "0"
      ]
     },
     "execution_count": 8,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "def comparison(x,y):\n",
    "    if x>y:\n",
    "        return 1\n",
    "    elif x == y:\n",
    "        return 0\n",
    "    else:\n",
    "        return \n",
    "    \n",
    "comparison(3,3)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 23,
   "metadata": {
    "collapsed": true
   },
   "outputs": [],
   "source": [
    "def comparison(x,y):\n",
    "    if x>y:\n",
    "        return 1\n",
    "    elif x == y:\n",
    "        return 0\n",
    "    else:\n",
    "        return \n",
    "\n",
    "comparison(3,5)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "collapsed": true
   },
   "outputs": [],
   "source": []
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "**Quick check:** Modify the `absolute_value` function so that it returns the correct result for all integer inputs."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 11,
   "metadata": {
    "collapsed": false
   },
   "outputs": [
    {
     "data": {
      "text/plain": [
       "0"
      ]
     },
     "execution_count": 11,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "def absolute_value(x):\n",
    "    if x < 0:\n",
    "        return -x\n",
    "    if x > 0:\n",
    "        return x\n",
    "    else:\n",
    "        return 0\n",
    "    \n",
    "absolute_value(0)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Chapter 6.4\n",
    "Write a function `is_between(x, y, z)` that returns `True` if `x ≤ y ≤ z` or `False` otherwise."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 16,
   "metadata": {
    "collapsed": false
   },
   "outputs": [
    {
     "data": {
      "text/plain": [
       "True"
      ]
     },
     "execution_count": 16,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "def is_between(x,y,z):\n",
    "    if x<= y <= z:\n",
    "        return True\n",
    "    else:\n",
    "        return False\n",
    "\n",
    "is_between(1,2,3)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 19,
   "metadata": {
    "collapsed": false
   },
   "outputs": [
    {
     "data": {
      "text/plain": [
       "False"
      ]
     },
     "execution_count": 19,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "def is_between(x,y,z):\n",
    "    if x<= y <= z:\n",
    "        return True\n",
    "    else:\n",
    "        return False\n",
    "\n",
    "is_between(1,5,3)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## [Chapter 7](http://greenteapress.com/thinkpython2/html/thinkpython2008.html)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "**Quick check:** How do you test for equality in Python?"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "= assigns the value to certain variable and == is used for testing equality."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "**Challenge:** Prove/disprove the Collatz conjecture :)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Nobody proved it before :)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Chapter 7.5\n",
    "Encapsulate the loop from Section 7.5 in a function called `square_root` that takes `a` as a parameter, chooses a reasonable value of `x`, and returns an estimate of the square root of `a`."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 4,
   "metadata": {
    "collapsed": false
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "3\n",
      "7.5\n",
      "6.15\n",
      "6.001829268292683\n",
      "6.000000278766883\n",
      "6.000000000000007\n",
      "6.0\n"
     ]
    }
   ],
   "source": [
    "def square_root(a):\n",
    "    x = 3\n",
    "    while True:\n",
    "        print(x)\n",
    "        y = (x + a/x) / 2\n",
    "        if y == x:\n",
    "            break\n",
    "        x = y\n",
    "\n",
    "square_root(36)\n"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Exercise 7.1  \n",
    "To test the square root algorithm you developed in Exercise 2, you could compare it with Python's `math.sqrt` function. Write a function named `test_square_root` that prints a table like this:\n",
    "\n",
    "```python\n",
    "1.0 1.0           1.0           0.0\n",
    "2.0 1.41421356237 1.41421356237 2.22044604925e-16\n",
    "3.0 1.73205080757 1.73205080757 0.0\n",
    "4.0 2.0           2.0           0.0\n",
    "5.0 2.2360679775  2.2360679775  0.0\n",
    "6.0 2.44948974278 2.44948974278 0.0\n",
    "7.0 2.64575131106 2.64575131106 0.0\n",
    "8.0 2.82842712475 2.82842712475 4.4408920985e-16\n",
    "9.0 3.0           3.0           0.0\n",
    "```\n",
    "\n",
    "The first column is a number, `a`; the second column is the square root of a computed with the function from Section 7.5; the third column is the square root computed by `math.sqrt`; the fourth column is the absolute value of the difference between the two estimates."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 26,
   "metadata": {
    "collapsed": false
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "            1.000000            1.000000            1.000000            0.000000\n",
      "            2.000000            1.414214            1.414214           -0.000000\n",
      "            3.000000            1.732051            1.732051            0.000000\n",
      "            4.000000            2.000000            2.000000            0.000000\n",
      "            5.000000            2.236068            2.236068            0.000000\n",
      "            6.000000            2.449490            2.449490            0.000000\n",
      "            7.000000            2.645751            2.645751            0.000000\n",
      "            8.000000            2.828427            2.828427           -0.000000\n",
      "            9.000000            3.000000            3.000000            0.000000\n"
     ]
    }
   ],
   "source": [
    "import math\n",
    "\n",
    "def square_root(a):\n",
    "    x = 3\n",
    "    while True:\n",
    "        y = (x + a/x) / 2\n",
    "        if y == x:\n",
    "            break\n",
    "        x = y\n",
    "    return y\n",
    "\n",
    "\n",
    "\"\"\"def table(max_num):\n",
    "    a = 1\n",
    "    while a <= max_num:\n",
    "        s = \"\"\n",
    "        s = s + str(a) + \" \"\n",
    "        s = s + str(square_root(a)) + \" \"\n",
    "        s = s + str(math.sqrt(a)) + \" \"\n",
    "        s = s + str(abs(square_root(a))-abs(math.sqrt(a))) + \" \"\n",
    "        a = a+1\n",
    "        print(s)\"\"\"\n",
    "            \n",
    "            \n",
    "def table(max_num):\n",
    "    a = 1\n",
    "    while a <= max_num:\n",
    "        q = a\n",
    "        w = square_root(a)\n",
    "        e = math.sqrt(a)\n",
    "        r = square_root(a)-abs(math.sqrt(a))\n",
    "        a = a+1\n",
    "        print('{0:20f}{1:20f}{2:20f}{3:20f}'.format(q,w,e,r))\n",
    "#def tableb(x):           \n",
    "    #for x in range(1,9):\n",
    "        #print('{0:2d}{1:3d}{2:4d}'.format(x,square_root(x),math.sqrt(x)))\n",
    "            \n",
    "\n",
    "table(9)\n",
    "    "
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Challenge: Exercise 7.3  (optional)\n",
    "The mathematician Srinivasa Ramanujan found an infinite series that can be used to generate a numerical approximation of\n",
    "$\\frac{1}{\\pi}$:\n",
    "\n",
    "$$\\frac{1}{\\pi} = \\frac{2 \\sqrt{2}}{9801} \\sum_{k=0}^{\\infty} \\frac{(4k)! (1103+26390k)}{(k!)^4 396^{4k}}$$\n",
    " \n",
    "Write a function called `estimate_pi` that uses this formula to compute and return an estimate of $\\pi$. It should use a `while` loop to compute terms of the summation until the last term is smaller than `1e-15` (which is Python notation for $10^{−15}$). You can check the result by comparing it to `math.pi`.\n",
    "\n",
    "[Possible solution](http://thinkpython.com/code/pi.py) (give the exercise a try before viewing the solution)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "collapsed": true
   },
   "outputs": [],
   "source": []
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Quick poll\n",
    "\n",
    "About how long did you spend working on this Reading Journal?"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "2 hours"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Reading Journal feedback\n",
    "\n",
    "Have any comments on this Reading Journal? Feel free to leave them below and we'll read them when you submit your journal entry. This could include suggestions to improve the exercises, topics you'd like to see covered in class next time, or other feedback.\n",
    "\n",
    "If you have Python questions or run into problems while completing the reading, you should post them to Piazza instead so you can get a quick response before your journal is submitted."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "N/A"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    " "
   ]
  }
 ],
 "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.5.2"
  }
 },
 "nbformat": 4,
 "nbformat_minor": 0
}