From ab548036699852e806ed9bb92260664e72d7c1c5 Mon Sep 17 00:00:00 2001 From: andreadeans Date: Mon, 15 Oct 2018 15:52:30 +0200 Subject: [PATCH 1/7] 01_Fundamentals.ipynb --- 01_Fundamentals.ipynb | 6 +++--- 1 file changed, 3 insertions(+), 3 deletions(-) diff --git a/01_Fundamentals.ipynb b/01_Fundamentals.ipynb index 0955d74..73b9534 100644 --- a/01_Fundamentals.ipynb +++ b/01_Fundamentals.ipynb @@ -654,14 +654,14 @@ "language_info": { "codemirror_mode": { "name": "ipython", - "version": 3 + "version": 2 }, "file_extension": ".py", "mimetype": "text/x-python", "name": "python", "nbconvert_exporter": "python", - "pygments_lexer": "ipython3", - "version": "3.5.4" + "pygments_lexer": "ipython2", + "version": "2.7.15rc1" } }, "nbformat": 4, From c92a53d25264fb798383b69d01a8349737badb61 Mon Sep 17 00:00:00 2001 From: andreadeans Date: Tue, 16 Oct 2018 14:48:50 +0200 Subject: [PATCH 2/7] ok --- 01_Fundamentals.ipynb | 91 ++++++++++++++++++++++++++++++++--------- 01ex_Fundamentals.ipynb | 6 +-- 2 files changed, 75 insertions(+), 22 deletions(-) diff --git a/01_Fundamentals.ipynb b/01_Fundamentals.ipynb index 07435ca..eeea15e 100644 --- a/01_Fundamentals.ipynb +++ b/01_Fundamentals.ipynb @@ -429,9 +429,17 @@ }, { "cell_type": "code", - "execution_count": null, - "metadata": {}, - "outputs": [], + "execution_count": 9, + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "[1, 1, 2, 3, 5, 8, 13, 21, 34, 55]\n" + ] + } + ], "source": [ "def fib1(n):\n", " \"\"\"Fib with recursion.\"\"\"\n", @@ -449,9 +457,17 @@ }, { "cell_type": "code", - "execution_count": null, - "metadata": {}, - "outputs": [], + "execution_count": 10, + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "[1, 1, 2, 3, 5, 8, 13, 21, 34, 55]\n" + ] + } + ], "source": [ "# In Python, a more efficient version that does not use recursion is\n", "\n", @@ -467,9 +483,18 @@ }, { "cell_type": "code", - "execution_count": null, - "metadata": {}, - "outputs": [], + "execution_count": 11, + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "100 loops, best of 3: 6.67 ms per loop\n", + "100000 loops, best of 3: 4.2 µs per loop\n" + ] + } + ], "source": [ "# check indeed the timing:\n", "\n", @@ -578,7 +603,7 @@ }, { "cell_type": "code", - "execution_count": null, + "execution_count": 4, "metadata": {}, "outputs": [], "source": [ @@ -597,9 +622,19 @@ }, { "cell_type": "code", - "execution_count": null, - "metadata": {}, - "outputs": [], + "execution_count": 5, + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "Something is happening before the function is called.\n", + "Whee!\n", + "Something is happening after the function is called.\n" + ] + } + ], "source": [ "say_whee()" ] @@ -617,9 +652,18 @@ }, { "cell_type": "code", - "execution_count": null, - "metadata": {}, - "outputs": [], + "execution_count": 6, + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "('buddy', 12)\n", + "6.0\n" + ] + } + ], "source": [ "class Pet:\n", " # the \"constructor\"\n", @@ -641,9 +685,18 @@ }, { "cell_type": "code", - "execution_count": null, - "metadata": {}, - "outputs": [], + "execution_count": 7, + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "tobia\n", + "70\n" + ] + } + ], "source": [ "# ineritance is straightforward\n", "class Dog(Pet):\n", diff --git a/01ex_Fundamentals.ipynb b/01ex_Fundamentals.ipynb index 5852179..135dff2 100644 --- a/01ex_Fundamentals.ipynb +++ b/01ex_Fundamentals.ipynb @@ -153,14 +153,14 @@ "language_info": { "codemirror_mode": { "name": "ipython", - "version": 3 + "version": 2 }, "file_extension": ".py", "mimetype": "text/x-python", "name": "python", "nbconvert_exporter": "python", - "pygments_lexer": "ipython3", - "version": "3.5.4" + "pygments_lexer": "ipython2", + "version": "2.7.15rc1" } }, "nbformat": 4, From 83ad8fdee03c54dd92fd9a613c2f157926d4e584 Mon Sep 17 00:00:00 2001 From: andreadeans Date: Wed, 17 Oct 2018 15:30:55 +0200 Subject: [PATCH 3/7] yes --- 01_Fundamentals.ipynb | 49 +++++++++---------------------------------- 1 file changed, 10 insertions(+), 39 deletions(-) diff --git a/01_Fundamentals.ipynb b/01_Fundamentals.ipynb index b65478b..5d8aad7 100644 --- a/01_Fundamentals.ipynb +++ b/01_Fundamentals.ipynb @@ -457,15 +457,8 @@ }, { "cell_type": "code", -<<<<<<< HEAD -<<<<<<< HEAD - "execution_count": 10, -======= - "execution_count": 80, ->>>>>>> upstream/master -======= + "execution_count": null, ->>>>>>> upstream/master "metadata": {}, "outputs": [], "source": [ @@ -483,33 +476,23 @@ }, { "cell_type": "code", -<<<<<<< HEAD -<<<<<<< HEAD - "execution_count": 11, -======= + "execution_count": 81, ->>>>>>> upstream/master + "metadata": {}, "outputs": [ { "name": "stdout", "output_type": "stream", "text": [ -<<<<<<< HEAD - "100 loops, best of 3: 6.67 ms per loop\n", - "100000 loops, best of 3: 4.2 µs per loop\n" -======= + "7.27 ms ± 90.4 µs per loop (mean ± std. dev. of 7 runs, 100 loops each)\n", "4.47 µs ± 108 ns per loop (mean ± std. dev. of 7 runs, 100000 loops each)\n" ->>>>>>> upstream/master + ] } ], -======= - "execution_count": null, - "metadata": {}, - "outputs": [], ->>>>>>> upstream/master + "source": [ "# check indeed the timing:\n", "\n", @@ -618,15 +601,9 @@ }, { "cell_type": "code", -<<<<<<< HEAD -<<<<<<< HEAD - "execution_count": 4, -======= - "execution_count": 85, ->>>>>>> upstream/master -======= + "execution_count": null, ->>>>>>> upstream/master + "metadata": {}, "outputs": [], "source": [ @@ -651,15 +628,9 @@ }, { "cell_type": "code", -<<<<<<< HEAD -<<<<<<< HEAD - "execution_count": 5, -======= - "execution_count": 86, ->>>>>>> upstream/master -======= + "execution_count": null, ->>>>>>> upstream/master + "metadata": {}, "outputs": [], "source": [ From 3cde8da28b518ad5e95c1535f87c876d6fb53704 Mon Sep 17 00:00:00 2001 From: andreadeans Date: Wed, 17 Oct 2018 15:33:48 +0200 Subject: [PATCH 4/7] yes --- 01_Fundamentals.ipynb | 9 +-------- 1 file changed, 1 insertion(+), 8 deletions(-) diff --git a/01_Fundamentals.ipynb b/01_Fundamentals.ipynb index 5d8aad7..e1551d1 100644 --- a/01_Fundamentals.ipynb +++ b/01_Fundamentals.ipynb @@ -429,15 +429,8 @@ }, { "cell_type": "code", -<<<<<<< HEAD -<<<<<<< HEAD - "execution_count": 9, -======= - "execution_count": 79, ->>>>>>> upstream/master -======= + "execution_count": null, ->>>>>>> upstream/master "metadata": {}, "outputs": [], "source": [ From a9ddca8490bdb699c161b292670e82501b20b7e2 Mon Sep 17 00:00:00 2001 From: andreadeans Date: Mon, 22 Oct 2018 14:21:06 +0200 Subject: [PATCH 5/7] yes --- 01_Fundamentals.ipynb | 177 +++++++++++++++++++++++++++++++++--------- 1 file changed, 140 insertions(+), 37 deletions(-) diff --git a/01_Fundamentals.ipynb b/01_Fundamentals.ipynb index e1551d1..d71b75e 100644 --- a/01_Fundamentals.ipynb +++ b/01_Fundamentals.ipynb @@ -87,9 +87,20 @@ }, { "cell_type": "code", - "execution_count": null, + "execution_count": 15, "metadata": {}, - "outputs": [], + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "4\n", + "8\n", + "('cube', 8)\n", + "('square', 4)\n" + ] + } + ], "source": [ "def square(x):\n", " \"\"\"Square of x.\"\"\"\n", @@ -229,9 +240,22 @@ }, { "cell_type": "code", - "execution_count": null, + "execution_count": 19, "metadata": {}, - "outputs": [], + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "[0, 1, 4, 9, 16]\n", + "0\n", + "1\n", + "4\n", + "9\n", + "16\n" + ] + } + ], "source": [ "x = list(map(square, range(5)))\n", "print (x)\n", @@ -282,9 +306,20 @@ }, { "cell_type": "code", - "execution_count": null, + "execution_count": 13, "metadata": {}, - "outputs": [], + "outputs": [ + { + "data": { + "text/plain": [ + "15" + ] + }, + "execution_count": 13, + "metadata": {}, + "output_type": "execute_result" + } + ], "source": [ "from functools import reduce\n", "\n", @@ -306,9 +341,20 @@ }, { "cell_type": "code", - "execution_count": null, + "execution_count": 24, "metadata": {}, - "outputs": [], + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "(1, 10, 'a')\n", + "(2, 20, 'b')\n", + "(3, 30, 'c')\n", + "(4, 40, 'd')\n" + ] + } + ], "source": [ "xs = [1, 2, 3, 4]\n", "ys = [10, 20, 30, 40]\n", @@ -327,9 +373,22 @@ }, { "cell_type": "code", - "execution_count": null, + "execution_count": 18, "metadata": {}, - "outputs": [], + "outputs": [ + { + "ename": "TypeError", + "evalue": "() takes exactly 2 arguments (1 given)", + "output_type": "error", + "traceback": [ + "\u001b[0;31m---------------------------------------------------------------------------\u001b[0m", + "\u001b[0;31mTypeError\u001b[0m Traceback (most recent call last)", + "\u001b[0;32m\u001b[0m in \u001b[0;36m\u001b[0;34m()\u001b[0m\n\u001b[1;32m 4\u001b[0m \u001b[0;34m\u001b[0m\u001b[0m\n\u001b[1;32m 5\u001b[0m \u001b[0mxs\u001b[0m \u001b[0;34m=\u001b[0m \u001b[0mrange\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0;36m5\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0;32m----> 6\u001b[0;31m \u001b[0;32mprint\u001b[0m \u001b[0;34m(\u001b[0m\u001b[0mcustom_sum\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0mxs\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0msquare\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0m\u001b[1;32m 7\u001b[0m \u001b[0;32mprint\u001b[0m \u001b[0;34m(\u001b[0m\u001b[0mcustom_sum\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0mxs\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0mcube\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[1;32m 8\u001b[0m \u001b[0;34m\u001b[0m\u001b[0m\n", + "\u001b[0;32m\u001b[0m in \u001b[0;36mcustom_sum\u001b[0;34m(xs, transform)\u001b[0m\n\u001b[1;32m 1\u001b[0m \u001b[0;32mdef\u001b[0m \u001b[0mcustom_sum\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0mxs\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0mtransform\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m:\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[1;32m 2\u001b[0m \u001b[0;34m\"\"\"Returns the sum of xs after a user specified transform.\"\"\"\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0;32m----> 3\u001b[0;31m \u001b[0;32mreturn\u001b[0m \u001b[0msum\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0mmap\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0mtransform\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0mxs\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0m\u001b[1;32m 4\u001b[0m \u001b[0;34m\u001b[0m\u001b[0m\n\u001b[1;32m 5\u001b[0m \u001b[0mxs\u001b[0m \u001b[0;34m=\u001b[0m \u001b[0mrange\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0;36m5\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n", + "\u001b[0;31mTypeError\u001b[0m: () takes exactly 2 arguments (1 given)" + ] + } + ], "source": [ "def custom_sum(xs, transform):\n", " \"\"\"Returns the sum of xs after a user specified transform.\"\"\"\n", @@ -391,9 +450,20 @@ }, { "cell_type": "code", - "execution_count": null, + "execution_count": 10, "metadata": {}, - "outputs": [], + "outputs": [ + { + "data": { + "text/plain": [ + "7" + ] + }, + "execution_count": 10, + "metadata": {}, + "output_type": "execute_result" + } + ], "source": [ "sum = lambda x,y: x+y\n", "sum(3,4)" @@ -401,18 +471,38 @@ }, { "cell_type": "code", - "execution_count": null, + "execution_count": 11, "metadata": {}, - "outputs": [], + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "1\n", + "5\n", + "11\n", + "19\n", + "29\n" + ] + } + ], "source": [ "for i in map(lambda x: x*x+3*x+1, range(5)): print (i)" ] }, { "cell_type": "code", - "execution_count": null, + "execution_count": 12, "metadata": {}, - "outputs": [], + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "285\n" + ] + } + ], "source": [ "# what does this function do?\n", "from functools import reduce\n", @@ -429,10 +519,17 @@ }, { "cell_type": "code", - - "execution_count": null, + "execution_count": 5, "metadata": {}, - "outputs": [], + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "[1, 1, 2, 3, 5, 8, 13, 21, 34, 55]\n" + ] + } + ], "source": [ "def fib1(n):\n", " \"\"\"Fib with recursion.\"\"\"\n", @@ -450,10 +547,17 @@ }, { "cell_type": "code", - - "execution_count": null, + "execution_count": 6, "metadata": {}, - "outputs": [], + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "[1, 1, 2, 3, 5, 8, 13, 21, 34, 55]\n" + ] + } + ], "source": [ "# In Python, a more efficient version that does not use recursion is\n", "\n", @@ -469,23 +573,18 @@ }, { "cell_type": "code", - - "execution_count": 81, - + "execution_count": 8, "metadata": {}, "outputs": [ { "name": "stdout", "output_type": "stream", "text": [ - - "7.27 ms ± 90.4 µs per loop (mean ± std. dev. of 7 runs, 100 loops each)\n", - "4.47 µs ± 108 ns per loop (mean ± std. dev. of 7 runs, 100000 loops each)\n" - + "100 loops, best of 3: 4.66 ms per loop\n", + "100000 loops, best of 3: 3.41 µs per loop\n" ] } ], - "source": [ "# check indeed the timing:\n", "\n", @@ -594,9 +693,7 @@ }, { "cell_type": "code", - - "execution_count": null, - + "execution_count": 3, "metadata": {}, "outputs": [], "source": [ @@ -621,11 +718,17 @@ }, { "cell_type": "code", - - "execution_count": null, - + "execution_count": 4, "metadata": {}, - "outputs": [], + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "Whee!\n" + ] + } + ], "source": [ "say_whee()" ] From 02ca658612bd3e058fd07b40ada03662adec562f Mon Sep 17 00:00:00 2001 From: andreadeans Date: Thu, 15 Nov 2018 08:55:35 +0100 Subject: [PATCH 6/7] done --- 03_Numpy.ipynb | 2 +- 1 file changed, 1 insertion(+), 1 deletion(-) diff --git a/03_Numpy.ipynb b/03_Numpy.ipynb index 844c5fc..bba9efc 100644 --- a/03_Numpy.ipynb +++ b/03_Numpy.ipynb @@ -872,7 +872,7 @@ "name": "python", "nbconvert_exporter": "python", "pygments_lexer": "ipython3", - "version": "3.5.4" + "version": "3.6.6" } }, "nbformat": 4, From 4572de870f7f1d0006cb4278dd97f1f56ab308b2 Mon Sep 17 00:00:00 2001 From: andreadeans Date: Tue, 20 Nov 2018 14:50:06 +0100 Subject: [PATCH 7/7] exercise 3 --- 03ex_Numpy_andrea.ipynb | 722 ++++++++++++++++++++++++++++++++++++++++ 1 file changed, 722 insertions(+) create mode 100644 03ex_Numpy_andrea.ipynb diff --git a/03ex_Numpy_andrea.ipynb b/03ex_Numpy_andrea.ipynb new file mode 100644 index 0000000..be7550e --- /dev/null +++ b/03ex_Numpy_andrea.ipynb @@ -0,0 +1,722 @@ +{ + "cells": [ + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "### Numpy basics" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "1\\. Find the row, column and overall means for the following matrix:\n", + "\n", + "```python\n", + "m = np.arange(12).reshape((3,4))\n", + "```" + ] + }, + { + "cell_type": "code", + "execution_count": 1, + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "[[ 0 1 2 3]\n", + " [ 4 5 6 7]\n", + " [ 8 9 10 11]]\n", + "[0. 0. 0. 0.]\n", + "La media lungo le colonne è: [4. 5. 6. 7.] [4. 5. 6. 7.]\n", + "La media lungo le righe è: [1.5 5.5 9.5] [1.5 5.5 9.5]\n", + "La media su tutti gli elementi è: 5.5 5.5\n" + ] + } + ], + "source": [ + "#1\n", + "import numpy as np\n", + "\n", + "m = np.arange(12).reshape((3,4))\n", + "print(m)\n", + "\n", + "mcolumns = np.zeros(4)\n", + "mrows = np.zeros(3)\n", + "print(mcolumns)\n", + "mean = 0.\n", + "\n", + "for i in range(3):\n", + " for j in range(4):\n", + " mcolumns[j] += m[i,j]\n", + " mrows[i] += m[i,j]\n", + " mean += m[i,j]\n", + "#print(mcolumns/3,mrows/4,mean/(4*3))\n", + "print(\"La media lungo le colonne è:\", m.mean(axis=0), mcolumns/3)\n", + "print(\"La media lungo le righe è:\", m.mean(axis=1), mrows/4)\n", + "print(\"La media su tutti gli elementi è:\", m.mean(), mean/(4*3))" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "2\\. Find the outer product of the following two vecotrs\n", + "\n", + "```python\n", + "u = np.array([1,3,5,7])\n", + "v = np.array([2,4,6,8])\n", + "```\n", + "\n", + "Do this in the following ways:\n", + "\n", + " * Using the function outer in numpy\n", + " * Using a nested for loop or list comprehension\n", + " * Using numpy broadcasting operatoins\n" + ] + }, + { + "cell_type": "code", + "execution_count": 2, + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "[[ 2 4 6 8]\n", + " [ 6 12 18 24]\n", + " [10 20 30 40]\n", + " [14 28 42 56]]\n", + "[[ 2. 4. 6. 8.]\n", + " [ 6. 12. 18. 24.]\n", + " [10. 20. 30. 40.]\n", + " [14. 28. 42. 56.]]\n", + "[[ 2 4 6 8]\n", + " [ 6 12 18 24]\n", + " [10 20 30 40]\n", + " [14 28 42 56]]\n" + ] + } + ], + "source": [ + "#2\n", + "u = np.array([1,3,5,7])\n", + "v = np.array([2,4,6,8])\n", + "\n", + "#2.a\n", + "print(np.outer(u,v))\n", + "\n", + "#2.b\n", + "l = np.zeros((4,4))\n", + "for i in range(len(u)):\n", + " for j in range(len(v)):\n", + " l[j,i] = u[j]*v[i]\n", + "print(l)\n", + "\n", + "#2.c\n", + "A = v*u.reshape(4,1)\n", + "print(A)" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "3\\. Create a 10 by 6 matrix of random uniform numbers. Set all rows with any entry less than 0.1 to be zero\n", + "\n", + "Hint: Use the following numpy functions - np.random.random, np.any as well as Boolean indexing and the axis argument." + ] + }, + { + "cell_type": "code", + "execution_count": 3, + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "[[0.42170872 0.91112329 0.8050634 0.41753934 0.01221813 0.29049741]\n", + " [0.48560741 0.86282963 0.02107422 0.35615905 0.23272441 0.65184514]\n", + " [0.94353812 0.60173279 0.19377344 0.88940467 0.16564044 0.31142581]\n", + " [0.20659817 0.18043479 0.81810608 0.88227876 0.24802947 0.18019832]\n", + " [0.56915748 0.61494723 0.90793213 0.88000911 0.60232619 0.63006451]\n", + " [0.26913716 0.78372763 0.50954497 0.1525559 0.7718165 0.39612942]\n", + " [0.10249383 0.70321075 0.69370804 0.47083267 0.33685156 0.22614914]\n", + " [0.03941187 0.63211544 0.91216015 0.66558269 0.280254 0.25794337]\n", + " [0.47012615 0.18849851 0.02748516 0.17854179 0.6688643 0.91752731]\n", + " [0.07664385 0.73026562 0.37478523 0.71621558 0.64105781 0.9557536 ]]\n", + "[[False False False False True False]\n", + " [False False True False False False]\n", + " [False False False False False False]\n", + " [False False False False False False]\n", + " [False False False False False False]\n", + " [False False False False False False]\n", + " [False False False False False False]\n", + " [ True False False False False False]\n", + " [False False True False False False]\n", + " [ True False False False False False]]\n", + "[False False False False True False]\n", + "[[0. 0. 0. 0. 0. 0. ]\n", + " [0. 0. 0. 0. 0. 0. ]\n", + " [0.94353812 0.60173279 0.19377344 0.88940467 0.16564044 0.31142581]\n", + " [0.20659817 0.18043479 0.81810608 0.88227876 0.24802947 0.18019832]\n", + " [0.56915748 0.61494723 0.90793213 0.88000911 0.60232619 0.63006451]\n", + " [0.26913716 0.78372763 0.50954497 0.1525559 0.7718165 0.39612942]\n", + " [0.10249383 0.70321075 0.69370804 0.47083267 0.33685156 0.22614914]\n", + " [0. 0. 0. 0. 0. 0. ]\n", + " [0. 0. 0. 0. 0. 0. ]\n", + " [0. 0. 0. 0. 0. 0. ]]\n" + ] + } + ], + "source": [ + "#3\n", + "R = np.random.random(60)\n", + "#print(R)\n", + "R = R.reshape(10,6)\n", + "print(R)\n", + "mask = (R < 0.1)\n", + "print(mask)\n", + "print(mask[0,:])\n", + "for i in range(10):\n", + " if np.any(mask[i,:]) == True:\n", + " R[i,:] = np.zeros(6)\n", + "print(R)" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "4\\. Use np.linspace to create an array of 100 numbers between 0 and 2π (includsive).\n", + "\n", + " * Extract every 10th element using slice notation\n", + " * Reverse the array using slice notation\n", + " * Extract elements where the absolute difference between the sine and cosine functions evaluated at that element is less than 0.1\n", + " * Make a plot showing the sin and cos functions and indicate where they are close" + ] + }, + { + "cell_type": "code", + "execution_count": 4, + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "[0.57119866 1.20586385 1.84052903 2.47519421 3.10985939 3.74452458\n", + " 4.37918976 5.01385494 5.64852012 6.28318531]\n", + "[6.28318531 6.21971879 6.15625227 6.09278575 6.02931923 5.96585272\n", + " 5.9023862 5.83891968 5.77545316 5.71198664 5.64852012 5.58505361\n", + " 5.52158709 5.45812057 5.39465405 5.33118753 5.26772102 5.2042545\n", + " 5.14078798 5.07732146 5.01385494 4.95038842 4.88692191 4.82345539\n", + " 4.75998887 4.69652235 4.63305583 4.56958931 4.5061228 4.44265628\n", + " 4.37918976 4.31572324 4.25225672 4.1887902 4.12532369 4.06185717\n", + " 3.99839065 3.93492413 3.87145761 3.8079911 3.74452458 3.68105806\n", + " 3.61759154 3.55412502 3.4906585 3.42719199 3.36372547 3.30025895\n", + " 3.23679243 3.17332591 3.10985939 3.04639288 2.98292636 2.91945984\n", + " 2.85599332 2.7925268 2.72906028 2.66559377 2.60212725 2.53866073\n", + " 2.47519421 2.41172769 2.34826118 2.28479466 2.22132814 2.15786162\n", + " 2.0943951 2.03092858 1.96746207 1.90399555 1.84052903 1.77706251\n", + " 1.71359599 1.65012947 1.58666296 1.52319644 1.45972992 1.3962634\n", + " 1.33279688 1.26933037 1.20586385 1.14239733 1.07893081 1.01546429\n", + " 0.95199777 0.88853126 0.82506474 0.76159822 0.6981317 0.63466518\n", + " 0.57119866 0.50773215 0.44426563 0.38079911 0.31733259 0.25386607\n", + " 0.19039955 0.12693304 0.06346652 0. ]\n" + ] + }, + { + "data": { + "text/plain": [ + "[]" + ] + }, + "execution_count": 4, + "metadata": {}, + "output_type": "execute_result" + }, + { + "data": { + "image/png": "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\n", + "text/plain": [ + "
" + ] + }, + "metadata": { + "needs_background": "light" + }, + "output_type": "display_data" + } + ], + "source": [ + "#4\n", + "import matplotlib.pyplot as plt \n", + "\n", + "%matplotlib inline \n", + "\n", + "P = np.linspace(0,2*np.pi,100)\n", + "i = [i for i in range(9,100,10)]\n", + "reverse = [-j for j in range(1,101)]\n", + "#print(i)\n", + "#print(reverse)\n", + "\n", + "#extraction on 10th element\n", + "print(P[i])\n", + "\n", + "#reverse\n", + "#print(P[reverse])\n", + "print(P[::-1])\n", + "\n", + "#absolute difference\n", + "C = P[abs(np.sin(P)-np.cos(P)) < 0.1]\n", + "\n", + "#plot\n", + "plt.plot(P, np.sin(P))\n", + "plt.plot(P, np.cos(P))\n", + "plt.plot(C, np.sin(C), 'bo')\n", + "plt.plot(C, np.cos(C), 'ro')" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "5\\. Create a matrix that shows the 10 by 10 multiplication table.\n", + "\n", + " * Find the trace of the matrix\n", + " * Extract the anto-diagonal (this should be ```array([10, 18, 24, 28, 30, 30, 28, 24, 18, 10])```)\n", + " * Extract the diagnoal offset by 1 upwards (this should be ```array([ 2, 6, 12, 20, 30, 42, 56, 72, 90])```)" + ] + }, + { + "cell_type": "code", + "execution_count": 5, + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "[[ 1. 2. 3. 4. 5. 6. 7. 8. 9. 10.]\n", + " [ 2. 4. 6. 8. 10. 12. 14. 16. 18. 20.]\n", + " [ 3. 6. 9. 12. 15. 18. 21. 24. 27. 30.]\n", + " [ 4. 8. 12. 16. 20. 24. 28. 32. 36. 40.]\n", + " [ 5. 10. 15. 20. 25. 30. 35. 40. 45. 50.]\n", + " [ 6. 12. 18. 24. 30. 36. 42. 48. 54. 60.]\n", + " [ 7. 14. 21. 28. 35. 42. 49. 56. 63. 70.]\n", + " [ 8. 16. 24. 32. 40. 48. 56. 64. 72. 80.]\n", + " [ 9. 18. 27. 36. 45. 54. 63. 72. 81. 90.]\n", + " [ 10. 20. 30. 40. 50. 60. 70. 80. 90. 100.]]\n", + "385.0\n", + "385.0\n", + "[10. 18. 24. 28. 30. 30. 28. 24. 18. 10.]\n", + "[ 2. 6. 12. 20. 30. 42. 56. 72. 90.]\n" + ] + } + ], + "source": [ + "#5\n", + "M = np.zeros((10,10))\n", + "for i in range(0,10):\n", + " for j in range(0,10):\n", + " M[i,j] = (j+1)*(i+1)\n", + "print(M)\n", + "\n", + "#trace\n", + "d = np.diag(M)\n", + "print(d.sum())\n", + "print(M.trace())\n", + "\n", + "#anti-diagonal\n", + "\n", + "#MT = np.zeros((10,10))\n", + "\n", + "#for i in range(-10,0):\n", + " #for j in range(0,10):\n", + " #MT[i,j] = (j+1)*abs(i)\n", + "#print(MT)\n", + "#antid = np.diag(MT)\n", + "#print(antid)\n", + "B = M[::-1]\n", + "print(np.diag(B))\n", + "\n", + "#offset diagonal\n", + "print(np.diag(M,1))" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "6\\. Use broadcasting to create a grid of distances\n", + "\n", + "Route 66 crosses the following cities in the US: Chicago, Springfield, Saint-Louis, Tulsa, Oklahoma City, Amarillo, Santa Fe, Albuquerque, Flagstaff, Los Angeles\n", + "The corresponding positions in miles are: 0, 198, 303, 736, 871, 1175, 1475, 1544, 1913, 2448\n", + "\n", + " * Construct a 2D grid of distances among each city along Route 66\n", + " * Convert that in km (those savages...)" + ] + }, + { + "cell_type": "code", + "execution_count": 6, + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "[[ 0 198 303 736 871 1175 1475 1544 1913 2448]\n", + " [ -198 0 105 538 673 977 1277 1346 1715 2250]\n", + " [ -303 -105 0 433 568 872 1172 1241 1610 2145]\n", + " [ -736 -538 -433 0 135 439 739 808 1177 1712]\n", + " [ -871 -673 -568 -135 0 304 604 673 1042 1577]\n", + " [-1175 -977 -872 -439 -304 0 300 369 738 1273]\n", + " [-1475 -1277 -1172 -739 -604 -300 0 69 438 973]\n", + " [-1544 -1346 -1241 -808 -673 -369 -69 0 369 904]\n", + " [-1913 -1715 -1610 -1177 -1042 -738 -438 -369 0 535]\n", + " [-2448 -2250 -2145 -1712 -1577 -1273 -973 -904 -535 0]]\n", + "[[ 0. 318.78 487.83 1184.96 1402.31 1891.75 2374.75 2485.84\n", + " 3079.93 3941.28]\n", + " [ -318.78 0. 169.05 866.18 1083.53 1572.97 2055.97 2167.06\n", + " 2761.15 3622.5 ]\n", + " [ -487.83 -169.05 0. 697.13 914.48 1403.92 1886.92 1998.01\n", + " 2592.1 3453.45]\n", + " [-1184.96 -866.18 -697.13 0. 217.35 706.79 1189.79 1300.88\n", + " 1894.97 2756.32]\n", + " [-1402.31 -1083.53 -914.48 -217.35 0. 489.44 972.44 1083.53\n", + " 1677.62 2538.97]\n", + " [-1891.75 -1572.97 -1403.92 -706.79 -489.44 0. 483. 594.09\n", + " 1188.18 2049.53]\n", + " [-2374.75 -2055.97 -1886.92 -1189.79 -972.44 -483. 0. 111.09\n", + " 705.18 1566.53]\n", + " [-2485.84 -2167.06 -1998.01 -1300.88 -1083.53 -594.09 -111.09 0.\n", + " 594.09 1455.44]\n", + " [-3079.93 -2761.15 -2592.1 -1894.97 -1677.62 -1188.18 -705.18 -594.09\n", + " 0. 861.35]\n", + " [-3941.28 -3622.5 -3453.45 -2756.32 -2538.97 -2049.53 -1566.53 -1455.44\n", + " -861.35 0. ]]\n" + ] + } + ], + "source": [ + "#6\n", + "D1 = np.array([0,198,303,736,871,1175,1475,1544,1913,2448])\n", + "D2 = D1.reshape(10,1)\n", + "Dmiles = D1-D2\n", + "Dkm = Dmiles*1.61\n", + "print(Dmiles)\n", + "print(Dkm)" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "[ 2 3 5 7 11 13 17 19 23 29 31 37 41 43 47 53 59 61 67 71 73 79 83 89\n", + " 97]\n", + "15.2 ms ± 4.86 ms per loop (mean ± std. dev. of 7 runs, 10 loops each)\n", + "22.1 ms ± 1.46 ms per loop (mean ± std. dev. of 7 runs, 10 loops each)\n", + "34.2 ms ± 161 µs per loop (mean ± std. dev. of 7 runs, 10 loops each)\n", + "52 ms ± 1.03 ms per loop (mean ± std. dev. of 7 runs, 10 loops each)\n" + ] + } + ], + "source": [ + "#7\n", + "\n", + "N = 100\n", + "def Nprimes(M):\n", + " primes = np.arange(2,M+1)\n", + " i = 2\n", + " remain = np.arange(2,M+1)\n", + " atemp = np.array([i])\n", + " while (i]" + ] + }, + "execution_count": 8, + "metadata": {}, + "output_type": "execute_result" + }, + { + "data": { + "image/png": "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\n", + "text/plain": [ + "
" + ] + }, + "metadata": { + "needs_background": "light" + }, + "output_type": "display_data" + } + ], + "source": [ + "#8\n", + "import random as rand\n", + "\n", + "#walkers array\n", + "N = 200\n", + "M = 1000\n", + "\n", + "walkers = np.zeros((M,N))\n", + "distances = np.zeros((M,N))\n", + "for i in range(M):\n", + " for j in range(N):\n", + " r = rand.randint(0,1)\n", + " if r == 0:\n", + " walkers[i,j] = -1\n", + " else:\n", + " walkers[i,j] = +1\n", + " if j == 0:\n", + " distances[i,0] = walkers[i,0]\n", + " else:\n", + " distances[i,j] += walkers[i,j] + distances[i,j-1]\n", + " \n", + "#print(distances)\n", + "sqdist = distances**2\n", + "#print(sqdist)\n", + "\n", + "meandistance = np.zeros((1,N))\n", + "for j in range(N):\n", + " meandistance[:,j] = sqdist[:,j].mean()\n", + "#print(meandistance)\n", + "\n", + "%matplotlib inline \n", + "t = np.arange(0,N)\n", + "avgdist = np.sqrt(meandistance)\n", + "#print(t)\n", + "#print(avgdist)\n", + "plt.plot(t, avgdist.T[t])" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "9\\. Analyze a data file \n", + " * Download the population of hares, lynxes and carrots at the beginning of the last century.\n", + " ```python\n", + " ! wget https://www.dropbox.com/s/3vigxoqayo389uc/populations.txt\n", + " ```\n", + "\n", + " * Check the content by looking within the file\n", + " * Load the data (use an appropriate numpy method) into a 2D array\n", + " * Create arrays out of the columns, the arrays being (in order): *year*, *hares*, *lynxes*, *carrots* \n", + " * Plot the 3 populations over the years\n", + " * Compute the main statistical properties of the dataset (mean, std, correlations, etc.)\n", + " * Which species has the highest population each year?\n", + "\n", + "Do you feel there is some evident correlation here? [Studies](https://www.enr.gov.nt.ca/en/services/lynx/lynx-snowshoe-hare-cycle) tend to believe so." + ] + }, + { + "cell_type": "code", + "execution_count": 9, + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "--2018-11-15 09:23:57-- https://www.dropbox.com/s/3vigxoqayo389uc/populations.txt\n", + "Resolving www.dropbox.com (www.dropbox.com)... 162.125.69.1, 2620:100:6025:1::a27d:4501\n", + "Connecting to www.dropbox.com (www.dropbox.com)|162.125.69.1|:443... connected.\n", + "HTTP request sent, awaiting response... 301 Moved Permanently\n", + "Location: /s/raw/3vigxoqayo389uc/populations.txt [following]\n", + "--2018-11-15 09:23:57-- https://www.dropbox.com/s/raw/3vigxoqayo389uc/populations.txt\n", + "Reusing existing connection to www.dropbox.com:443.\n", + "HTTP request sent, awaiting response... 302 Found\n", + "Location: https://uc3d1b3890ced912dfc41a3792f8.dl.dropboxusercontent.com/cd/0/inline/AVrOImCAdQbDj7JlsBD5DAVO1pnmhItd8TsqzQeoFx8ztp9Uusq2aLz_V79o_Gia0qsW5CrnoPzdsKeoWBUVcnPKIgn3f_ZXepgm8ZPNbNFAdH-ORFreOWM5Uk_rn0z8D_96tyPuzFf087sx-qPkbguopQ_FsINUWIO7Chw7UMHWh-kbHEKZBh-Fju-CamaQDVM/file [following]\n", + "--2018-11-15 09:23:57-- https://uc3d1b3890ced912dfc41a3792f8.dl.dropboxusercontent.com/cd/0/inline/AVrOImCAdQbDj7JlsBD5DAVO1pnmhItd8TsqzQeoFx8ztp9Uusq2aLz_V79o_Gia0qsW5CrnoPzdsKeoWBUVcnPKIgn3f_ZXepgm8ZPNbNFAdH-ORFreOWM5Uk_rn0z8D_96tyPuzFf087sx-qPkbguopQ_FsINUWIO7Chw7UMHWh-kbHEKZBh-Fju-CamaQDVM/file\n", + "Resolving uc3d1b3890ced912dfc41a3792f8.dl.dropboxusercontent.com (uc3d1b3890ced912dfc41a3792f8.dl.dropboxusercontent.com)... 162.125.69.6, 2620:100:6025:6::a27d:4506\n", + "Connecting to uc3d1b3890ced912dfc41a3792f8.dl.dropboxusercontent.com (uc3d1b3890ced912dfc41a3792f8.dl.dropboxusercontent.com)|162.125.69.6|:443... connected.\n", + "HTTP request sent, awaiting response... 200 OK\n", + "Length: 525 [text/plain]\n", + "Saving to: ‘populations.txt.2’\n", + "\n", + "populations.txt.2 100%[===================>] 525 --.-KB/s in 0s \n", + "\n", + "2018-11-15 09:23:58 (70,6 MB/s) - ‘populations.txt.2’ saved [525/525]\n", + "\n" + ] + } + ], + "source": [ + "! wget https://www.dropbox.com/s/3vigxoqayo389uc/populations.txt\n" + ] + }, + { + "cell_type": "code", + "execution_count": 10, + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "Average number of hares, median and standard deviation: 34080.95238095238 25400.0 20897.906458089667\n", + "Average number of linxes, median and standard deviation: 20166.666666666668 12300.0 16254.591536908763\n", + "Average number of carrots, median and standard deviation: 42400.0 41800.0 3322.5062255844787\n", + "1900 carrots\n", + "1901 carrots\n", + "1902 hares\n", + "1903 hares\n", + "1904 linxes\n", + "1905 linxes\n", + "1906 carrots\n", + "1907 carrots\n", + "1908 carrots\n", + "1909 carrots\n", + "1910 carrots\n", + "1911 carrots\n", + "1912 hares\n", + "1913 hares\n", + "1914 hares\n", + "1915 linxes\n", + "1916 carrots\n", + "1917 carrots\n", + "1918 carrots\n", + "1919 carrots\n" + ] + }, + { + "data": { + "image/png": "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\n", + "text/plain": [ + "
" + ] + }, + "metadata": { + "needs_background": "light" + }, + "output_type": "display_data" + } + ], + "source": [ + "#9 YEARS DA RIVEDERE\n", + "data=np.genfromtxt(\"populations.txt\", skip_header = 1)\n", + "#print(data)\n", + "year = data[:,0]\n", + "hares = data[:,1]\n", + "linxes = data[:,2]\n", + "carrots = data[:,3]\n", + "\n", + "\n", + "#plot\n", + "%matplotlib inline \n", + "t = np.arange(int(year[0]),int(year[len(year)-1]))\n", + "i = [x for x in range(len(t))]\n", + "\n", + "plt.plot(t, hares[i], \"r\")\n", + "plt.plot(t, linxes[i], \"b\")\n", + "plt.plot(t, carrots[i], \"g\")\n", + "\n", + "#statistical properties\n", + "print(\"Average number of hares, median and standard deviation:\",hares.mean(),np.median(hares),hares.std())\n", + "print(\"Average number of linxes, median and standard deviation:\",linxes.mean(),np.median(linxes),linxes.std())\n", + "print(\"Average number of carrots, median and standard deviation:\",carrots.mean(),np.median(carrots),carrots.std())\n", + "\n", + "#max population\n", + "labels = [\"year\",\"hares\",\"linxes\",\"carrots\"]\n", + "for i in range(len(t)):\n", + " print(t[i], labels[np.argmax(data[i,])])\n" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "metadata": {}, + "outputs": [], + "source": [] + } + ], + "metadata": { + "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.6.6" + } + }, + "nbformat": 4, + "nbformat_minor": 2 +}