some minor updates

Author: mbakker7

notebook4_functions/py_exploratory_comp_4.ipynb

@@ -84,6 +84,7 @@
     "    else:\n",
     "        f = np.exp(-x)\n",
     "    return f\n",
+    "\n",
     "print(func(3))"
    ]
   },
@@ -115,7 +116,7 @@
     "\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]."
+    "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]."
    ]
   },
   {
@@ -145,7 +146,7 @@
    "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 ot the function `func`. Inside the function, this value is used for the variable `x`."
+    "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`."
    ]
   },
   {
@@ -167,7 +168,7 @@
     "\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` 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."
+    "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."
    ]
   },
   {
@@ -195,27 +196,32 @@
   {
    "cell_type": "code",
    "execution_count": null,
-   "metadata": {
-    "scrolled": true
-   },
+   "metadata": {},
    "outputs": [],
    "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, 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])."
+    "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])."
    ]
   },
   {
@@ -253,14 +259,17 @@
     "    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))  "
    ]
   },
@@ -278,9 +287,11 @@
    "outputs": [],
    "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)"
    ]
@@ -348,6 +359,7 @@
     "    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"
    ]
@@ -364,7 +376,7 @@
     "\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)"
+    "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. "
    ]
   },
   {
@@ -383,7 +395,7 @@
    "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 a range of `x` values and a range 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:"
+    "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:"
    ]
   },
   {
@@ -392,7 +404,7 @@
    "metadata": {},
    "outputs": [],
    "source": [
-    "x,y = np.meshgrid( np.linspace(-1,1,5), np.linspace(0,10,3) ) \n",
+    "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",
@@ -438,10 +450,12 @@
     "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",
@@ -469,6 +483,7 @@
     "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",
@@ -647,7 +662,7 @@
    "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). "
+    "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). "
    ]
   },
   {
@@ -975,7 +990,7 @@
    "name": "python",
    "nbconvert_exporter": "python",
    "pygments_lexer": "ipython3",
-   "version": "3.7.0"
+   "version": "3.8.2"
   },
   "varInspector": {
    "cols": {
@@ -1012,5 +1027,5 @@
   }
  },
  "nbformat": 4,
- "nbformat_minor": 1
+ "nbformat_minor": 4
 }