02-functions.ipynb

{
  "cells": [
    {
      "cell_type": "markdown",
      "metadata": {},
      "source": [
        "# \n",
        "\n",
        "# Functions in Julia\n",
        "\n",
        "Read more about this [here](http://mth229.github.io/functions.html).\n",
        "\n",
        "For some problems herein, you will need features made available in the\n",
        "add-on `MTH229` package, which is loaded with the following command:"
      ],
      "id": "3e725808-2730-4cef-9537-c8f1fd4cb3db"
    },
    {
      "cell_type": "code",
      "execution_count": 1,
      "metadata": {},
      "outputs": [],
      "source": [
        "using MTH229"
      ],
      "id": "2"
    },
    {
      "cell_type": "markdown",
      "metadata": {},
      "source": [
        "(When you run the cell to load the `MTH229` – and other add-on packages\n",
        "– an asterisk will appear in the label to the left of the cell: `[*]`.\n",
        "When the packages have been loaded, which can take awhile, the asterisk\n",
        "will turn into a number.)\n",
        "\n",
        "This command loads the `Plots` package, which we will use in these\n",
        "notes."
      ],
      "id": "384ea474-5817-480a-ad2a-af691a7408fe"
    },
    {
      "cell_type": "code",
      "execution_count": 1,
      "metadata": {},
      "outputs": [],
      "source": [
        "using Plots"
      ],
      "id": "4"
    },
    {
      "cell_type": "markdown",
      "metadata": {},
      "source": [
        "We will typically combine these and run this command when loading a\n",
        "`Julia` notebook at the *start* of a session:"
      ],
      "id": "1b983da8-c390-4d21-8c0a-a67f5f342e89"
    },
    {
      "cell_type": "code",
      "execution_count": 0,
      "metadata": {},
      "outputs": [],
      "source": [
        "using MTH229\n",
        "using Plots\n",
        "plotly()"
      ],
      "id": "6"
    },
    {
      "cell_type": "markdown",
      "metadata": {},
      "source": [
        "(The last command loads a plotting backend which allows some\n",
        "interactivity.)\n",
        "\n",
        "------------------------------------------------------------------------\n",
        "\n",
        "A *function* in mathematics is [defined](http://tinyurl.com/c2rwqyb) as\n",
        "“a relation between a set of inputs and a set of permissible outputs\n",
        "with the property that each input is related to exactly one output.”\n",
        "That is a general definition. Specialized to mathematical functions of\n",
        "one real variable returning a real value (univariate, scalar-valued\n",
        "functions), we can define a function in terms of a rule—what happens to\n",
        "$x$ to produce $y$, such as this one which squares $x$ then subtracts\n",
        "$2$:\n",
        "\n",
        "$$\n",
        "f(x) = x^2 - 2.\n",
        "$$\n",
        "\n",
        "The **domain** of a function is the set of all permissible values for\n",
        "$x$, in this example this is all $x$, but this need not be the case\n",
        "either due to the rule not being defined for some $x$ or a more explicit\n",
        "restriction, such as $x \\geq 0$.\n",
        "\n",
        "The **range** is the set of all possible outputs. Written in set\n",
        "notation, this is $\\{f(x): x \\in \\text{ the domain }\\}$.\n",
        "\n",
        "Mathematically, we evaluate or **call** a function with the notation\n",
        "$f(2)$ or $f(3)$, say.\n",
        "\n",
        "Mathematically we might refer to the function by its name, $f$, or its\n",
        "values such as $f(2)$ or $f(\\pi)$.\n",
        "\n",
        "In `Julia` basic mathematical functions are defined and used with the\n",
        "*exact* same notation, save for accommodations in translating math to\n",
        "`Julia`.\n",
        "\n",
        "For example, this command creates a function `f`:"
      ],
      "id": "233ebfce-b160-4d5f-80fd-6f950727a5f5"
    },
    {
      "cell_type": "code",
      "execution_count": 1,
      "metadata": {},
      "outputs": [
        {
          "output_type": "display_data",
          "metadata": {},
          "data": {
            "text/plain": [
              "f (generic function with 1 method)"
            ]
          }
        }
      ],
      "source": [
        "f(x) = x^2 - 2"
      ],
      "id": "10"
    },
    {
      "cell_type": "markdown",
      "metadata": {},
      "source": [
        "Unlike an expression, the value `x` in the definition of `f(x)` does not\n",
        "need to be defined until the function is actually called. As with math,\n",
        "this variable name need not be `x` – it could be `t`, `y`, `theta`, or\n",
        "any other valid name.\n",
        "\n",
        "We *call* `f` for the given value using the same `f(x)` notation. For\n",
        "example, finding our `f` at the value of `2` is done with:"
      ],
      "id": "a2c3ca32-2547-41f3-97c7-e8b06aab20e4"
    },
    {
      "cell_type": "code",
      "execution_count": 1,
      "metadata": {},
      "outputs": [
        {
          "output_type": "display_data",
          "metadata": {},
          "data": {
            "text/plain": [
              "2"
            ]
          }
        }
      ],
      "source": [
        "f(2)"
      ],
      "id": "12"
    },
    {
      "cell_type": "markdown",
      "metadata": {},
      "source": [
        "That is, as with typical mathematical notation, the function is “called”\n",
        "by passing a value to it with parentheses.\n",
        "\n",
        "Within a cell, we can evaluate one or more values by using commas to\n",
        "separate them:"
      ],
      "id": "23e7902a-cea2-498d-9001-201bade187ed"
    },
    {
      "cell_type": "code",
      "execution_count": 1,
      "metadata": {},
      "outputs": [
        {
          "output_type": "display_data",
          "metadata": {},
          "data": {
            "text/plain": [
              "(-1, 2, 7)"
            ]
          }
        }
      ],
      "source": [
        "f(1), f(2), f(3)"
      ],
      "id": "14"
    },
    {
      "cell_type": "markdown",
      "metadata": {},
      "source": [
        "The function name refers to the function object:"
      ],
      "id": "c7c2fd7e-cd3e-4174-9e95-6e1330d65f68"
    },
    {
      "cell_type": "code",
      "execution_count": 1,
      "metadata": {},
      "outputs": [
        {
          "output_type": "display_data",
          "metadata": {},
          "data": {
            "text/plain": [
              "f (generic function with 1 method)"
            ]
          }
        }
      ],
      "source": [
        "f"
      ],
      "id": "16"
    },
    {
      "cell_type": "markdown",
      "metadata": {},
      "source": [
        "Don’t worry about the words “generic” and “method”, but be aware that\n",
        "because of this once you have defined a name as a variable it can not be\n",
        "re-purposed as a *generic* function name and vice versa. (In the common\n",
        "first case, read the error message, it will say something like:\n",
        "`ERROR: cannot define function a; it already has a value`.)\n",
        "\n",
        "The “domain” of a `Julia` function is similar in meaning to its\n",
        "mathematical counterpart. `Julia` may respond with different values,\n",
        "such as `Inf`, for infinity; `NaN`, when an expression is indeterminate;\n",
        "or it may throw an error, typically a `DomainError`:"
      ],
      "id": "cf78852b-60bf-4590-a29a-77d2115e702f"
    },
    {
      "cell_type": "code",
      "execution_count": 1,
      "metadata": {},
      "outputs": [
        {
          "output_type": "display_data",
          "metadata": {},
          "data": {
            "text/plain": [
              "(Inf, NaN)"
            ]
          }
        }
      ],
      "source": [
        "f(x) = sqrt(x)/(x*(1-x))\n",
        "f(1), f(0)"
      ],
      "id": "18"
    },
    {
      "cell_type": "markdown",
      "metadata": {},
      "source": [
        "and an error with:"
      ],
      "id": "376a5f2b-9c4a-4b60-9179-e7afac5a9e2e"
    },
    {
      "cell_type": "code",
      "execution_count": 1,
      "metadata": {},
      "outputs": [],
      "source": [
        "f(-1)"
      ],
      "id": "20"
    },
    {
      "cell_type": "markdown",
      "metadata": {},
      "source": [
        "Functions can be more complicated than the “one-liners” illustrated. In\n",
        "that case, a multiline form is available:"
      ],
      "id": "fc065ffa-435a-4576-aa9c-7996106de663"
    },
    {
      "cell_type": "code",
      "execution_count": 0,
      "metadata": {},
      "outputs": [],
      "source": [
        "function fn_name(args...)\n",
        "  body\n",
        "end"
      ],
      "id": "22"
    },
    {
      "cell_type": "markdown",
      "metadata": {},
      "source": [
        "The keyword `function` indicates this is a function whose name is given\n",
        "in the definition. Within the body, the last expression evaluated is the\n",
        "output, unless a `return` statement is used.\n",
        "\n",
        "------------------------------------------------------------------------\n",
        "\n",
        "For basic uses of functions—90 percent of the uses in this class—the\n",
        "above covers what you need to know about functions.\n",
        "\n",
        "## Cases\n",
        "\n",
        "Some functions are defined in terms of cases. For example, a cell phone\n",
        "plan might depend on the data used through:\n",
        "\n",
        "> The amount is 35 dollars for the first 9 Gb of data, and 10 dollars\n",
        "> more for each *additional* Gb of data.\n",
        "\n",
        "This function has two cases to consider: one if the data is less than 9\n",
        "Gb and the other when it is more.\n",
        "\n",
        "In a math class we would write this as:\n",
        "\n",
        "$$\n",
        "\\text{cost}(\\text{data}) = \\begin{cases}\n",
        "35.0,                   & \\text{data} \\leq 9.0 \\\\\\\\\n",
        "35.0+10.0\\cdot(\\text{data}-9.0), & \\text{otherwise.}\n",
        "\\end{cases}\n",
        "$$\n",
        "\n",
        "How to write this in `Julia`?\n",
        "\n",
        "The ternary operator `predicate ? expression1 : expression2` has three\n",
        "pieces: a predicate question, such as `x < 10` and two expressions, the\n",
        "first is evaluated if the predicate is `true` and the second if the\n",
        "predicate is `false`. Using the ternary operator, simple case-like\n",
        "functions can be defined in one line.\n",
        "\n",
        "For example, the above can be defined in `Julia` with:"
      ],
      "id": "5ae9842e-e371-464e-8b2b-46005537eb2b"
    },
    {
      "cell_type": "code",
      "execution_count": 1,
      "metadata": {},
      "outputs": [
        {
          "output_type": "display_data",
          "metadata": {},
          "data": {
            "text/plain": [
              "cost (generic function with 1 method)"
            ]
          }
        }
      ],
      "source": [
        "cost(data) = data <= 9.0 ? 35.00 : 35.00 + 10.00 * (data - 9.0)"
      ],
      "id": "24"
    },
    {
      "cell_type": "markdown",
      "metadata": {},
      "source": [
        "So, three pieces: **First**, you ask a question. **Second**, what should\n",
        "the function do if the answer is ‘yes’? **Third**, what should the\n",
        "function do if the answer is ‘no’?\n",
        "\n",
        "## Composition\n",
        "\n",
        "Composition of functions is a useful means to break complicated problems\n",
        "into easier to solve ones. The math notation is typically $f(g(x))$ and\n",
        "in `Julia` this is no different.\n",
        "\n",
        "## Functions may need more than one argument\n",
        "\n",
        "In `Julia` some functions require more than one argument. There are two\n",
        "ways that a function can distinguish between arguments:\n",
        "\n",
        "**Using position**. A typical case is the function expressing the $\\log$\n",
        "of $x$ base $b$. The function must have both a position to pass in\n",
        "values for either $x$ or $b$. In `Julia` the function is written\n",
        "`log(b, x)`:"
      ],
      "id": "501d028b-34de-4529-980e-19ef1cd38965"
    },
    {
      "cell_type": "code",
      "execution_count": 1,
      "metadata": {},
      "outputs": [
        {
          "output_type": "display_data",
          "metadata": {},
          "data": {
            "text/plain": [
              "8.526512829121202e-14"
            ]
          }
        }
      ],
      "source": [
        "b, x = 5, 100\n",
        "a = log(b, x)\n",
        "b^a - x  # verify, is this close to 0?"
      ],
      "id": "26"
    },
    {
      "cell_type": "markdown",
      "metadata": {},
      "source": [
        "(This also shows that `Julia` can have the same name for **different**\n",
        "functions, as `log(x)` does the logarithm base $e$ and takes only $1$\n",
        "argument.)\n",
        "\n",
        "**Using keyword names**. Some arguments can be designated by a\n",
        "“keyword”, which have default values. This is heavily used with the\n",
        "plotting package we use, where data is specified by position and\n",
        "attributes of the resulting figure are adjusted with keyword arguments.\n",
        "Plotting features are provided in add-on packages; we use `Plots` in\n",
        "these projects.\n",
        "\n",
        "Here is a mathematical example from the theory of\n",
        "[wavelets](https://en.wikipedia.org/wiki/Wavelet).\n",
        "\n",
        "Define `mother` by"
      ],
      "id": "36880c33-066d-47a2-8c19-17cbfed14366"
    },
    {
      "cell_type": "code",
      "execution_count": 1,
      "metadata": {},
      "outputs": [
        {
          "output_type": "display_data",
          "metadata": {},
          "data": {
            "text/plain": [
              "mother (generic function with 1 method)"
            ]
          }
        }
      ],
      "source": [
        "mother(x) = (sin(2*pi*x) - sin(pi*x))/(pi*x)"
      ],
      "id": "28"
    },
    {
      "cell_type": "markdown",
      "metadata": {},
      "source": [
        "This function is *scaled* and *shifted* in application. To keep track of\n",
        "the scale (by `a`) and the shift (by `b`) we might define a function\n",
        "that allows these to be passed as *parameters*"
      ],
      "id": "25dd81b5-1a8c-4633-a46f-e57aeed05aaa"
    },
    {
      "cell_type": "code",
      "execution_count": 1,
      "metadata": {},
      "outputs": [
        {
          "output_type": "display_data",
          "metadata": {},
          "data": {
            "text/plain": [
              "child (generic function with 1 method)"
            ]
          }
        }
      ],
      "source": [
        "child(x, a, b) = mother((x-b)/a) / sqrt(a)"
      ],
      "id": "30"
    },
    {
      "cell_type": "markdown",
      "metadata": {},
      "source": [
        "This would then be called like:"
      ],
      "id": "045695ab-26a5-4faa-9e2f-e89c69d61c43"
    },
    {
      "cell_type": "code",
      "execution_count": 1,
      "metadata": {},
      "outputs": [
        {
          "output_type": "display_data",
          "metadata": {},
          "data": {
            "text/plain": [
              "-0.6366197723675813"
            ]
          }
        }
      ],
      "source": [
        "child(1/2, 1, 0)"
      ],
      "id": "32"
    },
    {
      "cell_type": "markdown",
      "metadata": {},
      "source": [
        "or like"
      ],
      "id": "45418c15-46e8-4a42-8f88-c00f89157e41"
    },
    {
      "cell_type": "code",
      "execution_count": 1,
      "metadata": {},
      "outputs": [
        {
          "output_type": "display_data",
          "metadata": {},
          "data": {
            "text/plain": [
              "0.2636965437895248"
            ]
          }
        }
      ],
      "source": [
        "child(1/2, 2, 1)"
      ],
      "id": "34"
    },
    {
      "cell_type": "markdown",
      "metadata": {},
      "source": [
        "(It isn’t illustrated, but there are means to make default values for\n",
        "the parameters.)\n",
        "\n",
        "## Functions can be used as arguments to other functions:\n",
        "\n",
        "Calculus has three main operations: The limit of a *function*, the\n",
        "derivative of a *function*, and the integral of a *function*. These\n",
        "operations take a function and compute some value. For limits this value\n",
        "is a number, for derivatives this value is another function. In `Julia`\n",
        "we will use functions to implement each.\n",
        "\n",
        "Using `Julia` operations on functions are just functions where the\n",
        "*arguments* are themselves functions and, *possibly*, the return value\n",
        "is also a function.\n",
        "\n",
        "The first example we will encounter is related to plotting. The details\n",
        "come later:"
      ],
      "id": "73edef67-c01d-427c-beec-c8c67983b1c5"
    },
    {
      "cell_type": "code",
      "execution_count": 1,
      "metadata": {},
      "outputs": [
        {
          "output_type": "display_data",
          "metadata": {},
          "data": {
            "text/html": [
              "<img src=\"data:image/png;base64,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\" />"
            ]
          }
        }
      ],
      "source": [
        "f(x) = sin(x^2)\n",
        "plot(f, 0, pi)"
      ],
      "id": "36"
    },
    {
      "cell_type": "markdown",
      "metadata": {},
      "source": [
        "The first argument to `plot` is a function object–not a function call,\n",
        "as in `f(x)`, the second and third describe an interval to plot over.\n",
        "This will be a typical pattern: `someaction(f, arguments...)`.\n",
        "\n",
        "When a function returns a function, we may simply assign it a name. For\n",
        "example, there is a `tangent` function in the `MTH229` package takes a\n",
        "function `f` and a point `c` and returns a function that computes the\n",
        "tangent line to `f` at `c`. Here we give it a name:"
      ],
      "id": "be231322-3df6-421a-b796-1b2b1320b944"
    },
    {
      "cell_type": "code",
      "execution_count": 1,
      "metadata": {},
      "outputs": [
        {
          "output_type": "display_data",
          "metadata": {},
          "data": {
            "text/plain": [
              "Function of `x` to compute the tangent line of `f` at `c`:\n",
              "    f(c) + f'(c) * (x-c)"
            ]
          }
        }
      ],
      "source": [
        "tl = tangent(f, pi/4)"
      ],
      "id": "38"
    },
    {
      "cell_type": "markdown",
      "metadata": {},
      "source": [
        "It is called, just like other functions:"
      ],
      "id": "6cfa08b4-3496-4b86-9d06-178910ec1a15"
    },
    {
      "cell_type": "code",
      "execution_count": 1,
      "metadata": {},
      "outputs": [
        {
          "output_type": "display_data",
          "metadata": {},
          "data": {
            "text/plain": [
              "(0.38460897507732444, 0.3772017669761397)"
            ]
          }
        }
      ],
      "source": [
        "f(pi/5), tl(pi/5)"
      ],
      "id": "40"
    },
    {
      "cell_type": "markdown",
      "metadata": {},
      "source": [
        "------------------------------------------------------------------------"
      ],
      "id": "b431ca47-7f0a-4194-9058-842c7afb949a"
    },
    {
      "cell_type": "code",
      "execution_count": 1,
      "metadata": {},
      "outputs": [],
      "source": [
        "# Enter your commands here\n"
      ],
      "id": "42"
    }
  ],
  "nbformat": 4,
  "nbformat_minor": 5,
  "metadata": {
    "kernel_info": {
      "name": "julia"
    },
    "kernelspec": {
      "name": "julia",
      "display_name": "Julia",
      "language": "julia"
    },
    "language_info": {
      "name": "julia",
      "codemirror_mode": "julia",
      "version": "1.10.0"
    }
  }
}