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 1D-arrays (vectors) `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 arrays of different lengths (use a very long array 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 arrays using built-in addition operator:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "nbgrader": {
     "grade": false,
     "grade_id": "cell-2c856e54f7c3340e",
     "locked": false,
     "schema_version": 3,
     "solution": true
    },
    "tags": []
   },
   "outputs": [],
   "source": [
    "..."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "#### (2) Add two arrays using own implementation:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "nbgrader": {
     "grade": false,
     "grade_id": "cell-f34614f9f0068cc4",
     "locked": false,
     "schema_version": 3,
     "solution": true
    },
    "tags": []
   },
   "outputs": [],
   "source": [
    "..."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Optional extension: just-in-time (JIT) compilation\n",
    "\n",
    "You will see a large difference in the time required between your NumPy and 'plain' Python implementations. This is due to Python being an *interpreted* language as opposed to a *compiled* language. A way to speed up plain Python implementions is to convert the interpreted Python code into compiled code. A tool for doing this is [Numba](https://numba.pydata.org/).\n",
    "\n",
    "Below is an example using Numba and JIT to accelerate a computation:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "!pip -q install numba \n",
    "import numba\n",
    "import math\n",
    "\n",
    "def compute_sine_native(x):\n",
    "    z = np.zeros(len(x))\n",
    "    for i in range(len(z)):\n",
    "        z[i] = math.sin(x[i])\n",
    "    return z\n",
    "\n",
    "@numba.jit\n",
    "def compute_sine_jit(x):\n",
    "    z = np.zeros(len(x))\n",
    "    for i in range(len(z)):\n",
    "        z[i] = math.sin(x[i])\n",
    "    return z\n",
    "    \n",
    "x = np.ones(10000000)\n",
    "%time z = compute_sine_native(x)\n",
    "compute_sine_jit(x)\n",
    "%time z = compute_sine_jit(x)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "**Task:** Test if Numba can be used to accelerate your implementation that uses indexing to sum two arrays, and by how much."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "tags": []
   },
   "outputs": [],
   "source": [
    "..."
   ]
  },
  {
   "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": {
    "nbgrader": {
     "grade": false,
     "grade_id": "cell-169ebae60810c6be",
     "locked": false,
     "schema_version": 3,
     "solution": true
    },
    "tags": []
   },
   "outputs": [],
   "source": [
    "def to_percentage_and_sort(scores):\n",
    "    ...\n",
    "\n",
    "def statistics(scores, exclude=False):\n",
    "    ..."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "nbgrader": {
     "grade": true,
     "grade_id": "cell-af0b6fd8a3cadb1a",
     "locked": true,
     "points": 0,
     "schema_version": 3,
     "solution": false
    }
   },
   "outputs": [],
   "source": [
    "## tests ##\n",
    "\n",
    "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 np.isclose(s0[\"min\"], 7.8)\n",
    "assert np.isclose(s0[\"mean\"], 33.36)\n",
    "assert np.isclose(s0[\"max\"], 58.0)\n",
    "\n",
    "s1 = statistics(scores, True)\n",
    "assert np.isclose(s1[\"min\"], 24.0)\n",
    "assert np.isclose(s1[\"mean\"], 33.666666666666666667)\n",
    "assert np.isclose(s1[\"max\"], 42.0)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "nbgrader": {
     "grade": false,
     "grade_id": "cell-27beb42d6b15acad",
     "locked": true,
     "schema_version": 3,
     "solution": false
    }
   },
   "source": [
    "## Exercise 07.3 (slicing)\n",
    "\n",
    "For the two-dimensional array"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "nbgrader": {
     "grade": false,
     "grade_id": "cell-73a8893e46856789",
     "locked": true,
     "schema_version": 3,
     "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",
    "**Check your results carefully against hand computations.**"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "nbgrader": {
     "grade": false,
     "grade_id": "cell-f6744c8a86e68cac",
     "locked": true,
     "schema_version": 3,
     "solution": false
    }
   },
   "source": [
    "#### 1. Extract the third column as a 1D array"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "nbgrader": {
     "grade": false,
     "grade_id": "cell-dfee6b0ed9343682",
     "locked": false,
     "schema_version": 3,
     "solution": true
    },
    "tags": []
   },
   "outputs": [],
   "source": [
    "..."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "#### 2. Extract the first two rows as a 2D sub-array"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "nbgrader": {
     "grade": true,
     "grade_id": "cell-7bf2f9a8c67029f8",
     "locked": false,
     "points": 0,
     "schema_version": 3,
     "solution": true
    },
    "tags": []
   },
   "outputs": [],
   "source": [
    "..."
   ]
  },
  {
   "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": {
    "nbgrader": {
     "grade": false,
     "grade_id": "cell-5206fea47d246222",
     "locked": false,
     "schema_version": 3,
     "solution": true
    },
    "tags": []
   },
   "outputs": [],
   "source": [
    "..."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "#### 4. Sum the last column"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "nbgrader": {
     "grade": false,
     "grade_id": "cell-34f74988e47b9f87",
     "locked": false,
     "schema_version": 3,
     "solution": true
    },
    "tags": []
   },
   "outputs": [],
   "source": [
    "..."
   ]
  },
  {
   "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": {
    "nbgrader": {
     "grade": false,
     "grade_id": "cell-dd2999d2da8070f6",
     "locked": false,
     "schema_version": 3,
     "solution": true
    },
    "tags": []
   },
   "outputs": [],
   "source": [
    "..."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "nbgrader": {
     "grade": false,
     "grade_id": "cell-f1255669c8aa78d2",
     "locked": true,
     "schema_version": 3,
     "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` (https://docs.scipy.org/doc/scipy/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": {
    "nbgrader": {
     "grade": false,
     "grade_id": "cell-b6580accbcb3c2da",
     "locked": false,
     "schema_version": 3,
     "solution": true
    },
    "tags": []
   },
   "outputs": [],
   "source": [
    "from scipy import optimize\n",
    "\n",
    "..."
   ]
  }
 ],
 "metadata": {
  "celltoolbar": "Create Assignment",
  "kernelspec": {
   "display_name": "Python 3 (ipykernel)",
   "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.10.6"
  },
  "otter": {
   "OK_FORMAT": true,
   "assignment_name": "Exercises 7",
   "tests": {}
  }
 },
 "nbformat": 4,
 "nbformat_minor": 4
}