diff --git a/Test/00 Test Assignment.ipynb b/Test/00 Test Assignment.ipynb index 0958f3f..6e902f6 100644 --- a/Test/00 Test Assignment.ipynb +++ b/Test/00 Test Assignment.ipynb @@ -41,7 +41,7 @@ "id": "b4d38256", "metadata": {}, "source": [ - "team_members = \"Koen Vendrig, Kees van Kempen\"" + "team_members = \"Kees van Kempen, Koen Vendrig\"" ] }, { @@ -90,18 +90,27 @@ "name": "stdout", "output_type": "stream", "text": [ - "Hello Malte/Yann/Taha, is this okay?\n" + "Hoi Yann, hoe was Japan?\n" ] } ], "source": [ - "print(\"Hello Malte/Yann/Taha, is this okay?\")" + "# Test code\n", + "print(\"Hoi Yann, hoe was Japan?\")" ] }, { "cell_type": "code", "execution_count": null, - "id": "86e78dbb", + "id": "28242874", + "metadata": {}, + "outputs": [], + "source": [] + }, + { + "cell_type": "code", + "execution_count": null, + "id": "3c4836ec", "metadata": {}, "outputs": [], "source": [] @@ -109,7 +118,7 @@ ], "metadata": { "kernelspec": { - "display_name": "Python 3", + "display_name": "Python 3 (ipykernel)", "language": "python", "name": "python3" }, diff --git a/Test/feedback/2022-02-03 09:34:20.682254 UTC/00 Test Assignment.html b/Test/feedback/2022-02-03 09:34:20.682254 UTC/00 Test Assignment.html new file mode 100644 index 0000000..e076258 --- /dev/null +++ b/Test/feedback/2022-02-03 09:34:20.682254 UTC/00 Test Assignment.html @@ -0,0 +1,13280 @@ + + + + + +00 Test Assignment + + + + + + + + + + + + + + + + + +
+
+
+

00 Test Assignment (Score: 1.0 / 1.0)

+
+
    + + + + + + + + + + + +
  1. Coding free-response (Score: 1.0 / 1.0)
    2. + + +
  2. Comment
    3. + + + + + + + + + +
+
+
+
+
+
+ +
+
+
+
+

CDS: Numerical Methods Assignments

    +

  • See lecture notes and documentation on Brightspace for Python and Jupyter basics. If you are stuck, try to google or get in touch via Discord.

    +
    • +

  • Solutions must be submitted via the Jupyter Hub.

    +
    • +

  • Make sure you fill in any place that says YOUR CODE HERE or "YOUR ANSWER HERE".

    +
    • +
+

Submission

    +
  1. Name all team members in the the cell below
    2. +
  2. make sure everything runs as expected
    3. +
  3. restart the kernel (in the menubar, select Kernel$\rightarrow$Restart)
    4. +
  4. run all cells (in the menubar, select Cell$\rightarrow$Run All)
    5. +
  5. Check all outputs (Out[*]) for errors and resolve them if necessary
    6. +
  6. submit your solutions in time (before the deadline)
    7. +
+ +
+
+team_members = "Kees van Kempen, Koen Vendrig" +
+
+
+
+

Task 0

This is how a task will look like ...

+ +
+
+ +
+
+
In [1]:
+
Student's answer + Score: 1.0 / 1.0 (Top) +
+
+
+ 
# Test code
+print("Hoi Yann, hoe was Japan?")
+
+ +
+
+
+
+ Comments:

Hey Kees en Koen! Japan was helemaal geweldig :D Ondanks de pandemie alsnog een hoop nieuwe mensen kunnen ontmoeten en nieuwe dingen kunnen zien. Gezellig dat jullie het vak volgen :)

+

Dit lijkt trouwens helemaal te werken! Hopelijk kunnen jullie mijn feedback ook zien.

+ +
+
+
+
+ +
+
+ + +
+ +
+ + +
+
Hoi Yann, hoe was Japan?
+
+
+
+ +
+
+ +
+
+
+
In [ ]:
+
+ 
 
