Revise C0-A30

Author: UPstartDeveloper

chapter0-exercises/chapter_0_part2.ipynb

@@ -2902,55 +2902,128 @@
         "id": "cognitive-toolbox"
       },
       "source": [
-        "## Activity: Compound function\n",
+        "## Activity 30: Function Composition\n",
         "\n",
-        "- For a given function (f), starting point (a0) and number of iteration (m), write a function that calculates f(a0), f(f(a0)), ..., f(f(f(...f(a0)))))"
+        "At this point, we presume you understand how functions work: \n",
+        "- they take in values, \n",
+        "- and output values. \n",
+        "\n",
+        "When the output of one function becomes the input for another, we have a special name for it: *function composition*.\n",
+        "\n",
+        "In this activity, you are given a function `f`, an initial value `a0`, and some number of iterations to perform, `m`. How would you write Python code to show how the value of `a` changes as it is passed to `f`, over `m` iterations?\n",
+        "\n",
+        "Return the values $a$<sub>1</sub>, $a$<sub>2</sub>, $a$<sub>3</sub>, and $a$<sub>4</sub>, using a `list`. Please round your answers to 8 decimal places."
       ],
       "id": "cognitive-toolbox"
     },
+    {
+      "cell_type": "markdown",
+      "metadata": {
+        "id": "xClzxxP1Fkyv"
+      },
+      "source": [
+        "### Example Input\n",
+        "In mathematics, whenever we have a function that takes in the output of another as a parameter, then we call that a *compound function*.\n",
+        "\n",
+        "In this activity, `f` is a compound function (note that you could also call it a *recursive function*, since it takes the output of itself as a parameter). \n",
+        "\n",
+        "Consider the function $f(x) = \\frac{x + n}{2x}$. Let's see how an initial value of `1.0` changes over `4` iterations:\n",
+        "```\n",
+        "Input:\n",
+        "f = lambda x: (x+n/x)/2  # our function\n",
+        "n = 2 \n",
+        "a0 = 1.0  # the initial value\n",
+        "m = 4  # the number of iterations\n",
+        "\n",
+        "Output\n",
+        "[1.5, 1.41666667, 1.41421569, 1.41421356]\n",
+        "\n",
+        "Explanation:\n",
+        "This output is the result of the following:\n",
+        "[\n",
+        "    round(output, 8) for output in (\n",
+        "        f(a0), \n",
+        "        f(f(a0)), \n",
+        "        f(f(f(a0))), \n",
+        "        f(f(f(f(a0))))\n",
+        "    )\n",
+        "]\n",
+        "``` "
+      ],
+      "id": "xClzxxP1Fkyv"
+    },
     {
       "cell_type": "code",
       "metadata": {
-        "id": "rubber-terry",
-        "outputId": "5b8b3558-ff3f-4d57-e9bf-b4f2cce63acc"
+        "id": "I3DzpHX2Kj6w"
       },
       "source": [
-        "f= lambda x: (x+n/x)/2\n",
-        "n = 2\n",
-        "a0 = 1.0\n",
-        "m = 4\n",
-        "# This implementation is not good as it is hard-coded\n",
-        "print([round(x, 8) for x in (f(a0), f(f(a0)), f(f(f(a0))), f(f(f(f(a0)))))])"
+        "f = lambda x: (x+n/x)/2  # our function\n",
+        "n = 2 \n",
+        "a0 = 1.0  # the initial value\n",
+        "m = 4  # the number of iterations"
       ],
-      "id": "rubber-terry",
-      "execution_count": null,
-      "outputs": [
-        {
-          "output_type": "stream",
-          "text": [
-            "[1.5, 1.41666667, 1.41421569, 1.41421356]\n"
-          ],
-          "name": "stdout"
-        }
-      ]
+      "id": "I3DzpHX2Kj6w",
+      "execution_count": 27,
+      "outputs": []
+    },
+    {
+      "cell_type": "markdown",
+      "metadata": {
+        "id": "WJVrZ1HUJqG1"
+      },
+      "source": [
+        "### Solution 1: Using a Generator\n",
+        "While you could simply implement the code in the \"Explanation\" section above, it wouldn't be very readable, and it would stop working the moment the value of `m` changes.\n",
+        "\n",
+        "Therefore, it is much more preferable to create a function to complete this activity. In a separate activity we can do something like this using a `generator` function in Python, via the `yield` keyword:"
+      ],
+      "id": "WJVrZ1HUJqG1"
     },
     {
       "cell_type": "code",
       "metadata": {
-        "id": "informational-cuisine",
-        "outputId": "6f95ea62-721a-487a-dcae-f52014b273ec"
+        "id": "informational-cuisine"
       },
       "source": [
-        "def repeat(f, a, m):\n",
+        "def compound_function(f, a, m):\n",
+        "    # compute the value of a after each iteration\n",
         "    for _ in range(m):\n",
+        "        # apply the function\n",
         "        a = f(a)  \n",
-        "        yield a\n",
-        "    \n",
-        "for i in repeat(f, 1, 4):\n",
-        "    print(round(i, 8))"
+        "        # output the result (don't forget to round!)\n",
+        "        yield round(a, 8)"
       ],
       "id": "informational-cuisine",
-      "execution_count": null,
+      "execution_count": 28,
+      "outputs": []
+    },
+    {
+      "cell_type": "markdown",
+      "metadata": {
+        "id": "MBBobFw7LfQN"
+      },
+      "source": [
+        "#### Test Out Solution 1\n",
+        "Recall we can use a `for` loop to iterate over the values returned by a `generator` object:"
+      ],
+      "id": "MBBobFw7LfQN"
+    },
+    {
+      "cell_type": "code",
+      "metadata": {
+        "colab": {
+          "base_uri": "https://localhost:8080/"
+        },
+        "id": "uOI3asirLtG8",
+        "outputId": "b311d371-d4b9-4797-ab95-ab2048e34b58"
+      },
+      "source": [
+        "for output in compound_function(f, a0, m):\n",
+        "    print(output)"
+      ],
+      "id": "uOI3asirLtG8",
+      "execution_count": 29,
       "outputs": [
         {
           "output_type": "stream",
@@ -2970,23 +3043,34 @@
         "id": "close-trinity"
       },
       "source": [
-        "### Note: the above compound iteration will converge to $\\sqrt{n}$ "
+        "### Special Note: Convergence\n",
+        "Did you notice anything special about $f(x)$ in Activity 30? *Hint:* try increasing the number of iterations `m`, and trying out different values of `n` - then see if you spot a familiar pattern!\n",
+        "\n",
+        "<hr>\n",
+        "\n",
+        "#### The Answer:\n",
+        "\n",
+        "As the number of iterations `m` increases, the outputs of the compound function $f(x)$ converges to $\\sqrt{n}$. \n",
+        "\n",
+        "We can even verify this by comparing it with the result of the `numpy.sqrt` function!\n"
       ],
       "id": "close-trinity"
     },
     {
       "cell_type": "code",
       "metadata": {
         "id": "freelance-skiing",
-        "outputId": "20727ae8-d2b0-46da-ee6a-323aa61279c8"
+        "colab": {
+          "base_uri": "https://localhost:8080/"
+        },
+        "outputId": "7a137816-a27f-496b-c772-a67ac7b782cd"
       },
       "source": [
-        "# Note: the above coumpound iteration will converge to np.sqrt(n) \n",
         "import numpy as np\n",
         "np.sqrt(n)"
       ],
       "id": "freelance-skiing",
-      "execution_count": null,
+      "execution_count": 32,
       "outputs": [
         {
           "output_type": "execute_result",
@@ -2998,7 +3082,7 @@
           "metadata": {
             "tags": []
           },
-          "execution_count": 203
+          "execution_count": 32
         }
       ]
     }