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": [
    "A fruitful function returns something. More specifically, \"a result that can be used later.\""
   ]
  },
  {
   "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": 3,
   "metadata": {
    "collapsed": false
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "0\n"
     ]
    }
   ],
   "source": [
    "def whichisgreater(x,y):\n",
    "    if x>y:\n",
    "        print '1'\n",
    "    elif x<y:\n",
    "        print '-1'\n",
    "    else:\n",
    "        print '0'\n",
    "        \n",
    "whichisgreater(2,2) #can test different values"
   ]
  },
  {
   "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": 19,
   "metadata": {
    "collapsed": false
   },
   "outputs": [
    {
     "data": {
      "text/plain": [
       "'Not an interger'"
      ]
     },
     "execution_count": 19,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "def absolute_value(x):\n",
    "    if type(x) != int:\n",
    "        return 'Not an interger'\n",
    "    if x < 0:\n",
    "        return -x\n",
    "    if x >= 0:\n",
    "        return x\n",
    "    \n",
    "absolute_value(-3.7)"
   ]
  },
  {
   "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": 97,
   "metadata": {
    "collapsed": false
   },
   "outputs": [
    {
     "data": {
      "text/plain": [
       "5.0"
      ]
     },
     "execution_count": 97,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    ">>> import math\n",
    "#(1) for lengths of legs of triangles, you need to use the pythagorean  \n",
    "#theorem, which uses sqrt. Start by importing math.\n",
    "\n",
    "\n",
    "#(2)the function should be called 'hypotenuse' and has 2 inputs. \n",
    "#check that there are no syntax errors by having it return '0.\n",
    "def hypotenuse(a,b):\n",
    "    # return '0.0'\n",
    "    #(3) write the math!\n",
    "    c= math.sqrt(a**2 + b**2)\n",
    "    return c\n",
    "\n",
    "#(4)test with simple values you know the answer to. For example, \n",
    "#side lengths of 3 and 4 should return a hypotenuse of 5.   \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": 36,
   "metadata": {
    "collapsed": false
   },
   "outputs": [
    {
     "data": {
      "text/plain": [
       "True"
      ]
     },
     "execution_count": 36,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "def is_between(x,y,z):\n",
    "    return x<=y and 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": [
    "Note to self: ',' supresses the newline, prints on single line"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "**Quick check:** How do you test for equality in Python?"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "boolean operator! (==)"
   ]
  },
  {
   "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": 84,
   "metadata": {
    "collapsed": false
   },
   "outputs": [
    {
     "data": {
      "text/plain": [
       "12.0"
      ]
     },
     "execution_count": 84,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    ">>> import math\n",
    "\n",
    "def square_root(a):\n",
    "    x= a/2.0\n",
    "    y= (x+(a/x))/2.0\n",
    "    while abs(y-x)>0.000000000001 :  #essentially==x, but for floats. \n",
    "        x=y                     # also epsilon wasn't working, so \n",
    "        y=(x+(a/x))/2.0         # I typed a number value instead.\n",
    "    return x\n",
    "\n",
    "square_root(144)"
   ]
  },
  {
   "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": 103,
   "metadata": {
    "collapsed": false
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "1.0   1.0              1.0              1.11022302463e-15 \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    8.881784197e-16 \n",
      "7.0   2.64575131106    2.64575131106    1.02584607475e-13 \n",
      "8.0   2.82842712475    2.82842712475    4.4408920985e-16 \n",
      "9.0   3.0              3.0              0.0             \n"
     ]
    }
   ],
   "source": [
    ">>> import math\n",
    "\n",
    "def square_root(a):\n",
    "    x= a/2.0\n",
    "    y= (x+(a/x))/2.0\n",
    "    while abs(y-x)>0.000000000001 :  #essentially==x, but for floats. \n",
    "        x=y                          # also epsilon wasn't working, so \n",
    "        y=(x+(a/x))/2.0              # I typed a number value instead.\n",
    "    return x\n",
    "    \n",
    "def test_square_root():\n",
    "    a=1.0\n",
    "    while a<=9.0:\n",
    "        #calculating table values\n",
    "        b= square_root(a)\n",
    "        c= math.sqrt(a)\n",
    "        d= abs(b-c)\n",
    "        \n",
    "        #arranging table format\n",
    "        spacer  = ' '\n",
    "        c_width = 15\n",
    "        column1 = spacer\n",
    "        column2 = spacer*(c_width - len(str(b)))\n",
    "        column3 = spacer*(c_width - len(str(c)))\n",
    "        column4 = spacer*(c_width - len(str(d)))\n",
    "        \n",
    "        #printing table\n",
    "        print a,column1,b,column2,c,column3,d,column4\n",
    "\n",
    "        #set new value for a\n",
    "        a=a+1.0\n",
    "        \n",
    "test_square_root()"
   ]
  },
  {
   "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": null,
   "metadata": {
    "collapsed": true
   },
   "outputs": [],
   "source": []
  },
  {
   "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.6"
  }
 },
 "nbformat": 4,
 "nbformat_minor": 0
}