Coding_Hour3.ipynb

{
  "nbformat": 4,
  "nbformat_minor": 0,
  "metadata": {
    "colab": {
      "name": "Coding_Hour3.ipynb",
      "provenance": [],
      "collapsed_sections": [],
      "toc_visible": true
    },
    "kernelspec": {
      "name": "python3",
      "display_name": "Python 3"
    }
  },
  "cells": [
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "WTJX0pFCQpSH"
      },
      "source": [
        "# Loop\n",
        "\n",
        "---\n",
        "Many nummerical problem become easier when using loop."
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "i-iZvqKlUTUZ"
      },
      "source": [
        "Famous numerical problem\n",
        "$$2^x=x^2$$ which has two real-solutions $x=2$ and $x=4$. The equation is equivalent to $$ x=\\frac{2\\ln(x)}{\\ln2} $$ or $$ x=\\sqrt{2^x} $$\n",
        "\n",
        "We can use the following code to safely secure the answer $x$ using numerical method."
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "Z4QrQk9ABGpm"
      },
      "source": [
        "**First, we can try the following iterations**\n",
        "$$x_{i+1}=\\frac{2\\ln{x_i}}{\\ln{2}}$$"
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "ZZARyv5HYI26"
      },
      "source": [
        "import math\n",
        "x=5\n",
        "while True:\n",
        "  x=2*math.log(x)/math.log(2)\n",
        "  _=2*math.log(x)/math.log(2)\n",
        "  if abs(x-_)<1e-15:\n",
        "    break\n",
        "print(x)"
      ],
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "ucLFMd6UB2_1"
      },
      "source": [
        "We can observe how the value of $x$ approach the root of equation by plotting the graph.  "
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "JVafYhJ1BwRO"
      },
      "source": [
        "import matplotlib.pyplot as plt\n",
        "for x in [2,2.5,3,3.5,4,4.5,5,5.5,6]:\n",
        "  x_list=[x]\n",
        "  while True:\n",
        "      x=2*math.log(x)/math.log(2)\n",
        "      x_list.append(x)\n",
        "      _=2*math.log(x)/math.log(2)\n",
        "      if abs(x-_)<1e-3:\n",
        "        break\n",
        "      plt.plot(x_list)\n",
        "plt.xlabel('Number of Iterations')\n",
        "plt.ylabel('Current Value of x')\n",
        "plt.show()"
      ],
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "39cbK4KgGwyM"
      },
      "source": [
        "Now, let's see what happens if we use the sequence \n",
        "$$x_{i+1}=\\sqrt{2^{x_i}}$$\n",
        "in the iteration"
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "y23iAtTkZROI"
      },
      "source": [
        "x=3.8\n",
        "while True:\n",
        "  x=math.sqrt(2**x)\n",
        "  _=math.sqrt(2**x)\n",
        "  if abs(x-_)<1e-15:\n",
        "    break\n",
        "print(x)"
      ],
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "Flyn6NaVHnkP"
      },
      "source": [
        "for x in [-1,0,1,1.5,2,2.5,3,3.5,4]:\n",
        "  x_list=[x]\n",
        "  while True:\n",
        "      x=math.sqrt(2**x)\n",
        "      x_list.append(x)\n",
        "      _=math.sqrt(2**x)\n",
        "      if abs(x-_)<1e-3:\n",
        "        break\n",
        "      plt.plot(x_list)\n",
        "plt.xlabel('Number of Iterations')\n",
        "plt.ylabel('Current Value of x')\n",
        "plt.show()"
      ],
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "Gt2lBd_rdPDq"
      },
      "source": [
        "This example shows that, we can also use basics operation to solve some numerical problems that are hard to solve\n",
        "$$\\sqrt{3}=?$$\n",
        "First, we see that this is equivalent to find the positive root of $$x^2 -3=0$$\n",
        "we can write\n",
        "$$x=\\sqrt{3}$$\n",
        "We cannot use the previous method to find $\\sqrt{3}$ (really?)"
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "YH5NFyySQtaT"
      },
      "source": [
        "## for loop: definite iterations\n",
        "___\n",
        "We use <a>for</a> when the elements for iteration are present. For statement will implement the sets operations under the <a>for</a> block for each elements in the given iterable object. (<a>list, string, dict, tuple, range</a>). The order of element in which the loop excute follows the order of elements in that iterable object.\n",
        "### Structure of <a>For Loop</a>\n",
        "For loop has the following structure,\n",
        "\n",
        "\n",
        "\n",
        "```\n",
        "for item in (iterable)object:\n",
        "    action 1\n",
        "    action 2\n",
        "    action 3\n",
        "          .\n",
        "          .\n",
        "          .\n",
        "    action n\n",
        "```\n",
        "\n",
        "**Unindentations** imply the action outside the loop and termination of *loop block*.\n",
        "\n",
        "```\n",
        "for item in (iterable)object:\n",
        "    action in loop 1\n",
        "    action in loop 2\n",
        "    action in loop 3\n",
        "    ## This is where the loop block end\n",
        "action outside\n",
        "```\n",
        "\n",
        "**Else** can be used with for loop. The code inside *else* block is excuted after the loop finish all the elements in iterable object.\n",
        "\n",
        "```\n",
        "for item in (iterable)object:\n",
        "    action in loop 1\n",
        "    action in loop 2\n",
        "    action in loop 3\n",
        "    ## This is where the loop block end\n",
        "else:\n",
        "    action_else 1\n",
        "    action_else 2\n",
        "             .\n",
        "             .\n",
        "             .\n",
        "action outside\n",
        "```\n"
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "fJWAmWVYHGpY"
      },
      "source": [
        "for i in range(5):\n",
        "    print('  looping ....')\n",
        "print('I am outside the loop')"
      ],
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "kM6DW8zIkUbQ"
      },
      "source": [
        "For <a>list</a> object, the iterations are done in the same order as the arrangement of **list**"
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "E6KCStvoRBUK"
      },
      "source": [
        "x = [1,'s', True, [1,2,3]]\n",
        "for i in x:\n",
        "  print(i)"
      ],
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "gziRSN7FSCJD"
      },
      "source": [
        "This example shows how we can find the sum of 1 to 100"
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "qiIhTyTeRaO6"
      },
      "source": [
        "sum=0\n",
        "for i in range(0,101):\n",
        "    sum=sum+i\n",
        "print(sum)"
      ],
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "1mlgkEsUSRvq"
      },
      "source": [
        "Two examples below shows how we can find the sum of even integer up until 100 by loop."
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "8XBfEr-6SLWe"
      },
      "source": [
        "sum=0\n",
        "for i in range(0,101,2):\n",
        "    sum=sum+i\n",
        "    print('This is the iterations of number ',i,' and the total summation is ',sum)\n",
        "print('Summation of this interations yields ',sum)"
      ],
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "73_N7Q3yShMG"
      },
      "source": [
        "sum=0\n",
        "for i in range(0,101):\n",
        "    if i%2==0:\n",
        "        sum=sum+i\n",
        "        print('This is the iterations of number ',i,' and the total summation is ',sum)\n",
        "print('Summation of this interations yields ',sum)"
      ],
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "HYuis6qJWEfX"
      },
      "source": [
        "Here is the example to calculate the fibonacci number using for loop<br>\n",
        "\n",
        "\n",
        "Fibonacci number is defined by recurrence\n",
        "$$ F(n) =\n",
        "  \\begin{cases}\n",
        "    1      & \\quad  n =1,2\\\\\n",
        "    F(n)=F(n-1)+F(n-2)  & \\quad \\text{for } n >2\n",
        "  \\end{cases}\n",
        "$$\n",
        "\n",
        "The closed form of this recurrent relation is\n",
        "\n",
        "$$F(n)=\\frac{\\left({\\frac{1+\\sqrt{5}}{2}}\\right)^n-\\left({\\frac{1-\\sqrt{5}}{2}}\\right)^n}{\\sqrt{5}}$$\n",
        "We can find all Fibonacci number without advance knowledge in mathematics using loop as follows "
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "AhiZTnIfVQft"
      },
      "source": [
        "N=int(input('n= '))\n",
        "if N >2:\n",
        "  a=1\n",
        "  b=1\n",
        "  for i in range(N-2):\n",
        "      fibo=a+b\n",
        "      a=b\n",
        "      b=fibo\n",
        "else:\n",
        "  fibo=1\n",
        "print(fibo)"
      ],
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "VufC6mgzQ1HR"
      },
      "source": [
        "## while loop: indefinite iterations\n",
        "___\n",
        "\n",
        "Unlike <a>for</a>, the loop <a>while</a> can be used without iterable object. However, this comes with consequence that *infinite* loop may occurs.\n",
        "\n",
        "### Structure of <a>while loop</a>\n",
        "```\n",
        "while boolean (value or statement):\n",
        "    action in loop 1\n",
        "    action in loop 2\n",
        "    action in loop 3\n",
        "              .\n",
        "              .\n",
        "              .\n",
        "    ## This is where the loop block end\n",
        "action outside\n",
        "```\n",
        "**Unindentation** and **else** can be used the same way as for loop."
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "ec2DJQo6TTTE",
        "cellView": "both"
      },
      "source": [
        "x=0\n",
        "while True:\n",
        "    print('Hello World '+str(x))\n",
        "    x=x+1"
      ],
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "uepafnyDQzgo"
      },
      "source": [
        "x=0\n",
        "while x<100:\n",
        "    x=x+1\n",
        "    print(x)\n",
        "else:\n",
        "    print('done')"
      ],
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "6m17o9ZjPcRW"
      },
      "source": [
        "# Continue and Break\n",
        "___\n",
        "In some case, we need to skip some operation in the loop if some statement is True. Sometimes, the loop should be terminated when time pass. In Python, we have<a>continue</a> and <a>break</a> keywords for this kind of manipulation."
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "Hj0A3xiIObfj"
      },
      "source": [
        "## Continue\n",
        "<a>continue</a> is a keyword in both types of loop.<a>continue</a> inside *for* block will skip all the action within that *iteration*. For example"
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "Nti1FO1aQMJn"
      },
      "source": [
        "for i in range(5):\n",
        "  print(i)\n",
        "  print('Yahoo')"
      ],
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "psA9gOKWQiJS"
      },
      "source": [
        "for i in range(5):\n",
        "  print(i)\n",
        "  if i == 2:\n",
        "    continue\n",
        "    print(i+100)  # This comes after continue so it wont be printed out\n",
        "  print('Yahoo')"
      ],
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "tmbg8TOorlc2"
      },
      "source": [
        "## Break\n",
        "<a>break</a> is a keyword that **terminates**(no kidding) the loop. "
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "Z1gh0C4NqE9w"
      },
      "source": [
        "x=0\n",
        "while x<10:\n",
        "    x=x+1\n",
        "    if x==7:\n",
        "      break\n",
        "    print(x)\n",
        "else:\n",
        "    print('done')"
      ],
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "3Bd09SxhtbPX"
      },
      "source": [
        "for i in range(5):\n",
        "  print(i)\n",
        "  if i == 2:\n",
        "    break\n",
        "  print('Yahoo')"
      ],
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "LDwJp-IJ4u1d"
      },
      "source": [
        "# Function\n",
        "___\n"
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "-9RztcJ9OXTj"
      },
      "source": [
        "## Definition of Function\n",
        "In python, like other programming language, we can define additional function to be called when needed. The syntax for function definition is\n",
        "```\n",
        "def function_name(arg1,arg2,...):\n",
        "    action 1  ##\n",
        "    action 2\n",
        "          .\n",
        "          .\n",
        "          .\n",
        "```\n",
        "\n",
        "arg1, arg2, arg3 are variables or values used as inputs for the function. For example,"
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "BTHR8hNTtt9m"
      },
      "source": [
        "def square(value):\n",
        "    print(value**2)"
      ],
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "I77uacyIt1id"
      },
      "source": [
        "square(3)"
      ],
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "fRaju75Ft4uT"
      },
      "source": [
        "## Variable Space\n",
        "Unlike loop, the variables used in function is *local*."
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "b4hZ0xKFQUqG"
      },
      "source": [
        "x=0\n",
        "def test():\n",
        "  x=1\n",
        "  print(x)"
      ],
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "uWsN-s65QbkM"
      },
      "source": [
        "test()"
      ],
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "gBgPX1k8QfkT"
      },
      "source": [
        "x"
      ],
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "cTPP7S7mZjc5"
      },
      "source": [
        "def test():\n",
        "  global x\n",
        "  x=1\n",
        "  print(x)"
      ],
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "ZpA-jmzYZrLw"
      },
      "source": [
        "test()"
      ],
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "qQq7uPxqZtEB"
      },
      "source": [
        "x"
      ],
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "sBTrwZKtQr5H"
      },
      "source": [
        "## Return Vs None-Return Function\n",
        "In function definition, the keywords <a>return</a> defines the value of that function. If there is no <a>return</a> in the function, it value is defined to be <a>None</a>\n",
        "\n",
        "**The values for return can be of any type.** Function can return function or any other object."
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "WPuxWjge4t3a"
      },
      "source": [
        "def returnfn():\n",
        "  return 3\n",
        "print(returnfn())"
      ],
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "wzkddDnv5XVh"
      },
      "source": [
        "def nonreturnfn():\n",
        "  pass\n",
        "print(nonreturnfn())"
      ],
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "hxIVVVRIS7D-"
      },
      "source": [
        "def ff():\n",
        "  def a():\n",
        "    pass\n",
        "  return a"
      ],
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "yricxOnsTF0_"
      },
      "source": [
        "ff()"
      ],
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "4wFb7Wd4SWE1"
      },
      "source": [
        "1+returnfn()"
      ],
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "W0bxSW8nSdLQ"
      },
      "source": [
        "1+nonreturnfn()"
      ],
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "4qP4fO_aTmhx"
      },
      "source": [
        "x=returnfn()"
      ],
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "cx2jPbdYTpuQ"
      },
      "source": [
        "x"
      ],
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "aagXUtdhTu2I"
      },
      "source": [
        "print(x)"
      ],
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "YiqIEuCw6sl_"
      },
      "source": [
        "x=nonreturnfn()"
      ],
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "Tk852SNPc0Ge"
      },
      "source": [
        "x"
      ],
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "d27szHOhTwoY"
      },
      "source": [
        "print(x)"
      ],
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "JrfqCHB-T8lj"
      },
      "source": [
        "## Passing argument to function"
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "Fh2bL0_t6u6I"
      },
      "source": [
        "def mod2_addition(x,y):\n",
        "    return (x+y)%2"
      ],
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "pyDLXTSZMeA7"
      },
      "source": [
        "mod2_addition(3,4)"
      ],
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "ZIrFgHklUKMH"
      },
      "source": [
        "mod2_addition(3,y=4)"
      ],
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "mq4PZpKSUVve"
      },
      "source": [
        "mod2_addition(x=3,y=4)"
      ],
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "lR_coviyUYHi"
      },
      "source": [
        "mod2_addition(x=3,4)"
      ],
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "dF3K-nQLUgVC"
      },
      "source": [
        "## Default value"
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "sQu43QjEMga0"
      },
      "source": [
        "def modulo_addition(x,y,mod=2):\n",
        "    return (x+y)%mod"
      ],
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "kkKlU34Fcnte"
      },
      "source": [
        "modulo_addition(2,3)"
      ],
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "gURB8mf0UIuj"
      },
      "source": [
        "modulo_addition(5,6)"
      ],
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "HrpxvwQtUrsn"
      },
      "source": [
        "modulo_addition(5,6,7)"
      ],
      "execution_count": null,
      "outputs": []
    }
  ]
}