7_RecursionAndBeauty.ipynb

{
  "cells": [
    {
      "cell_type": "markdown",
      "metadata": {
        "collapsed": true
      },
      "source": [
        "# Introduction to Programming with Python\n",
        "\n",
        "# Unit 7: Recursion and the Beauty of Programming\n",
        "\n",
        "As we are coming towards the end of our module, let's focus on more difficult topics, while also exploring some more beautiful fractal figures."
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {},
      "source": [
        "## Recursion\n",
        "\n",
        "We have just discussed Fibonacci numbers, which are defined in the following way (if we number them starting from 0, as all programmers do):\n",
        "$$\n",
        "\\begin{array}{l}\n",
        "f_n = 1, 0\\le n\\le 1 \\\\\n",
        "f_n = f_{n-1} + f_{n-2}, \\quad n\\ge2\\\\\n",
        "\\end{array}\n",
        "$$\n",
        "\n",
        "We have used some clever trick to compute them, having two variables:"
      ]
    },
    {
      "cell_type": "code",
      "execution_count": 7,
      "metadata": {
        "trusted": true
      },
      "outputs": [
        {
          "data": {
            "text/plain": [
              "89"
            ]
          },
          "execution_count": 7,
          "metadata": {},
          "output_type": "execute_result"
        }
      ],
      "source": [
        "def fib(n):\n",
        "    c,p = 1,1\n",
        "    for _ in range(n):\n",
        "        c,p = c+p,c\n",
        "    return p\n",
        "\n",
        "fib(10)"
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {},
      "source": [
        "However, we may also define the same function in another way, very similar to the mathematical definition of Fibonacci number given above:"
      ]
    },
    {
      "cell_type": "code",
      "execution_count": 8,
      "metadata": {
        "trusted": true
      },
      "outputs": [
        {
          "data": {
            "text/plain": [
              "89"
            ]
          },
          "execution_count": 8,
          "metadata": {},
          "output_type": "execute_result"
        }
      ],
      "source": [
        "def fib(n):\n",
        "    if n<=1:\n",
        "        return 1\n",
        "    else:\n",
        "        return fib(n-1) + fib(n-2)\n",
        "    \n",
        "fib(10)"
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {},
      "source": [
        "You may be surprised: how is it possible to use the function `fib` inside its own definition? In face, such technique is called **recursion**, and it often used in programming. \n",
        "\n",
        "Let us consider the example of calculating `fib(3)`. Recursion works as follows:\n",
        "\n",
        "1. To calculate `fib(3)`, the function calls `fib(2)` and `fib(1)`\n",
        "2. When `fib(2)` is called, it calls `fib(1)` and `fib(0)`.\n",
        "3. Both of those calls `return 1` (because the argument `n` is less than 2)\n",
        "4. Thus `fib(2)` is computed as `1+1=2`\n",
        "5. When `fib(1)` is called in step 1, it also returns 1 (as in step 3)\n",
        "6. `fib(3)` is computed to be equal to `2+1=3`.\n",
        "\n",
        "We can actually add some `print` operators to the function to see how those calls are made:"
      ]
    },
    {
      "cell_type": "code",
      "execution_count": 9,
      "metadata": {
        "trusted": true
      },
      "outputs": [
        {
          "name": "stdout",
          "output_type": "stream",
          "text": [
            "Calling fib(3)\n",
            "Calling fib(2)\n",
            "Calling fib(1)\n",
            "fib(1) returns 1\n",
            "Calling fib(0)\n",
            "fib(0) returns 1\n",
            "fib(2) returns 2=1+1\n",
            "Calling fib(1)\n",
            "fib(1) returns 1\n",
            "fib(3) returns 3=2+1\n"
          ]
        },
        {
          "data": {
            "text/plain": [
              "3"
            ]
          },
          "execution_count": 9,
          "metadata": {},
          "output_type": "execute_result"
        }
      ],
      "source": [
        "def fib(n):\n",
        "    print(f'Calling fib({n})')\n",
        "    if n<=1:\n",
        "        print(f'fib({n}) returns 1')\n",
        "        return 1\n",
        "    else:\n",
        "        f1 = fib(n-1)\n",
        "        f2 = fib(n-2)\n",
        "        print(f'fib({n}) returns {f1+f2}={f1}+{f2}')\n",
        "        return f1+f2 \n",
        "    \n",
        "fib(3)"
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {},
      "source": [
        "You may notice that during those computations `fib(1)` is called twice. In fact, if you try to compute `fib` for any number larger than 20, you may notice significant delay - that is because number of calls to function `fib` increases very rapidly. For example, to compute `fib(16)` we would need to make aroung 65000 calls, while during our previous algorithm with a loop we need to repeat the loop only 16 times.\n",
        "\n",
        "This does not necessarily mean that recursion is bad. Sometimes it is not easy to program an algorithm without recursion, as we will see in the next example. However, if you can think of a non-recursive way to solve the problem - you should prefer it, because it is likely to be more effective. However, recursive algorithms often tend to be shorter and more beautiful."
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {},
      "source": [
        "## Koch Snowflake\n",
        "\n",
        "The best graphical example of recursion is a **[Koch Snowflake](https://en.wikipedia.org/wiki/Koch_snowflake)**, which looks like this:\n",
        "\n",
        "![Koch Snowflake](./images/KochFlake.PNG)\n",
        "Image [from Wikipedia](https://commons.wikimedia.org/w/index.php?curid=1898291), CC BY-SA 3.0\n",
        "\n",
        "This picture shows snowflakes of different *complexities*:\n",
        "\n",
        "* When complexity $n=0$ (first figure), to draw one side of the snowflake of size $x$ we just draw a straight line of length $x$\n",
        "* When complexity $n=1$ (second figure), we draw the side in the following manner:\n",
        "   - Draw the side of length $x\\over3$ and complexity $0$\n",
        "   - Turn $60^\\circ$ left\n",
        "   - Draw the side of length $x\\over3$ and complexity $0$\n",
        "   - Turn $120^\\circ$ right\n",
        "   - Draw the side of length $x\\over3$ and complexity $0$\n",
        "   - Turn $60^\\circ$ left\n",
        "* In a similar manner, for any other complexity $n>1$:\n",
        "   - Draw the side of length $x\\over3$ and complexity $n-1$\n",
        "   - Turn $60^\\circ$ left\n",
        "   - Draw the side of length $x\\over3$ and complexity $n-1$\n",
        "   - Turn $120^\\circ$ right\n",
        "   - Draw the side of length $x\\over3$ and complexity $n-1$\n",
        "   - Turn $60^\\circ$ left\n",
        "\n",
        "You probably recognized *recursion* in this algorithm:\n",
        "* For $n=0$ - we draw straight line. This is called **termination** of recursion, because we do not make a recursive call to the function\n",
        "* For $n>0$ - we follow the algorithm described above, which involves calling the same function with argument $n-1$\n",
        "\n",
        "The function to draw **Koch Curve** will look like this:"
      ]
    },
    {
      "cell_type": "code",
      "execution_count": 17,
      "metadata": {
        "trusted": true
      },
      "outputs": [
        {
          "data": {
            "image/png": "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",
            "text/plain": [
              "<Figure size 432x288 with 1 Axes>"
            ]
          },
          "metadata": {
            "needs_background": "light"
          },
          "output_type": "display_data"
        }
      ],
      "source": [
        "import jturtle as turtle\n",
        "\n",
        "def koch_curve(n,x):\n",
        "    if n==0:\n",
        "        turtle.forward(x)\n",
        "    else:\n",
        "        koch_curve(n-1,x/3)\n",
        "        turtle.left(60)\n",
        "        koch_curve(n-1,x/3)\n",
        "        turtle.right(120)\n",
        "        koch_curve(n-1,x/3)\n",
        "        turtle.left(60)\n",
        "        koch_curve(n-1,x/3)\n",
        "\n",
        "turtle.right(90)\n",
        "koch_curve(2,100)\n",
        "turtle.done()"
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {},
      "source": [
        "Let's draw Koch curvers with different $n$-s:"
      ]
    },
    {
      "cell_type": "code",
      "execution_count": 18,
      "metadata": {
        "trusted": true
      },
      "outputs": [
        {
          "data": {
            "image/png": "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",
            "text/plain": [
              "<Figure size 432x288 with 1 Axes>"
            ]
          },
          "metadata": {
            "needs_background": "light"
          },
          "output_type": "display_data"
        }
      ],
      "source": [
        "turtle.right(90)\n",
        "for n in range(4):\n",
        "    koch_curve(n,100)\n",
        "    turtle.penup()\n",
        "    turtle.forward(-100)\n",
        "    turtle.right(90)\n",
        "    turtle.forward(40)\n",
        "    turtle.left(90)\n",
        "    turtle.pendown()\n",
        "turtle.done()"
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {},
      "source": [
        "Finally, to produce Koch's Snowflake, we need to draw 3 Koch curves:"
      ]
    },
    {
      "cell_type": "code",
      "execution_count": 20,
      "metadata": {
        "trusted": true
      },
      "outputs": [
        {
          "data": {
            "image/png": "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",
            "text/plain": [
              "<Figure size 432x288 with 1 Axes>"
            ]
          },
          "metadata": {
            "needs_background": "light"
          },
          "output_type": "display_data"
        }
      ],
      "source": [
        "def koch_snowflake(n,x):\n",
        "    for _ in range(3):\n",
        "        koch_curve(n,x)\n",
        "        turtle.right(120)\n",
        "\n",
        "koch_snowflake(3,100)\n",
        "turtle.done()"
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {},
      "source": [
        "## Minkowski Island\n",
        "\n",
        "A very similar figure to Koch Snowflake is called **Minkowski Island**, or **Quadratic Koch Curve**. The idea is similar, but instead of turning 60 degrees - we turn 90.\n",
        "\n",
        "![](../images/Quadratic_Koch_curve_type2_iterations.png)\n",
        "By <a title=\"User:Prokofiev\" href=\"//commons.wikimedia.org/wiki/User:Prokofiev\">Prokofiev</a> - <span class=\"int-own-work\" lang=\"en\">Own work</span>, <a title=\"Creative Commons Attribution-Share Alike 4.0\" href=\"https://creativecommons.org/licenses/by-sa/4.0\">CC BY-SA 4.0</a>, <a href=\"https://commons.wikimedia.org/w/index.php?curid=3194494\">Link</a>\n",
        "\n",
        "While writing this function, we will try to be creative and use loop to draw each part of the curve. The trick is to use the **list** of all angles that we need to turn in between, together with their direction (i.e. 90 will mean turn $90^\\circ$ left, 0 - do not turn at all, and -90 - turn $90^\\circ$ right)"
      ]
    },
    {
      "cell_type": "code",
      "execution_count": 25,
      "metadata": {
        "trusted": true
      },
      "outputs": [
        {
          "data": {
            "image/png": "iVBORw0KGgoAAAANSUhEUgAAAOcAAADnCAYAAADl9EEgAAAABHNCSVQICAgIfAhkiAAAAAlwSFlzAAALEgAACxIB0t1+/AAAADh0RVh0U29mdHdhcmUAbWF0cGxvdGxpYiB2ZXJzaW9uMy4xLjMsIGh0dHA6Ly9tYXRwbG90bGliLm9yZy+AADFEAAAFNUlEQVR4nO3d0W6jOABAUbLa///l7FOlbpK2CXHMBc557rTImivZgPHler0uQM8/W18A8Jg4IUqcECVOiBInRIkTosQJUeKEKHFClDghSpwQJU6IEidEiROixAlR4oQocUKUOCFKnBAlTogSJ0SJE6LECVH/bn0BNZfL5eGHfK/X62X2tXBu4nzgNsSfgoVPMq2FKHFClDgh6vRrzjXryUf/xg0jRjt9nMuyLqzv/8YNIz7BtBaixAlRprXL/bT00TT3r6mrdSijXZxs/X+Xy+U6IqpRv4fzMq2FKHFC1OnWnCMee3h0wgyni3NZxtyosZ7k00xrIUqcECVOiDrUmvPZrxg889LBq3/rE2tQLzac26HiXJbXQ1xz53XmlxK8YH9eprUQJU6I2vW0dtRG6Qobv/lu13Euy/sbpWts/OaLaS1EiROidj+tHbFR+hPX8dO1vPp71jy2mfEMls871Gbr0gbnEddS+R1sw7QWosQJUeKEqF3dEKo8wyt9TaEyJoy3qziXpXPnsfQ1hcqYMJZpLUSJE6J2N6397QH7zCPj17wssOZn3r2WmWPCWLuKc1QAM67j9uc+9SZTZUwYz7QWosQJUbua1j7y6hTtU5uTR1zHKJUx4T27jnPtf6DRm5NHXMcolTHhfaa1ECVOiBInRO16zfmsV4+M/9TNkNJarjIm/OxQX0IYwZcD7hmTbZjWQpQ4IeoUa87vSuu+CmPSdLo4l8XNjUeMSY9pLUSJE6Iy09oRL1/PPNl6BmNybpk4l2XMy9czTraeyZicl2ktRIkTosQJUZutObc6Mr68njImfLfpDaGtjowv34k0JnwxrYUocULUptPaWc/b9rSmMiZ8yWy2tqH3njE5N9NaiBInRE1Zc1rf3DMm/GXaDSFrp3vGhN+Y1kKUOCFKnBA1bc35167+yjF0Wx5df/t3KmPCNqbE+ewR65Vj6LY4uv6nv1MZE+YzrYUocUJU6sX3NT//7hps1AbnUWvBwpjQsFmcpePR393gvOV1fOpa2J5pLUSJE6JSH5W+9cwUbcSXyp/5Ha+eBL32Wv4ya0zYXmaz9QgjNieP2uBc2ShduQ5eZ1oLUeKEqPSa81blA8qlxxWla2GsXcW5LJ0PKJfWcaVrYRzTWogSJ0SJE6J2t+b87QH7zCPWZzzof/bFBi8dHNOu4nxmE/SMI9ZnHtP+6pcR3L09DtNaiBInRO1qWvvIiM3JFVudbE3TruMcsTm5ZquTrekxrYUocULUrqe1z5qxLhu12XrWydb0HWqzdUlp4zf7ZFoLUeKEKHFC1CluCI12tK8p0CTOlY72NQV6TGshSpwQZVq70pqXBdb8DOclzhWefWvnt43Sa4584FxMayFKnBBlWjvIkTZ90yDOAY646ZvtmdZClDghSpwQZc05kZtAvMKXECDKtBaixAlR4oQocUKUOCFKnBAlTogSJ0SJE6LECVHihChxQpQ4IUqcECVOiBInRIkTosQJUeKEKHFClDghSpwQJU6IEidEiROixAlR4oQocUKUOCFKnBAlTogSJ0SJE6LECVHihChxQpQ4IUqcECVOiBInRIkTosQJUeKEKHFClDghSpwQJU6IEidEiROixAlR4oQocUKUOCFKnBAlTogSJ0SJE6LECVHihChxQpQ4IUqcECVOiBInRIkTosQJUeKEKHFClDghSpwQJU6IEidEiROixAlR4oQocUKUOCFKnBAlTogSJ0SJE6LECVHihChxQpQ4IUqcECVOiBInRIkTosQJUeKEKHFC1H/BXX5LsGImPgAAAABJRU5ErkJggg==",
            "text/plain": [
              "<Figure size 432x288 with 1 Axes>"
            ]
          },
          "metadata": {
            "needs_background": "light"
          },
          "output_type": "display_data"
        }
      ],
      "source": [
        "def minkowski(n,x):\n",
        "    if n==0:\n",
        "        turtle.forward(x)\n",
        "    else:\n",
        "        for t in [90,-90,-90,0,90,90,-90,0]:\n",
        "            minkowski(n-1,x/4)\n",
        "            turtle.left(t)\n",
        "            \n",
        "for _ in range(4):\n",
        "    minkowski(2,100)\n",
        "    turtle.left(90)\n",
        "turtle.done()"
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {},
      "source": [
        "## Flowers and Trees\n",
        "\n",
        "If you continue studying Programming or Computer Science, you will learn that an important data structure is **tree** - a collection of elements that have parent and child elements. For example, folders or directories in our computer form a tree.\n",
        "\n",
        "In our final example, we will draw something similar to a tree, and on the other hand similar to a dandelion or some umbrella-like plant. We will start with one branch, and then for each branch generate $n$ sub-branches, and so on. "
      ]
    },
    {
      "cell_type": "code",
      "execution_count": 31,
      "metadata": {
        "trusted": true
      },
      "outputs": [
        {
          "data": {
            "image/png": "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",
            "text/plain": [
              "<Figure size 432x288 with 1 Axes>"
            ]
          },
          "metadata": {
            "needs_background": "light"
          },
          "output_type": "display_data"
        }
      ],
      "source": [
        "from random import randint\n",
        "def tree(n,b,x):\n",
        "    turtle.forward(x) # draw the branch\n",
        "    if n>0: # draw n sub-branches on top of it\n",
        "        for _ in range(b):\n",
        "            a = randint(-40,40)\n",
        "            turtle.left(a)\n",
        "            tree(n-1,b,x)\n",
        "            turtle.right(a)\n",
        "    turtle.forward(-x) # move back to the beginning of the branch\n",
        "\n",
        "tree(3,3,100)\n",
        "turtle.done()"
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {},
      "source": [
        "This code is very clever, and it might take you some time to figure out. The difficult thing here is to make turtle return to the original position each time the branch is drawn. So, at the top level, the logic of the function is the following:\n",
        "* Draw one branch by calling `forward(x)`\n",
        "* Optionally (if $n>0$), draw $b$ sub-branches. Here $b$ is the **branching factor**. \n",
        "* Move back to the starting position by calling `forward(-x)`.\n",
        "\n",
        "When drawing branched, we always assume that `tree` moves the turtle back to its original position before the drawing."
      ]
    },
    {
      "cell_type": "code",
      "execution_count": 33,
      "metadata": {
        "trusted": true
      },
      "outputs": [
        {
          "data": {
            "image/png": "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",
            "text/plain": [
              "<Figure size 432x288 with 1 Axes>"
            ]
          },
          "metadata": {
            "needs_background": "light"
          },
          "output_type": "display_data"
        }
      ],
      "source": [
        "for _ in range(5):\n",
        "    tree(3,3,100)\n",
        "    turtle.right(90)\n",
        "    turtle.forward(120)\n",
        "    turtle.left(90)\n",
        "turtle.done()"
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {},
      "source": [
        "We have cosidered just a few examples of drawing trees, but there could be many more. For example, try to experiment with our `tree` function to produce different types of flora by doing one or more of the following:\n",
        "* Experiment with different branching factors\n",
        "* The line `a = randint(-40,40)` defines random angle for each branch. By changing the angles you can control the spread of branches, and also whether the tree would look *straight*, or falling to the left or right\n",
        "* Try to make branches shorter and longer as you go up towards the top of the tree. This can be achieved by multiplying `x` by some **growth factor**, which should be somewhat close to 1\n",
        "* You may pass angle boundaries and growth factor as parameters to play with them freely. Finally, produce a forest that combines different kinds of trees together. "
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "trusted": true
      },
      "source": [
        "## The Beauty of Programming\n",
        "\n",
        "I hope you would agree with me, that in the examples above we have managed to draw pretty beautiful pictures! They are not only pleasant aesthetically, but they are beautiful in *mathematical* sense. Koch Snowflake and Minkowski Island are examples of **fractal structures**, which can be infinitely complex, i.e. if you draw such a figure for very large $n$, you would be able to zoom into it, and part of the figure would be similar to the original one. Ideally, such a fractal would be infinitely complex. However, we managed to write a simple and rather short program, which can produce arbitrary complex figures. I believe this shows the main beauty of programming -- with simple code you can program computer to perform many complex operations and achieve very complex results!\n",
        "\n",
        "## Where to go Next\n",
        "\n",
        "Of course, real programs are more complex than those we have seen in this course, and you are still to learn how to fight complexity in programming. However, Python is a very good starting point, because from here you can start exploring programming in many different directions:\n",
        "\n",
        "* **Web Programming** is about creating web sites. You can use Python and Django Framework to create web applications [see how](https://channel9.msdn.com/shows/Azure-Friday/Python-on-Azure-Part-1-Building-Django-apps-with-Visual-Studio-Code/?WT.mc_id=python-github-dmitryso)\n",
        "* You can do **Game Development** with Python, a good place to start would be [PyGame](https://www.pygame.org) library. And you can also run Python on small programmable consoles, like [PyBadge](https://learn.adafruit.com/adafruit-pybadge)\n",
        "<img src=\"./images/pybadge.jpg\" width=\"30%\"/><br/>\n",
        "Picture from [this project at hackday.io](https://hackaday.io/project/164929/gallery#692b286060e43ce2e9ae50b5c3b1b0c5)\n",
        "* **Data Science** is a branch of computer science which studies the ways you can extract knowledge from data. For example, having a large set of people's photographs and their corresponding age you can create a program that will **learn** how to determine person's age from a picture. This is closely related to another discipline, **Artificial Intelligence**. See [this example](http://aka.ms/facestudies) for how you can use information extracted from people's photographs to make interesting conclusions.\n",
        "* **Science Art** is another direction at the intersection of science and art. Python is a great language for science art, because it contains powerful libraries for image manipulation. See [this blog post](http://aka.ms/peopleblending) on how you can create your own cognitive portrait from photographs like this one:\n",
        "<img src=\"./images/VickieRotator.png\" width=\"30%\"/>\n",
        "\n",
        "And there are many more areas where Pyton can be used as a language! However, before diving right into one of those specific areas, I suggest that you learn a little bit more of core language features in our next course. \n",
        "\n",
        "I hope you enjoyed the course, and are curious to learn more! Good luck!"
      ]
    },
    {
      "cell_type": "code",
      "execution_count": null,
      "metadata": {
        "trusted": true
      },
      "outputs": [],
      "source": []
    }
  ],
  "metadata": {
    "kernelspec": {
      "display_name": "Python 3.6",
      "language": "python",
      "name": "python36"
    },
    "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.6"
    }
  },
  "nbformat": 4,
  "nbformat_minor": 2
}