Exercises/07 Exercises.ipynb

{
 "cells": [
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Make NumPy available:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "import numpy as np"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Exercise 07.1 (indexing and timing)\n",
    "\n",
    "Create two very long NumPy arrays `x` and `y` and sum the arrays using:\n",
    "\n",
    "1. The NumPy addition syntax, `z = x + y`; and\n",
    "2. A `for` loop that computes the sum entry-by-entry\n",
    "\n",
    "Compare the time required for the two approaches for vectors of different lengths (use a very long vector for \n",
    "the timing). The values of the array entries are not important for this test. Use `%time` to report the time.\n",
    "\n",
    "*Hint:* To loop over an array using indices, try a construction like:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "x = np.ones(10)\n",
    "y = np.ones(len(x))\n",
    "for i in range(len(x)):\n",
    "    print(x[i]*y[i])"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "#### (1) Add two vectors using built-in addition operator:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "deletable": false,
    "nbgrader": {
     "checksum": "4b3a6fbbfcbe89681e9e2f04cab73d67",
     "grade": false,
     "grade_id": "cell-2c856e54f7c3340e",
     "locked": false,
     "schema_version": 1,
     "solution": true
    }
   },
   "outputs": [],
   "source": [
    "# YOUR CODE HERE\n",
    "raise NotImplementedError()"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "#### (2) Add two vectors using own implementation:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "deletable": false,
    "nbgrader": {
     "checksum": "f5195f8b039c21a10b079fa7129adf0a",
     "grade": false,
     "grade_id": "cell-f34614f9f0068cc4",
     "locked": false,
     "schema_version": 1,
     "solution": true
    }
   },
   "outputs": [],
   "source": [
    "# YOUR CODE HERE\n",
    "raise NotImplementedError()"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Exercise 07.2 (member functions and slicing)\n",
    "\n",
    "Anonymised scores (out of 60) for an examination are stored in a NumPy array. Write:\n",
    "\n",
    "1. A function that takes a NumPy array of the raw scores and returns the scores as percentages, sorted from \n",
    "   lowest to highest (try using `scores.sort()`, where `scores` is a NumPy array holding the scores).\n",
    "1. A function that returns the maximum, minimum and mean of the raw scores as a dictionary with the \n",
    "   keys '`min`', '`max`' and '`mean`'. Use the NumPy array functions `min()`, `max()` and `mean()` to do the \n",
    "   computation, e.g. `max = scores.max()`.  \n",
    "   \n",
    "   Design your function for the min, max and mean to optionally exclude the highest and lowest scores from the \n",
    "   computation of the min, max and mean. \n",
    "   \n",
    "   *Hint:* sort the array of scores and use array slicing to exclude\n",
    "   the first and the last entries.\n",
    "\n",
    "Use the scores \n",
    "```python\n",
    "scores = np.array([58.0, 35.0, 24.0, 42, 7.8])\n",
    "```\n",
    "to test your functions."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "deletable": false,
    "nbgrader": {
     "checksum": "0d3f6132335348940f562c8a70c520e9",
     "grade": false,
     "grade_id": "cell-169ebae60810c6be",
     "locked": false,
     "schema_version": 1,
     "solution": true
    }
   },
   "outputs": [],
   "source": [
    "def to_percentage_and_sort(scores):\n",
    "    # YOUR CODE HERE\n",
    "    raise NotImplementedError()\n",
    "\n",
    "def statistics(scores, exclude=False):\n",
    "    # YOUR CODE HERE\n",
    "    raise NotImplementedError()"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "deletable": false,
    "editable": false,
    "nbgrader": {
     "checksum": "49817c794fad305adbe95251448b7bf2",
     "grade": true,
     "grade_id": "cell-af0b6fd8a3cadb1a",
     "locked": true,
     "points": 0,
     "schema_version": 1,
     "solution": false
    }
   },
   "outputs": [],
   "source": [
    "scores = np.array([58.0, 35.0, 24.0, 42, 7.8])\n",
    "assert np.isclose(to_percentage_and_sort(scores), [ 13.0, 40.0, 58.33333333,  70.0, 96.66666667]).all()\n",
    "\n",
    "s0 = statistics(scores)\n",
    "assert round(s0[\"min\"] - 7.8, 10) == 0.0\n",
    "assert round(s0[\"mean\"] - 33.36, 10) == 0.0\n",
    "assert round(s0[\"max\"] - 58.0, 10) == 0.0\n",
    "\n",
    "s1 = statistics(scores, True)\n",
    "assert round(s1[\"min\"] - 24.0, 10) == 0.0\n",
    "assert round(s1[\"mean\"] - 33.666666666666666667, 10) == 0.0\n",
    "assert round(s1[\"max\"] - 42.0, 10) == 0.0"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "deletable": false,
    "editable": false,
    "nbgrader": {
     "checksum": "59fe9ff8629e2b641f8c654b3c0c36ee",
     "grade": false,
     "grade_id": "cell-27beb42d6b15acad",
     "locked": true,
     "schema_version": 1,
     "solution": false
    }
   },
   "source": [
    "## Exercise 07.3 (slicing)\n",
    "\n",
    "For the two-dimensional array"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "deletable": false,
    "editable": false,
    "nbgrader": {
     "checksum": "72617327e9686e23fc46fd8b050dfddc",
     "grade": false,
     "grade_id": "cell-73a8893e46856789",
     "locked": true,
     "schema_version": 1,
     "solution": false
    }
   },
   "outputs": [],
   "source": [
    "A = np.array([[4.0, 7.0, -2.43, 67.1],\n",
    "             [-4.0, 64.0, 54.7, -3.33],\n",
    "             [2.43, 23.2, 3.64, 4.11],\n",
    "             [1.2, 2.5, -113.2, 323.22]])\n",
    "print(A)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "use array slicing for the below operations, printing the results to the screen to check. Try to use array slicing such that your code would still work if the dimensions of `A` were enlarged.\n",
    "\n"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "deletable": false,
    "editable": false,
    "nbgrader": {
     "checksum": "6d041f0cf31860711599e3ee7b3491a3",
     "grade": false,
     "grade_id": "cell-f6744c8a86e68cac",
     "locked": true,
     "schema_version": 1,
     "solution": false
    }
   },
   "source": [
    "#### 1. Extract the third column as a 1D array"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "deletable": false,
    "nbgrader": {
     "checksum": "b64ade07370f5fee0946cac30ec0e2ad",
     "grade": false,
     "grade_id": "cell-dfee6b0ed9343682",
     "locked": false,
     "schema_version": 1,
     "solution": true
    }
   },
   "outputs": [],
   "source": [
    "# YOUR CODE HERE\n",
    "raise NotImplementedError()"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "#### 2. Extract the first two rows as a 2D sub-array"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "deletable": false,
    "nbgrader": {
     "checksum": "1501ee7c2e53e803ab2ee91f060600f6",
     "grade": true,
     "grade_id": "cell-7bf2f9a8c67029f8",
     "locked": false,
     "points": 0,
     "schema_version": 1,
     "solution": true
    }
   },
   "outputs": [],
   "source": [
    "# YOUR CODE HERE\n",
    "raise NotImplementedError()"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "#### 3.  Extract the bottom-right $2 \\times 2$ block as a 2D sub-array"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "deletable": false,
    "nbgrader": {
     "checksum": "f71dc316fa8df4bfd0d201a822e3649b",
     "grade": false,
     "grade_id": "cell-5206fea47d246222",
     "locked": false,
     "schema_version": 1,
     "solution": true
    }
   },
   "outputs": [],
   "source": [
    "# YOUR CODE HERE\n",
    "raise NotImplementedError()"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "#### 4. Sum the last column"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "deletable": false,
    "nbgrader": {
     "checksum": "e838dfdea65683c219df150d9e896d98",
     "grade": false,
     "grade_id": "cell-34f74988e47b9f87",
     "locked": false,
     "schema_version": 1,
     "solution": true
    }
   },
   "outputs": [],
   "source": [
    "# YOUR CODE HERE\n",
    "raise NotImplementedError()"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "#### Compute transpose\n",
    "\n",
    "Compute the transpose of `A` (search online to find the function/syntax to do this)."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "deletable": false,
    "nbgrader": {
     "checksum": "b9cbe5f84f05129cbc0152ce8c36f470",
     "grade": false,
     "grade_id": "cell-dd2999d2da8070f6",
     "locked": false,
     "schema_version": 1,
     "solution": true
    }
   },
   "outputs": [],
   "source": [
    "# YOUR CODE HERE\n",
    "raise NotImplementedError()"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "deletable": false,
    "editable": false,
    "nbgrader": {
     "checksum": "f68e05e6631a183befcd0eea778623a2",
     "grade": false,
     "grade_id": "cell-f1255669c8aa78d2",
     "locked": true,
     "schema_version": 1,
     "solution": false
    }
   },
   "source": [
    "## Exercise 07.4 (optional extension)\n",
    "\n",
    "In a previous exercise you implemented the bisection algorithm to find approximate roots of a mathematical function. Use the SciPy bisection function `optimize.bisect` (http://docs.scipy.org/doc/scipy-0.14.0/reference/generated/scipy.optimize.bisect.html) to find roots of the mathematical function that was used in the previous exercise. Compare the results computed by SciPy and your program from the earlier exercise, and compare the computational time (using `%time`)."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "deletable": false,
    "nbgrader": {
     "checksum": "ed949860804630c700d7f9885647c14d",
     "grade": false,
     "grade_id": "cell-b6580accbcb3c2da",
     "locked": false,
     "schema_version": 1,
     "solution": true
    }
   },
   "outputs": [],
   "source": [
    "from scipy import optimize\n",
    "\n",
    "# YOUR CODE HERE\n",
    "raise NotImplementedError()"
   ]
  }
 ],
 "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.5.3"
  }
 },
 "nbformat": 4,
 "nbformat_minor": 1
}