20.control-flow/10.for-while.ipynb

{
 "cells": [
  {
   "cell_type": "markdown",
   "metadata": {
    "id": "view-in-github",
    "colab_type": "text"
   },
   "source": [
    "<a href=\"https://colab.research.google.com/github/kangwonlee/2018pycpp/blob/main/20.control-flow/10.for-while.ipynb\" target=\"_parent\"><img src=\"https://colab.research.google.com/assets/colab-badge.svg\" alt=\"Open In Colab\"/></a>\n"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "# Controlling Flow : Repetitively\n",
    "\n"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "* One of important advantages of using computers is fast repetitive processing.\n",
    "* The **loop** clauses for such tasks.\n",
    "\n"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "* `for` loops are usually to repeat finite times.\n",
    "* `while` loops are to reiterate indefinite times.\n",
    "\n"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "* To avoid runaway codes, it is advisable to set limits of repetition in all loops at least initially.<br>If possible, please use a `for` loop. When using a `while` loop, add a counter variable and `break` after it reaches a limit.\n",
    "\n"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Iterating over elements of a list or an array\n",
    "\n"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### python\n",
    "\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "# s is a string\n",
    "s = 'abcd'\n",
    "\n",
    "# for each character of s\n",
    "for c in s:\n",
    "    # repeat the indented code block below\n",
    "    # c would have each character of s\n",
    "    print(c, end=' ')\n",
    "\n"
   ]
  },
  {
   "cell_type": "markdown",
   "source": [
    "`enumerate()`\n",
    "\n"
   ],
   "metadata": {}
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "# s is a string\n",
    "s = 'abcd'\n",
    "\n",
    "# for each character of s\n",
    "for i, c in enumerate(s):\n",
    "    # repeat the indented code block below\n",
    "    # c would have each character of s\n",
    "    # i would be the order of c in s\n",
    "    print(f\"s[{i}] = {c}\")\n",
    "\n"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### C/C++\n",
    "\n"
   ]
  },
  {
   "cell_type": "code",
   "source": [
    "%%writefile for_loop.cpp\n",
    "\n",
    "// int32_t\n",
    "#include <cstdint>\n",
    "// strlen()\n",
    "#include <cstring>\n",
    "// cout\n",
    "#include <iostream>\n",
    "\n",
    "\n",
    "// declaring intention to use namespace std\n",
    "using namespace std;\n",
    "\n",
    "\n",
    "// program starting point\n",
    "int32_t main(const int32_t argn, const char * argv[]){\n",
    "    // a zero terminated C string\n",
    "    const char s [ ] = \"abcd\";\n",
    "\n",
    "    // bound of n\n",
    "    const int32_t n = strlen(s);\n",
    "    \n",
    "    // this for loop will go through each character of s\n",
    "    for(int32_t i = 0; n > i; ++i){\n",
    "        // present i'th element of s\n",
    "        cout << \"s[\" << i << \"] = \" << s[i] << '\\n';\n",
    "\n",
    "    }\n",
    "    // change line\n",
    "    cout << '\\n';        \n",
    "\n",
    "    // indicate program could finish successfully\n",
    "    return 0;\n",
    "}\n",
    "\n"
   ],
   "metadata": {},
   "execution_count": null,
   "outputs": []
  },
  {
   "cell_type": "code",
   "source": [
    "!g++ -ofor_loop.out ./for_loop.cpp\n",
    "\n"
   ],
   "metadata": {},
   "execution_count": null,
   "outputs": []
  },
  {
   "cell_type": "code",
   "source": [
    "!./for_loop.out\n",
    "\n"
   ],
   "metadata": {},
   "execution_count": null,
   "outputs": []
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Example : Sum of an arithmatic sequence\n",
    "\n"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "* Followings would calculate the sum of the first 100 natural numbers.\n",
    "\n"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Python `for`\n",
    "\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "# initialize the sum\n",
    "s = 0\n",
    "\n",
    "# integer loop\n",
    "# would start from 1 to 100\n",
    "for i in range(1, 100+1):\n",
    "    # accumulate to s\n",
    "    s += i\n",
    "\n",
    "# present the sum\n",
    "print(f'sum = {s}')\n",
    "\n",
    "\n",
    "# check result with an expected value\n",
    "assert 5050 == s, \"Sum incorrect\"    \n",
    "\n"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Python `while`\n",
    "\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "# set both i and s to zero\n",
    "i, s = 0, 0\n",
    "\n",
    "# while loop will maintain as long as i is smaller then 100\n",
    "while 100 > i:\n",
    "    # increase i by one\n",
    "    i += 1\n",
    "    # accumulate to s\n",
    "    s += i\n",
    "\n",
    "# present the sum\n",
    "print(f'sum = {s}')\n",
    "\n",
    "# check result with an expected value\n",
    "assert 5050 == s, \"Sum incorrect\"\n",
    "\n"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### C++ `for`\n",
    "\n"
   ]
  },
  {
   "cell_type": "code",
   "source": [
    "%%writefile sum_for.cpp\n",
    "// assert()\n",
    "# include <cassert>\n",
    "// int32_t\n",
    "# include <cstdint>\n",
    "// std::cout\n",
    "# include <iostream>\n",
    "\n",
    "// program starting point\n",
    "int32_t main(int32_t argn, char *argv[]){\n",
    "    // initialize the sum\n",
    "    int32_t s = 0;\n",
    "\n",
    "    // integer loop\n",
    "    // would start from 1 to 100\n",
    "    // increment i by one at each iteration\n",
    "    for (int32_t i=1; i <= 100; ++i){\n",
    "        // accumulate to s\n",
    "        s += i;\n",
    "    }\n",
    "\n",
    "    // present result\n",
    "    std::cout << \"sum = \" << s << '\\n';\n",
    "\n",
    "    // compare with an expected value\n",
    "    assert(5050 == s);\n",
    "\n",
    "    // indicate the program successful\n",
    "    return 0;\n",
    "}\n",
    "\n"
   ],
   "metadata": {},
   "execution_count": null,
   "outputs": []
  },
  {
   "cell_type": "code",
   "source": [
    "!g++ -o sum_for.out ./sum_for.cpp\n",
    "\n"
   ],
   "metadata": {},
   "execution_count": null,
   "outputs": []
  },
  {
   "cell_type": "code",
   "source": [
    "!./sum_for.out\n",
    "\n"
   ],
   "metadata": {},
   "execution_count": null,
   "outputs": []
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "#### Compiling and running in `vi`\n",
    "\n"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "* Please start by entering `vi cpp_for.cpp` at a shell prompt.\n",
    "* Press <kbd>i</kbd> to switch to *insert mode*.\n",
    "* Enter the source code.\n",
    "* When finished, press <kbd>ESC</kbd> to switch to *command mode*.\n",
    "* Enter `:w` to save the file.\n",
    "* Enter `:!g++ -Wall -g cpp_for.cpp -o cpp_for` to compile the file.<br>If no error message, compile should have been successful.<br>Press <kbd>Enter</kbd>to return to the `vi` editor.\n",
    "* Enter `:!./cpp_for` to run the program.<br>Press <kbd>Enter</kbd>to return to the `vi` editor.\n",
    "* Above two steps in one line : `:!g++ -Wall -g cpp_for.cpp -o cpp_for && ./cpp_for`\n",
    "\n"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "#### Compiling and debugging using MS VS Code\n",
    "[[ref0](https://stackoverflow.com/questions/45679035/build-currently-opened-file-in-visual-studio-code)]\n",
    ",[[ref1](https://code.visualstudio.com/docs/editor/variables-reference)]\n",
    "\n"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "* See [C/C++ for Visual Studio Code](https://code.visualstudio.com/docs/languages/cpp) for details.\n",
    "* Please start by entering `code . &`\n",
    "* If not done yet, please install **Microsoft C/C++ extension**.<br>Press <kbd>Ctrl</kbd>+<kbd>Shift</kbd>+<kbd>x</kbd> and search.\n",
    "* Open the Command Palate using <kbd>Ctrl</kbd>+<kbd>Shift</kbd>+<kbd>p</kbd>.\n",
    "* Select **Tasks: Configure Tasks...**.\n",
    "* Select **Create tasks.json file from template**.\n",
    "* Choose **Others**.\n",
    "* Change value of **command** to \"`g++`\" and add a comma at the end.\n",
    "\n"
   ]
  },
  {
   "cell_type": "markdown",
   "source": [
    "* Add key \"`args`\" and its value as a bracket list as follows.\n",
    "``` json\n",
    "[\"-g\", \"${fileBasename}\"]\n",
    "```\n",
    "\n"
   ],
   "metadata": {}
  },
  {
   "cell_type": "markdown",
   "source": [
    "* To enable **Tasks: Run Build Task**, add \"`group`\" key-value pair.<br>\n",
    "The `tasks.json` file would look as follows: <br>\n",
    "\n",
    "``` json \n",
    "{\n",
    "    \"version\": \"2.0.0\",\n",
    "    \"tasks\": [\n",
    "        {\n",
    "            \"label\": \"build current file\",\n",
    "            \"type\": \"shell\",\n",
    "            \"command\": \"g++\",\n",
    "            \"args\": [\n",
    "                \"-Wall\", \"-g\", \"${fileBasename}\", \n",
    "                \"-Wa,-adhln=${fileBasenameNoExtension}.s\",\n",
    "            ],\n",
    "            \"group\": {\n",
    "                \"kind\": \"build\",\n",
    "                \"isDefault\": true\n",
    "            }\n",
    "        }\n",
    "    ]\n",
    "}\n",
    "```\n"
   ],
   "metadata": {}
  },
  {
   "cell_type": "markdown",
   "source": [
    "* To build, press <kbd>Ctrl</kbd>+<kbd>Shift</kbd>+<kbd>b</kbd>.\n",
    "* To debug, press <kbd>F5</kbd>.\n",
    "* When `launch.json` appears, change the value of `\"program\"` to something like `\"${workspaceFolder}/a.out\"`.\n",
    "* Click on the left side of the row `int32_t s = 0;` to set a break point.<br>\n",
    "A red circle would appear.\n",
    "* Press <kbd>F5</kbd>.<br>\n",
    "The debugger would wait for your command at the breakpoint.\n",
    "* Press <kbd>F10</kbd>.<br>\n",
    "The debugger would move the highlight line to the next line.\n",
    "* Continue pressing <kbd>F10</kbd>.<br>\n",
    "The debugger would update variables as the program executes.\n",
    "* To open console pane, press <kbd>Ctrl</kbd>+<kbd>~</kbd>.\n",
    "* Select `Debug Console` and enter a name of a variable to check its value.\n",
    "* If there is an iteration and you want to skip it, make another breakpoint after the loop and press <kbd>F5</kbd>.\n",
    "* To finish debugging press <kbd>Shift</kbd>+<kbd>F5</kbd>.\n",
    "* If you think it might be helpful, commit `tasks.json` and `launch.json` files into your repository.\n",
    "\n"
   ],
   "metadata": {}
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### C++ `while`\n",
    "\n"
   ]
  },
  {
   "cell_type": "code",
   "source": [
    "%%writefile sum_while.cpp\n",
    "// assert()\n",
    "# include <cassert>\n",
    "// int32_t\n",
    "# include <cstdint>\n",
    "// std::cout\n",
    "# include <iostream>\n",
    "\n",
    "// program starting point\n",
    "int32_t main(int32_t argn, char *argv[]){\n",
    "    // initialize i and s\n",
    "    int32_t i = 0, s = 0;\n",
    "\n",
    "    // while loop will repeat as long as i is smaller than 100 \n",
    "    while (i < 100){\n",
    "        // increment i and accumulate to s\n",
    "        s += (++i);\n",
    "        // What if \"s += (i++);\" ?\n",
    "        // https://stackoverflow.com/questions/24853/\n",
    "    }\n",
    "\n",
    "    // present the sum\n",
    "    std::cout << \"sum = \" << s << '\\n';\n",
    "\n",
    "    // check with expected result\n",
    "    assert(5050 == s);\n",
    "\n",
    "    // program finished successfully\n",
    "    return 0;\n",
    "}\n",
    "\n"
   ],
   "metadata": {},
   "execution_count": null,
   "outputs": []
  },
  {
   "cell_type": "code",
   "source": [
    "!g++ -o sum_while.out ./sum_while.cpp\n",
    "\n"
   ],
   "metadata": {},
   "execution_count": null,
   "outputs": []
  },
  {
   "cell_type": "code",
   "source": [
    "!./sum_while.out\n",
    "\n"
   ],
   "metadata": {},
   "execution_count": null,
   "outputs": []
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Example: Smallest positive number in floating point?\n",
    "\n"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "* Is $0<2^{-n}$ always true? Let's find out.\n",
    "\n"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Python `for`\n",
    "\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "# Initialize with one\n",
    "a = 1.0\n",
    "\n",
    "# counter loop that will iterate seemingly sufficiently many times\n",
    "for counter in range(1, 100000000):\n",
    "    # divide a by half\n",
    "    a *= 0.5\n",
    "\n",
    "    # if unable to distinguish a from zero, break the loop\n",
    "    # mathematically, would this be true ever?\n",
    "    if not (0 < a):\n",
    "        break\n",
    "\n",
    "    # present the intermediate result\n",
    "    print(f\"{counter:9d} : {a}\")\n",
    "\n"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Python `while`\n",
    "\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "# Initialize with one\n",
    "a = 1.0\n",
    "\n",
    "# initialize with zero\n",
    "counter = 0\n",
    "\n",
    "# the loop will stop when unable to distinghish zero and a\n",
    "while 0 < a:\n",
    "    # divide a by half\n",
    "    a *= 0.5\n",
    "    # increment the counter\n",
    "    counter += 1\n",
    "\n",
    "    # iteration limit\n",
    "    if 1e10 < counter:\n",
    "        break\n",
    "    # present intermediate result\n",
    "    print(f\"{counter:9d} : {a}\")\n",
    "\n"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### C++ `for`\n",
    "\n"
   ]
  },
  {
   "cell_type": "code",
   "source": [
    "%%writefile power_half_for.cpp\n",
    "// int32_t\n",
    "# include <cstdint>\n",
    "// setw\n",
    "# include <iomanip>\n",
    "// std::cout\n",
    "# include <iostream>\n",
    "\n",
    "// program starting point\n",
    "int32_t main(int32_t argn, char *argv[]){\n",
    "    // initialize\n",
    "    double a = 1.0;\n",
    "\n",
    "    for (int32_t counter=0;counter < 1e10; ++counter){\n",
    "        // divide by two\n",
    "        a *= 0.5;\n",
    "        std::cout << \"(\" << std::setw(9) << counter << \") \" << a << '\\n';\n",
    "        // break if unable to distinguish\n",
    "        if (!(0<a)){\n",
    "            break;\n",
    "        }\n",
    "    }\n",
    "\n",
    "    // indicate successful\n",
    "    return 0;\n",
    "}\n",
    "\n"
   ],
   "metadata": {},
   "execution_count": null,
   "outputs": []
  },
  {
   "cell_type": "code",
   "source": [
    "!g++ -o power_half_for.out ./power_half_for.cpp\n",
    "\n"
   ],
   "metadata": {},
   "execution_count": null,
   "outputs": []
  },
  {
   "cell_type": "code",
   "source": [
    "!./power_half_for.out\n",
    "\n"
   ],
   "metadata": {},
   "execution_count": null,
   "outputs": []
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### C++ `while`\n",
    "\n"
   ]
  },
  {
   "cell_type": "code",
   "source": [
    "%%writefile power_half_while.cpp\n",
    "// int32_t\n",
    "# include <cstdint>\n",
    "// setw\n",
    "# include <iomanip>\n",
    "// std::cout\n",
    "# include <iostream>\n",
    "\n",
    "// program starting point\n",
    "int32_t main(int32_t argn, char *argv[]){\n",
    "    // initialize\n",
    "    double a = 1.0;\n",
    "\n",
    "    // initialize counter\n",
    "    int32_t counter = 0;\n",
    "\n",
    "    // loop would stop when a becomes zero\n",
    "    while (0<a){\n",
    "        // divide a by two\n",
    "        a *= 0.5;\n",
    "        std::cout << \"(\" << std::setw(9)\n",
    "                  << (++counter) << \") \"\n",
    "                  << a\n",
    "                  << '\\n';\n",
    "\n",
    "        // max iteration limit\n",
    "        if (10000<counter){\n",
    "                break;\n",
    "        }\n",
    "    }\n",
    "    // indicate program success\n",
    "    return 0;\n",
    "}\n",
    "\n"
   ],
   "metadata": {},
   "execution_count": null,
   "outputs": []
  },
  {
   "cell_type": "code",
   "source": [
    "!g++ -o power_half_while.out ./power_half_while.cpp\n",
    "\n"
   ],
   "metadata": {},
   "execution_count": null,
   "outputs": []
  },
  {
   "cell_type": "code",
   "source": [
    "!./power_half_while.out\n",
    "\n"
   ],
   "metadata": {},
   "execution_count": null,
   "outputs": []
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Example : Largest Fibonacci number below 100\n",
    "\n"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Python `for`\n",
    "\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "# first two of the Fibonacci sequence\n",
    "a0, a1 = 0, 1\n",
    "# iteration limit\n",
    "max_iter = 10000\n",
    "# upper bound of the Fibonacci sequence\n",
    "upper_bound = 100\n",
    "\n",
    "for i in range(max_iter):\n",
    "    # next \n",
    "    a2 = a0 + a1\n",
    "    # if a2 reaches the upper_bound, stop\n",
    "    if a2 >= upper_bound:\n",
    "        break\n",
    "    # present intermediate result\n",
    "    # with end=' ', print would append ' ' instead of '\\n'\n",
    "    print(a2, end=' ')\n",
    "    # update previous values\n",
    "    a0, a1 = a1, a2\n",
    "\n",
    "# present result\n",
    "print(f'\\nLargest Fibo below {upper_bound} = {a1}')\n",
    "\n"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Python `while`\n",
    "\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "a0, a1 = 0, 1\n",
    "a2 = 0\n",
    "max_iter = 10000\n",
    "upper_bound = 100\n",
    "\n",
    "i = 0\n",
    "while (a2 < upper_bound) and (i < max_iter):\n",
    "    i += 1\n",
    "    a2 = a0 + a1\n",
    "    print(a1, end=' ')\n",
    "    a0, a1 = a1, a2\n",
    "    if i > max_iter:\n",
    "        break\n",
    "\n",
    "print(f'\\nLargest Fibo below {upper_bound} = {a0}')\n",
    "\n"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### C/C++ `for`\n",
    "\n"
   ]
  },
  {
   "cell_type": "code",
   "source": [
    "%%writefile fib_for.cpp\n",
    "// int32_t\n",
    "# include <cstdint>\n",
    "// std::cout\n",
    "# include <iostream>\n",
    "\n",
    "// program starting point\n",
    "int32_t main(int32_t argn, char *argv[]){\n",
    "\n",
    "    // maximum number of iterations\n",
    "    const int32_t max_iter = 10000;\n",
    "    const int32_t upper_bound = 100;\n",
    "\n",
    "    // current and two previous values of Fibonacci Sequence\n",
    "    int32_t a0 = 0, a1 = 1, a2 = 0;\n",
    "\n",
    "    // for loop\n",
    "    // i would start from 0\n",
    "    // loop will stop when max_iter <= i\n",
    "    // at every iteration increase i by one\n",
    "    for (int32_t i=0; (max_iter > i); ++i){\n",
    "        // next Fibonacci Sequence is sum of two previous values\n",
    "        a2 = a0 + a1;\n",
    "\n",
    "        // stop if a2 becomes larger than upper_bound\n",
    "        if (upper_bound < a2){\n",
    "            break;\n",
    "        }\n",
    "\n",
    "        // update previous values\n",
    "        a0 = a1;\n",
    "        a1 = a2;\n",
    "\n",
    "        // present the new value\n",
    "        std::cout << a2 << ' ';\n",
    "    }\n",
    "\n",
    "    // indicate a1 because a2 > upper_bound\n",
    "    std::cout << \"\\nLargest Fibo below \" << upper_bound << \" = \" << a1 << \"\\n\";\n",
    "\n",
    "    return 0;\n",
    "}\n",
    "\n"
   ],
   "metadata": {},
   "execution_count": null,
   "outputs": []
  },
  {
   "cell_type": "code",
   "source": [
    "!g++ -o fib_for.out ./fib_for.cpp\n",
    "\n"
   ],
   "metadata": {},
   "execution_count": null,
   "outputs": []
  },
  {
   "cell_type": "code",
   "source": [
    "!./fib_for.out\n",
    "\n"
   ],
   "metadata": {},
   "execution_count": null,
   "outputs": []
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### C++ `while`\n",
    "\n"
   ]
  },
  {
   "cell_type": "code",
   "source": [
    "%%writefile fib_while.cpp\n",
    "\n",
    "# include <iostream>\n",
    "\n",
    "using namespace std;\n",
    "\n",
    "int main(int argn, char *argv[]){\n",
    "\n",
    "    const int max_iter =10000;\n",
    "    const int upper_bound = 100;\n",
    "\n",
    "    int a0 = 0, a1 = 1, a2 = 0;\n",
    "\n",
    "    int i = 0;\n",
    "\n",
    "    while ((upper_bound > a2) && (max_iter > i)){\n",
    "        i ++;\n",
    "        a2 = a0 + a1;\n",
    "        a0 = a1;\n",
    "        a1 = a2;\n",
    "        cout << a0 << ' ';\n",
    "    }\n",
    "\n",
    "    cout << \"\\nLargest Fibo below \" << upper_bound << \" = \" << a0 << '\\n';\n",
    "\n",
    "    return 0;\n",
    "}\n",
    "\n"
   ],
   "metadata": {},
   "execution_count": null,
   "outputs": []
  },
  {
   "cell_type": "code",
   "source": [
    "!g++ -o fib_while.out ./fib_while.cpp\n",
    "\n"
   ],
   "metadata": {},
   "execution_count": null,
   "outputs": []
  },
  {
   "cell_type": "code",
   "source": [
    "!./fib_while.out\n",
    "\n"
   ],
   "metadata": {},
   "execution_count": null,
   "outputs": []
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "* Please see if you could improve the code.\n",
    "\n"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Exercise\n",
    "\n"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### 00 Smallest $\\Delta x$ for $x=10.0$ (python)\n",
    "\n"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "* Add a cell below and write a python program that finds smallest number satisfying $x + \\Delta x > x$ when $x=10$.\n",
    "\n"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### 01 Smallest $\\Delta x$ for $x=10.0$ (C/C++)\n",
    "\n"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "* Create a new .cpp file and write a C/C++ program that finds smallest number satisfying $x + \\Delta x > x$ when $x=10$.\n",
    "\n"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### 02 Minimum value of a polynomial (python)\n",
    "\n"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "* Complete the python program of the following cell.\n",
    "\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "# Random number generator\n",
    "import random\n",
    "\n",
    "# Initalize the random number generator\n",
    "random.seed()\n",
    "\n",
    "# Paramaters for the polynomial\n",
    "a0 = random.random() + 0.1\n",
    "a1 = random.random() - 0.5\n",
    "a2 = random.random() - 0.5\n",
    "\n",
    "x = 1\n",
    "\n",
    "for counter in range(100000):\n",
    "    fx = a0 * x * x + a1 * x + a2 + (random.random() - 0.5) * 1e-5\n",
    "\n",
    "# Write a python program that would try to find x minimzing fx\n",
    "# within -100 < x < 100 or an interval of your choice\n",
    "\n"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### 03 Minimum value of a polynomial (C/C++)\n",
    "\n"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "* Complete a C++ program of the following cell in a separate .cpp file.\n",
    "\n"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "``` C++\n",
    "// http://www.cplusplus.com/reference/cstdlib/rand/\n",
    "#include <cstdlib>\n",
    "#include <ctime>\n",
    "#include <iostream>\n",
    "\n",
    "int main(const int argn, const char * argv[]){\n",
    "    srand(time(NULL));\n",
    "\n",
    "    const double a0 = (rand() * 1.0 / RAND_MAX) + 0.1;\n",
    "    const double a1 = (rand() * 1.0 / RAND_MAX) - 0.5;\n",
    "    const double a2 = (rand() * 1.0 / RAND_MAX) - 0.5;\n",
    "    \n",
    "    double x = 1.0;\n",
    "    double fx = 0.0;\n",
    "    \n",
    "    for (int counter=0; 100000 > counter; ++counter){\n",
    "        fx = a0 * x * x + a1 * x + a2 \n",
    "           + ((rand() * 1.0 / RAND_MAX) - 0.5) * 1e-5;\n",
    "\n",
    "        // Write a program that would try to find x \n",
    "        // minimzing fx \n",
    "        // within -100 < x < 100 or an interval of your choice\n",
    "    \n",
    "    }\n",
    "    \n",
    "    \n",
    "    return 0;\n",
    "}\n",
    "```\n",
    "\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "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.6.5"
  },
  "colab": {
   "provenance": [],
   "include_colab_link": true
  }
 },
 "nbformat": 4,
 "nbformat_minor": 0
}