+
+ +
+
+
+ +
+
+
+
In [ ]:
+
+ 
 
+
+ +
+
+
+ +
+
+
+
+
+
+ + diff --git a/Week 1/01 Rounding and Truncation Error Analysis.ipynb b/Week 1/01 Rounding and Truncation Error Analysis.ipynb index e62c16a..1098403 100644 --- a/Week 1/01 Rounding and Truncation Error Analysis.ipynb +++ b/Week 1/01 Rounding and Truncation Error Analysis.ipynb @@ -39,7 +39,7 @@ "cell_type": "raw", "metadata": {}, "source": [ - "team_members = \"Koen Vendrig, Kees van Kempen\"" + "team_members = \"Kees van Kempen, Koen Vendrig\"" ] }, { @@ -69,8 +69,7 @@ ] }, { - "cell_type": "code", - "execution_count": 1, + "cell_type": "markdown", "metadata": { "deletable": false, "nbgrader": { @@ -85,7 +84,6 @@ "task": false } }, - "outputs": [], "source": [ "import numpy as np\n", "import scipy.special\n", @@ -116,7 +114,7 @@ }, { "cell_type": "code", - "execution_count": 2, + "execution_count": 3, "metadata": { "deletable": false, "nbgrader": { @@ -132,6 +130,17 @@ } }, "outputs": [], + "source": [ + "import numpy as np\n", + "import scipy.special\n", + "from matplotlib import pyplot as plt" + ] + }, + { + "cell_type": "code", + "execution_count": 4, + "metadata": {}, + "outputs": [], "source": [ "def getEuler0(N):\n", " \"\"\"\n", @@ -171,27 +180,7 @@ }, { "cell_type": "code", - "execution_count": 3, - "metadata": {}, - "outputs": [ - { - "name": "stdout", - "output_type": "stream", - "text": [ - "75.4 ms ± 368 µs per loop (mean ± std. dev. of 7 runs, 10 loops each)\n", - "25.8 µs ± 8.69 µs per loop (mean ± std. dev. of 7 runs, 10 loops each)\n" - ] - } - ], - "source": [ - "# It really does seem that the loop in getEuler0 is terribly slow:\n", - "%timeit -n10 getEuler0(2000)\n", - "%timeit -n10 getEuler1(2000)" - ] - }, - { - "cell_type": "code", - "execution_count": 4, + "execution_count": 5, "metadata": { "deletable": false, "nbgrader": { @@ -206,6 +195,26 @@ "task": false } }, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "76.2 ms ± 486 µs per loop (mean ± std. dev. of 7 runs, 10 loops each)\n", + "25.5 µs ± 6.91 µs per loop (mean ± std. dev. of 7 runs, 10 loops each)\n" + ] + } + ], + "source": [ + "# It really does seem that the loop in getEuler0 is terribly slow:\n", + "%timeit -n10 getEuler0(2000)\n", + "%timeit -n10 getEuler1(2000)" + ] + }, + { + "cell_type": "code", + "execution_count": 6, + "metadata": {}, "outputs": [ { "data": { @@ -235,7 +244,7 @@ }, { "cell_type": "code", - "execution_count": 5, + "execution_count": 7, "metadata": { "deletable": false, "editable": false, @@ -286,7 +295,7 @@ }, { "cell_type": "code", - "execution_count": 6, + "execution_count": 8, "metadata": { "deletable": false, "nbgrader": { @@ -322,7 +331,7 @@ }, { "cell_type": "code", - "execution_count": 7, + "execution_count": 9, "metadata": { "deletable": false, "nbgrader": { @@ -368,7 +377,7 @@ }, { "cell_type": "code", - "execution_count": 8, + "execution_count": 10, "metadata": { "deletable": false, "editable": false, @@ -425,7 +434,7 @@ }, { "cell_type": "code", - "execution_count": 9, + "execution_count": 11, "metadata": { "deletable": false, "nbgrader": { @@ -455,18 +464,7 @@ }, { "cell_type": "code", - "execution_count": 10, - "metadata": {}, - "outputs": [], - "source": [ - "d_list = np.arange(1, 5)\n", - "x = np.arange(30)\n", - "eulerErrs = [getEulerErr(np.array([getEulerRounding(N, d) for N in x])) for d in d_list]" - ] - }, - { - "cell_type": "code", - "execution_count": 11, + "execution_count": 12, "metadata": { "deletable": false, "nbgrader": { @@ -481,6 +479,17 @@ "task": false } }, + "outputs": [], + "source": [ + "d_list = np.arange(1, 5)\n", + "x = np.arange(30)\n", + "eulerErrs = [getEulerErr(np.array([getEulerRounding(N, d) for N in x])) for d in d_list]" + ] + }, + { + "cell_type": "code", + "execution_count": 13, + "metadata": {}, "outputs": [ { "data": { @@ -508,7 +517,7 @@ }, { "cell_type": "code", - "execution_count": 12, + "execution_count": 14, "metadata": { "deletable": false, "editable": false, @@ -566,11 +575,18 @@ "c = round(a, 2)\n", "```" ] + }, + { + "cell_type": "code", + "execution_count": null, + "metadata": {}, + "outputs": [], + "source": [] } ], "metadata": { "kernelspec": { - "display_name": "Python 3", + "display_name": "Python 3 (ipykernel)", "language": "python", "name": "python3" }, diff --git a/Week 1/02 Polynomial Interpolation.ipynb b/Week 1/02 Polynomial Interpolation.ipynb index 8257da6..e370472 100644 --- a/Week 1/02 Polynomial Interpolation.ipynb +++ b/Week 1/02 Polynomial Interpolation.ipynb @@ -66,7 +66,7 @@ }, { "cell_type": "code", - "execution_count": null, + "execution_count": 12, "metadata": { "deletable": false, "nbgrader": { @@ -83,10 +83,10 @@ }, "outputs": [], "source": [ - "# Import packages here ...\n", - "\n", - "# YOUR CODE HERE\n", - "raise NotImplementedError()" + "import numpy as np\n", + "import math as m\n", + "import scipy.special\n", + "from matplotlib import pyplot as plt" ] }, { @@ -113,7 +113,7 @@ }, { "cell_type": "code", - "execution_count": null, + "execution_count": 20, "metadata": { "deletable": false, "nbgrader": { @@ -130,16 +130,17 @@ }, "outputs": [], "source": [ + "xk = np.array([2,3,4,5,6])\n", + "yk = np.array([2,5,5,5,6])\n", "def GetVDMMatrix(xk):\n", - " \"\"\"Don't forget to write a docstring ...\n", - " \"\"\"\n", - " # YOUR CODE HERE\n", - " raise NotImplementedError()" + " \"\"\"Function generates a VDM matrix with the same format as the lecture\"\"\"\n", + " VDM = np.vander(xk,len(xk))\n", + " return VDM" ] }, { "cell_type": "code", - "execution_count": null, + "execution_count": 21, "metadata": { "deletable": false, "nbgrader": { @@ -154,17 +155,32 @@ "task": false } }, - "outputs": [], + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "[[ 16 8 4 2 1]\n", + " [ 81 27 9 3 1]\n", + " [ 256 64 16 4 1]\n", + " [ 625 125 25 5 1]\n", + " [1296 216 36 6 1]]\n", + "288.0000000000136\n" + ] + } + ], "source": [ "# print the Vandermonde matrix here in an appropriate format and calculate the determinant\n", + "\"\"\"VDM matrix is printed and determinant is calculated\"\"\"\n", + "print(GetVDMMatrix(xk))\n", "\n", - "# YOUR CODE HERE\n", - "raise NotImplementedError()" + "detVDM = np.linalg.det(GetVDMMatrix(xk))\n", + "print(detVDM)" ] }, { "cell_type": "code", - "execution_count": null, + "execution_count": 22, "metadata": { "deletable": false, "editable": false, @@ -179,7 +195,19 @@ "task": false } }, - "outputs": [], + "outputs": [ + { + "ename": "AssertionError", + "evalue": "", + "output_type": "error", + "traceback": [ + "\u001b[0;31m---------------------------------------------------------------------------\u001b[0m", + "\u001b[0;31mAssertionError\u001b[0m Traceback (most recent call last)", + "\u001b[0;32m/tmp/ipykernel_93712/3791331615.py\u001b[0m in \u001b[0;36m\u001b[0;34m\u001b[0m\n\u001b[1;32m 1\u001b[0m \u001b[0;34m\"\"\"Check that GetVDMMatrix returns the correct output\"\"\"\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0;32m----> 2\u001b[0;31m \u001b[0;32massert\u001b[0m \u001b[0mnp\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0mallclose\u001b[0m\u001b[0;34m(\u001b[0m \u001b[0mGetVDMMatrix\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0;34m[\u001b[0m\u001b[0;36m2.0\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0;36m4.0\u001b[0m\u001b[0;34m]\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0;34m[\u001b[0m\u001b[0;34m[\u001b[0m\u001b[0;36m1.0\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0;36m2.0\u001b[0m\u001b[0;34m]\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0;34m[\u001b[0m\u001b[0;36m1.0\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0;36m4.0\u001b[0m\u001b[0;34m]\u001b[0m\u001b[0;34m]\u001b[0m \u001b[0;34m)\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0m", + "\u001b[0;31mAssertionError\u001b[0m: " + ] + } + ], "source": [ "\"\"\"Check that GetVDMMatrix returns the correct output\"\"\"\n", "assert np.allclose( GetVDMMatrix([2.0, 4.0]), [[1.0, 2.0], [1.0, 4.0]] )" @@ -209,7 +237,7 @@ }, { "cell_type": "code", - "execution_count": null, + "execution_count": 59, "metadata": { "deletable": false, "nbgrader": { @@ -227,13 +255,21 @@ "outputs": [], "source": [ "def interpVDM(xk, yk, x):\n", - " # YOUR CODE HERE\n", - " raise NotImplementedError()" + " \"\"\"Interpolating polynomial is generated with x values and corresponding y_values (xk and yk respectively).\n", + " Returns an array with y values generated using this polynomial corresponding with given input array x\"\"\"\n", + " VDM = GetVDMMatrix(xk)\n", + " Invert = np.linalg.inv(VDM)\n", + " a_values = np.matmul(Invert,yk)\n", + " y = np.zeros(len(x))\n", + " for i in range(len(x)):\n", + " for j in range(len(a_values)):\n", + " y[i] += a_values[len(a_values)-1-j]*(x[i]**j)\n", + " return y" ] }, { "cell_type": "code", - "execution_count": null, + "execution_count": 60, "metadata": { "deletable": false, "editable": false, @@ -279,7 +315,7 @@ }, { "cell_type": "code", - "execution_count": null, + "execution_count": 64, "metadata": { "deletable": false, "nbgrader": { @@ -294,11 +330,42 @@ "task": false } }, - "outputs": [], + "outputs": [ + { + "data": { + "image/png": "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\n", + "text/plain": [ + "
" + ] + }, + "metadata": { + "needs_background": "light" + }, + "output_type": "display_data" + } + ], "source": [ - "# YOUR CODE HERE\n", - "raise NotImplementedError()" + "x_values = np.linspace(2,6,400)\n", + "def generate_y(x_values):\n", + " \"\"\"Generates y values to plot by using function interpVDM from previous exercise with corresponding x values\"\"\"\n", + " y_values = interpVDM(xk,yk,x_values)\n", + " return y_values\n", + "y_values = generate_y(x_values)\n", + " \n", + "plt.figure()\n", + "plt.xlabel(\"x\")\n", + "plt.ylabel(\"y\")\n", + "plt.title(\"Interpolating polynomial\")\n", + "plt.plot(x_values, y_values)\n", + "plt.show()" ] + }, + { + "cell_type": "code", + "execution_count": null, + "metadata": {}, + "outputs": [], + "source": [] } ], "metadata": {