mat301a-soln.ipynb

{
 "cells": [
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "<center>\n",
    "<big>Lab A: Using Python as a Calculator</big><br>\n",
    "https://mybinder.org/v2/gh/anniebmcc/pycalclab/master?filepath=mat301a.ipynb <br>\n",
    "2020 Summer — Calculus 1<br>\n",
    "Dr Matthew H Sunderland<br>\n",
    "</center>\n",
    "\n",
    "\n",
    "### Jupyter Notebooks\n",
    "A1. **RUN** the following \"code cell\" (gray rectangle with **<font style=\"font-family:'Courier New';color:blue\">In[ ]</font>** next to it), by CLICKING the code cell and pressing SHIFT+RETURN. Notice that only the last result will display."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 1,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "500"
      ]
     },
     "execution_count": 1,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "1 + 2 + 3\n",
    "50 - 3\n",
    "100*5"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "A2. **RUN** the following.\n",
    "As always, only the last result displays,\n",
    "but the last result has 2 parts because of the comma."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 2,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "(500, 49)"
      ]
     },
     "execution_count": 2,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "1 + 2 + 3\n",
    "50 - 3, 1000*1000\n",
    "100*5, 7*7"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "A3. The \"+\" on the toolbar adds a code cell.\n",
    "The \"scissors\" deletes a cell."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Python arithmetic `+` `-` `*` `/` `**`\n",
    "\n",
    "A4. **RUN** the following."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 3,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "(53, 25, 2.7)"
      ]
     },
     "execution_count": 3,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "3 + 10*5,  5**2,  27/10"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "A5. **EXERCISE.**  \n",
    "a) What does each of the 5 arithmetic operations do?  \n",
    "b) Do spaces around the 5 operations matter, or is it just style?  "
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 4,
   "metadata": {},
   "outputs": [],
   "source": [
    "# TYPE YOUR ANSWERS BELOW\n",
    "#\n",
    "#  a) + is   addition\n",
    "#     - is   subtraction\n",
    "#     * is   multiplication\n",
    "#     / is   division\n",
    "#    ** is   exponentiation\n",
    "#\n",
    "#  b) No, spaces aroung + - * / ** don't matter"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Python `#` and `=`\n",
    "\n",
    "A6. **RUN** the following. You will notice python ignores everything after `#`"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 5,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "2"
      ]
     },
     "execution_count": 5,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "# This is a comment\n",
    "1 + 1 # This is also a comment"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "A7. **RUN** the following.\n",
    "Notice we assign variables using `=`\n",
    "Assignment itself does NOT produce output."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 6,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "10"
      ]
     },
     "execution_count": 6,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "a = 10\n",
    "a"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 7,
   "metadata": {},
   "outputs": [],
   "source": [
    "b = 20"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 8,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "-3"
      ]
     },
     "execution_count": 8,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "a = 18\n",
    "b = 21\n",
    "c = a - b\n",
    "c"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "A8. **RUN** the following. Notice you can assign multiple variables at once with a comma."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 9,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "100"
      ]
     },
     "execution_count": 9,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "x, y = 100, 500\n",
    "x"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 10,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "3.8"
      ]
     },
     "execution_count": 10,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "a,b,c = 3,4,5\n",
    "a + b/c"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "A9. **RUN** the following.\n",
    "See that we can compute $(2 - 3)*-3 \\over -1 + 2$ all at once (1st cell below),\n",
    "or we can assign variables to help us (2nd cell below)."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 11,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "3.0"
      ]
     },
     "execution_count": 11,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "(2 - 3)*-3/(-1 + 2)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 12,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "3.0"
      ]
     },
     "execution_count": 12,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "top = (2 - 3)*-3\n",
    "bottom = -1 + 2\n",
    "top/bottom"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "A10. **EXERCISE.** Assign variables to help you compute $3 - \\frac{3^2 - 2\\cdot3}{2\\cdot3 - 2}$"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 13,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "2.25"
      ]
     },
     "execution_count": 13,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "# Type your answer below and press SHIFT+ENTER\n",
    "\n",
    "top = 3**2 - 2*3\n",
    "bottom = 2*3 - 2\n",
    "3 - top/bottom"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Order of Operations\n",
    "\n",
    "A11. **RUN** the following. Notice $a-b*c = a-(b*c)$, but they do not equal $(a-b)*c$."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 14,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "(-17, -17, -5)"
      ]
     },
     "execution_count": 14,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "a,b,c = 3,4,5\n",
    "\n",
    "a - b*c,  a - (b*c),  (a - b)*c"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "A12. **EXERCISE.** In each row, identify NON-equivalent choice. For example, the answer to (1) is $(a - b)*c$ because $a - b*c = a - (b*c)$\n",
    "\n",
    "$\\begin{aligned}\n",
    "  (1) &&& a - b*c   && a - (b*c) && (a - b)*c \\\\\n",
    "  (2) &&& a*(b - c) && (a*b) - c && a*b - c \\\\\n",
    "  (3) &&& a\\,/\\,b + c   && a\\,/\\,(b + c) && (a\\,/\\,b) + c \\\\\n",
    "  (4) &&& (a + b)\\,/\\,c && a + (b\\,/\\,c) && a + b\\,/\\,c \\\\\n",
    "  (5) &&& a *\\!\\!*\\, (b*c) && (a *\\!\\!*\\, b)*c && a *\\!\\!*\\, b*c\\\\\n",
    "  (6) &&& a*(b *\\!\\!*\\, c) && a*b *\\!\\!*\\, c && (a*b) *\\!\\!*\\, c\\\\\n",
    "  (7) &&& a/b *\\!\\!*\\, c && (a/b) *\\!\\!*\\, c && a/(b *\\!\\!*\\, c)\\\\\n",
    "  (8) &&& a *\\!\\!*\\, b/c && (a *\\!\\!*\\, b)/c && a *\\!\\!*\\, (b/c)\\\\\n",
    "  (9) &&& (3 − 3) − 3 && 3 − 3 − 3 && 3 − (3 − 3)\\\\\n",
    "  (10) &&& (2 *\\!\\!*\\, 3) *\\!\\!*\\, 2 && 2 *\\!\\!*\\, (3 *\\!\\!*\\, 2) && 2 *\\!\\!*\\, 3 *\\!\\!*\\, 2\\\\\n",
    "  (11) &&& 6\\,/\\,3\\,/\\,2 && 6\\,/\\,(3\\,/\\,2) && (6\\,/\\,3)\\,/\\,2\\\\\n",
    "\\end{aligned}$"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 15,
   "metadata": {},
   "outputs": [],
   "source": [
    "# TYPE YOUR ANSWERS BELOW.\n",
    "#\n",
    "#  (1)   (a - b)*c \n",
    "#  (2)   a*(b - c)\n",
    "#  (3)   a/(b + c)\n",
    "#  (4)   (a + b)/c\n",
    "#  (5)   a ** (b*c)\n",
    "#  (6)   (a*b) ** c\n",
    "#  (7)   (a/b) ** c\n",
    "#  (8)   a ** (b/c)\n",
    "#  (9)   3 - (3 - 3)\n",
    "# (10)   (2 ** 3) ** 2\n",
    "# (11)   6/(3/2)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "A13. **RUN** the following example,\n",
    "where we add 2 sets of parentheses which show the order of the 2 operations."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 16,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "1.6"
      ]
     },
     "execution_count": 16,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "1 + 3/5"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 17,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "1.6"
      ]
     },
     "execution_count": 17,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "(1 + (3/5))"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "A14. **EXERCISE.**\n",
    "Add 4 sets of parentheses, which show the order of the 4 operations."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 18,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "10.0"
      ]
     },
     "execution_count": 18,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "7 - 3 ** 2/9 + 4"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 19,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "10.0"
      ]
     },
     "execution_count": 19,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "# Type your answer below and press SHIFT+ENTER\n",
    "\n",
    "((7 - ((3 ** 2)/9)) + 4)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "A15. **EXERCISE.**\n",
    "Assign `a,b,c = 4,5,8` and then evaluate\n",
    "$\\displaystyle \\frac{a^b - c/b}{c - a}, \\frac{a^{c - b}}{c - b}, \\frac{a^{3/2}}b, \\frac{a - b(c - a)}{c - a}$"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 20,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "(255.6, 21.333333333333332, 1.6, -4.0)"
      ]
     },
     "execution_count": 20,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "# Type your answer below and press SHIFT+ENTER\n",
    "\n",
    "a,b,c = 4,5,8\n",
    "\n",
    "(a**b - c/b)/(c-a),  a**(c-b)/(c-b),  a**(3/2)/b,  (a - b*(c-a))/(c-a)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Making python functions\n",
    "A16. **RUN** the following."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 21,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "49"
      ]
     },
     "execution_count": 21,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "def g(x):\n",
    "    return x**2\n",
    "\n",
    "g(7)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 22,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "107"
      ]
     },
     "execution_count": 22,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "def h(n): return n + 100\n",
    "\n",
    "h(7)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "A17. **EXERCISE.** Make the function $P(x) = x^2 - 2x + 1$ and find $P(P(7))$."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 23,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "1225"
      ]
     },
     "execution_count": 23,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "# Type your answer below and press SHIFT+ENTER\n",
    "\n",
    "def P(x):\n",
    "    return x**2 - 2*x + 1\n",
    "\n",
    "P(P(7))"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Built-in `%pylab` functions\n",
    "\n",
    "| Python      | Math notation | Meaning |\n",
    "| ---         | ---           | ---     |\n",
    "| `abs(x)`    | $\\mid x\\mid$  | absolute value\n",
    "| `sqrt(x)`   | $\\sqrt x$     | square root\n",
    "| `exp(x)`    | $e^x$         | exponential function\n",
    "| `log(x)`    | $\\ln x$       | natural logarithm\n",
    "| `sin(x)`    | $\\sin x$      | sine\n",
    "| `arcsin(x)` | $\\sin^{-1}x$  | inverse sine\n",
    "| `radians(x)`|               | converts degrees to radians\n",
    "\n",
    "A18. <a id='A18'></a> **RUN** the code cells below.\n",
    "The command `%pylab` only needs to be run once per lab;\n",
    "it loads \"built-in functions\"\n",
    "(from python packages numpy and matplotlib).\n",
    "\n",
    "<!--\n",
    "_(Specifically it loads functions from_  \n",
    "_the numpy math package and the matplotlib graphing package._  \n",
    "_These packages come included when you install Python from_  \n",
    "_http://www.anaconda.com/products/individual )_\n",
    "-->"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 24,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Using matplotlib backend: MacOSX\n",
      "Populating the interactive namespace from numpy and matplotlib\n"
     ]
    },
    {
     "data": {
      "text/plain": [
       "7.0"
      ]
     },
     "execution_count": 24,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "%pylab\n",
    "\n",
    "sqrt(49)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 25,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "(3.141592653589793, 2.718281828459045, 1.0)"
      ]
     },
     "execution_count": 25,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "pi, exp(1), sin(pi/2)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "A19. **EXERCISE.** Evaluate\n",
    "1. $\\sin 40^\\circ$\n",
    "1. $\\sin^2 65^\\circ$\n",
    "1. $e^{(10 - 8.5)/3}$\n",
    "1. $\\arcsin(\\sin(3\\pi/4))$\n",
    "\n",
    "Note. Python uses radians for all angle measurements,\n",
    "so you need to convert any degrees to radians.  "
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 26,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "(0.6427876096865393,\n",
       " 0.8213938048432696,\n",
       " 1.6487212707001282,\n",
       " 0.7853981633974484)"
      ]
     },
     "execution_count": 26,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "# Type your answer below and press SHIFT+ENTER\n",
    "\n",
    "sin(radians(40)),  sin(radians(65))**2,  exp((10-8.5)/3),  arcsin(sin(3*pi/4))"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Making an array with `r_[ ]`\n",
    "\n",
    "A20. **RUN** the following.\n",
    "(If you get an error, go back and run [A17](#A17).)\n",
    "The function `r_[ ]` can make an array of numbers of your choice.\n",
    "We will need arrays for graphing (Lab B)."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 27,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "array([   8,   27,   64,  125, 1000])"
      ]
     },
     "execution_count": 27,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "x = r_[2,3,4,5,10]\n",
    "x**3"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "A21. **EXERCISE.** Use `r_[ ]` to store the numbers 2,3,5,7,11 in an array named `x`. Find `x*x`."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 28,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "array([  4,   9,  25,  49, 121])"
      ]
     },
     "execution_count": 28,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "# Type your answer below and press SHIFT+ENTER\n",
    "\n",
    "x = r_[2,3,5,7,11]\n",
    "x*x"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Making an array with `r_[a:b:stride]`\n",
    "\n",
    "A22. **RUN** the following.\n",
    "In general, `r_[a:b]` will list integers from $a$ up to but _not_ including $b$.\n",
    "A missing $a$ is the same as 0."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 29,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "array([5, 6, 7, 8, 9])"
      ]
     },
     "execution_count": 29,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "r_[5:10]"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 30,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "array([0, 1, 2, 3, 4])"
      ]
     },
     "execution_count": 30,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "r_[:5]"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "A23. **EXERCISE.** Use `r_[a:b]` to make the array 1,2,3,4,5,6,7,8,9"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 31,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "array([1, 2, 3, 4, 5, 6, 7, 8, 9])"
      ]
     },
     "execution_count": 31,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "# Type your answer below and press SHIFT+ENTER\n",
    "\n",
    "r_[1:10]"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "A24. **RUN** the following. In general, `r_[a:b:stride]` spaces out your numbers by the amount `stride`."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 32,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "array([ 0,  2,  4,  6,  8, 10, 12, 14, 16, 18, 20, 22, 24, 26, 28, 30, 32,\n",
       "       34, 36, 38, 40, 42, 44, 46, 48, 50, 52, 54, 56, 58, 60, 62, 64, 66,\n",
       "       68, 70, 72, 74, 76, 78, 80, 82, 84, 86, 88, 90, 92, 94, 96, 98])"
      ]
     },
     "execution_count": 32,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "r_[0:100:2]"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "A25. **EXERCISE.** Use `r_[a:b:stride]` to make the array $1,3,5,\\dots,99$"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 33,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "array([ 1,  3,  5,  7,  9, 11, 13, 15, 17, 19, 21, 23, 25, 27, 29, 31, 33,\n",
       "       35, 37, 39, 41, 43, 45, 47, 49, 51, 53, 55, 57, 59, 61, 63, 65, 67,\n",
       "       69, 71, 73, 75, 77, 79, 81, 83, 85, 87, 89, 91, 93, 95, 97, 99])"
      ]
     },
     "execution_count": 33,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "# Type your answer below and press SHIFT+ENTER\n",
    "\n",
    "r_[1:100:2]"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Making an array with `linspace(a,b,n)`\n",
    "\n",
    "A26. **RUN** the following.\n",
    "Observe that `linspace(a,b,n)` lists n numbers from a to b inclusive.\n",
    "This is useful for generating a lot of evenly-spaced numbers, such as when graphing (Lab B).\n",
    "Observe that `linspace(a,b)` lists 50 numbers from a to b inclusive."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 34,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "array([ 0.,  2.,  4.,  6.,  8., 10.])"
      ]
     },
     "execution_count": 34,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "linspace(0,10,6)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 35,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "array([ 0.        ,  0.20408163,  0.40816327,  0.6122449 ,  0.81632653,\n",
       "        1.02040816,  1.2244898 ,  1.42857143,  1.63265306,  1.83673469,\n",
       "        2.04081633,  2.24489796,  2.44897959,  2.65306122,  2.85714286,\n",
       "        3.06122449,  3.26530612,  3.46938776,  3.67346939,  3.87755102,\n",
       "        4.08163265,  4.28571429,  4.48979592,  4.69387755,  4.89795918,\n",
       "        5.10204082,  5.30612245,  5.51020408,  5.71428571,  5.91836735,\n",
       "        6.12244898,  6.32653061,  6.53061224,  6.73469388,  6.93877551,\n",
       "        7.14285714,  7.34693878,  7.55102041,  7.75510204,  7.95918367,\n",
       "        8.16326531,  8.36734694,  8.57142857,  8.7755102 ,  8.97959184,\n",
       "        9.18367347,  9.3877551 ,  9.59183673,  9.79591837, 10.        ])"
      ]
     },
     "execution_count": 35,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "linspace(0,10)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "A27. **EXERCISE.** Use `linspace(a,b,n)` to make the array $1,1.5,2,2.5,3,3.5,4$"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 36,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "array([1. , 1.5, 2. , 2.5, 3. , 3.5, 4. ])"
      ]
     },
     "execution_count": 36,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "# Type your answer below and press SHIFT+ENTER\n",
    "\n",
    "linspace(1,4,7)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "A28. **EXERCISE.**  \n",
    "Convert average body temperature $98.6^\\circ F$ to Celsius using $C = 5/9(F - 32)$."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 37,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "37.0"
      ]
     },
     "execution_count": 37,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "# Type your answer below and press SHIFT+ENTER\n",
    "\n",
    "5/9*(98.6 - 32)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "A29. **RUN** the following.  \n",
    "Notice that `x` and `y` are arrays,  \n",
    "`c_[x,y]` puts them into a table."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 38,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "array([[ 0,  0],\n",
       "       [ 1,  1],\n",
       "       [ 2,  4],\n",
       "       [ 3,  9],\n",
       "       [ 4, 16],\n",
       "       [ 5, 25],\n",
       "       [ 6, 36],\n",
       "       [ 7, 49],\n",
       "       [ 8, 64],\n",
       "       [ 9, 81]])"
      ]
     },
     "execution_count": 38,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "x = r_[:10]\n",
    "y = x**2\n",
    "c_[x,y]"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "A30. **EXERCISE.**  \n",
    "Use `r_` to make an array of Fahrenheit values `x` = $-100,-80,-60,\\dots,100$.  \n",
    "Make the corresponding array of Celsius values `y`  \n",
    "Use `c_` to put `x` and `y` into a table."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 39,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "array([[-100.        ,  -73.33333333],\n",
       "       [ -80.        ,  -62.22222222],\n",
       "       [ -60.        ,  -51.11111111],\n",
       "       [ -40.        ,  -40.        ],\n",
       "       [ -20.        ,  -28.88888889],\n",
       "       [   0.        ,  -17.77777778],\n",
       "       [  20.        ,   -6.66666667],\n",
       "       [  40.        ,    4.44444444],\n",
       "       [  60.        ,   15.55555556],\n",
       "       [  80.        ,   26.66666667],\n",
       "       [ 100.        ,   37.77777778]])"
      ]
     },
     "execution_count": 39,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "# Type your answer below and press SHIFT+ENTER\n",
    "\n",
    "x = r_[-100:101:20]\n",
    "y = 5/9*(x - 32)\n",
    "c_[x,y]"
   ]
  }
 ],
 "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.7.4"
  },
  "title": "yournamehere"
 },
 "nbformat": 4,
 "nbformat_minor": 4
}