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: Thursday, January 28 at 12 noon**\n",
    "\n"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## [Chapter 6.1-6.4](http://www.greenteapress.com/thinkpython/html/thinkpython007.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": [
    " "
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Exercise 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": 39,
   "metadata": {
    "collapsed": false
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "1\n",
      "0\n",
      "-1\n"
     ]
    }
   ],
   "source": [
    "def compare(x,y):\n",
    "    \n",
    "    if x > y:\n",
    "        return 1\n",
    "    if x == y:\n",
    "        return 0\n",
    "    if x < y:\n",
    "        return -1\n",
    "\n",
    "print compare(1,0)\n",
    "print compare(0,0)\n",
    "print compare(-1,0)"
   ]
  },
  {
   "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": 40,
   "metadata": {
    "collapsed": true
   },
   "outputs": [],
   "source": [
    "def absolute_value(x):\n",
    "    if x < 0:\n",
    "        return -x\n",
    "    if x >= 0:\n",
    "        return x"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Exercise 2  \n",
    "Use incremental development to write a function called `hypotenuse` that returns the length of the hypotenuse of a right triangle given the lengths of the two legs as arguments. Record each stage of the development process as you go, using as many cells as you need."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 41,
   "metadata": {
    "collapsed": false
   },
   "outputs": [
    {
     "data": {
      "text/plain": [
       "5.0"
      ]
     },
     "execution_count": 41,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "def hypotenuse(length1, length2):\n",
    "    ##print length1\n",
    "    ##print length2\n",
    "    ###print 1/2\n",
    "    ##print 1.0/2\n",
    "    \n",
    "    result = (length1**2 + length2**2)**(1.0/2)\n",
    "    #print result\n",
    "    \n",
    "    return result\n",
    "    \n",
    "hypotenuse(3,4)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    ")### Exercise 3  \n",
    "Write a function `is_between(x, y, z)` that returns `True` if `x ≤ y ≤ z` or `False` otherwise."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 42,
   "metadata": {
    "collapsed": false
   },
   "outputs": [
    {
     "data": {
      "text/plain": [
       "True"
      ]
     },
     "execution_count": 42,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "def is_between(x,y,z):\n",
    "    return x<=y<=z\n",
    "        \n",
    "is_between(1,2,3)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## [Chapter 7](http://www.greenteapress.com/thinkpython/html/thinkpython008.html)\n",
    "\n"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "**Quick check:** How do you test for equality in Python?"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    " "
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "**Challenge:** Prove/disprove the Collatz conjecture :)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Exercise 2  \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": 43,
   "metadata": {
    "collapsed": false
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "0.5\n",
      "16.25\n",
      "8.61730769231\n",
      "5.23701805057\n",
      "4.14609589299\n",
      "4.00257398894\n",
      "4.00000082764\n",
      "4.0\n",
      "4.0\n"
     ]
    }
   ],
   "source": [
    "def square_root(a,x):\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(16,.5)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Exercise 3  \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": 57,
   "metadata": {
    "collapsed": false
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "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"
     ]
    }
   ],
   "source": [
    "from math import sqrt\n",
    "\n",
    "def square_root(a,x):\n",
    "    while True:\n",
    "        y = (x + a/x) / 2\n",
    "        if y == x:\n",
    "            break\n",
    "        x = y\n",
    "    return x\n",
    "\n",
    "def spaced_result(x):\n",
    "    \"\"\"\n",
    "    argument string, return string with proper spacing\n",
    "    \"\"\"\n",
    "    return x + \" \" * abs(14 - len(x))\n",
    "\n",
    "for i in range(1,10):\n",
    "    i = i * 1.0\n",
    "    \n",
    "    my_square_root = square_root(i,3.0)\n",
    "    python_square_root = sqrt(i)\n",
    "    abs_diff = abs(my_square_root - python_square_root)\n",
    "    \n",
    "    str_my_square_root = spaced_result(str(my_square_root))\n",
    "    str_python_square_root = spaced_result(str(python_square_root))\n",
    "    str_abs_diff = spaced_result(str(abs_diff))\n",
    "    \n",
    "    print str(i),\n",
    "    print str_my_square_root,\n",
    "    print str_python_square_root,\n",
    "    print str_abs_diff\n",
    "    "
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Challenge: Exercise 5  (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": 59,
   "metadata": {
    "collapsed": false
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "3.14159273001\n",
      "0\n"
     ]
    }
   ],
   "source": [
    "#my calcualted pi gets stuck on 3.14159273001 so it never ends\n",
    "\n",
    "import math\n",
    "\n",
    "def estimate_pi():\n",
    "    #import necessary modules\n",
    "\n",
    "    #calcualte pi\n",
    "\n",
    "    k = 0\n",
    "    calc_pi = 0\n",
    "    coef = 2*math.sqrt(2)/9801\n",
    "\n",
    "\n",
    "    while True:\n",
    "    \tnumerator = math.factorial(4*k)*(1103+26390*k)\n",
    "    \tdenominator = (math.factorial(k)**4)*(396**(4*k))\n",
    "    \tcalc_pi = calc_pi + (coef*(numerator/denominator))\n",
    "        possible_pi = 1/calc_pi\n",
    "        print possible_pi\n",
    "        print k\n",
    "\n",
    "\n",
    "        if abs(possible_pi - math.pi) < 1e-7:\n",
    "        \tbreak\n",
    "\n",
    "        k = k + 1\n",
    "\n",
    "\n",
    "estimate_pi()"
   ]
  },
  {
   "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": [
    " "
   ]
  }
 ],
 "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
}