5_NumPy.ipynb

{
 "cells": [
  {
   "cell_type": "code",
   "execution_count": 1,
   "metadata": {
    "tags": []
   },
   "outputs": [
    {
     "data": {
      "text/html": [
       "<style>table {align:left;display:block} </style>"
      ],
      "text/plain": [
       "<IPython.core.display.HTML object>"
      ]
     },
     "execution_count": 1,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "from IPython.core.display import HTML\n",
    "table_css = 'table {align:left;display:block} '\n",
    "HTML('<style>{}</style>'.format(table_css))"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "# **ASI WA Python Workshop**"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "tags": []
   },
   "source": [
    "## **Jupyter Notebook Tips**\n",
    "\n",
    "Outside of a cell:\n",
    "\n",
    "| key combo | action |\n",
    "| :--: | ---- |\n",
    "| shift+enter |  run a cell |\n",
    "| b |  insert cell below | \n",
    "| a |  insert cell above |\n",
    "| dd | delete selected cell |\n",
    "\n",
    "<br>\n",
    "Within a cell:\n",
    "\n",
    "| key combo | action |\n",
    "| :--: | ---- |\n",
    "| Command + / |  comment out line(s) |\n",
    "| Alt + Cursor | vertical selection |\n",
    "\n",
    "**Control = Command\n",
    "<br><br><br>"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "---\n",
    "<a id='1.1'></a>"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "<br>\n",
    "\n",
    "**Some of the content for this notebook is from the individual listed below, but I have edited it for clarity and added content that I believe you will find more useful.**\n",
    "<br><br>"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Author: Nicolai Riis, DTU Compute, July 2017.\n",
    "\n",
    "For the original content that these notebooks are based upon please see:\n",
    "\n",
    "* https://github.com/jhamrick/nbgrader-demo/tree/master/instructor/source/ps1\n",
    "* https://github.com/jrjohansson/scientific-python-lectures\n"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "---\n",
    "<a id='1.1'></a>"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "# **NumPy**\n",
    "NumPy, short for Numerical Python, is a widely-used Python package for numerical computations. It is so popular it is considered part of the Python trinity (NumPy, Pandas, MatPlotLib). It provides high-performance data structures for handling arrays of numbers, such as vectors and matrices. Under the hood, numpy is programmed in C and Fortran, making it super fast.\n",
    "\n",
    "When using NumPy, we just need to import the module as we've done before. However people often use the shorthand `np` to refer to `numpy` for convenience. So, instead of writing `numpy.function()`, we can simply write `np.function()`."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 2,
   "metadata": {},
   "outputs": [],
   "source": [
    "import numpy as np"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "nbgrader": {
     "grade": false,
     "locked": false,
     "schema_version": 1,
     "solution": false
    }
   },
   "source": [
    "NumPy is incredibly powerful and has many features, but this can be a bit intimidating when you're first starting to use it. If you are familiar with other scientific computing languages, the following guides may be of use:\n",
    "* NumPy for Matlab Users: http://mathesaurus.sourceforge.net/matlab-numpy.html\n",
    "* NumPy for R (and S-Plus) Users: http://mathesaurus.sourceforge.net/r-numpy.html\n",
    "\n",
    "Here we'll go over the most common NumPy features."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "---\n",
    "<a id='2.1'></a>"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "nbgrader": {
     "grade": false,
     "locked": false,
     "schema_version": 1,
     "solution": false
    }
   },
   "source": [
    "## **Arrays**\n",
    "The core component of NumPy is the `ndarray`, which is pronounced like \"N-D array\" (i.e., 1-D, 2-D, ..., N-D). We'll use both the terms ndarray and \"array\" interchangeably. For now, we're going to stick to just 1-D arrays -- we'll get to multidimensional arrays later.\n",
    "\n",
    "Arrays are very similar to `lists`. Let's first review how lists work. Remember that we can create them using square brackets:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 3,
   "metadata": {
    "nbgrader": {
     "grade": false,
     "locked": false,
     "schema_version": 1,
     "solution": false
    }
   },
   "outputs": [
    {
     "data": {
      "text/plain": [
       "[3, 6, 1, 0, 10, 3]"
      ]
     },
     "execution_count": 3,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "mylist = [3, 6, 1, 0, 10, 3]\n",
    "mylist"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "nbgrader": {
     "grade": false,
     "locked": false,
     "schema_version": 1,
     "solution": false
    }
   },
   "source": [
    "And we can access an element via its *index*. To get the first element, we use an index of 0:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 4,
   "metadata": {
    "nbgrader": {
     "grade": false,
     "locked": false,
     "schema_version": 1,
     "solution": false
    }
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "The first element of 'mylist' is: 3\n"
     ]
    }
   ],
   "source": [
    "print(\"The first element of 'mylist' is: \" + str(mylist[0]))"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "nbgrader": {
     "grade": false,
     "locked": false,
     "schema_version": 1,
     "solution": false
    }
   },
   "source": [
    "To get the second element, we use an index of 1:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 5,
   "metadata": {
    "nbgrader": {
     "grade": false,
     "locked": false,
     "schema_version": 1,
     "solution": false
    }
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "The second element of 'mylist' is: 6\n"
     ]
    }
   ],
   "source": [
    "print(\"The second element of 'mylist' is: \" + str(mylist[1]))"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "nbgrader": {
     "grade": false,
     "locked": false,
     "schema_version": 1,
     "solution": false
    }
   },
   "source": [
    "And so on."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "nbgrader": {
     "grade": false,
     "locked": false,
     "schema_version": 1,
     "solution": false
    }
   },
   "source": [
    "Arrays work very similarly. The first way to create an array is from an already existing list:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 6,
   "metadata": {
    "nbgrader": {
     "grade": false,
     "locked": false,
     "schema_version": 1,
     "solution": false
    }
   },
   "outputs": [
    {
     "data": {
      "text/plain": [
       "array([ 3,  6,  1,  0, 10,  3])"
      ]
     },
     "execution_count": 6,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "myarray = np.array(mylist) # equivalent to np.array([3, 6, 1, 0, 10, 3])\n",
    "myarray"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "nbgrader": {
     "grade": false,
     "locked": false,
     "schema_version": 1,
     "solution": false
    }
   },
   "source": [
    "<div class=\"alert alert-info\">\n",
    "Notice that <code>myarray</code> looks different than <code>mylist</code> -- it actually tells you that it's an array. If we take a look at the <i>types</i> of <code>mylist</code> and <code>myarray</code>, we will also see that one is a list and one is an array. Using <code>type</code> can be a very useful way to verify that your variables contain what you want them to contain:\n",
    "</div>"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 7,
   "metadata": {
    "nbgrader": {
     "grade": false,
     "locked": false,
     "schema_version": 1,
     "solution": false
    }
   },
   "outputs": [
    {
     "data": {
      "text/plain": [
       "list"
      ]
     },
     "execution_count": 7,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "# look at what type mylist is\n",
    "type(mylist)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 8,
   "metadata": {
    "nbgrader": {
     "grade": false,
     "locked": false,
     "schema_version": 1,
     "solution": false
    }
   },
   "outputs": [
    {
     "data": {
      "text/plain": [
       "numpy.ndarray"
      ]
     },
     "execution_count": 8,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "# look at what type myarray is\n",
    "type(myarray)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "nbgrader": {
     "grade": false,
     "locked": false,
     "schema_version": 1,
     "solution": false
    }
   },
   "source": [
    "We can get elements from a NumPy array in exactly the same way as we get elements from a list:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 9,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "array([ 3,  6,  1,  0, 10,  3])"
      ]
     },
     "execution_count": 9,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "myarray"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 10,
   "metadata": {
    "nbgrader": {
     "grade": false,
     "locked": false,
     "schema_version": 1,
     "solution": false
    }
   },
   "outputs": [
    {
     "data": {
      "text/plain": [
       "6"
      ]
     },
     "execution_count": 10,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "myarray[1]"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "The numpy.ndarray may initially resemble a Python list or nested list. You might wonder why we need a new array type instead of just using Python lists for computations.\n",
    "\n",
    "Here are a few reasons:\n",
    "- Python lists are quite versatile and can hold any kind of object. However, they lack built-in support for mathematical functions like matrix and dot multiplications.\n",
    "- Numpy arrays, on the other hand, are specifically designed for numerical computations. They are statically typed and ensure that the elements have a consistent type throughout the array.\n",
    "- Numpy arrays are also memory efficient, providing better performance and reducing memory overhead compared to Python lists.\n",
    "\n",
    "By utilizing the dtype (data type) property of an ndarray, we can easily identify the type of data stored within the array."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 11,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "[ 3  6  1  0 10  3] \n",
      " is of type int64\n"
     ]
    }
   ],
   "source": [
    "print( f'{myarray} \\n is of type {myarray.dtype}')"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Methods for Arrays  "
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Like `range()` for a list, we can generate an array with regularly spaced values within a specified range"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 12,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "array([0, 1, 2, 3, 4, 5, 6, 7, 8, 9])"
      ]
     },
     "execution_count": 12,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "# create a range\n",
    "x = np.arange(0, 10, 1) # arguments: start, stop, step\n",
    "x"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "A useful function for plotting mathematical functions is \"linespace\". Linespace returns evenly spaced numbers over a specified interval. We specify the starting point of the sequence and the ending point of the sequence. The parameter \"num\" indicates the Number of samples to generate:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 13,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "array([ 0. ,  2.5,  5. ,  7.5, 10. ])"
      ]
     },
     "execution_count": 13,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "# using linspace, both end points ARE included\n",
    "np.linspace( start=0, stop=10, num=5)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "nbgrader": {
     "grade": false,
     "locked": false,
     "schema_version": 1,
     "solution": false
    }
   },
   "source": [
    "One thing that you can do with lists that you *cannot* do with NumPy arrays is adding and removing elements. For example, I can create a list and then add elements to it with `append`:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 14,
   "metadata": {
    "nbgrader": {
     "grade": false,
     "locked": false,
     "schema_version": 1,
     "solution": false
    }
   },
   "outputs": [
    {
     "data": {
      "text/plain": [
       "[7, 2]"
      ]
     },
     "execution_count": 14,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "mylist = []\n",
    "mylist.append(7)\n",
    "mylist.append(2)\n",
    "mylist"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "nbgrader": {
     "grade": false,
     "locked": false,
     "schema_version": 1,
     "solution": false
    }
   },
   "source": [
    "However, you *cannot* do this with NumPy arrays. If you tried to run the following code, for example:\n",
    "\n",
    "```python\n",
    "myarray = np.array([])\n",
    "myarray.append(7)\n",
    "```\n",
    "\n",
    "You'd get an error like this:\n",
    "\n",
    "```\n",
    "---------------------------------------------------------------------------\n",
    "AttributeError                            Traceback (most recent call last)\n",
    "<ipython-input-25-0017a7f2667c> in <module>()\n",
    "      1 myarray = np.array([])\n",
    "----> 2 myarray.append(7)\n",
    "\n",
    "AttributeError: 'numpy.ndarray' object has no attribute 'append'\n",
    "```"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "---\n",
    "<a id='2.1'></a>"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "**NumPy arrays prioritize speed and efficiency over the flexibility of Python lists.**"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "---\n",
    "<a id='2.1'></a>"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "nbgrader": {
     "grade": false,
     "locked": false,
     "schema_version": 1,
     "solution": false
    }
   },
   "source": [
    "<div class=\"alert alert-info\">To create a NumPy array, you must create an array with the correct shape <i>from the beginning</i>. However, the array doesn't have to have all the correct values from the very beginning: these you can fill in later.</div>"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "This is generally not a problem, we can almost always work out what the size or shape of array needs to be. "
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "nbgrader": {
     "grade": false,
     "locked": false,
     "schema_version": 1,
     "solution": false
    }
   },
   "source": [
    "There are a few ways to create a new array with a particular shape:\n",
    "\n",
    "* `np.empty(shape)` -- creates an empty array of shape `shape`\n",
    "* `np.zeros(shape)` -- creates an array of shape `shape` and sets all the elements to zero\n",
    "* `np.ones(shape)` -- creates an array of shape `shape` and sets all the elements to one\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 15,
   "metadata": {
    "nbgrader": {
     "grade": false,
     "locked": false,
     "schema_version": 1,
     "solution": false
    }
   },
   "outputs": [
    {
     "data": {
      "text/plain": [
       "array([[0., 0., 0., 0.],\n",
       "       [0., 0., 0., 0.],\n",
       "       [0., 0., 0., 0.]])"
      ]
     },
     "execution_count": 15,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "arr = np.zeros((3, 4))\n",
    "arr"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "nbgrader": {
     "grade": false,
     "locked": false,
     "schema_version": 1,
     "solution": false
    }
   },
   "source": [
    "<div class=\"alert alert-info\">\n",
    "The *shape* of the array is a very important concept. You can always get the shape of an array by accessing its <code>shape</code> attribute:\n",
    "</div>"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 16,
   "metadata": {
    "nbgrader": {
     "grade": false,
     "locked": false,
     "schema_version": 1,
     "solution": false
    }
   },
   "outputs": [
    {
     "data": {
      "text/plain": [
       "(3, 4)"
      ]
     },
     "execution_count": 16,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "arr.shape"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "nbgrader": {
     "grade": false,
     "locked": false,
     "schema_version": 1,
     "solution": false
    }
   },
   "source": [
    "Note that for 1-D arrays, the shape returned by the `shape` attribute is still a tuple, even though it only has a length of one:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 17,
   "metadata": {
    "nbgrader": {
     "grade": false,
     "locked": false,
     "schema_version": 1,
     "solution": false
    }
   },
   "outputs": [
    {
     "data": {
      "text/plain": [
       "(3,)"
      ]
     },
     "execution_count": 17,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "np.zeros(3).shape"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "nbgrader": {
     "grade": false,
     "locked": false,
     "schema_version": 1,
     "solution": false
    }
   },
   "source": [
    "This also means that we can *create* 1-D arrays by passing a length one tuple. Thus, the following two arrays are identical:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 18,
   "metadata": {
    "nbgrader": {
     "grade": false,
     "locked": false,
     "schema_version": 1,
     "solution": false
    }
   },
   "outputs": [
    {
     "data": {
      "text/plain": [
       "array([0., 0., 0.])"
      ]
     },
     "execution_count": 18,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "np.zeros((3,))"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 19,
   "metadata": {
    "nbgrader": {
     "grade": false,
     "locked": false,
     "schema_version": 1,
     "solution": false
    }
   },
   "outputs": [
    {
     "data": {
      "text/plain": [
       "array([0., 0., 0.])"
      ]
     },
     "execution_count": 19,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "np.zeros(3)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "nbgrader": {
     "grade": false,
     "locked": false,
     "schema_version": 1,
     "solution": false
    }
   },
   "source": [
    "<div class=\"alert alert-danger\">There is a warning that goes with this, however: be careful to always use tuples to specify the shape when you are creating multidimensional arrays. For example, to create an array of zeros with shape <code>(3, 4)</code>, we <b>must</b> use <code>np.zeros((3, 4))</code>. The following <b>will not work</b>:</div>\n",
    "\n",
    "```python\n",
    "np.zeros(3, 4)\n",
    "```\n",
    "\n",
    "It will give an error like this:\n",
    "\n",
    "```\n",
    "---------------------------------------------------------------------------\n",
    "TypeError                                 Traceback (most recent call last)\n",
    "<ipython-input-39-06beb765944a> in <module>()\n",
    "----> 1 np.zeros(3, 4)\n",
    "\n",
    "TypeError: data type not understood\n",
    "```\n",
    "\n",
    "This is because the second argument to `np.zeros` is the data type, so numpy thinks you are trying to create an array of zeros with shape `(3,)` and datatype `4`. It (understandably) doesn't know what you mean by a datatype of `4`, and so throws an error."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "nbgrader": {
     "grade": false,
     "locked": false,
     "schema_version": 1,
     "solution": false
    }
   },
   "source": [
    "<div class=\"alert alert-info\">\n",
    "Another important concept is the <i>size</i> of the array -- in other words, how many elements are in it. This is equivalent to the length of the array, for 1-D arrays, but not for multidimensional arrays. You can also see the total size of the array with the <code>size</code> attribute:\n",
    "</div>"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 20,
   "metadata": {
    "nbgrader": {
     "grade": false,
     "locked": false,
     "schema_version": 1,
     "solution": false
    }
   },
   "outputs": [
    {
     "data": {
      "text/plain": [
       "12"
      ]
     },
     "execution_count": 20,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "arr = np.zeros((3, 4))\n",
    "arr.size"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "nbgrader": {
     "grade": false,
     "locked": false,
     "schema_version": 1,
     "solution": false
    }
   },
   "source": [
    "We can also create arrays and then reshape them into any shape, provided the new array has the same size as the old array:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 21,
   "metadata": {
    "nbgrader": {
     "grade": false,
     "locked": false,
     "schema_version": 1,
     "solution": false
    }
   },
   "outputs": [
    {
     "data": {
      "text/plain": [
       "array([[ 0,  1,  2,  3],\n",
       "       [ 4,  5,  6,  7],\n",
       "       [ 8,  9, 10, 11],\n",
       "       [12, 13, 14, 15],\n",
       "       [16, 17, 18, 19],\n",
       "       [20, 21, 22, 23],\n",
       "       [24, 25, 26, 27],\n",
       "       [28, 29, 30, 31]])"
      ]
     },
     "execution_count": 21,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "arr = np.arange(32).reshape((8, 4))\n",
    "arr"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "#### *Task 5.1: Creating NumPy Arrays*\n",
    "\n",
    "1. Create a NumPy array using np.linspace to generate a sequence of 11 evenly spaced values between 0 and 100.\n",
    "\n",
    "2. Create an empty NumPy 1D array with a size of 7 using np.empty and print the size\n",
    "\n",
    "3. Create a NumPy array of shape 5x5 filled with ones using np.ones and print the shape of the array.\n",
    "\n",
    "4. Create a NumPy array of shape 4x6 filled with zeros using np.zeros and reshape it to 8x3. Print the shape before and after reshaping. "
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 22,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "(7,)\n",
      "(5, 5)\n",
      "(4, 6)\n",
      "(8, 3)\n"
     ]
    }
   ],
   "source": [
    "# Task 5.1\n",
    "lspace = np.linspace(start=0, stop=100, num=11)\n",
    "\n",
    "emp = np.empty(shape=7)\n",
    "print(emp.shape)\n",
    "\n",
    "print( np.ones((5,5)).shape)\n",
    "\n",
    "zeros = np.zeros((4,6))\n",
    "print( zeros.shape)\n",
    "print( zeros.reshape((8,3)).shape)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "---\n",
    "### Math Functions"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Example of how you would add a scaler to a 2d nested list:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 23,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "[[2, 3, 4], [5, 6, 7]]"
      ]
     },
     "execution_count": 23,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "lst = [[1, 2, 3], \n",
    "       [4, 5, 6]] # 2d array\n",
    "\n",
    "for row_idx, row_val in enumerate(lst):\n",
    "    for col_idx, col_val in enumerate(row_val):\n",
    "        lst[row_idx][col_idx] += 1\n",
    "lst"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "We can accomplish the same using NumPy's `+` for element-wise scalar addition as shown below:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 24,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "array([[2, 3, 4],\n",
       "       [5, 6, 7]])"
      ]
     },
     "execution_count": 24,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "ary = np.array([[1, 2, 3], [4, 5, 6]])\n",
    "ary = ary + 1\n",
    "ary"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "nbgrader": {
     "grade": false,
     "locked": false,
     "schema_version": 1,
     "solution": false
    }
   },
   "source": [
    "We can do the same thing for subtraction, multiplication, etc.:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 25,
   "metadata": {
    "nbgrader": {
     "grade": false,
     "locked": false,
     "schema_version": 1,
     "solution": false
    }
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Subtraction: \t[ 1  4 -1 -2  8  1]\n",
      "Multiplication:\t[ 30  60  10   0 100  30]\n",
      "Squared: \t[  9  36   1   0 100   9]\n",
      "Square root: \t[1.73205081 2.44948974 1.         0.         3.16227766 1.73205081]\n",
      "Exponential: \t[2.00855369e+01 4.03428793e+02 2.71828183e+00 1.00000000e+00\n",
      " 2.20264658e+04 2.00855369e+01]\n"
     ]
    }
   ],
   "source": [
    "print(\"Subtraction: \\t\" + str(myarray - 2))\n",
    "print(\"Multiplication:\\t\" + str(myarray * 10))\n",
    "print(\"Squared: \\t\" + str(myarray ** 2))\n",
    "print(\"Square root: \\t\" + str(np.sqrt(myarray)))\n",
    "print(\"Exponential: \\t\" + str(np.exp(myarray)))"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "nbgrader": {
     "grade": false,
     "locked": false,
     "schema_version": 1,
     "solution": false
    }
   },
   "source": [
    "### Working with multiple arrays"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "nbgrader": {
     "grade": false,
     "locked": false,
     "schema_version": 1,
     "solution": false
    }
   },
   "source": [
    "We can also easily do these operations for multiple arrays. For example, let's say we want to add the corresponding elements of two lists together. Here's how we'd do it with regular lists:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 26,
   "metadata": {
    "nbgrader": {
     "grade": false,
     "locked": false,
     "schema_version": 1,
     "solution": false
    }
   },
   "outputs": [
    {
     "data": {
      "text/plain": [
       "[7, 9, 11, 13, 15]"
      ]
     },
     "execution_count": 26,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "list_a = [1, 2, 3, 4, 5]\n",
    "list_b = [6, 7, 8, 9, 10]\n",
    "\n",
    "list_c = []\n",
    "for i in range(len(list_a)):\n",
    "    list_c.append( list_a[i] + list_b[i])\n",
    "list_c"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "nbgrader": {
     "grade": false,
     "locked": false,
     "schema_version": 1,
     "solution": false
    }
   },
   "source": [
    "With NumPy arrays, we just have to add the arrays together:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 27,
   "metadata": {
    "nbgrader": {
     "grade": false,
     "locked": false,
     "schema_version": 1,
     "solution": false
    }
   },
   "outputs": [
    {
     "data": {
      "text/plain": [
       "array([ 7,  9, 11, 13, 15])"
      ]
     },
     "execution_count": 27,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "array_a = np.array(list_a) # equivalent to np.array([1, 2, 3, 4, 5])\n",
    "array_b = np.array(list_b) # equivalent to np.array([6, 7, 8, 9, 10])\n",
    "array_c = array_a + array_b\n",
    "array_c"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "nbgrader": {
     "grade": false,
     "locked": false,
     "schema_version": 1,
     "solution": false
    }
   },
   "source": [
    "<div class=\"alert alert-warning\">\n",
    "Note: make sure when adding arrays that you are actually working with arrays, because if you try to add two lists, you will *not* get an error. Instead, the lists will be concatenated:\n",
    "</div>"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 28,
   "metadata": {
    "nbgrader": {
     "grade": false,
     "locked": false,
     "schema_version": 1,
     "solution": false
    }
   },
   "outputs": [
    {
     "data": {
      "text/plain": [
       "[1, 2, 3, 4, 5, 6, 7, 8, 9, 10]"
      ]
     },
     "execution_count": 28,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "list_a + list_b"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "nbgrader": {
     "grade": false,
     "locked": false,
     "schema_version": 1,
     "solution": false
    }
   },
   "source": [
    "Just as when we are working with a single array, we can add, subtract, divide, multiply, etc. several arrays together:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 29,
   "metadata": {
    "nbgrader": {
     "grade": false,
     "locked": false,
     "schema_version": 1,
     "solution": false
    }
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Subtraction: \t[-5 -5 -5 -5 -5]\n",
      "Multiplication:\t[ 6 14 24 36 50]\n",
      "Exponent: \t[      1     128    6561  262144 9765625]\n",
      "Division: \t[0.16666667 0.28571429 0.375      0.44444444 0.5       ]\n"
     ]
    }
   ],
   "source": [
    "print(\"Subtraction: \\t\" + str(array_a - array_b))\n",
    "print(\"Multiplication:\\t\" + str(array_a * array_b))\n",
    "print(\"Exponent: \\t\" + str(array_a ** array_b))\n",
    "print(\"Division: \\t\" + str(array_a / array_b))"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "All NumPy operators perform element wise operations (`+`, `-`, `/`, `*`, and `**`):"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 30,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "array([[ 4,  9, 16],\n",
       "       [25, 36, 49]])"
      ]
     },
     "execution_count": 30,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "ary**2"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "NumPy also has implementations of several useful functions that act element wise, such as `log` (natural logarithm), `log10` (base-10 logarithm), and `sqrt` (square root):"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 31,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "array([[1.41421356, 1.73205081, 2.        ],\n",
       "       [2.23606798, 2.44948974, 2.64575131]])"
      ]
     },
     "execution_count": 31,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "np.sqrt(ary)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 32,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "array([0., 1., 2., 3., 4., 5.])"
      ]
     },
     "execution_count": 32,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "np.log10( [1, 10, 100, 1e3, 1e4, 1e5])"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 33,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "array([0.        , 0.84147098, 0.90929743, 0.14112001])"
      ]
     },
     "execution_count": 33,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "np.sin( [0,1,2,3])"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "#### *Task 5.2: Task: Array Manipulation with Addition and Multiplication*\n",
    "\n",
    "1. Create a NumPy array of your choice with desired values.\n",
    "\n",
    "2. Add a scaler, such as 5, to your array from step 1.\n",
    "\n",
    "3. Create another NumPy array with desired values.\n",
    "\n",
    "4. Multiply arrays from step 1 and step 3."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 34,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "add 5 [10 15 20 25]\n",
      "[ 5 10 15 20]\n",
      "array1 None\n",
      "add another array [ 6. 11. 16. 21.]\n",
      "arry * [ 30. 110. 240. 420.]\n"
     ]
    }
   ],
   "source": [
    "# Task 5.2\n",
    "mylist1 = [5,10,15,20]\n",
    "myarr1 = np.array( mylist1)\n",
    "print( 'add 5', myarr1 + 5)\n",
    "\n",
    "print( 'array1', print( myarr1))\n",
    "myarr2 = np.ones(4)\n",
    "myarr3 = myarr1 + myarr2\n",
    "print( 'add another array',myarr3)\n",
    "print( 'arry *', myarr1 * myarr3)\n"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "#### *Task 5.3 Rewrite the list based code below using numpy*\n",
    "```\n",
    "from math import sin, cos\n",
    "import matplotlib.pyplot as plt\n",
    "\n",
    "# generate interval of points in a list\n",
    "interval = range( 0, 50, 1)\n",
    "# get sine values\n",
    "y1 = []\n",
    "x1 = []\n",
    "for ii in interval: \n",
    "    y1.append(sin(ii))\n",
    "    x1.append(cos(ii))\n",
    "\n",
    "# call the plt package and \n",
    "plt.plot(x1, y1)\n",
    "# tell matplotlib to produce the plot\n",
    "plt.show()\n",
    "```"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 35,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "image/png": "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\n",
      "text/plain": [
       "<Figure size 432x288 with 1 Axes>"
      ]
     },
     "metadata": {
      "needs_background": "light"
     },
     "output_type": "display_data"
    }
   ],
   "source": [
    "# Task 5.3\n",
    "%matplotlib inline \n",
    "import matplotlib.pyplot as plt\n",
    "\n",
    "interval = np.arange( 0, 50, 1)\n",
    "y1 = np.sin( interval)\n",
    "x1 = np.cos( interval)\n",
    "\n",
    "# call the plt package and \n",
    "plt.plot(x1, y1)\n",
    "# tell matplotlib to produce the plot\n",
    "plt.show()"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "---\n",
    "### Reduction Functions\n",
    "Reduction functions perform summary operations on arrays or matrices and condense the result into a single value or an array of values based on a specified axis, providing a summary or statistical insight into the data. They are particularly useful when working with large datasets and performing data analysis.\n",
    "\n",
    "By specifying the desired axis parameter, you can control whether the reduction is applied along rows or columns. An axis=0 is along the row axis and an axis=1 is summarized along the column axis.  \n",
    "\n",
    "---"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "This can be confusing....For example:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 36,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "array([[1, 2, 3, 4],\n",
       "       [5, 6, 7, 8]])"
      ]
     },
     "execution_count": 36,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "ary = np.array([[1, 2, 3, 4], [5, 6, 7, 8]])\n",
    "ary"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "When specifying **axis=0**, it means that the operation is applied across the rows. This implies that the resulting output will have the same size as the columns of the input data. \n",
    "\n",
    "In other words, **the operation is performed vertically**, considering each column as a separate entity."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 37,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "array([3., 4., 5., 6.])"
      ]
     },
     "execution_count": 37,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "ary.mean(axis=0) # column mean"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "**When specifying axis=1, the operation is performed horizontally**, considering each row as a separate entity."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 38,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "array([2.5, 6.5])"
      ]
     },
     "execution_count": 38,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "ary.mean(axis=1) # row mean"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "When an axis is not provided the action is performed across the whole array or matrix."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 39,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "4.5"
      ]
     },
     "execution_count": 39,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "ary.mean()"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "There are many useful reduction operations:\n",
    "    \n",
    "- `np.mean` (computes arithmetic mean or average)\n",
    "- `np.std` (computes the standard deviation)\n",
    "- `np.var` (computes variance)\n",
    "- `np.sort` (sorts an array)\n",
    "- `np.argsort` (returns indices that would sort an array)\n",
    "- `np.min` (returns the minimum value of an array)\n",
    "- `np.max` (returns the maximum value of an array)\n",
    "- `np.argmin` (returns the index of the minimum value)\n",
    "- `np.argmax` (returns the index of the maximum value)\n",
    "- `np.array_equal` (checks if two arrays have the same shape and elements)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "#### *Task 5.4: Task: Axis Parameter in NumPy Functions*\n",
    "\n",
    "Using the numpy array below:\n",
    "\n",
    "1. Use the `np.mean()` function to calculate the mean of the entire array. Print the result.\n",
    "\n",
    "2. Use the `np.max()` function to calculate the max along the rows. Print the result.\n",
    "\n",
    "3. Use the `np.var()` function to calculate the variance along the columns. Print the result."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 40,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "whole mean 6.5\n",
      "row maxs [ 4  8 12]\n",
      "col vars [20.66666667 13.55555556  8.22222222  4.66666667]\n"
     ]
    }
   ],
   "source": [
    "# Task 5.4\n",
    "ary = np.array([[ 1,  2,  3, 4], \n",
    "                [ 5,  6,  7, 8], \n",
    "                [12, 11, 10, 9]])\n",
    "\n",
    "print( 'whole mean', np.mean( ary))\n",
    "\n",
    "print( 'row maxs', np.max( ary, axis=1))\n",
    "\n",
    "print( 'col vars', np.var( ary, axis=0))"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "---\n",
    "### Random Data"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 41,
   "metadata": {},
   "outputs": [],
   "source": [
    "from numpy import random"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 42,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "array([[0.01113526, 0.98432242, 0.83729175],\n",
       "       [0.61169148, 0.94937569, 0.39037081],\n",
       "       [0.58262664, 0.14282291, 0.51685207]])"
      ]
     },
     "execution_count": 42,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "# uniform random numbers from 0 to 1\n",
    "random.rand(3,3)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 43,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "array([[-0.86559128, -1.60740461,  0.73854989],\n",
       "       [-1.64333626,  0.82300499,  1.13520432],\n",
       "       [ 0.48245451, -0.43733759,  1.19134162]])"
      ]
     },
     "execution_count": 43,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "# standard normal distributed random numbers\n",
    "random.randn(3,3)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 44,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "array([ 4,  6, 13, 26, 21,  4, 12,  6, 17, 23])"
      ]
     },
     "execution_count": 44,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "# numpy random contains many types of distributions\n",
    "random.negative_binomial( n=5, p=0.25, size=10)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "<br>\n",
    "\n",
    "#### Task 5.5: Plotting a Normal Distribution\n",
    "1. Generate a 10x100 matrix of random numbers sampled from a normal distribution.\n",
    "\n",
    "2. Reshape or flatten the matrix into an 1D array. \n",
    "\n",
    "3. Using matplotlib plot the distribution of the data in histogram plot."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 54,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "image/png": "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\n",
      "text/plain": [
       "<Figure size 432x288 with 1 Axes>"
      ]
     },
     "metadata": {
      "needs_background": "light"
     },
     "output_type": "display_data"
    }
   ],
   "source": [
    "# Task 5.5\n",
    "\n",
    "rand_norm = np.random.randn(10,100)\n",
    "\n",
    "# this can be accomplished a few ways\n",
    "flat = rand_norm.reshape(1000,)\n",
    "flat = rand_norm.flatten()\n",
    "\n",
    "plt.hist( flat, bins=100)\n",
    "plt.show()"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "nbgrader": {
     "grade": false,
     "locked": false,
     "schema_version": 1,
     "solution": false
    }
   },
   "source": [
    "## Accessing and modifying multidimensional array elements"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "nbgrader": {
     "grade": false,
     "locked": false,
     "schema_version": 1,
     "solution": false
    }
   },
   "source": [
    "To access or set individual elements of the array, we can index with a sequence of numbers:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 55,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "array([[1, 2, 3, 4],\n",
       "       [5, 6, 7, 8]])"
      ]
     },
     "execution_count": 55,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "arr = np.array([[1, 2, 3, 4], [5, 6, 7, 8]])\n",
    "arr"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 56,
   "metadata": {
    "nbgrader": {
     "grade": false,
     "locked": false,
     "schema_version": 1,
     "solution": false
    }
   },
   "outputs": [
    {
     "data": {
      "text/plain": [
       "array([[1, 2, 0, 4],\n",
       "       [5, 6, 7, 8]])"
      ]
     },
     "execution_count": 56,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "# set the 3rd element in the 1st row to 0\n",
    "arr[0, 2] = 0\n",
    "arr"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "nbgrader": {
     "grade": false,
     "locked": false,
     "schema_version": 1,
     "solution": false
    }
   },
   "source": [
    "We can also access the element on it's own, without having the equals sign and the stuff to the right of it:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 57,
   "metadata": {
    "nbgrader": {
     "grade": false,
     "locked": false,
     "schema_version": 1,
     "solution": false
    }
   },
   "outputs": [
    {
     "data": {
      "text/plain": [
       "0"
      ]
     },
     "execution_count": 57,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "arr[0, 2]"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "nbgrader": {
     "grade": false,
     "locked": false,
     "schema_version": 1,
     "solution": false
    }
   },
   "source": [
    "We frequently will want to access ranges of elements. In NumPy, the first dimension (or *axis*) corresponds to the rows of the array, and the second axis corresponds to the columns."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "nbgrader": {
     "grade": false,
     "locked": false,
     "schema_version": 1,
     "solution": false
    }
   },
   "source": [
    "<div class=\"alert alert-warning\">Note: be careful about setting modifying an array if what you really want is a <i>copy</i> of an array. Remember that in Python, variables are really just pointers to objects.</div>"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "nbgrader": {
     "grade": false,
     "locked": false,
     "schema_version": 1,
     "solution": false
    }
   },
   "source": [
    "For example, if I want to create a second array that mutliples every other value in `arr` by two, the following code will work but will have unexpected consequences:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 58,
   "metadata": {
    "nbgrader": {
     "grade": false,
     "locked": false,
     "schema_version": 1,
     "solution": false
    }
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "arr:  [ 0  1  4  3  8  5 12  7 16  9]\n",
      "arr2: [ 0  1  4  3  8  5 12  7 16  9]\n"
     ]
    }
   ],
   "source": [
    "arr = np.arange(10)\n",
    "arr2 = arr\n",
    "arr2[::2] = arr2[::2] * 2\n",
    "print(\"arr:  \" + str(arr))\n",
    "print(\"arr2: \" + str(arr2))"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "nbgrader": {
     "grade": false,
     "locked": false,
     "schema_version": 1,
     "solution": false
    }
   },
   "source": [
    "Note that `arr` and `arr2` both have the same values! This is because the line `arr2 = arr` doesn't actually copy the array: it just makes another pointer to the same object. To truly copy the array, we need to use the `.copy()` method:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 59,
   "metadata": {
    "nbgrader": {
     "grade": false,
     "locked": false,
     "schema_version": 1,
     "solution": false
    }
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "arr:  [0 1 2 3 4 5 6 7 8 9]\n",
      "arr2: [ 0  1  4  3  8  5 12  7 16  9]\n"
     ]
    }
   ],
   "source": [
    "arr = np.arange(10)\n",
    "arr2 = arr.copy()\n",
    "arr2[::2] = arr2[::2] * 2\n",
    "print(\"arr:  \" + str(arr))\n",
    "print(\"arr2: \" + str(arr2))"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Indexing"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "nbgrader": {
     "grade": false,
     "locked": false,
     "schema_version": 1,
     "solution": false
    }
   },
   "source": [
    "<div class=\"alert alert-info\">Also like lists, we can use \"slicing\" to get different parts of the array. Slices look like\n",
    "<code>myarray[a:b:c]</code>, where <code>a</code>, <code>b</code>, and <code>c</code> are all optional (though you have to specify at least one). <code>a</code> is the index of the beginning of the slice, <code>b</code> is the index of the end of the slice (exclusive), and <code>c</code> is the step size.\n",
    "</div>\n",
    "\n",
    "Note that the exclusive slice indexing described above is different than some other languages you may be familiar with, like Matlab and R. `myarray[1:2]` returns only the second elment in myarray in Python, instead of the first and second element. "
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "nbgrader": {
     "grade": false,
     "locked": false,
     "schema_version": 1,
     "solution": false
    }
   },
   "source": [
    "First, let's quickly look at what is in our array (defined above), for reference:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 60,
   "metadata": {
    "nbgrader": {
     "grade": false,
     "locked": false,
     "schema_version": 1,
     "solution": false
    }
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "myarray: [ 3  6  1  0 10  3]\n"
     ]
    }
   ],
   "source": [
    "print(\"myarray:\", myarray)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "nbgrader": {
     "grade": false,
     "locked": false,
     "schema_version": 1,
     "solution": false
    }
   },
   "source": [
    "Now, to get all elements except the first:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 61,
   "metadata": {
    "nbgrader": {
     "grade": false,
     "locked": false,
     "schema_version": 1,
     "solution": false
    }
   },
   "outputs": [
    {
     "data": {
      "text/plain": [
       "array([ 6,  1,  0, 10,  3])"
      ]
     },
     "execution_count": 61,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "myarray[1:]"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "nbgrader": {
     "grade": false,
     "locked": false,
     "schema_version": 1,
     "solution": false
    }
   },
   "source": [
    "To get all elements except the last:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 62,
   "metadata": {
    "nbgrader": {
     "grade": false,
     "locked": false,
     "schema_version": 1,
     "solution": false
    }
   },
   "outputs": [
    {
     "data": {
      "text/plain": [
       "array([ 3,  6,  1,  0, 10])"
      ]
     },
     "execution_count": 62,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "myarray[:-1]"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "nbgrader": {
     "grade": false,
     "locked": false,
     "schema_version": 1,
     "solution": false
    }
   },
   "source": [
    "To get all elements except the first and the last:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 63,
   "metadata": {
    "nbgrader": {
     "grade": false,
     "locked": false,
     "schema_version": 1,
     "solution": false
    }
   },
   "outputs": [
    {
     "data": {
      "text/plain": [
       "array([ 6,  1,  0, 10])"
      ]
     },
     "execution_count": 63,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "myarray[1:-1]"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "nbgrader": {
     "grade": false,
     "locked": false,
     "schema_version": 1,
     "solution": false
    }
   },
   "source": [
    "To get every other element of the array (beginning from the *first* element):"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 64,
   "metadata": {
    "nbgrader": {
     "grade": false,
     "locked": false,
     "schema_version": 1,
     "solution": false
    }
   },
   "outputs": [
    {
     "data": {
      "text/plain": [
       "array([ 3,  1, 10])"
      ]
     },
     "execution_count": 64,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "myarray[::2]"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "nbgrader": {
     "grade": false,
     "locked": false,
     "schema_version": 1,
     "solution": false
    }
   },
   "source": [
    "To get every element of the array (beginning from the *second* element):"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 65,
   "metadata": {
    "nbgrader": {
     "grade": false,
     "locked": false,
     "schema_version": 1,
     "solution": false
    }
   },
   "outputs": [
    {
     "data": {
      "text/plain": [
       "array([6, 0, 3])"
      ]
     },
     "execution_count": 65,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "myarray[1::2]"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "nbgrader": {
     "grade": false,
     "locked": false,
     "schema_version": 1,
     "solution": false
    }
   },
   "source": [
    "And to reverse the array:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 66,
   "metadata": {
    "nbgrader": {
     "grade": false,
     "locked": false,
     "schema_version": 1,
     "solution": false
    }
   },
   "outputs": [
    {
     "data": {
      "text/plain": [
       "array([ 3, 10,  0,  1,  6,  3])"
      ]
     },
     "execution_count": 66,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "myarray[::-1]"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Index slicing works exactly the same way for multidimensional \"Matrix\" arrays:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 67,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "array([[ 0,  1,  2,  3,  4],\n",
       "       [10, 11, 12, 13, 14],\n",
       "       [20, 21, 22, 23, 24],\n",
       "       [30, 31, 32, 33, 34],\n",
       "       [40, 41, 42, 43, 44]])"
      ]
     },
     "execution_count": 67,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "A = np.array([[n+m*10 for n in range(5)] for m in range(5)])\n",
    "\n",
    "A"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 68,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "array([[11, 12, 13],\n",
       "       [21, 22, 23],\n",
       "       [31, 32, 33]])"
      ]
     },
     "execution_count": 68,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "# a block from the original array\n",
    "A[1:4, 1:4]"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 69,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "array([[ 0,  2,  4],\n",
       "       [20, 22, 24],\n",
       "       [40, 42, 44]])"
      ]
     },
     "execution_count": 69,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "# strides\n",
    "A[::2, ::2]"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "<br>\n",
    "\n",
    "#### *Task 5.6: Indexing and Manipulating Multidimensional Arrays*\n",
    "\n",
    "Using the provided array:\n",
    "\n",
    "1. Use indexing to extract and print the element at row index 1 and column index 2.\n",
    "\n",
    "2. Update the element at row index 1 and column index 2 to 100.\n",
    "\n",
    "3. Print the updated my_array to verify the change.\n",
    "\n",
    "4. Use slicing to extract a subarray from my_array containing the elements from rows 1 to 2 (inclusive) and columns 2 to 3 (inclusive).\n",
    "\n",
    "5. Print the extracted subarray to see its content."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 70,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "7\n",
      "[[  1   2   3   4]\n",
      " [  5   6 100   8]\n",
      " [  9  10  11  12]]\n",
      "[[  2   3]\n",
      " [  6 100]]\n"
     ]
    }
   ],
   "source": [
    "# Task 5.6\n",
    "numarr = np.array([[1, 2, 3, 4],\n",
    "                   [5, 6, 7, 8],\n",
    "                   [9,10,11,12]])\n",
    "\n",
    "print( numarr[1,2])\n",
    "\n",
    "numarr[1,2] = 100\n",
    "print( numarr)\n",
    "\n",
    "print( numarr[:2,1:3])"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Boolean Indexing\n",
    "Boolean Indexing in NumPy allows you to select elements from an array based on a condition or Boolean mask. By using logical expressions, you can create Boolean arrays that serve as filters to extract specific elements that meet the desired criteria. This indexing technique is useful for filtering, subsetting, and manipulating array data based on logical conditions."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 71,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "array([0, 0, 1, 2, 3])"
      ]
     },
     "execution_count": 71,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "rand_arry = np.random.randint(0, 10, 5)\n",
    "rand_arry"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Numpy arrays will perform a comparison element wise, which will return an bool numpy array"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 72,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "array([False, False, False, False, False])"
      ]
     },
     "execution_count": 72,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "rand_mk = rand_arry>=5\n",
    "rand_mk"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "`~` operator with invert the book mask"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 73,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "array([ True,  True,  True,  True,  True])"
      ]
     },
     "execution_count": 73,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "~rand_mk"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "We can use this boolean mask to filter a numpy array"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 74,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "[]\n",
      "[0 0 1 2 3]\n"
     ]
    }
   ],
   "source": [
    "print( rand_arry[rand_mk])\n",
    "print( rand_arry[~rand_mk])"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "**Boolean indexing in numpy allows you to filter data based on multiple conditions. However, since the comparisons are performed element-wise (element-to-element) in numpy, logical combinations using `&` and `|` are used for performing the logical AND and OR operations between elements.** "
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 75,
   "metadata": {},
   "outputs": [
    {
     "ename": "ValueError",
     "evalue": "The truth value of an array with more than one element is ambiguous. Use a.any() or a.all()",
     "output_type": "error",
     "traceback": [
      "\u001b[0;31m---------------------------------------------------------------------------\u001b[0m",
      "\u001b[0;31mValueError\u001b[0m                                Traceback (most recent call last)",
      "Input \u001b[0;32mIn [75]\u001b[0m, in \u001b[0;36m<cell line: 4>\u001b[0;34m()\u001b[0m\n\u001b[1;32m      1\u001b[0m temps \u001b[38;5;241m=\u001b[39m np\u001b[38;5;241m.\u001b[39marray([\u001b[38;5;241m23\u001b[39m, \u001b[38;5;241m28\u001b[39m, \u001b[38;5;241m19\u001b[39m, \u001b[38;5;241m30\u001b[39m, \u001b[38;5;241m25\u001b[39m, \u001b[38;5;241m22\u001b[39m, \u001b[38;5;241m27\u001b[39m, \u001b[38;5;241m18\u001b[39m])\n\u001b[1;32m      3\u001b[0m \u001b[38;5;66;03m# Filter temperatures between 20 and 30 degrees Celsius\u001b[39;00m\n\u001b[0;32m----> 4\u001b[0m mask \u001b[38;5;241m=\u001b[39m (temps \u001b[38;5;241m>\u001b[39m \u001b[38;5;241m20\u001b[39m) \u001b[38;5;129;01mand\u001b[39;00m (temps \u001b[38;5;241m<\u001b[39m \u001b[38;5;241m30\u001b[39m)\n\u001b[1;32m      5\u001b[0m filtered_temps \u001b[38;5;241m=\u001b[39m temps[mask]\n\u001b[1;32m      6\u001b[0m \u001b[38;5;28mprint\u001b[39m(filtered_temps)\n",
      "\u001b[0;31mValueError\u001b[0m: The truth value of an array with more than one element is ambiguous. Use a.any() or a.all()"
     ]
    }
   ],
   "source": [
    "temps = np.array([23, 28, 19, 30, 25, 22, 27, 18])\n",
    "\n",
    "# Filter temperatures between 20 and 30 degrees Celsius\n",
    "mask = (temps > 20) and (temps < 30)\n",
    "filtered_temps = temps[mask]\n",
    "print(filtered_temps)\n"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "The full syntax is:\n",
    "\n",
    "`(condition1) & (condition2)`"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 76,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "[23 28 25 22 27]\n"
     ]
    }
   ],
   "source": [
    "temps = np.array([23, 28, 19, 30, 25, 22, 27, 18])\n",
    "\n",
    "# Filter temperatures between 20 and 30 degrees Celsius\n",
    "mask = (temps > 20) & (temps < 30)\n",
    "filtered_temps = temps[mask]\n",
    "\n",
    "print(filtered_temps)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "They are also very handy for assigning values."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 77,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "[23  0 19  0 25 22  0 18]\n"
     ]
    }
   ],
   "source": [
    "temperatures = np.array([23, 28, 19, 30, 25, 22, 27, 18])\n",
    "\n",
    "# Assign 0 to temperatures greater than 25 degrees Celsius\n",
    "temperatures[temperatures > 25] = 0\n",
    "print(temperatures)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "<br>\n",
    "\n",
    "#### *Task 5.7: Boolean Indexing*\n",
    "\n",
    "Consider the NumPy array given below representing student scores on a test. Create a boolean mask for test scores greater than or equal to 80. Use the mask to reassign them as grade of 'Pass' (>=80), or 'Fail' (<80). "
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 79,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "[ 70  75  80  82  77 100  96]\n"
     ]
    },
    {
     "data": {
      "text/plain": [
       "array([  0,   0, 100, 100,   0, 100, 100])"
      ]
     },
     "execution_count": 79,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "# Task 5.7\n",
    "scores = np.array([70,75,80,82,77,100,96])\n",
    "print( scores)\n",
    "\n",
    "mask = scores>=80\n",
    "\n",
    "scores[mask] = 100\n",
    "scores[~mask] = 0\n",
    "\n",
    "scores"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "tags": []
   },
   "source": [
    "<br>\n",
    "\n",
    "---\n",
    "<a id='2.1'></a>"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## 2.4 Exercises"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "nbgrader": {
     "grade": false,
     "locked": false,
     "schema_version": 1,
     "solution": false
    }
   },
   "source": [
    "### Exercise 1: Euclidean distance (2 points)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "nbgrader": {
     "grade": false,
     "locked": false,
     "schema_version": 1,
     "solution": false
    }
   },
   "source": [
    "Recall that the Euclidean distance $d$ is given by the following equation:\n",
    "\n",
    "$$\n",
    "d(a, b) = \\sqrt{\\sum_{i=1}^N (a_i - b_i) ^ 2}\n",
    "$$\n",
    "\n",
    "In NumPy, this is a fairly simple computation because we can rely on array computations and the `np.sum` function to do all the heavy lifting for us."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "nbgrader": {
     "grade": false,
     "locked": false,
     "schema_version": 1,
     "solution": false
    }
   },
   "source": [
    "<div class=\"alert alert-success\">\n",
    "Complete the function <code>euclidean_distance</code> below to compute $d(a,b)$, as given by the equation above. Note that you can compute the square root using <code>np.sqrt</code>.\n",
    "</div>"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 86,
   "metadata": {
    "deletable": false,
    "nbgrader": {
     "checksum": "2a3d7a8cdc2eb03a2cf8fe96d5151f69",
     "grade": false,
     "grade_id": "euclidean_distance",
     "locked": false,
     "schema_version": 1,
     "solution": true
    }
   },
   "outputs": [],
   "source": [
    "def euclidean_distance(a, b):\n",
    "    \"\"\"Computes the Euclidean distance between a and b.\n",
    "    \n",
    "    Hint: your solution can be done in a single line of code!\n",
    "    \n",
    "    Parameters\n",
    "    ----------\n",
    "    a, b : numpy arrays or scalars with the same size\n",
    "    \n",
    "    Returns\n",
    "    -------\n",
    "    the Euclidean distance between a and b\n",
    "    \n",
    "    \"\"\"\n",
    "    # YOUR CODE HERE\n",
    "    distance = np.sqrt(np.sum((a-b)**2))\n",
    "    return( distance)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "nbgrader": {
     "grade": false,
     "locked": false,
     "schema_version": 1,
     "solution": false
    }
   },
   "source": [
    "<div class=\"alert alert-warning\">Remember that you need to execute the cell above (with your definition of <code>euclidean_distance</code>), and then run the cell below to check your answer. If you make changes to the cell with your answer, you will need to <i>first</i> re-run that cell, and <i>then</i> re-run the test cell to check your answer again.</div>"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 90,
   "metadata": {
    "nbgrader": {
     "grade": false,
     "locked": false,
     "schema_version": 1,
     "solution": false
    }
   },
   "outputs": [
    {
     "data": {
      "text/plain": [
       "2.0"
      ]
     },
     "execution_count": 90,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "# add your own test cases in this cell!\n",
    "euclidean_distance(4,2)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "The code below will check you have coded the euclidean_distance function correctly."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 91,
   "metadata": {
    "deletable": false,
    "editable": false,
    "nbgrader": {
     "checksum": "9871b9105436729a0515c59ee0198be5",
     "grade": true,
     "grade_id": "test_euclidean_distance",
     "locked": false,
     "points": 2,
     "schema_version": 1,
     "solution": false
    }
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Success!\n"
     ]
    }
   ],
   "source": [
    "from nose.tools import assert_equal, assert_raises\n",
    "\n",
    "# check euclidean distance of size 3 integer arrays\n",
    "a = np.array([1, 2, 3])\n",
    "b = np.array([4, 5, 6])\n",
    "assert_equal(euclidean_distance(a, b), 5.196152422706632)\n",
    "\n",
    "# check euclidean distance of size 4 float arrays\n",
    "x = np.array([3.6, 7., 203., 3.])\n",
    "y = np.array([6., 20.2, 1., 2.])\n",
    "assert_equal(euclidean_distance(x, y), 202.44752406487959)\n",
    "\n",
    "# check euclidean distance of scalars\n",
    "assert_equal(euclidean_distance(1, 0.5), 0.5)\n",
    "\n",
    "# check that an error is thrown if the arrays are different sizes\n",
    "a = np.array([1, 2, 3])\n",
    "b = np.array([4, 5])\n",
    "assert_raises(ValueError, euclidean_distance, a, b)\n",
    "assert_raises(ValueError, euclidean_distance, b, a)\n",
    "\n",
    "print(\"Success!\")"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 92,
   "metadata": {
    "deletable": false,
    "nbgrader": {
     "checksum": "962d91ecb5d9812898959fa2564e1be9",
     "grade": false,
     "grade_id": "border",
     "locked": false,
     "schema_version": 1,
     "solution": true
    }
   },
   "outputs": [],
   "source": [
    "def border(n, m):\n",
    "    \"\"\"Creates an array with shape (n, m) that is all zeros\n",
    "    except for the border (i.e., the first and last rows and\n",
    "    columns), which should be filled with ones.\n",
    "\n",
    "    Hint: you should be able to do this in three lines\n",
    "    (including the return statement)\n",
    "\n",
    "    Parameters\n",
    "    ----------\n",
    "    n, m: int\n",
    "        Number of rows and number of columns\n",
    "\n",
    "    Returns\n",
    "    -------\n",
    "    numpy array with shape (n, m)\n",
    "\n",
    "    \"\"\"\n",
    "    # YOUR CODE HERE\n",
    "    raise NotImplementedError()"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "deletable": false,
    "editable": false,
    "nbgrader": {
     "checksum": "6a95c7371bad454b06f6bb7a2b7780a7",
     "grade": true,
     "grade_id": "test_border",
     "locked": false,
     "points": 3,
     "schema_version": 1,
     "solution": false
    }
   },
   "outputs": [],
   "source": [
    "from numpy.testing import assert_array_equal\n",
    "from nose.tools import assert_equal\n",
    "\n",
    "# check a few small examples explicitly\n",
    "assert_array_equal(border(1, 1), [[1]])\n",
    "assert_array_equal(border(2, 2), [[1, 1], [1, 1]])\n",
    "assert_array_equal(border(3, 3), [[1, 1, 1], [1, 0, 1], [1, 1, 1]])\n",
    "assert_array_equal(border(3, 4), [[1, 1, 1, 1], [1, 0, 0, 1], [1, 1, 1, 1]])\n",
    "\n",
    "# check a few large and random examples\n",
    "for i in range(10):\n",
    "    n, m = np.random.randint(2, 1000, 2)\n",
    "    result = border(n, m)\n",
    "\n",
    "    # check dtype and array shape\n",
    "    assert_equal(result.dtype, np.float)\n",
    "    assert_equal(result.shape, (n, m))\n",
    "\n",
    "    # check the borders\n",
    "    assert (result[0] == 1).all()\n",
    "    assert (result[-1] == 1).all()\n",
    "    assert (result[:, 0] == 1).all()\n",
    "    assert (result[:, -1] == 1).all()\n",
    "\n",
    "    # check that everything else is zero\n",
    "    assert np.sum(result) == (2*n + 2*m - 4)\n",
    "\n",
    "print(\"Success!\")"
   ]
  }
 ],
 "metadata": {
  "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.9.12"
  }
 },
 "nbformat": 4,
 "nbformat_minor": 4
}