{ "cells": [ { "cell_type": "markdown", "metadata": {}, "source": [ "
\n", " \n", "
\n", "\n", "# Exploratory Computing with Python\n", "*Developed by Mark Bakker*" ] }, { "cell_type": "markdown", "metadata": {}, "source": [ "## Notebook 4: Functions\n", "In this Notebook we learn how to write our own functions, but we start out with a bit about Python packages." ] }, { "cell_type": "markdown", "metadata": {}, "source": [ "### A bit about packages\n", "A package is a set of Python functions. When we want to use a function from a package, we need to import it. There are many different ways to import packages. The most basic syntax is\n", "\n", "`import numpy`\n", "\n", "after which any function in `numpy` can be called as `numpy.function()`. If you don't like the name of the package, for example because it is long, you can change the name. The `numpy` package is renamed to `np` by typing\n", "\n", "`import numpy as np`\n", "\n", "after which all functions in `numpy` can be called as `np.function()`. \n", "\n", "Packages can also have subpackages. For example, the `numpy` package has a subpackage called `random`, which has a bunch of functions to deal with random variables. If the `numpy` package is imported with `import numpy as np`, functions in the `random` subpackage can be called as `np.random.function()`. \n", "\n", "If you only need one specific function, you don't have to import the entire package. For example, if you only want the cosine function of the numpy package, you may import it as `from numpy import cos`, after which you can simply call the cosine function as `cos()`. You can even rename functions when you import them. For example, after `from numpy import cos as newname`, you can call the function `newname()` to compute the cosine (I know, pretty silly, but this can become handy). \n", "\n", "In the previous Notebooks we always imported `numpy` and called it `np` and we imported the `matplotlib.pyplot` and called it `plt`. Both are standard names in the Python community. The statement we added before importing `matplotlib` is `%matplotlib inline`. This latter command is an IPython command and not a Python command. It will only work in IPython and is called a magic command. All magic commands are preceded with a `%`. The statement `%matplotlib inline` puts all figures in the Notebook rather than in a separate window. \n", "\n", "Enough about packages for now. Let's start the way we always start." ] }, { "cell_type": "code", "execution_count": 1, "metadata": {}, "outputs": [], "source": [ "%matplotlib inline\n", "import numpy as np\n", "import matplotlib.pyplot as plt" ] }, { "cell_type": "markdown", "metadata": {}, "source": [ "### Functions\n", "Functions are an essential part of a programming language.\n", "You already used many functions like `plot`, `loadtxt`, and `linspace`.\n", "But you can also define your own functions.\n", "To define a new function, use the `def` command. After `def` follows the name of the function and then between parentheses the arguments of the function and finally a colon. After the colon you indent until you are done with the function. The last line of the function should be `return` followed by what you want to return. For example, consider the following function of $x$:\n", "\n", "$f(x)= \\cos(x) \\qquad x <0$\n", "\n", "$f(x) = \\exp(-x) \\qquad x \\ge 0$\n", "\n", "Let's implement $f(x)$ in a function called `func`. There is one input argument: $x$. " ] }, { "cell_type": "code", "execution_count": 2, "metadata": {}, "outputs": [ { "name": "stdout", "output_type": "stream", "text": [ "0.049787068367863944\n" ] } ], "source": [ "def func(x):\n", " if x < 0:\n", " f = np.cos(x)\n", " else:\n", " f = np.exp(-x)\n", " return f\n", "\n", "print(func(3))" ] }, { "cell_type": "markdown", "metadata": {}, "source": [ "Once you define a function in Python, you can call it whenever you want during the session. So we can call it again" ] }, { "cell_type": "code", "execution_count": 3, "metadata": {}, "outputs": [ { "name": "stdout", "output_type": "stream", "text": [ "-0.4161468365471424\n" ] } ], "source": [ "print(func(-2))" ] }, { "cell_type": "markdown", "metadata": {}, "source": [ "If you type\n", "\n", "`func(` and then hit [shift-tab]\n", "\n", "and wait a split second, the input arguments of the function pop-up in a little window, just like for other functions we already used. You can also provide additional documentation of your function. Put the documentation at the top of the indented block and put it between triple double quotes (`\"\"\"`). Run the code below to define the function `func` with the additional documentation, then in the code cell below type \n", "\n", "`func(` \n", "\n", "and hit [shift][tab] to see the additional documentation. Warning: don't leave a code cell with just `func(` or `func()` as you will get an error on [Kernel][Restart & Run All Cells]." ] }, { "cell_type": "code", "execution_count": 4, "metadata": {}, "outputs": [], "source": [ "def func(x):\n", " \"\"\"First Python function\n", " written by Student X\"\"\"\n", " if x < 0:\n", " f = np.cos(x)\n", " else:\n", " f = np.exp(-x)\n", " return f" ] }, { "cell_type": "code", "execution_count": null, "metadata": {}, "outputs": [], "source": [] }, { "cell_type": "markdown", "metadata": {}, "source": [ "The names of the arguments of a function are the names used inside the function. They have no relationship to the names used outside the function. When using a variable as the argument of a function, only the *value* gets passed to the function. In the example below, the *value* of `y` is passed as the first argument of the function `func`. Inside the function, this value is used for the variable `x`." ] }, { "cell_type": "code", "execution_count": 5, "metadata": {}, "outputs": [ { "name": "stdout", "output_type": "stream", "text": [ "func(2): 0.1353352832366127\n" ] } ], "source": [ "y = 2\n", "print('func(2):', func(y))" ] }, { "cell_type": "markdown", "metadata": {}, "source": [ "### Exercise 1. First function\n", "Write a Python function for the following function:\n", "\n", "$f(x)=e^{-\\alpha x}\\cos(x)$\n", "\n", "The function should take `x` and `alpha` as input arguments and return the function value. Give your function a unique name (if you also call it `func` it will overwrite the `func` function that we defined above). Make a plot of $f(x)$ vs. $x$ for $x$ going from 0 to $10\\pi$ using two different values of $\\alpha$: 0.1 and 0.2. Add a legend and label the axes." ] }, { "cell_type": "code", "execution_count": null, "metadata": {}, "outputs": [], "source": [] }, { "cell_type": "markdown", "metadata": {}, "source": [ "Answer to Exercise 1" ] }, { "cell_type": "markdown", "metadata": {}, "source": [ "### Keyword arguments\n", "Functions may have multiple input arguments followed by keyword arguments. Arguments *must* be entered and must be entered in the order defined. Keyword arguments don't need to be entered. When they are not entered, the default value is used. Keyword arguments may be given in any order as long as they come after the regular arguments. If you specify the keyword arguments in the order they are defined in the argument list, you don't even need to preceed them with the keyword, but it is saver to write the keywords out and it makes your code easier to read. For example, the function $f(x)=A\\cos(\\pi x+\\theta)$ can be written with keyword arguments for $A$ and $\\theta$ as follows." ] }, { "cell_type": "code", "execution_count": 6, "metadata": {}, "outputs": [ { "name": "stdout", "output_type": "stream", "text": [ "-1.0\n", "-2.0\n", "-1.4142135623730954\n", "-1.4142135623730954\n", "-0.7071067811865477\n" ] } ], "source": [ "def testfunc(x, A=1, theta=0):\n", " return A * np.cos(np.pi * x + theta)\n", "\n", "print(testfunc(1)) # Uses default A=1, theta=0: cos(pi)\n", "print(testfunc(1, A=2)) # Now A=2, and theta is still 0: 2*cos(pi)\n", "print(testfunc(1, A=2, theta=np.pi / 4)) # Now A=2, theta=pi/4: 2*cos(5pi/4)\n", "print(testfunc(1, theta=np.pi / 4, A=2)) # Same as above: 2*cos(5pi/4)\n", "print(testfunc(1, theta=np.pi / 4)) # Now theta=pi/4, and A is still 1: cos(5pi/4)" ] }, { "cell_type": "markdown", "metadata": {}, "source": [ "Note that the proper style was applied, as defined in Notebook 1: there are spaces around mathematical symbols, but not around the equal sign of the keyword argument. " ] }, { "cell_type": "markdown", "metadata": {}, "source": [ "### Local variables\n", "Variables declared inside a function can only be used inside that function. The outside of a function doesn't know about the variables used inside the function, except for the variables that are returned by the function. In the code below, remove the `#` before `print(a)` and you will get an error message, as `a` is a local variable inside the function `localtest` (then put the `#` back, else you get an error when running [Kernel][Restart & Run All Cells])." ] }, { "cell_type": "code", "execution_count": 7, "metadata": {}, "outputs": [ { "name": "stdout", "output_type": "stream", "text": [ "17\n" ] } ], "source": [ "def localtest(x):\n", " a = 3\n", " b = 5\n", " return a * x + b\n", "print(localtest(4))\n", "#print(a) # Will cause an error, as 'a' is not known outside function " ] }, { "cell_type": "markdown", "metadata": {}, "source": [ "### Three types of variables inside a function\n", "There are actually three types of variables inside a function. We already learned about two of them: variables passed to the function through the argument list, like `x` in the function above, and local variables, like `a` and `b` in the function above. The third type are variables defined outside the function but not passed to the function through the argument list. When a variable is used inside a Python function, Python first checks whether the variable has been defined locally. If not, it checks whether the variable is passed to the function through the argument list. And if that is not the case, Python checks whether the variable is defined outside the function, from the place the function was called. If that is not the case either, it will throw an error message. It is considered good coding practice to pass variables to a function when they are needed inside a function, rather than counting on Python to *find* the variable outside the function; it will likely lead to fewer coding errors as well.\n", "\n", "Note that when a variable is defined locally, Python will not check whether that variable is also declared outside the function. It will happily create a new variable with the same name inside the function. It is important to realize the difference between these different types, so let's do a few examples." ] }, { "cell_type": "code", "execution_count": 8, "metadata": {}, "outputs": [ { "name": "stdout", "output_type": "stream", "text": [ "17\n", "17\n" ] } ], "source": [ "# This function works properly\n", "def test1(x):\n", " a = 3\n", " b = 5\n", " return a * x + b\n", "\n", "print(test1(4))\n", "\n", "# This function also works, but it is sloppy coding\n", "# since variable a is defined outside the function\n", "a = 3\n", "\n", "def test2(x):\n", " b = 5\n", " return a * x + b\n", "\n", "print(test2(4)) " ] }, { "cell_type": "markdown", "metadata": {}, "source": [ "In the following function, we define variable `var1` outside the function `test3`. The function `test3` doesn't take any input arguments (but it still needs the parentheses, else Python doesn't know it is a function!), and it creates a local variable `var1`. This local `var1` variable is only known inside the function `test3` and doesn't effect the value of `var1` outside function `test3`." ] }, { "cell_type": "code", "execution_count": 9, "metadata": {}, "outputs": [ { "name": "stdout", "output_type": "stream", "text": [ "Inside the function test3, var1 equals: 4\n", "Value of var1 outside test3: 8\n" ] } ], "source": [ "var1 = 8\n", "\n", "def test3():\n", " var1 = 4\n", " print('Inside the function test3, var1 equals:', var1)\n", " \n", "test3()\n", "print('Value of var1 outside test3:', var1)" ] }, { "cell_type": "markdown", "metadata": {}, "source": [ "### Functions are building blocks that need to be tested separately\n", "Functions are the building blocks of a computer code. They represent a well-defined functionality, which means they can *and should* be tested separately. So make it a habit to test whether your function does what you intended it to do. Sometimes it is easy to test a function: you can compare the value to a hand-calculation, for example. Other times it is more difficult, and you need to write some additional code to test the function. It is always worthwhile to do that. If you test your functions well, it will aid you in debugging your code, because you know that the error is not inside the function." ] }, { "cell_type": "markdown", "metadata": {}, "source": [ "### Exercise 2, Stream function for flow around a cylinder\n", "Consider two-dimensional inviscid fluid flow (potential flow) around a cylinder.\n", "The origin of the coordinate system is at the center of the cylinder.\n", "The stream function is a function that is constant along stream lines. \n", "The stream function $\\psi$ is a function of polar coordinates $r$ and $\\theta$. The stream function is constant and equal to zero on the cylinder and doesn't really exist inside the cylinder, so let's make it zero there, like it is on the cylinder.\n", "\n", "$$\\begin{split}\n", "\\psi &= 0 \\qquad r\\le R \\\\\n", "\\psi &= U(r-R^2/r)\\sin(\\theta) \\qquad r\\ge R\n", "\\end{split}$$\n", "\n", "where $U$ is the flow in the $x$-direction, $r$ is the radial distance from the center of the cylinder, $\\theta$ is the angle, and $R$ is the radius of the cylinder. You may recall it is not always easy to compute the correct angle when given a value of $x$ and $y$, as the regular arctan function returns a value between $-\\pi/2$ and $+\\pi/2$ (radians), while if $x=-2$ and $y=2$, the angle should be $3\\pi/4$.\n", "`numpy` has a very cool function to compute the correct angle between $-\\pi$ and $+\\pi$ given the $x$ and $y$ coordinates. The function is `arctan2(y, x)`. Note that the function takes as its *first* argument `y` and as its *second* argument `x`. \n", "\n", "Write a function that computes the stream function for flow around a cylinder. The function should take two arguments, `x` and `y`, and two keyword arguments, `U` and `R`, and should return the stream function value. If you write the function correctly, it should give `psi(2, 4, U=2, R=1.5) = 7.1`, and `psi(0.5, 0, U=2, R=1.5) = 0` (inside the cylinder)." ] }, { "cell_type": "code", "execution_count": null, "metadata": {}, "outputs": [], "source": [] }, { "cell_type": "markdown", "metadata": {}, "source": [ "Answer to Exercise 2" ] }, { "cell_type": "markdown", "metadata": {}, "source": [ "### Vectorization of a function\n", "Not all functions can be called with an array of values as input argument. For example, the function `func` defined at the beginning of this notebook doesn't work with an array of `x` values. Remove the `#` and try it out. Then put the `#` back" ] }, { "cell_type": "code", "execution_count": 10, "metadata": {}, "outputs": [], "source": [ "def func(x):\n", " if x < 0:\n", " f = np.cos(x)\n", " else:\n", " f = np.exp(-x)\n", " return f\n", "\n", "x = np.linspace(-6, 6, 100)\n", "#y = func(x) # Run this line after removing the # to see the error that occurs. Then put the # back" ] }, { "cell_type": "markdown", "metadata": {}, "source": [ "The reason this doesn't work is that Python doesn't know what to do with the line \n", "\n", "`if x < 0` \n", "\n", "when `x` contains many values. Hence the error message \n", "\n", "`The truth value of an array with more than one element is ambiguous` \n", "\n", "For some values of `x` the `if` statement may be `True`, for others it may be `False`. A simple way around this problem is to vectorize the function. That means we create a new function, let's call it `funcvec`, that is a vectorized form of `func` and can be called with an array as an argument. This is by far the easiest but not necessarily the computationally fastest way to make sure a function can be called with an array as an argument, and, unfortunately, it won't work for all situations. " ] }, { "cell_type": "code", "execution_count": 11, "metadata": {}, "outputs": [ { "data": { "image/png": "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\n", "text/plain": [ "
" ] }, "metadata": { "needs_background": "light" }, "output_type": "display_data" } ], "source": [ "funcvec = np.vectorize(func)\n", "x = np.linspace(-6, 6, 100)\n", "y = funcvec(x)\n", "plt.plot(x, y);" ] }, { "cell_type": "markdown", "metadata": {}, "source": [ "Back now to the problem of flow around a clinder. Contours of the stream function represent stream lines around the cylinder. To make a contour plot, the function to be contoured needs to be evaluated on a grid of points. The grid of points and an array with the values of the stream function at these points can be passed to a contouring routine to create a contour plot. To create a grid of points, use the function `meshgrid` which takes as input an array of `x` values and an array of `y` values, and returns a grid of `x` values and a grid of `y` values. For example, to have 5 points in the $x$-direction from -1 to +1, and 3 points in y-direction from 0 to 10:" ] }, { "cell_type": "code", "execution_count": 12, "metadata": {}, "outputs": [ { "name": "stdout", "output_type": "stream", "text": [ "x values\n", "[[-1. -0.5 0. 0.5 1. ]\n", " [-1. -0.5 0. 0.5 1. ]\n", " [-1. -0.5 0. 0.5 1. ]]\n", "y values\n", "[[ 0. 0. 0. 0. 0.]\n", " [ 5. 5. 5. 5. 5.]\n", " [10. 10. 10. 10. 10.]]\n" ] } ], "source": [ "x,y = np.meshgrid(np.linspace(-1, 1, 5), np.linspace(0, 10, 3)) \n", "print('x values')\n", "print(x)\n", "print('y values')\n", "print(y)" ] }, { "cell_type": "markdown", "metadata": {}, "source": [ "### Exercise 3, Contour plot for flow around a cylinder\n", "Evaluate the function for the stream function around a cylinder with radius 1.5 on a grid of 100 by 100 points, where `x` varies from -4 to +4, and `y` varies from -3 to 3; use $U=1$. Evaluate the stream function on the entire grid (you need to create a vectorized version of the function you wrote to compute the stream function). Then use the `np.contour` function to create a contour plot (find out how by reading the help of the `contour` function or go to [this demo](http://matplotlib.org/examples/pylab_examples/contour_demo.html)) of the `matplotlib` gallery). You need to use the command `plt.axis('equal')`, so that the scales along the axes are equal and the circle looks like a circle rather than an ellipse. Finally, you may want to add a nice circular patch using the `fill` command and specifying a bunch of $x$ and $y$ values around the circumference of the cylinder." ] }, { "cell_type": "code", "execution_count": null, "metadata": {}, "outputs": [], "source": [] }, { "cell_type": "markdown", "metadata": {}, "source": [ "Answer to Exercise 3" ] }, { "cell_type": "markdown", "metadata": {}, "source": [ "### Return multiple *things*\n", "An assignment can assign values to multiple variables in one statement, for example" ] }, { "cell_type": "code", "execution_count": 13, "metadata": {}, "outputs": [ { "name": "stdout", "output_type": "stream", "text": [ "a: 4\n", "b: 3\n", "a: 27\n", "b: [0 1 2 3]\n", "c: hello\n", "d: 0\n", "e: 5\n", "f: 10\n" ] } ], "source": [ "a, b = 4, 3\n", "print('a:', a)\n", "print('b:', b)\n", "\n", "a, b, c = 27, np.arange(4), 'hello'\n", "print('a:', a)\n", "print('b:', b)\n", "print('c:', c)\n", "\n", "d, e, f = np.arange(0, 11, 5)\n", "print('d:', d)\n", "print('e:', e)\n", "print('f:', f)" ] }, { "cell_type": "markdown", "metadata": {}, "source": [ "Similarly, a function may return one value or one array. Or a function may return multiple values, multiple arrays, or whatever the programmer decides to return (including nothing, of course). When multiple *things* are returned, they are returned as a tuple. They can be stored as a tuple, or, if the user knows how many *things* are returned, they can be stored in individual variables right away, as in the example below." ] }, { "cell_type": "code", "execution_count": 14, "metadata": {}, "outputs": [ { "name": "stdout", "output_type": "stream", "text": [ "\n", "[100. 4. 4. 4. 4.]\n", "a: 33\n", "b: [100. 4. 4. 4. 4.]\n", "c: this works great!\n" ] } ], "source": [ "def newfunc():\n", " dump = 4 * np.ones(5)\n", " dump[0] = 100\n", " return 33, dump, 'this works great!'\n", "\n", "test = newfunc()\n", "print(type(test))\n", "print(test[1]) \n", "\n", "a, b, c = newfunc()\n", "print('a:', a)\n", "print('b:', b)\n", "print('c:', c)" ] }, { "cell_type": "markdown", "metadata": {}, "source": [ "### Exercise 4, Streamplot of flow around a cylinder\n", "The radial and tangential components of the velocity vector $\\vec{v}=(v_r,v_\\theta)$ for inviscid fluid flow around a cylinder are given by\n", "\n", "$\\begin{split}\n", "v_r&=U(1-R^2/r^2)\\cos(\\theta) \\qquad r\\ge R \\\\\n", "v_\\theta&=-U(1+R^2/r^2)\\sin(\\theta) \\qquad r\\ge R\n", "\\end{split}$\n", "\n", "and is zero otherwise. The $x$ and $y$ components of the velocity vector may be obtained from the radial and tangential components as\n", "\n", "$\\begin{split}\n", "v_x&=v_r\\cos(\\theta) - v_\\theta\\sin(\\theta) \\\\\n", "v_y &= v_r\\sin(\\theta) + v_\\theta\\cos(\\theta) \n", "\\end{split}$\n", "\n", "Write a function that returns the $x$ and $y$ components of the velocity vector for fluid flow around a cylinder with $R=1.5$ and $U=2$. \n", "Test your function by making sure that at $(x,y) = (2,3)$ the velocity vector is $(v_x,v_y)=(2.1331, -0.3195)$.\n", "Compute the $x$ and $y$ components of the velocity vector (vectorization won't help here, as your function returns two values, so you need a double loop) on a grid of 50 by 50 points where `x` varies from -4 to +4, and `y` varies from -3 to 3. Create a stream plot using the cool function `plt.streamplot`, which takes four arguments: `x`, `y`, `vx`, `vy`." ] }, { "cell_type": "code", "execution_count": null, "metadata": {}, "outputs": [], "source": [] }, { "cell_type": "markdown", "metadata": {}, "source": [ "Answer to Exercise 4" ] }, { "cell_type": "markdown", "metadata": {}, "source": [ "### Exercise 5, Derivative of a function\n", "The function `func`, which we wrote earlier in this notebook, implements the following function\n", "\n", "$f(x)= \\cos(x) \\qquad x <0$\n", "\n", "$f(x) = \\exp(-x) \\qquad x \\ge 0$\n", "\n", "Derive an analytic expression (by hand) for the first derivative of $f(x)$ and implement it in a Python function. Test your function by comparing its output to a numerical derivative using a central difference scheme \n", "\n", "$\\frac{\\text{d}f}{\\text{d}x}\\approx \\frac{f(x+d)-f(x-d)}{2d}$\n", "\n", "where $d$ is a small number. Test your function for both $x<0$ and $x>0$." ] }, { "cell_type": "code", "execution_count": null, "metadata": {}, "outputs": [], "source": [] }, { "cell_type": "markdown", "metadata": {}, "source": [ "Answer to Exercise 5" ] }, { "cell_type": "markdown", "metadata": {}, "source": [ "### Using a function as the argument of another function\n", "So far, we have used single values or arrays as input arguments of functions. But we can also use a function as one of the input arguments of another function. Consider, for example, a function called `takesquare` that takes two input arguments: a function `finput` and a value `x`, and it returns the function `finput` evaluated at `x` and then squared." ] }, { "cell_type": "code", "execution_count": 15, "metadata": {}, "outputs": [], "source": [ "def takesquare(finput, x):\n", " return finput(x) ** 2" ] }, { "cell_type": "markdown", "metadata": {}, "source": [ "We can now call `takesquare` with any function $f$ that can be called as $f(x)$ and returns one value. For example, we can call it with the cosine function, and we can test right away whether we got the right answer" ] }, { "cell_type": "code", "execution_count": 16, "metadata": {}, "outputs": [ { "name": "stdout", "output_type": "stream", "text": [ "takesquare result: 0.17317818956819406\n", "correct value is: 0.17317818956819406\n" ] } ], "source": [ "print('takesquare result:', takesquare(np.cos, 2))\n", "print('correct value is: ', np.cos(2) ** 2)" ] }, { "cell_type": "markdown", "metadata": {}, "source": [ "### Exercise 6. Numerical integration" ] }, { "cell_type": "markdown", "metadata": {}, "source": [ "Numerical integration of a function is a common engineering task. \n", "The `scipy` package has a specific subpackage called `integrate` with a number of numerical integration functions. We will use the `quad` function. Use the `quad` function to integrate the function $f(x)=\\text{e}^{-x}$ from 1 till 5 (note that `quad` returns two values; read the doc string to find out what they are). Check that you did it right by doing the integration by hand (which is easy for this function). \n", "\n", "Next, compute the following integral:\n", "\n", "$$\\int_1^5 \\frac{\\text{e}^{-x}}{x}\\text{d}x$$ \n", "\n", "This integral is more difficult to do analytically. Perform the integration numerically with the `quad` function and check your answer, for example, at the [wolframalpha website](https://www.wolframalpha.com) where you can simply type: `integrate exp(-x)/x from 1 to 5`." ] }, { "cell_type": "code", "execution_count": null, "metadata": {}, "outputs": [], "source": [] }, { "cell_type": "markdown", "metadata": {}, "source": [ "Answer to Exercise 6" ] }, { "cell_type": "markdown", "metadata": {}, "source": [ "### Interactive functions using `ipywidgets`\n", "The package `ipywidgets` constains widgets for use in Jupyter Notebooks. We will start here by using the simplest form, which is the `interact` function. The `interact` function can be used to, you guessed it, interact with a function. The `interact` function is a bit slow when interacting with a graph, but other than that it works nicely. \n", "\n", "For example, let's write a function that plots a line with length $L$ that makes an angle $\\alpha$ with the horizontal. The angle $\\alpha$ is an input argument." ] }, { "cell_type": "code", "execution_count": 17, "metadata": {}, "outputs": [ { "data": { "image/png": "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\n", "text/plain": [ "
" ] }, "metadata": { "needs_background": "light" }, "output_type": "display_data" } ], "source": [ "def plot_line(alpha):\n", " L = 20\n", " x = L / 2 * np.cos(np.deg2rad(alpha))\n", " y = L / 2 * np.sin(np.deg2rad(alpha))\n", " plt.plot([-x, x], [-y, y])\n", " plt.axis('scaled')\n", " plt.xlim(-20, 20)\n", " plt.ylim(-20, 20)\n", " \n", "plot_line(45)" ] }, { "cell_type": "markdown", "metadata": {}, "source": [ "The `interact` function of `ipywidgets` can now be used to interact with the `plot_line` function we just defined. The `interact` function takes as input arguments the name of the function to interact with, and then the minimum value, maximum value, and step of the input arguments. When you execute the code below, a slider will appear and you can move the slider to change the value of the angle $\\alpha$ (and again, it is a bit slow, so don't move it around too quickly). " ] }, { "cell_type": "code", "execution_count": 18, "metadata": {}, "outputs": [ { "data": { "application/vnd.jupyter.widget-view+json": { "model_id": "f8904008968d4fafbda32d791b99e4f3", "version_major": 2, "version_minor": 0 }, "text/plain": [ "interactive(children=(IntSlider(value=0, description='alpha', max=180, min=-180, step=5), Output()), _dom_clas…" ] }, "metadata": {}, "output_type": "display_data" } ], "source": [ "from ipywidgets import interact\n", "interact(plot_line, alpha=(-180, 180, 5)); " ] }, { "cell_type": "markdown", "metadata": {}, "source": [ "The `plot_line` function can be modified to also take the color of the line as an input argument. " ] }, { "cell_type": "code", "execution_count": 19, "metadata": {}, "outputs": [ { "data": { "image/png": "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\n", "text/plain": [ "
" ] }, "metadata": { "needs_background": "light" }, "output_type": "display_data" } ], "source": [ "def plot_line(alpha, color='g'):\n", " L = 20\n", " x = L / 2 * np.cos(np.deg2rad(alpha))\n", " y = L / 2 * np.sin(np.deg2rad(alpha))\n", " plt.plot([-x, x], [-y, y], color)\n", " plt.axis('scaled')\n", " plt.xlim(-20, 20)\n", " plt.ylim(-20, 20)\n", " \n", "plot_line(45)" ] }, { "cell_type": "markdown", "metadata": {}, "source": [ "The `interact` function can be used to both change the value of $\\alpha$ and the color of the line. Provide all the possible colors as a list, which will appear as a dropdown box when executing the code. " ] }, { "cell_type": "code", "execution_count": 20, "metadata": {}, "outputs": [ { "data": { "application/vnd.jupyter.widget-view+json": { "model_id": "835ef54816184d2681876f20f1bd0a0d", "version_major": 2, "version_minor": 0 }, "text/plain": [ "interactive(children=(IntSlider(value=0, description='alpha', max=180, min=-180, step=5), Dropdown(description…" ] }, "metadata": {}, "output_type": "display_data" } ], "source": [ "from ipywidgets import interact\n", "interact(plot_line, alpha=(-180, 180, 5), color=['orange', 'brown', 'fuchsia']); " ] }, { "cell_type": "markdown", "metadata": {}, "source": [ "### Exercise 7. First wiget" ] }, { "cell_type": "markdown", "metadata": {}, "source": [ "Write a function that plots $a\\cos(x)$ and $b\\sin(x)$ on the same graph for $x$ going from $0$ to $4\\pi$. Set the limits of the vertical axis from -5 to +5. Input arguments of the function are the amplitudes $a$ and $b$, the color of the cosine function, and the color of the sine function (so 4 input arguments in total). Use the interact function to allow $a$ and $b$ to vary from 0 to 5, the color of the cosine function to be orange, pink or red, and the colors of the sine function to be blue, grey or black. " ] }, { "cell_type": "code", "execution_count": null, "metadata": {}, "outputs": [], "source": [] }, { "cell_type": "markdown", "metadata": {}, "source": [ "Answer to Exercise 7" ] }, { "cell_type": "markdown", "metadata": {}, "source": [ "### Answers to the exercises" ] }, { "cell_type": "markdown", "metadata": {}, "source": [ "Answer to Exercise 1" ] }, { "cell_type": "code", "execution_count": 21, "metadata": {}, "outputs": [ { "data": { "image/png": "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\n", "text/plain": [ "
" ] }, "metadata": { "needs_background": "light" }, "output_type": "display_data" } ], "source": [ "def test(x, alpha):\n", " return np.exp(-alpha * x) * np.cos(x)\n", "\n", "x = np.linspace(0, 10 * np.pi, 100)\n", "y1 = test(x, 0.1) # This function can be called with an array\n", "y2 = test(x, 0.2)\n", "plt.plot(x, y1, label=r'$\\alpha$=0.1')\n", "plt.plot(x, y2, label=r'$\\alpha$=0.2')\n", "plt.xlabel('x')\n", "plt.ylabel('f(x)')\n", "plt.legend();" ] }, { "cell_type": "markdown", "metadata": {}, "source": [ " Back to Exercise 1\n", "\n", "Answer to Exercise 2" ] }, { "cell_type": "code", "execution_count": 22, "metadata": {}, "outputs": [ { "name": "stdout", "output_type": "stream", "text": [ "7.1000000000000005\n", "0.0\n" ] } ], "source": [ "def psi(x, y, U=1, R=1):\n", " r = np.sqrt(x ** 2 + y ** 2)\n", " if r < R:\n", " rv = 0.0\n", " else:\n", " theta = np.arctan2(y, x)\n", " rv = U * (r - R ** 2 / r) * np.sin(theta)\n", " return rv\n", "\n", "print(psi(2, 4, U=2, R=1.5))\n", "print(psi(0.5, 0, U=2, R=1.5))" ] }, { "cell_type": "markdown", "metadata": {}, "source": [ "Back to Exercise 2\n", "\n", "Answer to Exercise 3" ] }, { "cell_type": "code", "execution_count": 23, "metadata": {}, "outputs": [ { "data": { "text/plain": [ "(-4.0, 4.0, -3.0, 3.0)" ] }, "execution_count": 23, "metadata": {}, "output_type": "execute_result" }, { "data": { "image/png": "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\n", "text/plain": [ "
" ] }, "metadata": { "needs_background": "light" }, "output_type": "display_data" } ], "source": [ "x,y = np.meshgrid(np.linspace(-4, 4, 100), np.linspace(-3, 3, 100))\n", "psivec = np.vectorize(psi)\n", "R = 1.5\n", "p = psivec(x, y, U=2, R=R)\n", "plt.contour(x, y, p, 50)\n", "alpha = np.linspace(0, 2 * np.pi, 100)\n", "plt.fill(R * np.cos(alpha), R * np.sin(alpha), ec='g', fc='g')\n", "plt.axis('scaled')" ] }, { "cell_type": "markdown", "metadata": {}, "source": [ " Back to Exercise 3\n", "\n", "Answer to Exercise 4" ] }, { "cell_type": "code", "execution_count": 24, "metadata": {}, "outputs": [ { "name": "stdout", "output_type": "stream", "text": [ "velocity at (2,3): (2.133136094674556, -0.319526627218935)\n" ] }, { "data": { "image/png": "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\n", "text/plain": [ "
" ] }, "metadata": { "needs_background": "light" }, "output_type": "display_data" } ], "source": [ "def velocity(x, y, U=1, R=1):\n", " r = np.sqrt(x**2 + y**2)\n", " theta = np.arctan2(y, x)\n", " if r > R:\n", " vr = U * (1 - R**2 / r**2) * np.cos(theta)\n", " vt = -U * (1 + R**2 / r**2) * np.sin(theta)\n", " vx = vr * np.cos(theta) - vt * np.sin(theta)\n", " vy = vr * np.sin(theta) + vt * np.cos(theta)\n", " else:\n", " vx,vy = 0.0,0.0\n", " return vx,vy\n", "\n", "print('velocity at (2,3): ', velocity(2, 3, U=2, R=1.5))\n", "\n", "x,y = np.meshgrid(np.linspace(-4, 4, 50), np.linspace(-3, 3, 50))\n", "vx, vy = np.zeros((50, 50)), np.zeros((50, 50))\n", "R = 1.5\n", "for i in range(50):\n", " for j in range(50):\n", " vx[i,j], vy[i,j] = velocity(x[i,j], y[i,j], U=2, R=R)\n", "alpha = np.linspace(0, 2 * np.pi, 100)\n", "plt.fill(R * np.cos(alpha), R * np.sin(alpha), ec='g', fc='g')\n", "plt.streamplot(x, y, vx, vy)\n", "plt.axis('scaled')\n", "plt.xlim(-4, 4)\n", "plt.ylim(-3, 3);" ] }, { "cell_type": "markdown", "metadata": {}, "source": [ " Back to Exercise 4\n", "\n", "Answer to Exercise 5" ] }, { "cell_type": "code", "execution_count": 25, "metadata": {}, "outputs": [ { "name": "stdout", "output_type": "stream", "text": [ "True value 0.8414709848078965\n", "Approx value 0.8414709847803792\n", "True value -0.36787944117144233\n", "Approx value -0.3678794411599018\n" ] } ], "source": [ "def dfuncdx(x):\n", " if x < 0:\n", " rv = -np.sin(x)\n", " else:\n", " rv = -np.exp(-x)\n", " return rv\n", "\n", "d = 1e-6\n", "x = -1\n", "dfdx = (func(x+d) - func(x-d)) / (2*d)\n", "print('True value ', dfuncdx(x))\n", "print('Approx value ', dfdx)\n", "\n", "x = 1\n", "dfdx = (func(x+d) - func(x-d)) / (2*d)\n", "print('True value ', dfuncdx(x))\n", "print('Approx value ', dfdx)" ] }, { "cell_type": "markdown", "metadata": {}, "source": [ " Back to Exercise 5\n", "\n", "Answer to Exercise 6" ] }, { "cell_type": "code", "execution_count": 26, "metadata": {}, "outputs": [ { "name": "stdout", "output_type": "stream", "text": [ "func1:\n", "numerical integration: 0.3611414941723568\n", "analytic integration: 0.36114149417235686\n", "func2:\n", "numerical integration: 0.21823563880424607\n", "wolframalpha result: 0.218236\n" ] } ], "source": [ "def func1(x):\n", " return np.exp(-x)\n", "\n", "def func2(x):\n", " return np.exp(-x) / x\n", "\n", "from scipy.integrate import quad\n", "print('func1:')\n", "print('numerical integration:', quad(func1, 1, 5)[0])\n", "print('analytic integration:', -np.exp(-5) + np.exp(-1))\n", "\n", "print('func2:')\n", "print('numerical integration:', quad(func2, 1, 5)[0])\n", "print('wolframalpha result:', 0.218236)" ] }, { "cell_type": "markdown", "metadata": {}, "source": [ " Back to Exercise 6\n", "\n", "Answer to Exercise 7" ] }, { "cell_type": "code", "execution_count": 27, "metadata": {}, "outputs": [ { "data": { "application/vnd.jupyter.widget-view+json": { "model_id": "da78a202e79845058484b9d24780dc3e", "version_major": 2, "version_minor": 0 }, "text/plain": [ "interactive(children=(FloatSlider(value=1.0, description='acos', max=5.0, step=0.5), FloatSlider(value=1.0, de…" ] }, "metadata": {}, "output_type": "display_data" } ], "source": [ "def plot_func2(acos=1, asin=1, colorcos='C0', colorsin='C1'):\n", " x = np.linspace(0, 4 * np.pi)\n", " plt.plot(x, acos * np.cos(x), colorcos)\n", " plt.plot(x, asin * np.sin(x), colorsin)\n", " plt.ylim(-5, 5)\n", " \n", "interact(plot_func2, acos=(0, 5, 0.5), asin=(0, 5, 0.5), \n", " colorcos=['orange', 'pink', 'red'], \n", " colorsin=['blue', 'grey', 'black']);" ] }, { "cell_type": "markdown", "metadata": {}, "source": [ "Back to Exercise 7" ] } ], "metadata": { "anaconda-cloud": {}, "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.8.2" }, "varInspector": { "cols": { "lenName": 16, "lenType": 16, "lenVar": 40 }, "kernels_config": { "python": { "delete_cmd_postfix": "", "delete_cmd_prefix": "del ", "library": "var_list.py", "varRefreshCmd": "print(var_dic_list())" }, "r": { "delete_cmd_postfix": ") ", "delete_cmd_prefix": "rm(", "library": "var_list.r", "varRefreshCmd": "cat(var_dic_list()) " } }, "types_to_exclude": [ "module", "function", "builtin_function_or_method", "instance", "_Feature" ], "window_display": false }, "widgets": { "state": {}, "version": "1.1.2" } }, "nbformat": 4, "nbformat_minor": 4 }