Section_05_For_Loop.ipynb

{
 "cells": [
  {
   "cell_type": "markdown",
   "metadata": {
    "slideshow": {
     "slide_type": "slide"
    }
   },
   "source": [
    "# For Loop\n",
    "\n",
    "- [Introduction](#Introduction)\n",
    "- [Framework](#Framework)\n",
    "- [Array Indexing](#Array-Indexing)\n",
    "    - [The Range Object](#The-Range-Object)\n",
    "- [Array Assignment](#Array-Assignment)\n",
    "- [Lists and Arrays as Function inputs](#Lists-and-Arrays-as-Function-inputs)\n",
    "- [Additional Examples](#Additional-Examples)\n",
    "- [Nested Loops](#Nested-Loops)\n",
    "- [Recap](#Recap)\n"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "slideshow": {
     "slide_type": "slide"
    }
   },
   "source": [
    "## Introduction\n",
    "\n",
    "### Example - Constant acceleration motion\n",
    "\n",
    "- Example of an object falling:\n",
    "    - $s_0 \\: [m]$ (initial height)\n",
    "    - $v_0 \\: [m/s]$ (initial velocity)\n",
    "    - $a = -9.81 \\: m/s^2$ (gravitational acceleration)\n",
    "    - $t = \\: [s]$ (time)\n",
    "\n",
    "$$ \n",
    "\\begin{align}\n",
    "    a(t) &= \\text{const} \\\\\n",
    "    v(t) &= \\int a dt  =  v_0 + at \\\\\n",
    "    s(t) &= \\int v(t) dt = s_0 + v_0t + \\frac{1}{2} at^2\n",
    "\\end{align}\n",
    "$$\n",
    "\n",
    "- Calculate $s(t)$ for 100 different times `t` between 0 and 6 for the following initial values:\n",
    "    - $s_0=100$ and $v_0 = [10, 20, 30, 40, 50]$\n",
    "\n",
    "\n",
    "### Outcomes:\n",
    "- Using a `for` loop to change the data"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "slideshow": {
     "slide_type": "slide"
    }
   },
   "outputs": [],
   "source": [
    "import numpy as np\n",
    "\n",
    "def heights(s0, v0, t):\n",
    "    g = -9.81\n",
    "    return s0 + v0 * t + 0.5 * g * t**2\n",
    "\n",
    "\n",
    "times = np.linspace(0, 6, 100)\n",
    "st = heights(s0=100, v0=10, t=times)\n",
    "st = heights(s0=100, v0=20, t=times)\n",
    "st = heights(s0=100, v0=30, t=times)\n",
    "st = heights(s0=100, v0=40, t=times)\n",
    "st = heights(s0=100, v0=50, t=times)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "slideshow": {
     "slide_type": "slide"
    }
   },
   "outputs": [],
   "source": [
    "import numpy as np\n",
    "\n",
    "def heights(s0, v0, t):\n",
    "    g = -9.81\n",
    "    return s0 + v0 * t + 0.5 * g * t**2\n",
    "\n",
    "\n",
    "times = np.linspace(0, 6, 100)\n",
    "v_init = np.array([10, 20, 30, 40, 50])\n",
    "\n",
    "for v0 in v_init:\n",
    "    print(v0)\n",
    "    st = heights(s0=100, v0=v0, t=times)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "slideshow": {
     "slide_type": "slide"
    }
   },
   "source": [
    "## Framework\n",
    "\n",
    "- Executed from the top of the *Code Cell* to the bottom of the *Code Cell*"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "slideshow": {
     "slide_type": "subslide"
    }
   },
   "source": [
    "<img src=\"./figures/for_loop_framework.svg\" alt=\"For Loop Framework\" style=\"height: 500px;\"/>"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "slideshow": {
     "slide_type": "subslide"
    }
   },
   "source": [
    "- *sequence* $\\to$ *array* $\\to$ sequence of numbers\n",
    "\n",
    "\n",
    "- Indentation (white space) in front of the code tells *Python* it is part of the `for` loop\n",
    "\n",
    "\n",
    "- The code inside the `for` loop is repeated before the code below the `for` loop executes\n",
    "\n",
    "\n",
    "- At each repetition of the for loop $\\to$ the name ``val`` is assigned to the next value in the array\n",
    "    - \"**for** each **value in** the **sequence**, repeat the following\"\n",
    "\n",
    "\n",
    "- I.e. a `for` loop \"iterates / steps\" through the values in an array from the start to end\n",
    "\n",
    "\n",
    "- Used to repeat code a known and fixed number of times"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "slideshow": {
     "slide_type": "slide"
    }
   },
   "source": [
    "### Examples - Illustrative:\n",
    "\n",
    "- Printing values in an array to the screen, one-by-one\n",
    "\n",
    "\n",
    "- Doing repetitive calculations of the same nature, e.g., Gaussion elimination"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "slideshow": {
     "slide_type": "subslide"
    }
   },
   "source": [
    "### Outcomes:\n",
    "\n",
    "- Understand how a `for` loop works\n",
    "\n",
    "\n",
    "- **`For` loop $\\to$ known number of repetitions !!**"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "%load_ext nbtutor"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "slideshow": {
     "slide_type": "subslide"
    }
   },
   "outputs": [],
   "source": [
    "%%nbtutor -r -f\n",
    "import numpy as np\n",
    "\n",
    "coeffs = np.array([10, 20, 30, 40, 50])\n",
    "print(coeffs)\n",
    "\n",
    "print(\"\\nstart\")\n",
    "for a in coeffs:\n",
    "    print(\"a:\", a)\n",
    "\n",
    "print(\"end\")"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Example - Quadratic function\n",
    "\n",
    "- Compute $y = ax^2 + 5$ for $x = [-10, -9.9, -9.8, \\dots, 9.8, 9.9, 10]$ using\n",
    "    - $a = [1, 10, 50, 100]$"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "%matplotlib inline\n",
    "import numpy as np\n",
    "from matplotlib import pyplot as plt\n",
    "\n",
    "def quad_func(a, x):\n",
    "    return a * x**2 + 5\n",
    "\n",
    "\n",
    "a_coeffs = np.array([1, 10, 50, 100])\n",
    "x_coords = np.arange(-10, 10.1, 0.1)\n",
    "\n",
    "for a in a_coeffs:\n",
    "    y_coords = quad_func(a=a, x=x_coords)\n",
    "    plt.plot(x_coords, y_coords)\n",
    "\n",
    "#plt.show()"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "slideshow": {
     "slide_type": "slide"
    }
   },
   "source": [
    "### Example - Constant acceleration motion\n",
    "\n",
    "- Example of an object falling:\n",
    "    - $s_0 \\: [m]$ (initial height)\n",
    "    - $v_0 \\: [m/s]$ (initial velocity)\n",
    "    - $a = -9.81 \\: m/s^2$ (gravitational acceleration)\n",
    "    - $t = \\: [s]$ (time)\n",
    "\n",
    "$$ \n",
    "\\begin{align}\n",
    "    a(t) &= \\text{const} \\\\\n",
    "    v(t) &= \\int a dt  =  v_0 + at \\\\\n",
    "    s(t) &= \\int v(t) dt = s_0 + v_0t + \\frac{1}{2} at^2\n",
    "\\end{align}\n",
    "$$\n",
    "\n",
    "- Calculate $s(t)$ for 100 different times `t` between 0 and 6 for the following initial values:\n",
    "    - $s_0=100$ and $v_0 = [10, 20, 30, 40, 50]$\n",
    "\n",
    "\n",
    "### Outcomes:\n",
    "- Using a `for` loop to change the data"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "slideshow": {
     "slide_type": "subslide"
    }
   },
   "outputs": [],
   "source": [
    "%matplotlib inline\n",
    "import numpy as np\n",
    "from matplotlib import pyplot as plt\n",
    "\n",
    "\n",
    "def heights(s0, v0, t):\n",
    "    g = -9.81\n",
    "    return s0 + v0 * t + 0.5 * g * t**2\n",
    "\n",
    "\n",
    "times = np.linspace(0, 6, 100)\n",
    "v_init = np.array([10, 20, 30, 40, 50])\n",
    "\n",
    "for v0 in v_init:\n",
    "    st = heights(s0=100, v0=v0, t=times)\n",
    "    plt.plot(times, st)\n",
    "\n",
    "plt.show()"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Array Indexing"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "<img src=\"./figures/list_post_boxes.svg\" alt=\"Post Boxes\" style=\"height: 250px;\"/>"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "- Arrays\n",
    "    - Can be visualised as a row “post-boxes” that can only have one “letter” (value) in each “post-box” (element).\n",
    "    - Each Post-box number $\\to$ location in the array\n",
    "    - The “letter” in the post-box $\\to$ the value in that location"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Examples - Illustrative:\n",
    "- the first position in the array (first post-box number) is 0\n",
    "\n",
    "\n",
    "- the second position in the array (second post-box number) is 1, etc. Starts from 0 !!!\n",
    "\n",
    "\n",
    "- `values[0]` $\\to$ returns 1 (the “letter” in the first post-box)\n",
    "\n",
    "\n",
    "- `values[2]` $\\to$ returns 32 (the “letter” in the third post-box)\n",
    "\n",
    "\n",
    "- this is called indexing $\\to$ accessing the elements in the array\n",
    "\n",
    "\n",
    "- **index number must be an integer (whole number)**"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "%%nbtutor -r -f\n",
    "import numpy as np\n",
    "\n",
    "#                  0   1   2\n",
    "values = np.array([1, 13, 32])\n",
    "print(values[0])\n",
    "print(values[2])"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "slideshow": {
     "slide_type": "slide"
    }
   },
   "source": [
    "### Example - Constant acceleration motion\n",
    "\n",
    "- Example of an object falling:\n",
    "    - $s_0 \\: [m]$ (initial height)\n",
    "    - $v_0 \\: [m/s]$ (initial velocity)\n",
    "    - $a = -9.81 \\: m/s^2$ (gravitational acceleration)\n",
    "    - $t = \\: [s]$ (time)\n",
    "\n",
    "$$ \n",
    "\\begin{align}\n",
    "    a(t) &= \\text{const} \\\\\n",
    "    v(t) &= \\int a dt  =  v_0 + at \\\\\n",
    "    s(t) &= \\int v(t) dt = s_0 + v_0t + \\frac{1}{2} at^2\n",
    "\\end{align}\n",
    "$$\n",
    "\n",
    "- Calculate $s(t)$ for 100 different times `t` between 0 and 6 for the following initial values:\n",
    "    - $s_0=100$ and $v_0 = 50$\n",
    "    - $s_0=200$ and $v_0 = 40$\n",
    "    - $s_0=300$ and $v_0 = 30$\n",
    "    - $s_0=400$ and $v_0 = 20$\n",
    "    - $s_0=500$ and $v_0 = 10$\n",
    "\n",
    "\n",
    "### Outcomes:\n",
    "\n",
    "- Array indexing"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "slideshow": {
     "slide_type": "subslide"
    }
   },
   "outputs": [],
   "source": [
    "%matplotlib inline\n",
    "import numpy as np\n",
    "from matplotlib import pyplot as plt\n",
    "\n",
    "def heights(s0, v0, t):\n",
    "    g = -9.81\n",
    "    return s0 + v0 * t + 0.5 * g * t**2\n",
    "\n",
    "\n",
    "# init data\n",
    "times = np.linspace(0, 6, 100)\n",
    "h_init = np.array([100, 200, 300, 400, 500])\n",
    "v_init = np.array([50, 40, 30, 20, 10])\n",
    "\n",
    "for i in np.arange(0, 5, 1):  # iterate over array indexes\n",
    "    s0 = h_init[i]  # pull out ith value\n",
    "    v0 = v_init[i]  # pull out ith value\n",
    "\n",
    "    st = heights(s0=s0, v0=v0, t=times)\n",
    "    plt.plot(times, st)\n",
    "\n",
    "plt.show()"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "- Can create the index numbers either using:\n",
    "    - the `np.arange` function or\n",
    "    - the `range` function"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### The Range Object\n",
    "\n",
    "- Same as `np.arange`, but ensures only integer index numbers\n",
    "\n",
    "\n",
    "- Returns a special `range` object.\n",
    "    - Need to type cast (convert) to `array` to see the values\n",
    "\n",
    "\n",
    "- `start`, `end` and `increment` inputs into the range function must be integer values !!!"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "%%nbtutor -r -f\n",
    "import numpy as np\n",
    "\n",
    "inds = range(0, 10, 1)\n",
    "print(inds)\n",
    "print(np.array(inds))\n",
    "print(np.arange(0, 10, 1))"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Array Assignment\n",
    "\n",
    "<img src=\"./figures/list_set_get.svg\" alt=\"Set Get\" style=\"height: 50px;\"/>\n",
    "\n",
    "- RHS: indexing $\\to$ get value (\"What is the value in given position?\")\n",
    "- LHS: assignment $\\to$ set value (\"Overwrite the value in given position.\")"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "%%nbtutor -r -f\n",
    "import numpy as np\n",
    "\n",
    "#                  0   1   2\n",
    "values = np.array([1, 13, 32])\n",
    "\n",
    "values[0] = 10\n",
    "print(values)\n",
    "\n",
    "values[0] = values[1] + values[2]\n",
    "print(values)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "slideshow": {
     "slide_type": "slide"
    }
   },
   "source": [
    "### Example - Fibonacci Series:\n",
    "- Store the first 10 terms of the Fibonacci series in an array:\n",
    "$$ F_{k+1} = F_k + F_{k−1} \\qquad \\text{for} \\quad k = 1, 2, 3, \\dots $$\n",
    "\n",
    "\n",
    "- where it is also defined that the first two terms in the series are not calculated by the above formula, but are $F_0$ = 1 and $F_1$ = 1.  The the sequence is:\n",
    "$$ 1 , 1 , 2 , 3 , 5 , 8 , 13 , 21 ,\\cdots$$\n",
    "\n",
    "\n",
    "### Outcomes:\n",
    "- zero array (i.e., an array filled with zero values)\n",
    "\n",
    "\n",
    "- Indexing (RHS) and array assignment (LHS)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "slideshow": {
     "slide_type": "subslide"
    }
   },
   "outputs": [],
   "source": [
    "%%nbtutor -r -f\n",
    "import numpy as np\n",
    "\n",
    "def fib_sequence(N):\n",
    "    terms = np.zeros(N)\n",
    "    terms[0] = 1\n",
    "    terms[1] = 1\n",
    "\n",
    "    for k in range(1, N-1, 1):\n",
    "        terms[k+1] = terms[k] + terms[k-1]\n",
    "\n",
    "    return terms\n",
    "\n",
    "\n",
    "print(fib_sequence(10))"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Lists and Arrays as Function inputs\n",
    "\n",
    "- What will get printed to the screen?"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "%%nbtutor -r -f\n",
    "import numpy as np\n",
    "\n",
    "foo = np.array([5, 9, 2])\n",
    "bar = foo\n",
    "foo[1] = 100\n",
    "\n",
    "print(foo)\n",
    "print(bar)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "- This is the same for both lists and arrays\n",
    "\n",
    "\n",
    "- What will get printed to the screen?"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "%%nbtutor -r -f\n",
    "import numpy as np\n",
    "\n",
    "def foo(vec1):\n",
    "    vec2 = vec1\n",
    "    vec2[0] = 10\n",
    "    return vec2\n",
    "\n",
    "one = np.array([1, 1, 2, 1])\n",
    "two = foo(one)\n",
    "print(one)\n",
    "print(two)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "- This is the same for both lists and arrays\n",
    "\n",
    "\n",
    "- Objects are not copied when sent as inputs to a function\n",
    "\n",
    "\n",
    "- New names are assigned to the existing objects\n",
    "\n",
    "\n",
    "- Modifying list or array elements inside a function $\\to$ modifies the list or array object sent to the function\n",
    "\n",
    "\n",
    "- Making copies of arrays:\n",
    "     - `a = numpy.copy(arr)`\n",
    "\n",
    "\n",
    "- Making copies of lists:\n",
    "     - Need to type cast the list again $\\to$ `a = list(my_list)`\n",
    "\n",
    "\n",
    "- `id()` function $\\to$ can be used to check if objects are the same\n",
    "\n",
    "\n",
    "- Make sure you understand the memory model"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Additional Examples\n",
    "\n",
    "### Example - Constant acceleration motion\n",
    "\n",
    "- Example of an object falling:\n",
    "    - $s_0 \\: [m]$ (initial height)\n",
    "    - $v_0 \\: [m/s]$ (initial velocity)\n",
    "    - $g = -9.81 \\: m/s^2$ (gravitational acceleration)\n",
    "    - $t = \\: [s]$ (time)\n",
    "\n",
    "$$ \n",
    "\\begin{align}\n",
    "    a(t) &= g \\: (\\text{const}) \\\\\n",
    "    v(t) &= \\int a dt  =  v_0 + gt \\\\\n",
    "    s(t) &= \\int v(t) dt = s_0 + v_0t + \\frac{1}{2} gt^2\n",
    "\\end{align}\n",
    "$$\n",
    "\n",
    "\n",
    "- Calculate $s(t)$ for 100 different times `t` between 0 and $t_e$ for the following initial values:\n",
    "    - $s_0=100$ and $v_0 = 50$\n",
    "    - $s_0=200$ and $v_0 = 40$\n",
    "    - $s_0=300$ and $v_0 = 30$\n",
    "    - $s_0=400$ and $v_0 = 20$\n",
    "    - $s_0=500$ and $v_0 = 10$\n",
    "\n",
    "\n",
    "- $t_e$ $\\to$ time the object hits the ground\n",
    "    - Solution (Mathematical):\n",
    "    $$ t_e = \\frac{-B \\pm \\sqrt{B^2 - 4AC}}{2A} $$\n",
    "    \n",
    "    $$\n",
    "    \\begin{align}\n",
    "        A &= 0.5g \\\\\n",
    "        B &= v_0 \\\\\n",
    "        C &= s_0\n",
    "    \\end{align}\n",
    "    $$"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "%matplotlib inline\n",
    "import numpy as np\n",
    "from matplotlib import pyplot as plt\n",
    "\n",
    "def solve_time(A, B, C):\n",
    "    return (-B - (B**2 - 4*A*C)**0.5) / (2*A)\n",
    "\n",
    "\n",
    "def heights(s0, v0, t):\n",
    "    return s0 + v0 * t + 0.5 * g * t**2\n",
    "\n",
    "\n",
    "g = -9.81\n",
    "h_init = np.array([100, 200, 300, 400, 500])\n",
    "v_init = np.array([50, 40, 30, 20, 10])\n",
    "\n",
    "for i in range(0, 5, 1):\n",
    "    s0 = h_init[i]\n",
    "    v0 = v_init[i]\n",
    "    \n",
    "    te = solve_time(A=0.5*g, B=v0, C=s0)\n",
    "    times = np.linspace(0, te, 100)\n",
    "    \n",
    "    st = heights(s0=s0, v0=v0, t=times)\n",
    "    plt.plot(times, st)\n",
    "\n",
    "plt.show()"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "slideshow": {
     "slide_type": "slide"
    }
   },
   "source": [
    "## Nested Loops\n",
    "\n",
    "### Example - Constant acceleration motion\n",
    "\n",
    "- Example of an object falling:\n",
    "    - $s_0 \\: [m]$ (initial height)\n",
    "    - $v_0 \\: [m/s]$ (initial velocity)\n",
    "    - $a = -9.81 \\: m/s^2$ (gravitational acceleration)\n",
    "    - $t = \\: [s]$ (time)\n",
    "\n",
    "$$ \n",
    "\\begin{align}\n",
    "    a(t) &= \\text{const} \\\\\n",
    "    v(t) &= \\int a dt  =  v_0 + at \\\\\n",
    "    s(t) &= \\int v(t) dt = s_0 + v_0t + \\frac{1}{2} at^2\n",
    "\\end{align}\n",
    "$$\n",
    "\n",
    "- Calculate $s(t)$ for 100 different times `t` between 0 and 6 for the following initial values:\n",
    "    - $s_0=100$ and $v_0 = [10, 20, 30, 40, 50]$\n",
    "    - $s_0=200$ and $v_0 = [10, 20, 30, 40, 50]$\n",
    "    - $s_0=300$ and $v_0 = [10, 20, 30, 40, 50]$\n",
    "    - $s_0=400$ and $v_0 = [10, 20, 30, 40, 50]$\n",
    "    - $s_0=400$ and $v_0 = [10, 20, 30, 40, 50]$\n",
    "\n",
    "\n",
    "### Outcomes:\n",
    "- Nested `for` loop"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "slideshow": {
     "slide_type": "subslide"
    }
   },
   "outputs": [],
   "source": [
    "%matplotlib inline\n",
    "import numpy as np\n",
    "from matplotlib import pyplot as plt\n",
    "\n",
    "def solve_time(A, B, C):\n",
    "    return (-B - (B**2 - 4*A*C)**0.5) / (2*A)\n",
    "\n",
    "\n",
    "def heights(s0, v0, t):\n",
    "    return s0 + v0 * t + 0.5 * g * t**2\n",
    "\n",
    "\n",
    "g = -9.81\n",
    "h_init = np.array([100, 200, 300, 400, 500])\n",
    "v_init = np.array([50, 40, 30, 20, 10])\n",
    "\n",
    "for s0 in h_init:\n",
    "    for v0 in v_init:\n",
    "        te = solve_time(A=0.5*g, B=v0, C=s0)\n",
    "        times = np.linspace(0, te, 100)\n",
    "\n",
    "        st = heights(s0=s0, v0=v0, t=times)\n",
    "        plt.plot(times, st)\n",
    "\n",
    "plt.show()"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "slideshow": {
     "slide_type": "slide"
    }
   },
   "source": [
    "## Recap\n",
    "\n",
    "### For Loop and Strategies\n",
    "\n",
    "- `for` Loop\n",
    "    - Used to repeat code a known and fixed number of times\n",
    "    - At each repetition of the `for` loop $\\to$ the name ``val`` is assigned to the next value in the sequence\n",
    "    - I.e. a `for` loop ”iterates / steps” through the values in a sequence from start to end\n",
    "\n",
    "\n",
    "- Nested `for` Loops\n",
    "     - inner `for` loop is repeated for every iteration of the outer `for` loop\n",
    "\n",
    "\n",
    "- Complex problems\n",
    "     - Break the problem down into smaller pieces $\\to$ tackle each piece on its own"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "slideshow": {
     "slide_type": "slide"
    }
   },
   "source": [
    "### Recap Quiz\n",
    "\n",
    "- What will get printed to the screen when executing the following code?"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "slideshow": {
     "slide_type": "skip"
    }
   },
   "outputs": [],
   "source": [
    "import numpy as np\n",
    "\n",
    "def sum_at(x, inds):\n",
    "    val_sum = 0\n",
    "    for i in inds:\n",
    "        val_sum = val_sum + x[i]\n",
    "    return val_sum\n",
    "\n",
    "\n",
    "vals = np.array([2, 5, 3, 2, 1])\n",
    "foo = np.arange(0, 5, 2)\n",
    "print(foo)\n",
    "print(sum_at(vals, foo))"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "- What will get printed to the screen when executing the following code?"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "%load_ext nbtutor"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "%%nbtutor -r -f\n",
    "import numpy as np\n",
    "\n",
    "def foo(x):\n",
    "    x = 2 * x\n",
    "    return x\n",
    "\n",
    "\n",
    "x = 2\n",
    "for i in np.arange(0, 3, 1):\n",
    "    x = foo(x)\n",
    "print(x)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": []
  }
 ],
 "metadata": {
  "anaconda-cloud": {},
  "celltoolbar": "Visualize",
  "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"
  }
 },
 "nbformat": 4,
 "nbformat_minor": 1
}