Week2/NumPy.ipynb

{
 "cells": [
  {
   "cell_type": "markdown",
   "id": "7d8e0d10",
   "metadata": {},
   "source": [
    "# NumPy\n",
    "\n",
    "We always import NumPy using the standard `np` abbreviation."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 1,
   "id": "214bf62f",
   "metadata": {},
   "outputs": [],
   "source": [
    "import numpy as np"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "cf5f8fd1",
   "metadata": {},
   "source": [
    "## Regular arrays\n",
    "\n",
    "<iframe width=\"560\" height=\"315\" src=\"https://www.youtube.com/embed/8Iw8O5qNvvY\" title=\"YouTube video player\" frameborder=\"0\" allow=\"accelerometer; autoplay; clipboard-write; encrypted-media; gyroscope; picture-in-picture\" allowfullscreen></iframe>\n",
    "\n",
    "To learn some different methods for creating NumPy arrays, we will make the following arrays.  (The next one is written as a list, but our primary goal is to make the NumPy array version.)"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "72b4bd2b",
   "metadata": {},
   "source": [
    "### Example 1\n",
    "\n",
    "* [0, 0, 0, ..., 0] (length 10)"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "6be0a569-b26d-4516-b9b1-cc6c7f84fa97",
   "metadata": {},
   "source": [
    "Here we use `np.zeros`.  Many Matlab functions have an equivalent version in NumPy, and `zeros` is one such example."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 2,
   "id": "21413b3d",
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "array([0., 0., 0., 0., 0., 0., 0., 0., 0., 0.])"
      ]
     },
     "execution_count": 2,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "np.zeros(10)"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "1c83bac4-c90c-4e37-a14c-8b825d1895fe",
   "metadata": {},
   "source": [
    "Just as an aside, there is also a very elegant way to make a list (not a NumPy array) of 10 zeros using what is called *list comprehension*.  (We will introduce list comprehension more systematically [later in the course](list-comp).)  The underscore `_` in the following is just a way of naming a variable that we will never refer to again; it could be replaced by any variable name and the result would be the same.\n",
    "\n",
    "Here is the list comprehension way to make a list of 10 zeros."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 3,
   "id": "65e1864d",
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "[0, 0, 0, 0, 0, 0, 0, 0, 0, 0]"
      ]
     },
     "execution_count": 3,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "[0 for _ in range(10)]"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "81e5368e-1525-41b4-afaf-daf027cf7d69",
   "metadata": {},
   "source": [
    "One other way of making this list is based on the following, which uses `+` to concatenate two lists."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 4,
   "id": "0cdbbb88",
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "[0, 0]"
      ]
     },
     "execution_count": 4,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "[0]+[0]"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "32e40d32-a9d1-4364-a23c-4ae874d996f5",
   "metadata": {},
   "source": [
    "So if we want to add `[0]` to itself 10 times, we can use `*`."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 5,
   "id": "a3c7a302",
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "[0, 0, 0, 0, 0, 0, 0, 0, 0, 0]"
      ]
     },
     "execution_count": 5,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "[0]*10"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "79659c49",
   "metadata": {},
   "source": [
    "### Example 2\n",
    "\n",
    "* A five row, seven column matrix containing all 4s."
   ]
  },
  {
   "cell_type": "markdown",
   "id": "5c84aaff-7559-44bc-84de-08a232ed2a4e",
   "metadata": {},
   "source": [
    "Here we're trying to make a 5x7 NumPy array of all zeros (then we will add 4 to it).  The following is a common mistake I make.  The error message is not too helpful the first time you see it."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 6,
   "id": "3e0c872e",
   "metadata": {},
   "outputs": [
    {
     "ename": "TypeError",
     "evalue": "Cannot interpret '7' as a data type",
     "output_type": "error",
     "traceback": [
      "\u001b[0;31m---------------------------------------------------------------------------\u001b[0m",
      "\u001b[0;31mTypeError\u001b[0m                                 Traceback (most recent call last)",
      "Input \u001b[0;32mIn [6]\u001b[0m, in \u001b[0;36m<cell line: 1>\u001b[0;34m()\u001b[0m\n\u001b[0;32m----> 1\u001b[0m \u001b[43mnp\u001b[49m\u001b[38;5;241;43m.\u001b[39;49m\u001b[43mzeros\u001b[49m\u001b[43m(\u001b[49m\u001b[38;5;241;43m5\u001b[39;49m\u001b[43m,\u001b[49m\u001b[38;5;241;43m7\u001b[39;49m\u001b[43m)\u001b[49m\n",
      "\u001b[0;31mTypeError\u001b[0m: Cannot interpret '7' as a data type"
     ]
    }
   ],
   "source": [
    "np.zeros(5,7)"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "4abfb38c-cb59-418c-a690-37f39b680b9d",
   "metadata": {},
   "source": [
    "Notice in the documentation that the first argument for `shape` is supposed to be an integer or a tuple of integers.  The second positional argument is called `dtype`, and NumPy is trying to interpret our second input `7` as a `dtype`.  That was our mistake; we should have given a single input argument as a tuple, not two separate input arguments."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 7,
   "id": "b1c2466c",
   "metadata": {
    "tags": [
     "output_scroll"
    ]
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Help on built-in function zeros in module numpy:\n",
      "\n",
      "zeros(...)\n",
      "    zeros(shape, dtype=float, order='C', *, like=None)\n",
      "    \n",
      "    Return a new array of given shape and type, filled with zeros.\n",
      "    \n",
      "    Parameters\n",
      "    ----------\n",
      "    shape : int or tuple of ints\n",
      "        Shape of the new array, e.g., ``(2, 3)`` or ``2``.\n",
      "    dtype : data-type, optional\n",
      "        The desired data-type for the array, e.g., `numpy.int8`.  Default is\n",
      "        `numpy.float64`.\n",
      "    order : {'C', 'F'}, optional, default: 'C'\n",
      "        Whether to store multi-dimensional data in row-major\n",
      "        (C-style) or column-major (Fortran-style) order in\n",
      "        memory.\n",
      "    like : array_like, optional\n",
      "        Reference object to allow the creation of arrays which are not\n",
      "        NumPy arrays. If an array-like passed in as ``like`` supports\n",
      "        the ``__array_function__`` protocol, the result will be defined\n",
      "        by it. In this case, it ensures the creation of an array object\n",
      "        compatible with that passed in via this argument.\n",
      "    \n",
      "        .. versionadded:: 1.20.0\n",
      "    \n",
      "    Returns\n",
      "    -------\n",
      "    out : ndarray\n",
      "        Array of zeros with the given shape, dtype, and order.\n",
      "    \n",
      "    See Also\n",
      "    --------\n",
      "    zeros_like : Return an array of zeros with shape and type of input.\n",
      "    empty : Return a new uninitialized array.\n",
      "    ones : Return a new array setting values to one.\n",
      "    full : Return a new array of given shape filled with value.\n",
      "    \n",
      "    Examples\n",
      "    --------\n",
      "    >>> np.zeros(5)\n",
      "    array([ 0.,  0.,  0.,  0.,  0.])\n",
      "    \n",
      "    >>> np.zeros((5,), dtype=int)\n",
      "    array([0, 0, 0, 0, 0])\n",
      "    \n",
      "    >>> np.zeros((2, 1))\n",
      "    array([[ 0.],\n",
      "           [ 0.]])\n",
      "    \n",
      "    >>> s = (2,2)\n",
      "    >>> np.zeros(s)\n",
      "    array([[ 0.,  0.],\n",
      "           [ 0.,  0.]])\n",
      "    \n",
      "    >>> np.zeros((2,), dtype=[('x', 'i4'), ('y', 'i4')]) # custom dtype\n",
      "    array([(0, 0), (0, 0)],\n",
      "          dtype=[('x', '<i4'), ('y', '<i4')])\n",
      "\n"
     ]
    }
   ],
   "source": [
    "help(np.zeros)"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "b4a07d95-babe-4315-8514-13a4f19678f0",
   "metadata": {},
   "source": [
    "Here is the correct way to make a 5x7 NumPy array of all zeros.  Notice the extra set of parentheses around `(5,7)`.  The inner parentheses make a tuple, and the outer parentheses go together with the `zeros` function."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 8,
   "id": "28d916a6",
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "array([[0., 0., 0., 0., 0., 0., 0.],\n",
       "       [0., 0., 0., 0., 0., 0., 0.],\n",
       "       [0., 0., 0., 0., 0., 0., 0.],\n",
       "       [0., 0., 0., 0., 0., 0., 0.],\n",
       "       [0., 0., 0., 0., 0., 0., 0.]])"
      ]
     },
     "execution_count": 8,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "np.zeros((5,7))"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "38b33ba4-e4f1-4d63-b558-5c764eab7e34",
   "metadata": {},
   "source": [
    "Once we have the array of all zeros, it's easy to get the array of all 4s.  We just add 4, and NumPy automatically \"broadcasts\" the 4 to all of the entries in the array."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 9,
   "id": "f3f776ad",
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "array([[4., 4., 4., 4., 4., 4., 4.],\n",
       "       [4., 4., 4., 4., 4., 4., 4.],\n",
       "       [4., 4., 4., 4., 4., 4., 4.],\n",
       "       [4., 4., 4., 4., 4., 4., 4.],\n",
       "       [4., 4., 4., 4., 4., 4., 4.]])"
      ]
     },
     "execution_count": 9,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "np.zeros((5,7))+4"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "b3def697-f39e-4074-a22a-2c88945bfd89",
   "metadata": {},
   "source": [
    "Here is a similar strategy, using the `ones` function instead of the `zeros` function."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 10,
   "id": "4dcf5435",
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "array([[1., 1., 1., 1., 1., 1., 1.],\n",
       "       [1., 1., 1., 1., 1., 1., 1.],\n",
       "       [1., 1., 1., 1., 1., 1., 1.],\n",
       "       [1., 1., 1., 1., 1., 1., 1.],\n",
       "       [1., 1., 1., 1., 1., 1., 1.]])"
      ]
     },
     "execution_count": 10,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "np.ones((5,7))"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 11,
   "id": "694aaa5b",
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "array([[4., 4., 4., 4., 4., 4., 4.],\n",
       "       [4., 4., 4., 4., 4., 4., 4.],\n",
       "       [4., 4., 4., 4., 4., 4., 4.],\n",
       "       [4., 4., 4., 4., 4., 4., 4.],\n",
       "       [4., 4., 4., 4., 4., 4., 4.]])"
      ]
     },
     "execution_count": 11,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "np.ones((5,7))*4"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "0281bf7a-1750-46a6-a2f1-e354b018eeb9",
   "metadata": {},
   "source": [
    "If we would rather have integers on the inside (notice how the decimal point goes away), we can specify `int` as the `dtype`."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 12,
   "id": "f5b7da36",
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "array([[4, 4, 4, 4, 4, 4, 4],\n",
       "       [4, 4, 4, 4, 4, 4, 4],\n",
       "       [4, 4, 4, 4, 4, 4, 4],\n",
       "       [4, 4, 4, 4, 4, 4, 4],\n",
       "       [4, 4, 4, 4, 4, 4, 4]])"
      ]
     },
     "execution_count": 12,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "np.ones((5,7), int)*4"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "164461af",
   "metadata": {},
   "source": [
    "### Example 3\n",
    "\n",
    "* [0, ..., 100] (length 5, evenly distributed).\n",
    "\n",
    "In Matlab, this would be made using `linspace`, and NumPy has its own version of `linspace`."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 13,
   "id": "019120dc",
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "array([  0.,  25.,  50.,  75., 100.])"
      ]
     },
     "execution_count": 13,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "np.linspace(0,100,5)"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "943bbcbb",
   "metadata": {},
   "source": [
    "(3x3-array)=\n",
    "### Example 4\n",
    "\n",
    "* The 3x3 matrix $\\begin{pmatrix} 0 & 0 & 0 \\\\ 1 & 1 & 1 \\\\ 2 & 2 & 2 \\end{pmatrix}$"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "98d5c618-50ea-4baa-8c8b-16e34c999c5a",
   "metadata": {},
   "source": [
    "Here is a first way to make this matrix.  It's again using broadcasting.  For example, when `i` is 2, we broadcast 2 to the second row.  (The second row is specified by `arr[2]`.)  We will later see ways to make this sort of matrix avoiding the for loop."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 14,
   "id": "98f7d36b",
   "metadata": {},
   "outputs": [],
   "source": [
    "arr = np.zeros((3,3))\n",
    "for i in range(3):\n",
    "    arr[i] = i"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 15,
   "id": "772390b2",
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "array([[0., 0., 0.],\n",
       "       [1., 1., 1.],\n",
       "       [2., 2., 2.]])"
      ]
     },
     "execution_count": 15,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "arr"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "bb78ad5d",
   "metadata": {},
   "source": [
    "### Example 5\n",
    "\n",
    "* The 2x5 matrix $\n",
    "\\begin{pmatrix} 2 & 5 & 8 & 11 & 14 \\\\ 17 & 20 & 23 & 26 & 29 \\end{pmatrix}\n",
    "$"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "bcad52cf-7403-4303-a482-64ed6574bc72",
   "metadata": {},
   "source": [
    "We start with a nested for loop approach to make this matrix.  We will print out the current version of the array each step through the for loops.  Notice especially how `arr[i,j]` refers to the entry in the i-th row and the j-th column.  The following is almost correct, but it doesn't get the bottom row right."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 16,
   "id": "d734ae5a",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "[[2. 0. 0. 0. 0.]\n",
      " [0. 0. 0. 0. 0.]]\n",
      "[[2. 5. 0. 0. 0.]\n",
      " [0. 0. 0. 0. 0.]]\n",
      "[[2. 5. 8. 0. 0.]\n",
      " [0. 0. 0. 0. 0.]]\n",
      "[[ 2.  5.  8. 11.  0.]\n",
      " [ 0.  0.  0.  0.  0.]]\n",
      "[[ 2.  5.  8. 11. 14.]\n",
      " [ 0.  0.  0.  0.  0.]]\n",
      "[[ 2.  5.  8. 11. 14.]\n",
      " [ 2.  0.  0.  0.  0.]]\n",
      "[[ 2.  5.  8. 11. 14.]\n",
      " [ 2.  5.  0.  0.  0.]]\n",
      "[[ 2.  5.  8. 11. 14.]\n",
      " [ 2.  5.  8.  0.  0.]]\n",
      "[[ 2.  5.  8. 11. 14.]\n",
      " [ 2.  5.  8. 11.  0.]]\n",
      "[[ 2.  5.  8. 11. 14.]\n",
      " [ 2.  5.  8. 11. 14.]]\n"
     ]
    }
   ],
   "source": [
    "arr = np.zeros((2,5))\n",
    "for i in range(2):\n",
    "    for j in range(5):\n",
    "        arr[i,j] = 2+3*j\n",
    "        print(arr)"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "fb467303-9078-41b7-996c-0cb28846d891",
   "metadata": {},
   "source": [
    "Here is a final version of this approach.  We make the code a little more stable by replacing some of the numbers with variables, for example, we replace the 3 above with the variable `step`."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 17,
   "id": "45ad3247",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "[[ 2.  5.  8. 11. 14.]\n",
      " [17. 20. 23. 26. 29.]]\n"
     ]
    }
   ],
   "source": [
    "cols = 5\n",
    "step = 3\n",
    "arr = np.zeros((2,cols))\n",
    "for i in range(2):\n",
    "    for j in range(cols):\n",
    "        arr[i,j] = 2+step*j+cols*step*i\n",
    "print(arr)"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "7521c667-d703-45b4-bac8-80e6f23178d9",
   "metadata": {},
   "source": [
    "Here is an easier way to make the same NumPy array.  Here is a first step: `np.arange` is the NumPy analogue of `range` from Python (or the colon function from Matlab).  (We'll see later that `np.arange` has the advantage over `range` that it can use non-integer step sizes.)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 18,
   "id": "ce02f66b",
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "array([ 2,  5,  8, 11, 14, 17, 20, 23, 26])"
      ]
     },
     "execution_count": 18,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "np.arange(2,29,3)"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "a472d853-3eca-4fc6-853d-006378a2dfc9",
   "metadata": {},
   "source": [
    "Remember that the right endpoint is usually not included in Python.  Since we want our array to end at 29, we should list some number bigger than 29 (and less than or equal to 32) as our right endpoint."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 19,
   "id": "570e7bcd",
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "array([ 2,  5,  8, 11, 14, 17, 20, 23, 26, 29])"
      ]
     },
     "execution_count": 19,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "np.arange(2,30,3)"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "2a371809-09c0-4a26-b126-4b682da217c4",
   "metadata": {},
   "source": [
    "Now we will use the `reshape` method to turn this length-10 one-dimensional NumPy array into a 2x5 two-dimensional NumPy array."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 20,
   "id": "ee2af32f",
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "array([[ 2,  5,  8, 11, 14],\n",
       "       [17, 20, 23, 26, 29]])"
      ]
     },
     "execution_count": 20,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "np.arange(2,30,3).reshape((2,5))"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "03d30259",
   "metadata": {},
   "source": [
    "## Random numbers\n",
    "\n",
    "<iframe width=\"560\" height=\"315\" src=\"https://www.youtube.com/embed/UGqkJ2Z3RwY\" title=\"YouTube video player\" frameborder=\"0\" allow=\"accelerometer; autoplay; clipboard-write; encrypted-media; gyroscope; picture-in-picture\" allowfullscreen></iframe>"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "cb860fa0",
   "metadata": {},
   "source": [
    "* Make a length 10 NumPy array of random integers between 0 (inclusive) and 40 (exclusive).\n",
    "\n",
    "You will often see code like the following in code examples, but this is actually the \"old\" way of getting random numbers in NumPy."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 2,
   "id": "85757da9",
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "array([30, 35, 37,  3,  0, 18, 12, 17, 38, 16])"
      ]
     },
     "execution_count": 2,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "np.random.randint(0, 40, size=10)"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "fe26b6f2-7cd8-43d2-a269-3feab30efdb8",
   "metadata": {},
   "source": [
    "Notice the portion of the documentation:\n",
    "> New code should use the ``integers`` method of a ``default_rng()``\n",
    "        instance instead; please see the :ref:`random-quick-start`\n",
    "        \n",
    "For the rest of the course, we will use this `default_rng` method."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 3,
   "id": "48efcb15",
   "metadata": {
    "tags": [
     "output_scroll"
    ]
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Help on built-in function randint:\n",
      "\n",
      "randint(...) method of numpy.random.mtrand.RandomState instance\n",
      "    randint(low, high=None, size=None, dtype=int)\n",
      "    \n",
      "    Return random integers from `low` (inclusive) to `high` (exclusive).\n",
      "    \n",
      "    Return random integers from the \"discrete uniform\" distribution of\n",
      "    the specified dtype in the \"half-open\" interval [`low`, `high`). If\n",
      "    `high` is None (the default), then results are from [0, `low`).\n",
      "    \n",
      "    .. note::\n",
      "        New code should use the ``integers`` method of a ``default_rng()``\n",
      "        instance instead; please see the :ref:`random-quick-start`.\n",
      "    \n",
      "    Parameters\n",
      "    ----------\n",
      "    low : int or array-like of ints\n",
      "        Lowest (signed) integers to be drawn from the distribution (unless\n",
      "        ``high=None``, in which case this parameter is one above the\n",
      "        *highest* such integer).\n",
      "    high : int or array-like of ints, optional\n",
      "        If provided, one above the largest (signed) integer to be drawn\n",
      "        from the distribution (see above for behavior if ``high=None``).\n",
      "        If array-like, must contain integer values\n",
      "    size : int or tuple of ints, optional\n",
      "        Output shape.  If the given shape is, e.g., ``(m, n, k)``, then\n",
      "        ``m * n * k`` samples are drawn.  Default is None, in which case a\n",
      "        single value is returned.\n",
      "    dtype : dtype, optional\n",
      "        Desired dtype of the result. Byteorder must be native.\n",
      "        The default value is int.\n",
      "    \n",
      "        .. versionadded:: 1.11.0\n",
      "    \n",
      "    Returns\n",
      "    -------\n",
      "    out : int or ndarray of ints\n",
      "        `size`-shaped array of random integers from the appropriate\n",
      "        distribution, or a single such random int if `size` not provided.\n",
      "    \n",
      "    See Also\n",
      "    --------\n",
      "    random_integers : similar to `randint`, only for the closed\n",
      "        interval [`low`, `high`], and 1 is the lowest value if `high` is\n",
      "        omitted.\n",
      "    random.Generator.integers: which should be used for new code.\n",
      "    \n",
      "    Examples\n",
      "    --------\n",
      "    >>> np.random.randint(2, size=10)\n",
      "    array([1, 0, 0, 0, 1, 1, 0, 0, 1, 0]) # random\n",
      "    >>> np.random.randint(1, size=10)\n",
      "    array([0, 0, 0, 0, 0, 0, 0, 0, 0, 0])\n",
      "    \n",
      "    Generate a 2 x 4 array of ints between 0 and 4, inclusive:\n",
      "    \n",
      "    >>> np.random.randint(5, size=(2, 4))\n",
      "    array([[4, 0, 2, 1], # random\n",
      "           [3, 2, 2, 0]])\n",
      "    \n",
      "    Generate a 1 x 3 array with 3 different upper bounds\n",
      "    \n",
      "    >>> np.random.randint(1, [3, 5, 10])\n",
      "    array([2, 2, 9]) # random\n",
      "    \n",
      "    Generate a 1 by 3 array with 3 different lower bounds\n",
      "    \n",
      "    >>> np.random.randint([1, 5, 7], 10)\n",
      "    array([9, 8, 7]) # random\n",
      "    \n",
      "    Generate a 2 by 4 array using broadcasting with dtype of uint8\n",
      "    \n",
      "    >>> np.random.randint([1, 3, 5, 7], [[10], [20]], dtype=np.uint8)\n",
      "    array([[ 8,  6,  9,  7], # random\n",
      "           [ 1, 16,  9, 12]], dtype=uint8)\n",
      "\n"
     ]
    }
   ],
   "source": [
    "help(np.random.randint)"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "3d4e4ff5-5c98-4153-8762-b95aab1a7e44",
   "metadata": {},
   "source": [
    "The `default_rng` approach to random numbers is a good example of object-oriented programming, because we are making a new object, which we call `rng` here, and we are using methods on that object to produce random numbers."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 5,
   "id": "9ddb8acf",
   "metadata": {},
   "outputs": [],
   "source": [
    "rng = np.random.default_rng()"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 6,
   "id": "6769f15e",
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "numpy.random._generator.Generator"
      ]
     },
     "execution_count": 6,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "type(rng)"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "90724479-2ee3-4745-a33f-963a6af6a734",
   "metadata": {},
   "source": [
    "The note above said to use the `integers` method, which is what we do here.  This is the *modern* way (as of Summer 2022) to make random numbers in NumPy."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 8,
   "id": "7364b1ac",
   "metadata": {},
   "outputs": [],
   "source": [
    "arr = rng.integers(0, 40, size=10)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 9,
   "id": "f38dbadb",
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "array([10, 36, 39, 25, 23, 30,  5, 20, 25, 12])"
      ]
     },
     "execution_count": 9,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "arr"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "8d39ac81",
   "metadata": {},
   "source": [
    "For the rest of this section, we will see a variety of examples of different sorts of methods we can use from our random number generator `rng` object.\n",
    "\n",
    "* Choose 6 of those numbers (with replacement) and put them into a NumPy array."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 10,
   "id": "672e5fae",
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "array([23, 30, 23, 30, 30, 39])"
      ]
     },
     "execution_count": 10,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "rng.choice(arr, size=6)"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "adef8834",
   "metadata": {},
   "source": [
    "* Make a three row, five column NumPy array of random real numbers between -1 and 4.\n",
    "\n",
    "The following is what I would have expected, but the `random` method does not allow us to specify a low and a high value for getting random floats.  Instead `random` will always get us random numbers between 0 and 1, and if we want our random numbers in a different range, then we need to rescale the outputs."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 11,
   "id": "79c54ca5",
   "metadata": {},
   "outputs": [
    {
     "ename": "TypeError",
     "evalue": "random() got multiple values for keyword argument 'size'",
     "output_type": "error",
     "traceback": [
      "\u001b[0;31m---------------------------------------------------------------------------\u001b[0m",
      "\u001b[0;31mTypeError\u001b[0m                                 Traceback (most recent call last)",
      "Input \u001b[0;32mIn [11]\u001b[0m, in \u001b[0;36m<cell line: 1>\u001b[0;34m()\u001b[0m\n\u001b[0;32m----> 1\u001b[0m \u001b[43mrng\u001b[49m\u001b[38;5;241;43m.\u001b[39;49m\u001b[43mrandom\u001b[49m\u001b[43m(\u001b[49m\u001b[38;5;241;43m-\u001b[39;49m\u001b[38;5;241;43m1\u001b[39;49m\u001b[43m,\u001b[49m\u001b[43m \u001b[49m\u001b[38;5;241;43m4\u001b[39;49m\u001b[43m,\u001b[49m\u001b[43m \u001b[49m\u001b[43msize\u001b[49m\u001b[38;5;241;43m=\u001b[39;49m\u001b[43m(\u001b[49m\u001b[38;5;241;43m3\u001b[39;49m\u001b[43m,\u001b[49m\u001b[38;5;241;43m5\u001b[39;49m\u001b[43m)\u001b[49m\u001b[43m)\u001b[49m\n",
      "File \u001b[0;32m_generator.pyx:238\u001b[0m, in \u001b[0;36mnumpy.random._generator.Generator.random\u001b[0;34m()\u001b[0m\n",
      "\u001b[0;31mTypeError\u001b[0m: random() got multiple values for keyword argument 'size'"
     ]
    }
   ],
   "source": [
    "rng.random(-1, 4, size=(3,5))"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "4d16e3ef-247b-4ab5-824a-3dcba7756201",
   "metadata": {},
   "source": [
    "Notice that the outputs are between 0 and 1."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 12,
   "id": "95c95bfe",
   "metadata": {
    "tags": [
     "output_scroll"
    ]
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Help on built-in function random:\n",
      "\n",
      "random(...) method of numpy.random._generator.Generator instance\n",
      "    random(size=None, dtype=np.float64, out=None)\n",
      "    \n",
      "    Return random floats in the half-open interval [0.0, 1.0).\n",
      "    \n",
      "    Results are from the \"continuous uniform\" distribution over the\n",
      "    stated interval.  To sample :math:`Unif[a, b), b > a` multiply\n",
      "    the output of `random` by `(b-a)` and add `a`::\n",
      "    \n",
      "      (b - a) * random() + a\n",
      "    \n",
      "    Parameters\n",
      "    ----------\n",
      "    size : int or tuple of ints, optional\n",
      "        Output shape.  If the given shape is, e.g., ``(m, n, k)``, then\n",
      "        ``m * n * k`` samples are drawn.  Default is None, in which case a\n",
      "        single value is returned.\n",
      "    dtype : dtype, optional\n",
      "        Desired dtype of the result, only `float64` and `float32` are supported.\n",
      "        Byteorder must be native. The default value is np.float64.\n",
      "    out : ndarray, optional\n",
      "        Alternative output array in which to place the result. If size is not None,\n",
      "        it must have the same shape as the provided size and must match the type of\n",
      "        the output values.\n",
      "    \n",
      "    Returns\n",
      "    -------\n",
      "    out : float or ndarray of floats\n",
      "        Array of random floats of shape `size` (unless ``size=None``, in which\n",
      "        case a single float is returned).\n",
      "    \n",
      "    Examples\n",
      "    --------\n",
      "    >>> rng = np.random.default_rng()\n",
      "    >>> rng.random()\n",
      "    0.47108547995356098 # random\n",
      "    >>> type(rng.random())\n",
      "    <class 'float'>\n",
      "    >>> rng.random((5,))\n",
      "    array([ 0.30220482,  0.86820401,  0.1654503 ,  0.11659149,  0.54323428]) # random\n",
      "    \n",
      "    Three-by-two array of random numbers from [-5, 0):\n",
      "    \n",
      "    >>> 5 * rng.random((3, 2)) - 5\n",
      "    array([[-3.99149989, -0.52338984], # random\n",
      "           [-2.99091858, -0.79479508],\n",
      "           [-1.23204345, -1.75224494]])\n",
      "\n"
     ]
    }
   ],
   "source": [
    "help(rng.random)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 15,
   "id": "91b884c6",
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "array([[0.14373169, 0.04151085, 0.85160258, 0.5625753 , 0.77434184],\n",
       "       [0.09323801, 0.63691547, 0.83783101, 0.60707909, 0.69066845],\n",
       "       [0.65647018, 0.45466071, 0.77161217, 0.53020513, 0.71808796]])"
      ]
     },
     "execution_count": 15,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "arr = rng.random((3,5))\n",
    "arr"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "50d2e02b-0c05-45e7-8b1a-a1a323315899",
   "metadata": {},
   "source": [
    "The random numbers in `arr` span from 0 to 1 (a distance of 1 apart).  We want to go between -1 and 4, so we eventually want a width of 5.  That is why we will multiply by 5."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 16,
   "id": "81086e0b",
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "array([[0.71865844, 0.20755425, 4.25801288, 2.81287651, 3.87170919],\n",
       "       [0.46619004, 3.18457733, 4.18915507, 3.03539543, 3.45334223],\n",
       "       [3.28235092, 2.27330357, 3.85806084, 2.65102563, 3.59043979]])"
      ]
     },
     "execution_count": 16,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "arr*5"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "06caae64-6052-4666-9daa-065f503ce5c5",
   "metadata": {},
   "source": [
    "The above array goes between 0 and 5, but we want it to go between -1 and 4, so we subract 1."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 17,
   "id": "6ef81892",
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "array([[-0.28134156, -0.79244575,  3.25801288,  1.81287651,  2.87170919],\n",
       "       [-0.53380996,  2.18457733,  3.18915507,  2.03539543,  2.45334223],\n",
       "       [ 2.28235092,  1.27330357,  2.85806084,  1.65102563,  2.59043979]])"
      ]
     },
     "execution_count": 17,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "arr*5-1"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "397b0aef-0be9-4474-8f76-846b574a1f4e",
   "metadata": {},
   "source": [
    "Here is a way to make this array all at once (of course the specific random numbers will be different)."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 18,
   "id": "f37e9eb2",
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "array([[-0.01973026,  1.61155096,  2.9866675 ,  1.71899874, -0.01933733],\n",
       "       [ 1.36928355,  2.32786313, -0.00448403, -0.82777187,  0.89141526],\n",
       "       [ 3.13028253, -0.38060258,  3.05444416,  0.42173001,  1.3847107 ]])"
      ]
     },
     "execution_count": 18,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "5*rng.random(size=(3,5)) - 1"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "7db9526d",
   "metadata": {},
   "source": [
    "* Make a length 10 NumPy array of random numbers following a normal distribution with mean 2 and standard deviation 0.1.\n",
    "\n",
    "As just a last example in this section, here is how we can make normally distributed random numbers."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 19,
   "id": "508fe10e",
   "metadata": {
    "tags": [
     "output_scroll"
    ]
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Help on built-in function normal:\n",
      "\n",
      "normal(...) method of numpy.random._generator.Generator instance\n",
      "    normal(loc=0.0, scale=1.0, size=None)\n",
      "    \n",
      "    Draw random samples from a normal (Gaussian) distribution.\n",
      "    \n",
      "    The probability density function of the normal distribution, first\n",
      "    derived by De Moivre and 200 years later by both Gauss and Laplace\n",
      "    independently [2]_, is often called the bell curve because of\n",
      "    its characteristic shape (see the example below).\n",
      "    \n",
      "    The normal distributions occurs often in nature.  For example, it\n",
      "    describes the commonly occurring distribution of samples influenced\n",
      "    by a large number of tiny, random disturbances, each with its own\n",
      "    unique distribution [2]_.\n",
      "    \n",
      "    Parameters\n",
      "    ----------\n",
      "    loc : float or array_like of floats\n",
      "        Mean (\"centre\") of the distribution.\n",
      "    scale : float or array_like of floats\n",
      "        Standard deviation (spread or \"width\") of the distribution. Must be\n",
      "        non-negative.\n",
      "    size : int or tuple of ints, optional\n",
      "        Output shape.  If the given shape is, e.g., ``(m, n, k)``, then\n",
      "        ``m * n * k`` samples are drawn.  If size is ``None`` (default),\n",
      "        a single value is returned if ``loc`` and ``scale`` are both scalars.\n",
      "        Otherwise, ``np.broadcast(loc, scale).size`` samples are drawn.\n",
      "    \n",
      "    Returns\n",
      "    -------\n",
      "    out : ndarray or scalar\n",
      "        Drawn samples from the parameterized normal distribution.\n",
      "    \n",
      "    See Also\n",
      "    --------\n",
      "    scipy.stats.norm : probability density function, distribution or\n",
      "        cumulative density function, etc.\n",
      "    \n",
      "    Notes\n",
      "    -----\n",
      "    The probability density for the Gaussian distribution is\n",
      "    \n",
      "    .. math:: p(x) = \\frac{1}{\\sqrt{ 2 \\pi \\sigma^2 }}\n",
      "                     e^{ - \\frac{ (x - \\mu)^2 } {2 \\sigma^2} },\n",
      "    \n",
      "    where :math:`\\mu` is the mean and :math:`\\sigma` the standard\n",
      "    deviation. The square of the standard deviation, :math:`\\sigma^2`,\n",
      "    is called the variance.\n",
      "    \n",
      "    The function has its peak at the mean, and its \"spread\" increases with\n",
      "    the standard deviation (the function reaches 0.607 times its maximum at\n",
      "    :math:`x + \\sigma` and :math:`x - \\sigma` [2]_).  This implies that\n",
      "    :meth:`normal` is more likely to return samples lying close to the\n",
      "    mean, rather than those far away.\n",
      "    \n",
      "    References\n",
      "    ----------\n",
      "    .. [1] Wikipedia, \"Normal distribution\",\n",
      "           https://en.wikipedia.org/wiki/Normal_distribution\n",
      "    .. [2] P. R. Peebles Jr., \"Central Limit Theorem\" in \"Probability,\n",
      "           Random Variables and Random Signal Principles\", 4th ed., 2001,\n",
      "           pp. 51, 51, 125.\n",
      "    \n",
      "    Examples\n",
      "    --------\n",
      "    Draw samples from the distribution:\n",
      "    \n",
      "    >>> mu, sigma = 0, 0.1 # mean and standard deviation\n",
      "    >>> s = np.random.default_rng().normal(mu, sigma, 1000)\n",
      "    \n",
      "    Verify the mean and the variance:\n",
      "    \n",
      "    >>> abs(mu - np.mean(s))\n",
      "    0.0  # may vary\n",
      "    \n",
      "    >>> abs(sigma - np.std(s, ddof=1))\n",
      "    0.0  # may vary\n",
      "    \n",
      "    Display the histogram of the samples, along with\n",
      "    the probability density function:\n",
      "    \n",
      "    >>> import matplotlib.pyplot as plt\n",
      "    >>> count, bins, ignored = plt.hist(s, 30, density=True)\n",
      "    >>> plt.plot(bins, 1/(sigma * np.sqrt(2 * np.pi)) *\n",
      "    ...                np.exp( - (bins - mu)**2 / (2 * sigma**2) ),\n",
      "    ...          linewidth=2, color='r')\n",
      "    >>> plt.show()\n",
      "    \n",
      "    Two-by-four array of samples from N(3, 6.25):\n",
      "    \n",
      "    >>> np.random.default_rng().normal(3, 2.5, size=(2, 4))\n",
      "    array([[-4.49401501,  4.00950034, -1.81814867,  7.29718677],   # random\n",
      "           [ 0.39924804,  4.68456316,  4.99394529,  4.84057254]])  # random\n",
      "\n"
     ]
    }
   ],
   "source": [
    "help(rng.normal)"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "c2c9ae1c-cc25-4dfa-a54d-78745e473531",
   "metadata": {},
   "source": [
    "Notice that the result of the following does seem to be clustered around 2.  That makes sense because we had mean 2 with a relatively low standard deviation (0.1)."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 20,
   "id": "a08ea2ec",
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "array([1.97074003, 2.10991763, 1.98318881, 2.00287628, 2.10707454,\n",
       "       2.02365598, 1.89343959, 1.97254061, 1.97359416, 1.96238154])"
      ]
     },
     "execution_count": 20,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "rng.normal(2, 0.1, size=10)"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "026a62d8-9d07-46d9-b642-ce1f4b754bb7",
   "metadata": {},
   "source": [
    "The array is displayed almost like it's two-dimensional, but notice that there is only one set of brackets.  It really is one-dimensional, as we can verify by checking its `shape` attribute."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 21,
   "id": "4dc97adc",
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "(10,)"
      ]
     },
     "execution_count": 21,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "rng.normal(2, 0.1, size=10).shape"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "a0e2d890",
   "metadata": {},
   "source": [
    "## Changing rows and columns\n",
    "\n",
    "<iframe width=\"560\" height=\"315\" src=\"https://www.youtube.com/embed/cTBXH47Go_8\" title=\"YouTube video player\" frameborder=\"0\" allow=\"accelerometer; autoplay; clipboard-write; encrypted-media; gyroscope; picture-in-picture\" allowfullscreen></iframe>"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "4341320a-e5e2-4aae-9224-78689503d3d3",
   "metadata": {},
   "source": [
    "Here we're going to start with (a slight variant of) the code from an [earlier example](3x3-array)."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 2,
   "id": "35580479",
   "metadata": {},
   "outputs": [],
   "source": [
    "arr = np.zeros((4,4))\n",
    "for i in range(4):\n",
    "    arr[i] = i"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 3,
   "id": "7342ceb3",
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "array([[0., 0., 0., 0.],\n",
       "       [1., 1., 1., 1.],\n",
       "       [2., 2., 2., 2.],\n",
       "       [3., 3., 3., 3.]])"
      ]
     },
     "execution_count": 3,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "arr"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 4,
   "id": "2b097ed6",
   "metadata": {},
   "outputs": [],
   "source": [
    "arr = np.zeros((4,4))"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 6,
   "id": "c2798348",
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "array([[0., 0., 0., 0.],\n",
       "       [0., 0., 0., 0.],\n",
       "       [0., 0., 0., 0.],\n",
       "       [0., 0., 0., 0.]])"
      ]
     },
     "execution_count": 6,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "arr"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "d764fbf5-d9bc-402f-85e1-4450234195f7",
   "metadata": {},
   "source": [
    "If we use indexing of the form `arr[i]` where `arr` is a two-dimensional array, this `arr[i]` will represent the i-th row of `arr`."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 5,
   "id": "7c992dce",
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "array([0., 0., 0., 0.])"
      ]
     },
     "execution_count": 5,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "arr[2]"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "3146df19-5ba8-4e68-8871-152e79b67959",
   "metadata": {},
   "source": [
    "Here we set the second row (where as always we start counting from 0) to be all 13s."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 7,
   "id": "9e6a275b",
   "metadata": {},
   "outputs": [],
   "source": [
    "arr[2] = 13"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 8,
   "id": "581943a6",
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "array([[ 0.,  0.,  0.,  0.],\n",
       "       [ 0.,  0.,  0.,  0.],\n",
       "       [13., 13., 13., 13.],\n",
       "       [ 0.,  0.,  0.,  0.]])"
      ]
     },
     "execution_count": 8,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "arr"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "ab4e0038-851e-48e1-933d-ddf79fe1178e",
   "metadata": {},
   "source": [
    "Accessing a column is slightly harder.  You should read `arr[:,2]` as indicating \"every row, the second column\"."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 9,
   "id": "c2f83eb5",
   "metadata": {},
   "outputs": [],
   "source": [
    "arr[:,2] = -4"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 10,
   "id": "ffc070cc",
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "array([[ 0.,  0., -4.,  0.],\n",
       "       [ 0.,  0., -4.,  0.],\n",
       "       [13., 13., -4., 13.],\n",
       "       [ 0.,  0., -4.,  0.]])"
      ]
     },
     "execution_count": 10,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "arr"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "99bc594f-05c7-4312-9314-30c7df018c0c",
   "metadata": {},
   "source": [
    "The same sort of indexing with a colon could be used with rows.  Here `arr[1,:]` is the same as `arr[1]`.  The `:` in this case can be read as, \"every column\".  In the following, we go to row 1 and set all of its entries to be 1."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 11,
   "id": "e6e15116",
   "metadata": {},
   "outputs": [],
   "source": [
    "arr[1,:] = 1"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 12,
   "id": "5a673de6",
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "array([[ 0.,  0., -4.,  0.],\n",
       "       [ 1.,  1.,  1.,  1.],\n",
       "       [13., 13., -4., 13.],\n",
       "       [ 0.,  0., -4.,  0.]])"
      ]
     },
     "execution_count": 12,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "arr"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "126e964b-5a44-456f-9f71-6ac81922abcd",
   "metadata": {},
   "source": [
    "In the following, we are storing the second column with the variable name `v`.  This column is a one-dimensional NumPy array."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 13,
   "id": "acff2b60",
   "metadata": {},
   "outputs": [],
   "source": [
    "v = arr[:, 2]"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "44d41123-1907-4295-8b99-23897dcb5cc7",
   "metadata": {},
   "source": [
    "Notice how `v` is displayed horizontally.  Looking at `v`, there is no evidence that this corresponds to a column in our array."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 14,
   "id": "1ea68baf",
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "array([-4.,  1., -4., -4.])"
      ]
     },
     "execution_count": 14,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "v"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "fbc90753-5039-462a-9ebe-037004086e24",
   "metadata": {},
   "source": [
    "Here is how a length-1 tuple is displayed in Python, in this case, the length-1 tuple that has only the number 4 in it is written `(4,)`."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 15,
   "id": "9734a847",
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "(4,)"
      ]
     },
     "execution_count": 15,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "v.shape"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "63b85d90-d575-4091-b84e-a5a27b843ebd",
   "metadata": {},
   "source": [
    "The following code is trying to assign the 3rd row to have the values `[2,10]`.  In this case, we get an error message.  The error message says that we cannot *broadcast* from shape `(2,)` to shape `(4,)`.  In this case, `[2,10]` has shape `(2,)` and `arr[3]` has shape `(4,)`.  Broadcasting is a difficult and important notion in NumPy."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 16,
   "id": "0161b9c7",
   "metadata": {},
   "outputs": [
    {
     "ename": "ValueError",
     "evalue": "could not broadcast input array from shape (2,) into shape (4,)",
     "output_type": "error",
     "traceback": [
      "\u001b[0;31m---------------------------------------------------------------------------\u001b[0m",
      "\u001b[0;31mValueError\u001b[0m                                Traceback (most recent call last)",
      "Input \u001b[0;32mIn [16]\u001b[0m, in \u001b[0;36m<cell line: 1>\u001b[0;34m()\u001b[0m\n\u001b[0;32m----> 1\u001b[0m arr[\u001b[38;5;241m3\u001b[39m] \u001b[38;5;241m=\u001b[39m [\u001b[38;5;241m2\u001b[39m,\u001b[38;5;241m10\u001b[39m]\n",
      "\u001b[0;31mValueError\u001b[0m: could not broadcast input array from shape (2,) into shape (4,)"
     ]
    }
   ],
   "source": [
    "arr[3] = [2,10]"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "8b653635-ad37-40c5-b0d7-5ae4a14087ba",
   "metadata": {},
   "source": [
    "Here is an example of two different shapes where we can broadcast from one to the other.  In this case, `[1,3,4,7]` has shape `(4,)` and `arr[:]` stands for all the entries in the entire array `arr`, which has shape `(4,4)`.  These two shapes are compatible with respect to broadcasting.\n",
    "\n",
    "Two shapes in NumPy are compatible with respect to broadcasting if, starting from the right-most dimension (the last dimension), the two dimensions are either equal or one of them is equal to 1."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 17,
   "id": "be3e609f",
   "metadata": {},
   "outputs": [],
   "source": [
    "arr[:] = [1,3,4,7]"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 18,
   "id": "e3d6f5e8",
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "array([[1., 3., 4., 7.],\n",
       "       [1., 3., 4., 7.],\n",
       "       [1., 3., 4., 7.],\n",
       "       [1., 3., 4., 7.]])"
      ]
     },
     "execution_count": 18,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "arr"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 21,
   "id": "f273d5f0",
   "metadata": {},
   "outputs": [],
   "source": [
    "w = np.array([1,3,4,7])"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 19,
   "id": "65ce816d",
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "(4, 4)"
      ]
     },
     "execution_count": 19,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "arr.shape"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 22,
   "id": "28989753",
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "(4,)"
      ]
     },
     "execution_count": 22,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "w.shape"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "75f4114b-876a-41eb-a4cb-090fa8ef113d",
   "metadata": {},
   "source": [
    "Here is a for-loop version of creating an array `arr`."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 23,
   "id": "c8398eee",
   "metadata": {},
   "outputs": [],
   "source": [
    "arr = np.zeros((3,3))\n",
    "for i in range(3):\n",
    "    arr[i] = i"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 24,
   "id": "bae8bd4f",
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "array([[0., 0., 0.],\n",
       "       [1., 1., 1.],\n",
       "       [2., 2., 2.]])"
      ]
     },
     "execution_count": 24,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "arr"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "48ff1cd5-381b-4ccd-b036-9a4b00f0e161",
   "metadata": {},
   "source": [
    "Here is a way that uses broadcasting followed by taking the matrix transpose."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 27,
   "id": "691b525f",
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "array([[0., 0., 0.],\n",
       "       [1., 1., 1.],\n",
       "       [2., 2., 2.]])"
      ]
     },
     "execution_count": 27,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "arr = np.zeros((3,3))\n",
    "arr[:] = np.arange(3)\n",
    "arr.T"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "954eb0dd-1dbb-442d-9ec5-3dbcf87ca7c2",
   "metadata": {},
   "source": [
    "Here is what `arr` looked like before we took the matrix transpose.  We broadcast from `np.arange(3)` to the 3x3 array `arr`.  If we want to actually change `arr`, we need to reassign `arr` after taking the transpose, using `arr = arr.T`."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 28,
   "id": "626f53fa",
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "array([[0., 1., 2.],\n",
       "       [0., 1., 2.],\n",
       "       [0., 1., 2.]])"
      ]
     },
     "execution_count": 28,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "arr"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 29,
   "id": "9ab77043",
   "metadata": {},
   "outputs": [],
   "source": [
    "arr = np.zeros((3,3))\n",
    "arr[:] = np.arange(3)\n",
    "arr = arr.T"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 30,
   "id": "7634e2a4",
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "array([[0., 0., 0.],\n",
       "       [1., 1., 1.],\n",
       "       [2., 2., 2.]])"
      ]
     },
     "execution_count": 30,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "arr"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "35843d2f-34a5-4f1b-9c1e-6872bd98fea0",
   "metadata": {},
   "source": [
    "Here is the code for another way (that avoids taking the transpose).  It is a little complicated, so we will break down below what was happening."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 31,
   "id": "f9b52994",
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "array([[0., 0., 0.],\n",
       "       [1., 1., 1.],\n",
       "       [2., 2., 2.]])"
      ]
     },
     "execution_count": 31,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "arr = np.zeros((3,3))\n",
    "arr[:] = np.arange(3).reshape((3,1))\n",
    "arr"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "693327d9-1339-4999-a449-0b856c060ae0",
   "metadata": {},
   "source": [
    "Let's look in particular at the right-hand side of `arr[:] = np.arange(3).reshape((3,1))`."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 32,
   "id": "9257605b",
   "metadata": {},
   "outputs": [],
   "source": [
    "x = np.arange(3).reshape((3,1))"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 33,
   "id": "0f5e8a2b",
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "array([[0],\n",
       "       [1],\n",
       "       [2]])"
      ]
     },
     "execution_count": 33,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "x"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "e53ed026-6908-4820-b3a9-622e05a1ad9a",
   "metadata": {},
   "source": [
    "Notice that these dimensions are compatible: for the right-most dimensions, we have 1 and 3, which are compatible (since one of them is equal to 1), and in the next dimension, we have 3 and 3, which are compatible (since they are equal)."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 34,
   "id": "703dae1b",
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "(3, 1)"
      ]
     },
     "execution_count": 34,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "x.shape"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 35,
   "id": "46db1e1d",
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "(3, 3)"
      ]
     },
     "execution_count": 35,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "arr.shape"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "45736552-1167-4b74-ab6f-566b0171d8ce",
   "metadata": {},
   "source": [
    "If we tried to reshape using `(2,1)`, we would get an error, because we can't fit 3 numbers into an array of shape `(2,1)`."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 36,
   "id": "b43904c1",
   "metadata": {},
   "outputs": [
    {
     "ename": "ValueError",
     "evalue": "cannot reshape array of size 3 into shape (2,1)",
     "output_type": "error",
     "traceback": [
      "\u001b[0;31m---------------------------------------------------------------------------\u001b[0m",
      "\u001b[0;31mValueError\u001b[0m                                Traceback (most recent call last)",
      "Input \u001b[0;32mIn [36]\u001b[0m, in \u001b[0;36m<cell line: 1>\u001b[0;34m()\u001b[0m\n\u001b[0;32m----> 1\u001b[0m y \u001b[38;5;241m=\u001b[39m \u001b[43mnp\u001b[49m\u001b[38;5;241;43m.\u001b[39;49m\u001b[43marange\u001b[49m\u001b[43m(\u001b[49m\u001b[38;5;241;43m3\u001b[39;49m\u001b[43m)\u001b[49m\u001b[38;5;241;43m.\u001b[39;49m\u001b[43mreshape\u001b[49m\u001b[43m(\u001b[49m\u001b[43m(\u001b[49m\u001b[38;5;241;43m2\u001b[39;49m\u001b[43m,\u001b[49m\u001b[38;5;241;43m1\u001b[39;49m\u001b[43m)\u001b[49m\u001b[43m)\u001b[49m\n",
      "\u001b[0;31mValueError\u001b[0m: cannot reshape array of size 3 into shape (2,1)"
     ]
    }
   ],
   "source": [
    "y = np.arange(3).reshape((2,1))"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "7dfbd839-1658-4d9f-90c6-268396832b13",
   "metadata": {},
   "source": [
    "A very convenient abbreviation to specify \"just 1 column\" is to use `.reshape((-1,1))`.  Then NumPy is automatically going to replace the `-1` with whatever positive integer is necessary to fill in all the numbers.  In this case, the `-1` gets replaced by `3`."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 37,
   "id": "9e5053cf",
   "metadata": {
    "tags": []
   },
   "outputs": [],
   "source": [
    "z = np.arange(3).reshape((-1,1))"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 38,
   "id": "9d7da29d",
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "array([[0],\n",
       "       [1],\n",
       "       [2]])"
      ]
     },
     "execution_count": 38,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "z"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 39,
   "id": "2f97a596",
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "(3, 1)"
      ]
     },
     "execution_count": 39,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "z.shape"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 40,
   "id": "b90a1627",
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "array([[0., 0., 0.],\n",
       "       [1., 1., 1.],\n",
       "       [2., 2., 2.]])"
      ]
     },
     "execution_count": 40,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "arr"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "125cff7c-f9e8-4bba-ad55-2411a3535291",
   "metadata": {},
   "source": [
    "As another example of this `-1` syntax, we get the following length-9 one-dimensional NumPy array.  NumPy automatically replaced the `-1` with a `9` in this case, because there were nine numbers in `arr`."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 41,
   "id": "adcf9996",
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "array([0., 0., 0., 1., 1., 1., 2., 2., 2.])"
      ]
     },
     "execution_count": 41,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "arr.reshape(-1)"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "9814d547",
   "metadata": {},
   "source": [
    "## Timing a computation with a NumPy array vs with a list\n",
    "\n",
    "<iframe width=\"560\" height=\"315\" src=\"https://www.youtube.com/embed/-rsk3-YRFnY\" title=\"YouTube video player\" frameborder=\"0\" allow=\"accelerometer; autoplay; clipboard-write; encrypted-media; gyroscope; picture-in-picture\" allowfullscreen></iframe>\n",
    "\n",
    "The main goal in this section is to see examples where code written using NumPy can run much faster than code written using base Python.\n",
    "\n",
    "We'll make some examples using random numbers, so we start out by instantiating a random number generator object."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 2,
   "id": "b3a0ca9c",
   "metadata": {},
   "outputs": [],
   "source": [
    "rng = np.random.default_rng()"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "584c40ba-c03e-49ec-a4c8-dbd8cb7fbc1c",
   "metadata": {},
   "source": [
    "Now we make a length one million list of random integers from 1 to 10 (not including 10).  We will be dividing by these numbers, so that's why we don't start with 0.  The `integers` method of `rng` is a NumPy array."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 3,
   "id": "4381f879",
   "metadata": {},
   "outputs": [],
   "source": [
    "arr = rng.integers(1,10,size=10**6)"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "26da00ae-3399-46bc-8cf8-7d18f1c00957",
   "metadata": {},
   "source": [
    "Here is the list version of `arr`."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 4,
   "id": "796d0b3f",
   "metadata": {},
   "outputs": [],
   "source": [
    "mylist = list(arr)"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "3e13cdfd-6a31-4356-807e-dee1c920d93e",
   "metadata": {},
   "source": [
    "Here are the first 5 elements in `arr`."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 5,
   "id": "4cdbc465",
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "array([3, 7, 8, 2, 1])"
      ]
     },
     "execution_count": 5,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "arr[:5]"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "9f2cc719-4ef8-48e0-82b7-8c5a716361f5",
   "metadata": {},
   "source": [
    "Let's compute `1.5` divided by each of these five numbers."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 6,
   "id": "da7e774d",
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "array([0.5       , 0.21428571, 0.1875    , 0.75      , 1.5       ])"
      ]
     },
     "execution_count": 6,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "1.5/arr[:5]"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "b89e609e-ce65-4083-89dd-9f9204704993",
   "metadata": {},
   "source": [
    "If we try to do the same thing with a list, we get an error, saying we can't combine the float 1.5 with the list `mylist` using the operator `/`."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 7,
   "id": "cb610806",
   "metadata": {},
   "outputs": [
    {
     "ename": "TypeError",
     "evalue": "unsupported operand type(s) for /: 'float' and 'list'",
     "output_type": "error",
     "traceback": [
      "\u001b[0;31m---------------------------------------------------------------------------\u001b[0m",
      "\u001b[0;31mTypeError\u001b[0m                                 Traceback (most recent call last)",
      "Input \u001b[0;32mIn [7]\u001b[0m, in \u001b[0;36m<cell line: 1>\u001b[0;34m()\u001b[0m\n\u001b[0;32m----> 1\u001b[0m \u001b[38;5;241;43m1.5\u001b[39;49m\u001b[38;5;241;43m/\u001b[39;49m\u001b[43mmylist\u001b[49m\u001b[43m[\u001b[49m\u001b[43m:\u001b[49m\u001b[38;5;241;43m5\u001b[39;49m\u001b[43m]\u001b[49m\n",
      "\u001b[0;31mTypeError\u001b[0m: unsupported operand type(s) for /: 'float' and 'list'"
     ]
    }
   ],
   "source": [
    "1.5/mylist[:5]"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "b15e5ab7-36fb-4765-b828-9bbc634d6585",
   "metadata": {},
   "source": [
    "Here is one way to make the list version, using a for loop."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 8,
   "id": "897dd009",
   "metadata": {},
   "outputs": [],
   "source": [
    "newlist = []\n",
    "for x in mylist[:5]:\n",
    "    newlist.append(1.5/x)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 9,
   "id": "0f03e309",
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "[0.5, 0.21428571428571427, 0.1875, 0.75, 1.5]"
      ]
     },
     "execution_count": 9,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "newlist"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "5f426cc1-6075-45b6-91e7-6e6325b32830",
   "metadata": {},
   "source": [
    "We haven't carefully studied list comprehension yet (we will [next week](list-comp)), but just for contrast, here is how we can make this same list using list comprehension.  The list comprehension is definitely more elegant (often said to be more \"Pythonic\") than the for loop version."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 10,
   "id": "96b52f13",
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "[0.5, 0.21428571428571427, 0.1875, 0.75, 1.5]"
      ]
     },
     "execution_count": 10,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "[1.5/x for x in mylist[:5]]"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "acc4eb85-c09a-48fd-9c2b-1acd23eadd89",
   "metadata": {},
   "source": [
    "Let's see how the timings compare."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 11,
   "id": "795d35ad",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "1.12 ms ± 38.9 µs per loop (mean ± std. dev. of 7 runs, 1,000 loops each)\n"
     ]
    }
   ],
   "source": [
    "%%timeit\n",
    "1.5/arr"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 12,
   "id": "60e7324f",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "1.66 s ± 35.3 ms per loop (mean ± std. dev. of 7 runs, 1 loop each)\n"
     ]
    }
   ],
   "source": [
    "%%timeit\n",
    "newlist = []\n",
    "for x in mylist:\n",
    "    newlist.append(1.5/x)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 13,
   "id": "6c1e90c8",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "1.62 s ± 27.2 ms per loop (mean ± std. dev. of 7 runs, 1 loop each)\n"
     ]
    }
   ],
   "source": [
    "%%timeit\n",
    "[1.5/x for x in mylist]"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "8f0bc2db-4871-41dc-a876-a2d9fc8b9a40",
   "metadata": {},
   "source": [
    "Notice how the NumPy version is over one thousand times faster than the list versions.  My understanding is that there are two important reasons the NumPy version is much faster.  One reason is that the NumPy version of division is *vectorized*, meaning all the divisions are performed at once (no looping is required).  The other reason is that the entries in `arr` are attached to a specific data type, so no time is spent checking the data types of the elements in `arr`.\n",
    "\n",
    "Also notice that, even though the list comprehension version is more elegant than the for loop version, the timings are very similar."
   ]
  },
  {
   "cell_type": "markdown",
   "id": "0a2303e3",
   "metadata": {
    "tags": []
   },
   "source": [
    "## Counting using NumPy\n",
    "\n",
    "<iframe width=\"560\" height=\"315\" src=\"https://www.youtube.com/embed/7QIKxp2B3iU\" title=\"YouTube video player\" frameborder=\"0\" allow=\"accelerometer; autoplay; clipboard-write; encrypted-media; gyroscope; picture-in-picture\" allowfullscreen></iframe>"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "ca66d001-ca01-411a-9898-033eb7687c27",
   "metadata": {},
   "source": [
    "We've seen examples of making arrays using NumPy and of performing basic arithmetic with NumPy arrays.  In this section, we'll see some examples of counting using NumPy.  For example, if we want to make a probability estimate using the formula \"number of successes divided by number of experiments\", then being able to count efficiently will be very helpful.\n",
    "\n",
    "Our example will involve random numbers.  We'll start with a small number (`n = 20`) of random numbers, and then later we will increase `n`.  In general, you should imagine that the bigger the sample, the more accurate our probability estimate should be."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 2,
   "id": "ca354d28",
   "metadata": {},
   "outputs": [],
   "source": [
    "rng = np.random.default_rng()"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 3,
   "id": "fe5a8a64",
   "metadata": {},
   "outputs": [],
   "source": [
    "n = 20"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "0048e73d",
   "metadata": {},
   "source": [
    "* Make a NumPy array of random integers between -50 and 50 (inclusive).  Also make a list with the same numbers."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 4,
   "id": "f184e28c",
   "metadata": {},
   "outputs": [],
   "source": [
    "arr = rng.integers(-50, 51, size=n)"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "fe0648f7-fac2-4c9f-8edd-19afac714b3b",
   "metadata": {},
   "source": [
    "Here is the list version of the array `arr`.  (Be sure to always use a somewhat random variable name like `mylist`, as opposed to something like `list`, because `list` is already a built-in term in Python.)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 5,
   "id": "5f8df3f8",
   "metadata": {},
   "outputs": [],
   "source": [
    "mylist = list(arr)"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "ab1f09c9",
   "metadata": {},
   "source": [
    "* How many of the integers are strictly less than 10?"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "2bb3ee35-3d10-4bfe-8d3b-7a3e5eb58339",
   "metadata": {},
   "source": [
    "Here is a for-loop approach to the above question."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 6,
   "id": "3aa287e7",
   "metadata": {},
   "outputs": [],
   "source": [
    "count = 0\n",
    "for x in mylist:\n",
    "    if x < 10:\n",
    "        count += 1"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 7,
   "id": "6bcfae9e",
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "13"
      ]
     },
     "execution_count": 7,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "count"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "d9d6e405-2ec1-4785-b31c-cbddd4f936f3",
   "metadata": {},
   "source": [
    "Here is the list comprehension version of making this count; again, notice how much more concise this is than the for-loop approach.  (We will cover list comprehension more systematically [next week](list-comp)... for now just think of these list comprehension examples as previews.)  We get the same answer `13` as before."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 8,
   "id": "618887f0",
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "13"
      ]
     },
     "execution_count": 8,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "len([x for x in mylist if x < 10])"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "c0546a99-8360-46eb-b275-1312ef26962b",
   "metadata": {},
   "source": [
    "To explain the NumPy approach to counting, it helps to actually look at the values in `arr`."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 9,
   "id": "b36d9012",
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "array([-20,   7,  32, -46,  -2, -16, -12, -39, -22, -38,  17, -20,  49,\n",
       "        27, -36,   0,  49,   3,  41,  39])"
      ]
     },
     "execution_count": 9,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "arr"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "bd54f23b-b1c7-432e-a8fa-5ea15d61eff8",
   "metadata": {},
   "source": [
    "The expression `arr < 10` creates what is called a Boolean array (meaning an array of `True`s and `False`s).  One way to think about this is, it is broadcasting the `< 10` portion to all of the entries in `arr`.  Be sure you understand how the following Boolean array relates to the numbers in `arr`."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 10,
   "id": "00a00c36",
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "array([ True,  True, False,  True,  True,  True,  True,  True,  True,\n",
       "        True, False,  True, False, False,  True,  True, False,  True,\n",
       "       False, False])"
      ]
     },
     "execution_count": 10,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "arr < 10"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "dd11edb4-f209-429e-a702-edd2aac2c105",
   "metadata": {},
   "source": [
    "There are many different possible ways to count `True` in this Boolean array.  I believe the approach which is usually fastest is to use NumPy's `count_nonzero` function.  (Remember that `True` corresponds to `1` and that `False` corresponds to `0`, so in a Boolean array, counting nonzero elements is the same as counting how often `True` occurs.)  Again, we get the same answer `13` as above."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 11,
   "id": "76ffdefd",
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "13"
      ]
     },
     "execution_count": 11,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "np.count_nonzero(arr < 10)"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "f33b48cf",
   "metadata": {},
   "source": [
    "* At what indices do these integers less than 10 occur?"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "8ca3852f-9145-4ee0-94af-250927f95e02",
   "metadata": {},
   "source": [
    "We use the NumPy function `np.nonzero` to find indices where the value is `True` (compare this to `np.count_nonzero` which we found above).  Notice that the resulting output is *not* a NumPy array... the output is a length-1 tuple which contains a NumPy array."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 12,
   "id": "0c0ac6e6",
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "(array([ 0,  1,  3,  4,  5,  6,  7,  8,  9, 11, 14, 15, 17]),)"
      ]
     },
     "execution_count": 12,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "np.nonzero(arr < 10)"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "5017b366",
   "metadata": {},
   "source": [
    "* Make a new array containing only these integers."
   ]
  },
  {
   "cell_type": "markdown",
   "id": "d961d81f-1de0-469f-ad18-39d46ef0f6f7",
   "metadata": {},
   "source": [
    "We first show the for-loop approach."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 13,
   "id": "b0f8632d",
   "metadata": {},
   "outputs": [],
   "source": [
    "newlist = []\n",
    "for x in mylist:\n",
    "    if x < 10:\n",
    "        newlist.append(x)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 14,
   "id": "adad42b9",
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "[-20, 7, -46, -2, -16, -12, -39, -22, -38, -20, -36, 0, 3]"
      ]
     },
     "execution_count": 14,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "newlist"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "77d6b63b-5ddb-41b8-8a41-de64fc98c037",
   "metadata": {},
   "source": [
    "Here is the list comprehension aproach.  We basically already did this approach above (the only difference is that we included a `len` wrapper above)."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 15,
   "id": "b2e3e24a",
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "[-20, 7, -46, -2, -16, -12, -39, -22, -38, -20, -36, 0, 3]"
      ]
     },
     "execution_count": 15,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "[x for x in mylist if x < 10]"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 17,
   "id": "9799c3bd",
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "array([-20,   7,  32, -46,  -2, -16, -12, -39, -22, -38,  17, -20,  49,\n",
       "        27, -36,   0,  49,   3,  41,  39])"
      ]
     },
     "execution_count": 17,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "arr"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 16,
   "id": "990bb3fb",
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "array([ True,  True, False,  True,  True,  True,  True,  True,  True,\n",
       "        True, False,  True, False, False,  True,  True, False,  True,\n",
       "       False, False])"
      ]
     },
     "execution_count": 16,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "arr < 10"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "0b72c40d-9a9c-4560-a234-d81f210fcc4c",
   "metadata": {},
   "source": [
    "The following is what is called \"Boolean indexing\" or \"Applying a Boolean mask\".  You should read `arr[arr < 10]` similarly to how you would read `arr[:5]`.  Both are indicating which elements in `arr` to keep.  In the case of `arr[arr < 10]`, the part inside the brackets is a Boolean array, and we keep all the elements where `True` occurs."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 18,
   "id": "8a0d7eb2",
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "array([-20,   7, -46,  -2, -16, -12, -39, -22, -38, -20, -36,   0,   3])"
      ]
     },
     "execution_count": 18,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "arr[arr < 10]"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "31cee626",
   "metadata": {},
   "source": [
    "* If you pick a random integer from such an array, what's the probability it is less than 10?\n",
    "\n",
    "To get an accurate probability estimate, we want to use as large a value of `n` as can be handled in a reasonably short amount of time; ten million works well in this case."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 19,
   "id": "fb52261f",
   "metadata": {},
   "outputs": [],
   "source": [
    "n = 10**7"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 20,
   "id": "5d4a3362",
   "metadata": {},
   "outputs": [],
   "source": [
    "arr = rng.integers(-50, 51, size=n)\n",
    "mylist = list(arr)"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "4b1a98dd-bd5b-4ef2-af77-c44228e99dfa",
   "metadata": {},
   "source": [
    "Here is the for-loop approach.  We think of `count` as the number of successes and we think of `n` as the number of experiments."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 21,
   "id": "af5c3f75",
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "0.5942684"
      ]
     },
     "execution_count": 21,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "count = 0\n",
    "for x in mylist:\n",
    "    if x < 10:\n",
    "        count += 1\n",
    "count/n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 22,
   "id": "2db89a0c",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "930 ms ± 134 ms per loop (mean ± std. dev. of 7 runs, 1 loop each)\n"
     ]
    }
   ],
   "source": [
    "%%timeit\n",
    "count = 0\n",
    "for x in mylist:\n",
    "    if x < 10:\n",
    "        count += 1\n",
    "count/n"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "7c240845-a028-4ce9-b832-ca35d2ea1364",
   "metadata": {},
   "source": [
    "The list comprehension takes a similar amount of time (it's a little faster than the for-loop version)."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 23,
   "id": "868b2a38",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "717 ms ± 69.4 ms per loop (mean ± std. dev. of 7 runs, 1 loop each)\n"
     ]
    }
   ],
   "source": [
    "%%timeit\n",
    "len([x for x in mylist if x < 10])"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "a902c392-7e39-4160-b91c-a22696bf8102",
   "metadata": {},
   "source": [
    "Again, the NumPy version is much faster, over 100 times faster than the list comprehension version (and nearly 200 times faster than the for-loop version)."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 24,
   "id": "0a66b07a",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "5.13 ms ± 235 µs per loop (mean ± std. dev. of 7 runs, 100 loops each)\n"
     ]
    }
   ],
   "source": [
    "%%timeit\n",
    "np.count_nonzero(arr < 10)"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "799b8fa3-74c3-4aaf-8d77-f2089c2aa8bc",
   "metadata": {},
   "source": [
    "To get a sense for how accurate our probability estimate is, we can run the estimate again with new random numbers and see how similar the probability is."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 25,
   "id": "7a632dc4",
   "metadata": {},
   "outputs": [],
   "source": [
    "arr = rng.integers(-50, 51, size=n)"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "1077c94b-bf97-49bb-9306-2c8d3eea1c25",
   "metadata": {},
   "source": [
    "In both cases, we get a probability estimate of approximately 0.594."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 27,
   "id": "a1ab22f2",
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "0.5939019"
      ]
     },
     "execution_count": 27,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "np.count_nonzero(arr < 10)/n"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "4de35227-9c77-45b2-9980-2642a1d54bec",
   "metadata": {},
   "source": [
    "There are 101 numbers from -50 to 50 (inclusive), and 60 of those are strictly less than 10, so the exact probability is 60/101.  That exact value, 60/101, is very close to our probability estimates, so `n = 10**7` in this case was a big enough sample size to get a very accurate probability estimate."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 28,
   "id": "6bf70392",
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "0.594059405940594"
      ]
     },
     "execution_count": 28,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "60/101"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "be6b1874",
   "metadata": {},
   "source": [
    "## Logic in Python and NumPy\n",
    "\n",
    "<iframe width=\"560\" height=\"315\" src=\"https://www.youtube.com/embed/vdB2jy5h8Nw\" title=\"YouTube video player\" frameborder=\"0\" allow=\"accelerometer; autoplay; clipboard-write; encrypted-media; gyroscope; picture-in-picture\" allowfullscreen></iframe>\n",
    "\n",
    "General rule of thumb:\n",
    "* In base Python, use `and`, `or`, `not`\n",
    "* In NumPy (or pandas), use `&`, `|`, `~` (tilde)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 2,
   "id": "62cc51be",
   "metadata": {},
   "outputs": [],
   "source": [
    "rng = np.random.default_rng()\n",
    "n = 20\n",
    "\n",
    "arr = rng.integers(-50, 51, size=n)\n",
    "mylist = list(arr)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 3,
   "id": "419eabf0",
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "[-20,\n",
       " 17,\n",
       " -11,\n",
       " 29,\n",
       " -4,\n",
       " -50,\n",
       " 40,\n",
       " -36,\n",
       " 23,\n",
       " 24,\n",
       " -38,\n",
       " 37,\n",
       " 6,\n",
       " -32,\n",
       " -35,\n",
       " 2,\n",
       " 16,\n",
       " -32,\n",
       " -46,\n",
       " -47]"
      ]
     },
     "execution_count": 3,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "mylist"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "b6604ff8",
   "metadata": {},
   "source": [
    "* Find all the entries in `arr` and in `mylist` that are strictly between -10 and 10."
   ]
  },
  {
   "cell_type": "markdown",
   "id": "45a13d73-3279-4d95-8f69-96a838022a4d",
   "metadata": {},
   "source": [
    "Here is the list comprehension solution.  We use `and` because we are doing this in base Python."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 4,
   "id": "2f7e6d83",
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "[-4, 6, 2]"
      ]
     },
     "execution_count": 4,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "[x for x in mylist if (x > -10) and (x < 10)]"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "7964a39c-4e29-45e4-a45e-7f32901c5d6e",
   "metadata": {},
   "source": [
    "Here is a more complicated approach, that's just here as an excuse to use `not` and `or`."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 6,
   "id": "b2a24267",
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "[-4, 6, 2]"
      ]
     },
     "execution_count": 6,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "[x for x in mylist if not ((x <= -10) or (x >= 10))]"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "7e343686-8b7c-48f2-b077-8f33f4dbc39e",
   "metadata": {},
   "source": [
    "Here is the NumPy version."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 7,
   "id": "4712dc37",
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "array([-20,  17, -11,  29,  -4, -50,  40, -36,  23,  24, -38,  37,   6,\n",
       "       -32, -35,   2,  16, -32, -46, -47])"
      ]
     },
     "execution_count": 7,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "arr"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 8,
   "id": "448c2b2d",
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "array([False,  True, False,  True,  True, False,  True, False,  True,\n",
       "        True, False,  True,  True, False, False,  True,  True, False,\n",
       "       False, False])"
      ]
     },
     "execution_count": 8,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "arr > -10"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 9,
   "id": "48309359",
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "array([ True, False,  True, False,  True,  True, False,  True, False,\n",
       "       False,  True, False,  True,  True,  True,  True, False,  True,\n",
       "        True,  True])"
      ]
     },
     "execution_count": 9,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "arr < 10"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "bf3f32dd-e32e-4f1d-a2cb-19b37b169e41",
   "metadata": {},
   "source": [
    "If we try to use `and` spelled out between these two Boolean arrays, we will get an error."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 10,
   "id": "7c738709",
   "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 [10]\u001b[0m, in \u001b[0;36m<cell line: 1>\u001b[0;34m()\u001b[0m\n\u001b[0;32m----> 1\u001b[0m (arr \u001b[38;5;241m>\u001b[39m \u001b[38;5;241m-\u001b[39m\u001b[38;5;241m10\u001b[39m) \u001b[38;5;129;01mand\u001b[39;00m (arr \u001b[38;5;241m<\u001b[39m \u001b[38;5;241m10\u001b[39m)\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": [
    "(arr > -10) and (arr < 10)"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "d8a46340-f4a8-4cbc-93f4-b698fc3f5de4",
   "metadata": {},
   "source": [
    "We need to use the `&` to combine these Boolean arrays."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 11,
   "id": "f3baf3f6",
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "array([False, False, False, False,  True, False, False, False, False,\n",
       "       False, False, False,  True, False, False,  True, False, False,\n",
       "       False, False])"
      ]
     },
     "execution_count": 11,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "(arr > -10) & (arr < 10)"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "9aac51cd-79b8-43ec-bafc-c7585919f5b4",
   "metadata": {},
   "source": [
    "Here we find the values using Boolean indexing."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 12,
   "id": "3cf163af",
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "array([-4,  6,  2])"
      ]
     },
     "execution_count": 12,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "arr[(arr > -10) & (arr < 10)]"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "db012604-4274-4754-a4b2-40b360859a8b",
   "metadata": {},
   "source": [
    "Just for fun, here are some other ways to get the same arrays.  We use `~` to negate, and we use the vertical line `|` (sometimes called \"pipe\") for `or`."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 13,
   "id": "7cfde506",
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "array([-4,  6,  2])"
      ]
     },
     "execution_count": 13,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "arr[(~(arr <= -10)) & (~(arr >= 10))]"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "77b90ea9-3aec-4beb-8b8d-7ae69046b197",
   "metadata": {},
   "source": [
    "The following is the analogue of the complicated list example from above.  Notice how we replace `not` and `or` in the list version with `~` and `|` in this NumPy version."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 14,
   "id": "41391c5b",
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "array([-4,  6,  2])"
      ]
     },
     "execution_count": 14,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "arr[~((arr <= -10) | (arr >= 10))]"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "85fed115",
   "metadata": {},
   "source": [
    "## The `axis` keyword argument\n",
    "\n",
    "<iframe width=\"560\" height=\"315\" src=\"https://www.youtube.com/embed/2FPjPFXBjFs\" title=\"YouTube video player\" frameborder=\"0\" allow=\"accelerometer; autoplay; clipboard-write; encrypted-media; gyroscope; picture-in-picture\" allowfullscreen></iframe>"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "e83bf744",
   "metadata": {},
   "source": [
    "* If you roll four distinct 6-sided dice, what is the probability that the biggest value is 5?"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 2,
   "id": "d3f247bc",
   "metadata": {},
   "outputs": [],
   "source": [
    "rng = np.random.default_rng()"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "e4f3ada0-2888-48f5-940d-dd3e35f942a4",
   "metadata": {},
   "source": [
    "Here is an example of simulating this experiment using a NumPy random number generator."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 3,
   "id": "cece30ac",
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "array([4, 3, 5, 1])"
      ]
     },
     "execution_count": 3,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "rng.integers(1, 7, size=4)"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "3e585e93-df3f-4044-b152-b9d3917c510e",
   "metadata": {},
   "source": [
    "Let's try this using ten experiments and a for loop.  (We will eventually want to use many more experiments and we will want to avoid thee for loop.)  Think of `s` as standing for the number of successes.  In the following, we use `np.max` instead of the built-in Python function `max`.  In general, if you have a choice between using a NumPy version or a built-in Python version, you should always prefer the NumPy version."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 4,
   "id": "eef89d7a",
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "0.3"
      ]
     },
     "execution_count": 4,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "exps = 10\n",
    "s = 0\n",
    "\n",
    "for i in range(exps):\n",
    "    if np.max(rng.integers(1, 7, size=4)) == 5:\n",
    "        s += 1\n",
    "\n",
    "s/exps"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "eb1d6736-7e46-4745-91aa-20ac2f2e3852",
   "metadata": {},
   "source": [
    "What we just did is very slow.  Even for just one million experiments, the following took 13 seconds.  (It is slow enough that I wanted to use `%%time`, which runs once, instead of `%%timeit`, which runs multiple times and takes an average.)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 5,
   "id": "e229055d",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "CPU times: user 13.7 s, sys: 164 ms, total: 13.9 s\n",
      "Wall time: 14.3 s\n"
     ]
    },
    {
     "data": {
      "text/plain": [
       "0.284671"
      ]
     },
     "execution_count": 5,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "%%time\n",
    "\n",
    "exps = 10**6\n",
    "s = 0\n",
    "\n",
    "for i in range(exps):\n",
    "    if np.max(rng.integers(1, 7, size=4)) == 5:\n",
    "        s += 1\n",
    "\n",
    "s/exps"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "df36d56e-8e1c-4e7b-8e48-bbf06fafeb9b",
   "metadata": {},
   "source": [
    "The key idea to making this computation more efficient is to work with a two-dimensional array, and to think of each row as corresponding to one experiment."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 6,
   "id": "a3ebc543",
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "array([[1, 2, 3, 5],\n",
       "       [5, 6, 1, 4],\n",
       "       [2, 3, 4, 3],\n",
       "       [5, 5, 5, 4],\n",
       "       [4, 5, 4, 3],\n",
       "       [3, 3, 5, 1],\n",
       "       [6, 4, 2, 5],\n",
       "       [3, 2, 2, 4],\n",
       "       [3, 1, 5, 6],\n",
       "       [2, 3, 4, 2]])"
      ]
     },
     "execution_count": 6,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "exps = 10\n",
    "rng.integers(1, 7, size=(exps,4))"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "312bb61c-4e14-41d1-9959-c33639659188",
   "metadata": {},
   "source": [
    "We can't use `np.max` directly this context (at least, not without using the `axis` keyword argument), because `np.max` will find the maximum of all 40 numbers in this array."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 7,
   "id": "0b92c9df",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "[[1 4 5 1]\n",
      " [6 5 4 4]\n",
      " [2 1 3 3]\n",
      " [6 6 1 6]\n",
      " [6 6 6 6]\n",
      " [1 4 2 2]\n",
      " [4 1 3 3]\n",
      " [5 1 4 5]\n",
      " [3 5 3 5]\n",
      " [3 4 6 1]]\n"
     ]
    },
    {
     "data": {
      "text/plain": [
       "6"
      ]
     },
     "execution_count": 7,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "exps = 10\n",
    "arr = rng.integers(1, 7, size=(exps,4))\n",
    "print(arr)\n",
    "np.max(arr)"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "bb83560f-77d8-4c17-bef1-cf1843976245",
   "metadata": {},
   "source": [
    "As a first workaround, we could use NumPy's `apply_along_axis` function.  The documentation shows that the first three input arguments are: a function, an axis, and an array.  In our case, the function will be `np.max` and the array will be `arr`.  The main topic of this video is, what is meant by the `axis` keyword argument?"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 8,
   "id": "8bf7b2bd",
   "metadata": {
    "tags": [
     "output_scroll"
    ]
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Help on function apply_along_axis in module numpy:\n",
      "\n",
      "apply_along_axis(func1d, axis, arr, *args, **kwargs)\n",
      "    Apply a function to 1-D slices along the given axis.\n",
      "    \n",
      "    Execute `func1d(a, *args, **kwargs)` where `func1d` operates on 1-D arrays\n",
      "    and `a` is a 1-D slice of `arr` along `axis`.\n",
      "    \n",
      "    This is equivalent to (but faster than) the following use of `ndindex` and\n",
      "    `s_`, which sets each of ``ii``, ``jj``, and ``kk`` to a tuple of indices::\n",
      "    \n",
      "        Ni, Nk = a.shape[:axis], a.shape[axis+1:]\n",
      "        for ii in ndindex(Ni):\n",
      "            for kk in ndindex(Nk):\n",
      "                f = func1d(arr[ii + s_[:,] + kk])\n",
      "                Nj = f.shape\n",
      "                for jj in ndindex(Nj):\n",
      "                    out[ii + jj + kk] = f[jj]\n",
      "    \n",
      "    Equivalently, eliminating the inner loop, this can be expressed as::\n",
      "    \n",
      "        Ni, Nk = a.shape[:axis], a.shape[axis+1:]\n",
      "        for ii in ndindex(Ni):\n",
      "            for kk in ndindex(Nk):\n",
      "                out[ii + s_[...,] + kk] = func1d(arr[ii + s_[:,] + kk])\n",
      "    \n",
      "    Parameters\n",
      "    ----------\n",
      "    func1d : function (M,) -> (Nj...)\n",
      "        This function should accept 1-D arrays. It is applied to 1-D\n",
      "        slices of `arr` along the specified axis.\n",
      "    axis : integer\n",
      "        Axis along which `arr` is sliced.\n",
      "    arr : ndarray (Ni..., M, Nk...)\n",
      "        Input array.\n",
      "    args : any\n",
      "        Additional arguments to `func1d`.\n",
      "    kwargs : any\n",
      "        Additional named arguments to `func1d`.\n",
      "    \n",
      "        .. versionadded:: 1.9.0\n",
      "    \n",
      "    \n",
      "    Returns\n",
      "    -------\n",
      "    out : ndarray  (Ni..., Nj..., Nk...)\n",
      "        The output array. The shape of `out` is identical to the shape of\n",
      "        `arr`, except along the `axis` dimension. This axis is removed, and\n",
      "        replaced with new dimensions equal to the shape of the return value\n",
      "        of `func1d`. So if `func1d` returns a scalar `out` will have one\n",
      "        fewer dimensions than `arr`.\n",
      "    \n",
      "    See Also\n",
      "    --------\n",
      "    apply_over_axes : Apply a function repeatedly over multiple axes.\n",
      "    \n",
      "    Examples\n",
      "    --------\n",
      "    >>> def my_func(a):\n",
      "    ...     \"\"\"Average first and last element of a 1-D array\"\"\"\n",
      "    ...     return (a[0] + a[-1]) * 0.5\n",
      "    >>> b = np.array([[1,2,3], [4,5,6], [7,8,9]])\n",
      "    >>> np.apply_along_axis(my_func, 0, b)\n",
      "    array([4., 5., 6.])\n",
      "    >>> np.apply_along_axis(my_func, 1, b)\n",
      "    array([2.,  5.,  8.])\n",
      "    \n",
      "    For a function that returns a 1D array, the number of dimensions in\n",
      "    `outarr` is the same as `arr`.\n",
      "    \n",
      "    >>> b = np.array([[8,1,7], [4,3,9], [5,2,6]])\n",
      "    >>> np.apply_along_axis(sorted, 1, b)\n",
      "    array([[1, 7, 8],\n",
      "           [3, 4, 9],\n",
      "           [2, 5, 6]])\n",
      "    \n",
      "    For a function that returns a higher dimensional array, those dimensions\n",
      "    are inserted in place of the `axis` dimension.\n",
      "    \n",
      "    >>> b = np.array([[1,2,3], [4,5,6], [7,8,9]])\n",
      "    >>> np.apply_along_axis(np.diag, -1, b)\n",
      "    array([[[1, 0, 0],\n",
      "            [0, 2, 0],\n",
      "            [0, 0, 3]],\n",
      "           [[4, 0, 0],\n",
      "            [0, 5, 0],\n",
      "            [0, 0, 6]],\n",
      "           [[7, 0, 0],\n",
      "            [0, 8, 0],\n",
      "            [0, 0, 9]]])\n",
      "\n"
     ]
    }
   ],
   "source": [
    "help(np.apply_along_axis)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 9,
   "id": "b59e6bfd",
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "array([[1, 4, 5, 1],\n",
       "       [6, 5, 4, 4],\n",
       "       [2, 1, 3, 3],\n",
       "       [6, 6, 1, 6],\n",
       "       [6, 6, 6, 6],\n",
       "       [1, 4, 2, 2],\n",
       "       [4, 1, 3, 3],\n",
       "       [5, 1, 4, 5],\n",
       "       [3, 5, 3, 5],\n",
       "       [3, 4, 6, 1]])"
      ]
     },
     "execution_count": 9,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "arr"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "30c8ae79-802f-4f33-ad4a-a01e49a0a3f0",
   "metadata": {},
   "source": [
    "Think of `axis=1` as plugging in one row at a time, and think of `axis=0` as plugging in one column at a time.  In the following example, we get 5 as our first value, because 5 is the maximum of the top row.  We get 6 as our next value, because 6 is the maximum of the next row, and so on."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 10,
   "id": "dda705aa",
   "metadata": {
    "tags": []
   },
   "outputs": [
    {
     "data": {
      "text/plain": [
       "array([5, 6, 3, 6, 6, 4, 4, 5, 5, 6])"
      ]
     },
     "execution_count": 10,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "np.apply_along_axis(np.max, axis=1, arr=arr)"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "0a5a39e0-4528-439b-82ac-1f4c7e0b405e",
   "metadata": {},
   "source": [
    "What if we used `axis=0` instead?  Then we will get four 6s, because there are four columns, and each column has a 6 as its maximum."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 11,
   "id": "92f32bdd",
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "array([6, 6, 6, 6])"
      ]
     },
     "execution_count": 11,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "np.apply_along_axis(np.max, axis=0, arr=arr)"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "0dd0b6a5-9252-4778-82c8-17567a87333c",
   "metadata": {},
   "source": [
    "There is a trick for getting \"successes divided by experiments\" as our probability estimate in this context.  We make a Boolean array `np.apply_along_axis(np.max, axis=1, arr=arr) == 5`, and then we compute its average.  The intuition is that you can think of the Boolean array as containing 1s and 0s (even though it actually contains Trues and Falses), and if we take its average, that is the same as \"number of Trues divided by total number\"."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 14,
   "id": "c50cb4d8",
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "0.284891"
      ]
     },
     "execution_count": 14,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "exps = 10**6\n",
    "\n",
    "arr = rng.integers(1, 7, size=(exps,4))\n",
    "(np.apply_along_axis(np.max, axis=1, arr=arr) == 5).mean()"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "805a4a2f-b57b-4a39-a4df-773e810b048b",
   "metadata": {},
   "source": [
    "This method is somewhat faster than our for loop method from above, but it still takes about 5 seconds, which is still fairly slow for only having one million experiments. "
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 15,
   "id": "b2e717c4",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "CPU times: user 5.27 s, sys: 82.5 ms, total: 5.36 s\n",
      "Wall time: 5.5 s\n"
     ]
    },
    {
     "data": {
      "text/plain": [
       "0.284142"
      ]
     },
     "execution_count": 15,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "%%time\n",
    "\n",
    "exps = 10**6\n",
    "\n",
    "arr = rng.integers(1, 7, size=(exps,4))\n",
    "(np.apply_along_axis(np.max, axis=1, arr=arr) == 5).mean()"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "65ae6808-a22e-4144-8c67-a56481602912",
   "metadata": {},
   "source": [
    "The problem above is that `np.apply_along_axis` is very general, and is not optimized to the specific maximum computation we're making.  We will replace it by using the `max` method of `arr`.  If we call `max()` on its own, we get the maximum of the whole array, which is not what we want."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 17,
   "id": "8088f24a",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "[[6 6 5 6]\n",
      " [5 1 5 5]\n",
      " [4 5 4 5]\n",
      " [1 3 2 3]\n",
      " [2 4 5 6]\n",
      " [1 1 1 5]\n",
      " [1 2 1 3]\n",
      " [2 5 6 1]\n",
      " [5 6 1 1]\n",
      " [2 1 2 6]]\n"
     ]
    },
    {
     "data": {
      "text/plain": [
       "6"
      ]
     },
     "execution_count": 17,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "exps = 10\n",
    "\n",
    "arr = rng.integers(1, 7, size=(exps,4))\n",
    "print(arr)\n",
    "arr.max()"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "348a4f91-6b3d-477f-9a64-b6aee7ea89cf",
   "metadata": {},
   "source": [
    "If we check the documentation for `arr.max` (notice that you get documentation for this sort of method by calling `help(arr.max)`, not `help(arr.max()` and not `help(max)`), we see that this `max` method also accepts an `axis` keyword argument, just like `np.apply_along_axis`."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 18,
   "id": "2a7a62c3",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Help on built-in function max:\n",
      "\n",
      "max(...) method of numpy.ndarray instance\n",
      "    a.max(axis=None, out=None, keepdims=False, initial=<no value>, where=True)\n",
      "    \n",
      "    Return the maximum along a given axis.\n",
      "    \n",
      "    Refer to `numpy.amax` for full documentation.\n",
      "    \n",
      "    See Also\n",
      "    --------\n",
      "    numpy.amax : equivalent function\n",
      "\n"
     ]
    }
   ],
   "source": [
    "help(arr.max)"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "fd0d3df2-fdb2-40b2-a298-45e7503d7d31",
   "metadata": {},
   "source": [
    "Here is an example of using the `axis` keyword argument on a 10-row, 4-column NumPy array."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 19,
   "id": "bea06d32",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "[[5 3 6 4]\n",
      " [6 3 1 1]\n",
      " [6 6 1 5]\n",
      " [1 6 6 2]\n",
      " [5 6 4 6]\n",
      " [3 1 5 2]\n",
      " [1 3 5 1]\n",
      " [6 2 4 2]\n",
      " [6 1 1 3]\n",
      " [2 6 1 5]]\n"
     ]
    },
    {
     "data": {
      "text/plain": [
       "array([6, 6, 6, 6, 6, 5, 5, 6, 6, 6])"
      ]
     },
     "execution_count": 19,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "exps = 10\n",
    "\n",
    "arr = rng.integers(1, 7, size=(exps,4))\n",
    "print(arr)\n",
    "arr.max(axis=1)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 20,
   "id": "98ae66da",
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "array([ True, False, False, False, False, False,  True,  True, False,\n",
       "        True])"
      ]
     },
     "execution_count": 20,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "exps = 10\n",
    "\n",
    "arr = rng.integers(1, 7, size=(exps,4))\n",
    "(arr.max(axis=1) == 5)"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "d278c75c-5618-41fa-a065-f38959c45afb",
   "metadata": {},
   "source": [
    "If we try to use `axis=1` as an input argument to `mean` in this case, we will get an error, because the array is one-dimensional, so `axis=1` does not exist."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 21,
   "id": "d7aa815b",
   "metadata": {
    "tags": [
     "output_scroll"
    ]
   },
   "outputs": [
    {
     "ename": "AxisError",
     "evalue": "axis 1 is out of bounds for array of dimension 1",
     "output_type": "error",
     "traceback": [
      "\u001b[0;31m---------------------------------------------------------------------------\u001b[0m",
      "\u001b[0;31mAxisError\u001b[0m                                 Traceback (most recent call last)",
      "Input \u001b[0;32mIn [21]\u001b[0m, in \u001b[0;36m<cell line: 4>\u001b[0;34m()\u001b[0m\n\u001b[1;32m      1\u001b[0m exps \u001b[38;5;241m=\u001b[39m \u001b[38;5;241m10\u001b[39m\n\u001b[1;32m      3\u001b[0m arr \u001b[38;5;241m=\u001b[39m rng\u001b[38;5;241m.\u001b[39mintegers(\u001b[38;5;241m1\u001b[39m, \u001b[38;5;241m7\u001b[39m, size\u001b[38;5;241m=\u001b[39m(exps,\u001b[38;5;241m4\u001b[39m))\n\u001b[0;32m----> 4\u001b[0m \u001b[43m(\u001b[49m\u001b[43marr\u001b[49m\u001b[38;5;241;43m.\u001b[39;49m\u001b[43mmax\u001b[49m\u001b[43m(\u001b[49m\u001b[43maxis\u001b[49m\u001b[38;5;241;43m=\u001b[39;49m\u001b[38;5;241;43m1\u001b[39;49m\u001b[43m)\u001b[49m\u001b[43m \u001b[49m\u001b[38;5;241;43m==\u001b[39;49m\u001b[43m \u001b[49m\u001b[38;5;241;43m5\u001b[39;49m\u001b[43m)\u001b[49m\u001b[38;5;241;43m.\u001b[39;49m\u001b[43mmean\u001b[49m\u001b[43m(\u001b[49m\u001b[43maxis\u001b[49m\u001b[38;5;241;43m=\u001b[39;49m\u001b[38;5;241;43m1\u001b[39;49m\u001b[43m)\u001b[49m\n",
      "File \u001b[0;32m~/miniconda3/envs/math9f22/lib/python3.10/site-packages/numpy/core/_methods.py:168\u001b[0m, in \u001b[0;36m_mean\u001b[0;34m(a, axis, dtype, out, keepdims, where)\u001b[0m\n\u001b[1;32m    164\u001b[0m arr \u001b[38;5;241m=\u001b[39m asanyarray(a)\n\u001b[1;32m    166\u001b[0m is_float16_result \u001b[38;5;241m=\u001b[39m \u001b[38;5;28;01mFalse\u001b[39;00m\n\u001b[0;32m--> 168\u001b[0m rcount \u001b[38;5;241m=\u001b[39m \u001b[43m_count_reduce_items\u001b[49m\u001b[43m(\u001b[49m\u001b[43marr\u001b[49m\u001b[43m,\u001b[49m\u001b[43m \u001b[49m\u001b[43maxis\u001b[49m\u001b[43m,\u001b[49m\u001b[43m \u001b[49m\u001b[43mkeepdims\u001b[49m\u001b[38;5;241;43m=\u001b[39;49m\u001b[43mkeepdims\u001b[49m\u001b[43m,\u001b[49m\u001b[43m \u001b[49m\u001b[43mwhere\u001b[49m\u001b[38;5;241;43m=\u001b[39;49m\u001b[43mwhere\u001b[49m\u001b[43m)\u001b[49m\n\u001b[1;32m    169\u001b[0m \u001b[38;5;28;01mif\u001b[39;00m rcount \u001b[38;5;241m==\u001b[39m \u001b[38;5;241m0\u001b[39m \u001b[38;5;28;01mif\u001b[39;00m where \u001b[38;5;129;01mis\u001b[39;00m \u001b[38;5;28;01mTrue\u001b[39;00m \u001b[38;5;28;01melse\u001b[39;00m umr_any(rcount \u001b[38;5;241m==\u001b[39m \u001b[38;5;241m0\u001b[39m, axis\u001b[38;5;241m=\u001b[39m\u001b[38;5;28;01mNone\u001b[39;00m):\n\u001b[1;32m    170\u001b[0m     warnings\u001b[38;5;241m.\u001b[39mwarn(\u001b[38;5;124m\"\u001b[39m\u001b[38;5;124mMean of empty slice.\u001b[39m\u001b[38;5;124m\"\u001b[39m, \u001b[38;5;167;01mRuntimeWarning\u001b[39;00m, stacklevel\u001b[38;5;241m=\u001b[39m\u001b[38;5;241m2\u001b[39m)\n",
      "File \u001b[0;32m~/miniconda3/envs/math9f22/lib/python3.10/site-packages/numpy/core/_methods.py:76\u001b[0m, in \u001b[0;36m_count_reduce_items\u001b[0;34m(arr, axis, keepdims, where)\u001b[0m\n\u001b[1;32m     74\u001b[0m     items \u001b[38;5;241m=\u001b[39m \u001b[38;5;241m1\u001b[39m\n\u001b[1;32m     75\u001b[0m     \u001b[38;5;28;01mfor\u001b[39;00m ax \u001b[38;5;129;01min\u001b[39;00m axis:\n\u001b[0;32m---> 76\u001b[0m         items \u001b[38;5;241m*\u001b[39m\u001b[38;5;241m=\u001b[39m arr\u001b[38;5;241m.\u001b[39mshape[\u001b[43mmu\u001b[49m\u001b[38;5;241;43m.\u001b[39;49m\u001b[43mnormalize_axis_index\u001b[49m\u001b[43m(\u001b[49m\u001b[43max\u001b[49m\u001b[43m,\u001b[49m\u001b[43m \u001b[49m\u001b[43marr\u001b[49m\u001b[38;5;241;43m.\u001b[39;49m\u001b[43mndim\u001b[49m\u001b[43m)\u001b[49m]\n\u001b[1;32m     77\u001b[0m     items \u001b[38;5;241m=\u001b[39m nt\u001b[38;5;241m.\u001b[39mintp(items)\n\u001b[1;32m     78\u001b[0m \u001b[38;5;28;01melse\u001b[39;00m:\n\u001b[1;32m     79\u001b[0m     \u001b[38;5;66;03m# TODO: Optimize case when `where` is broadcast along a non-reduction\u001b[39;00m\n\u001b[1;32m     80\u001b[0m     \u001b[38;5;66;03m# axis and full sum is more excessive than needed.\u001b[39;00m\n\u001b[1;32m     81\u001b[0m \n\u001b[1;32m     82\u001b[0m     \u001b[38;5;66;03m# guarded to protect circular imports\u001b[39;00m\n",
      "\u001b[0;31mAxisError\u001b[0m: axis 1 is out of bounds for array of dimension 1"
     ]
    }
   ],
   "source": [
    "exps = 10\n",
    "\n",
    "arr = rng.integers(1, 7, size=(exps,4))\n",
    "(arr.max(axis=1) == 5).mean(axis=1)"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "842d2fa1-4630-42bc-bfcf-9e3b71e335d2",
   "metadata": {},
   "source": [
    "We could do `axis=0`, but for a one-dimensional NumPy array, we might as well just not provide an `axis` argument."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 22,
   "id": "0ec159ff",
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "0.4"
      ]
     },
     "execution_count": 22,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "exps = 10\n",
    "\n",
    "arr = rng.integers(1, 7, size=(exps,4))\n",
    "(arr.max(axis=1) == 5).mean(axis=0)"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "15d2d5c4-71bd-4135-b7e2-77acda9e26e6",
   "metadata": {},
   "source": [
    "Here is the best version of our computation."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 24,
   "id": "8953c35f",
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "0.285484"
      ]
     },
     "execution_count": 24,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "exps = 10**6\n",
    "\n",
    "arr = rng.integers(1, 7, size=(exps,4))\n",
    "(arr.max(axis=1) == 5).mean()"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "1cf7082b-44cd-4f12-a51e-2497fb3bf5ef",
   "metadata": {},
   "source": [
    "The code is not only concise but it is also very efficient.  Whereas even our NumPy code above took over 5 seconds, this is about one hundred times faster."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 25,
   "id": "045516c3",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "CPU times: user 46.5 ms, sys: 5.92 ms, total: 52.4 ms\n",
      "Wall time: 51.3 ms\n"
     ]
    },
    {
     "data": {
      "text/plain": [
       "0.284911"
      ]
     },
     "execution_count": 25,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "%%time\n",
    "exps = 10**6\n",
    "\n",
    "arr = rng.integers(1, 7, size=(exps,4))\n",
    "(arr.max(axis=1) == 5).mean()"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "be2fcd62",
   "metadata": {},
   "source": [
    "## An exact probability\n",
    "\n",
    "<iframe width=\"560\" height=\"315\" src=\"https://www.youtube.com/embed/nS-FIi17grE\" title=\"YouTube video player\" frameborder=\"0\" allow=\"accelerometer; autoplay; clipboard-write; encrypted-media; gyroscope; picture-in-picture\" allowfullscreen></iframe>"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "303e23b9",
   "metadata": {},
   "source": [
    "We ask the same question as last time, but now we will compute the exact probability.\n",
    "\n",
    "* If you roll four distinct 6-sided dice, what is the probability that the biggest value is 5?"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "e0b0a820-d4bd-4424-a451-47256dde2d39",
   "metadata": {},
   "source": [
    "Often computing the exact probability (at least using an exhaustive search where we check every possibility) is not feasible, but in this case, there are only $6^4$ possible values (six different values for each of the four dice), so it's no problem to compute all of the possibilities."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 2,
   "id": "f57e9d43",
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "1296"
      ]
     },
     "execution_count": 2,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "6**4"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "1b9680ee-a8ee-4196-bf3e-7b2704d7f0ba",
   "metadata": {},
   "source": [
    "Here is a correct but inelegant way to make a list of all possible quadruples of integers from 1 to 6 (including 6)."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 3,
   "id": "b0c41c76",
   "metadata": {},
   "outputs": [],
   "source": [
    "all_dice = []\n",
    "for i in range(1,7):\n",
    "    for j in range(1,7):\n",
    "        for k in range(1,7):\n",
    "            for l in range(1,7):\n",
    "                all_dice.append((i,j,k,l))"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "6dbed894-e75b-4593-b652-01fd0877dd64",
   "metadata": {},
   "source": [
    "As a reality check, this list does have the correct length."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 4,
   "id": "810ed869",
   "metadata": {
    "tags": []
   },
   "outputs": [
    {
     "data": {
      "text/plain": [
       "1296"
      ]
     },
     "execution_count": 4,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "len(all_dice)"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "c4045e01-fddd-4ada-b268-0a1cf7eb847a",
   "metadata": {},
   "source": [
    "Here are the first ten values in `all_dice`.  Do you see why it begins this way, and not for example `[(1,1,1,1), (2,1,1,1), ...]`?"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 5,
   "id": "fd5d12ac",
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "[(1, 1, 1, 1),\n",
       " (1, 1, 1, 2),\n",
       " (1, 1, 1, 3),\n",
       " (1, 1, 1, 4),\n",
       " (1, 1, 1, 5),\n",
       " (1, 1, 1, 6),\n",
       " (1, 1, 2, 1),\n",
       " (1, 1, 2, 2),\n",
       " (1, 1, 2, 3),\n",
       " (1, 1, 2, 4)]"
      ]
     },
     "execution_count": 5,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "all_dice[:10]"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "5ccee60c-8211-4b81-9d00-a608b3a6dc29",
   "metadata": {},
   "source": [
    "What we really want to do is compute the Cartesian product of `[1,2,3,4,5,6]` with itself four times.  The standard way to do that in Python is to use the `itertools` library, which is part of the standard Python libraries (meaning it does not need to be installed).  We won't import the whole module; we'll just import its `product` function."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 6,
   "id": "bf7b0e4b",
   "metadata": {},
   "outputs": [],
   "source": [
    "from itertools import product"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 7,
   "id": "1fddd214",
   "metadata": {
    "tags": [
     "output_scroll"
    ]
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Help on class product in module itertools:\n",
      "\n",
      "class product(builtins.object)\n",
      " |  product(*iterables, repeat=1) --> product object\n",
      " |  \n",
      " |  Cartesian product of input iterables.  Equivalent to nested for-loops.\n",
      " |  \n",
      " |  For example, product(A, B) returns the same as:  ((x,y) for x in A for y in B).\n",
      " |  The leftmost iterators are in the outermost for-loop, so the output tuples\n",
      " |  cycle in a manner similar to an odometer (with the rightmost element changing\n",
      " |  on every iteration).\n",
      " |  \n",
      " |  To compute the product of an iterable with itself, specify the number\n",
      " |  of repetitions with the optional repeat keyword argument. For example,\n",
      " |  product(A, repeat=4) means the same as product(A, A, A, A).\n",
      " |  \n",
      " |  product('ab', range(3)) --> ('a',0) ('a',1) ('a',2) ('b',0) ('b',1) ('b',2)\n",
      " |  product((0,1), (0,1), (0,1)) --> (0,0,0) (0,0,1) (0,1,0) (0,1,1) (1,0,0) ...\n",
      " |  \n",
      " |  Methods defined here:\n",
      " |  \n",
      " |  __getattribute__(self, name, /)\n",
      " |      Return getattr(self, name).\n",
      " |  \n",
      " |  __iter__(self, /)\n",
      " |      Implement iter(self).\n",
      " |  \n",
      " |  __next__(self, /)\n",
      " |      Implement next(self).\n",
      " |  \n",
      " |  __reduce__(...)\n",
      " |      Return state information for pickling.\n",
      " |  \n",
      " |  __setstate__(...)\n",
      " |      Set state information for unpickling.\n",
      " |  \n",
      " |  __sizeof__(...)\n",
      " |      Returns size in memory, in bytes.\n",
      " |  \n",
      " |  ----------------------------------------------------------------------\n",
      " |  Static methods defined here:\n",
      " |  \n",
      " |  __new__(*args, **kwargs) from builtins.type\n",
      " |      Create and return a new object.  See help(type) for accurate signature.\n",
      "\n"
     ]
    }
   ],
   "source": [
    "help(product)"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "816b17e9-6294-43a1-af61-8c88e6140933",
   "metadata": {},
   "source": [
    "Here is an example of getting all possible (ordered) pairs of integers from 1 to 6.  It returns an itertools `product` object, but we can convert that object into a list if we want to see all the pairs at once."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 8,
   "id": "c3b06347",
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "<itertools.product at 0x112cd4900>"
      ]
     },
     "execution_count": 8,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "product(range(1,7), repeat=2)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 9,
   "id": "03407440",
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "[(1, 1),\n",
       " (1, 2),\n",
       " (1, 3),\n",
       " (1, 4),\n",
       " (1, 5),\n",
       " (1, 6),\n",
       " (2, 1),\n",
       " (2, 2),\n",
       " (2, 3),\n",
       " (2, 4),\n",
       " (2, 5),\n",
       " (2, 6),\n",
       " (3, 1),\n",
       " (3, 2),\n",
       " (3, 3),\n",
       " (3, 4),\n",
       " (3, 5),\n",
       " (3, 6),\n",
       " (4, 1),\n",
       " (4, 2),\n",
       " (4, 3),\n",
       " (4, 4),\n",
       " (4, 5),\n",
       " (4, 6),\n",
       " (5, 1),\n",
       " (5, 2),\n",
       " (5, 3),\n",
       " (5, 4),\n",
       " (5, 5),\n",
       " (5, 6),\n",
       " (6, 1),\n",
       " (6, 2),\n",
       " (6, 3),\n",
       " (6, 4),\n",
       " (6, 5),\n",
       " (6, 6)]"
      ]
     },
     "execution_count": 9,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "list(product(range(1,7), repeat=2))"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "a82a7110-5858-4cf7-9b6d-df978f84925a",
   "metadata": {},
   "source": [
    "Here is another example of using the `product` function without using the `repeat` keyword argument.  In this case, we're getting the Cartesian product of the list `[\"a\", \"b\", \"c\"]` with the list `[5, 6]`.  In total, this product has $3 \\cdot 2 = 6$ elements."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 10,
   "id": "1e7b352f",
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "[('a', 5), ('a', 6), ('b', 5), ('b', 6), ('c', 5), ('c', 6)]"
      ]
     },
     "execution_count": 10,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "list(product([\"a\",\"b\",\"c\"], [5, 6]))"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "af3812db-cc92-4a60-80d0-7f0114da42a0",
   "metadata": {},
   "source": [
    "One more example."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 12,
   "id": "a89127ca",
   "metadata": {
    "tags": []
   },
   "outputs": [
    {
     "data": {
      "text/plain": [
       "[('a', 'a', 'a'),\n",
       " ('a', 'a', 'b'),\n",
       " ('a', 'a', 'c'),\n",
       " ('a', 'b', 'a'),\n",
       " ('a', 'b', 'b'),\n",
       " ('a', 'b', 'c'),\n",
       " ('a', 'c', 'a'),\n",
       " ('a', 'c', 'b'),\n",
       " ('a', 'c', 'c'),\n",
       " ('b', 'a', 'a'),\n",
       " ('b', 'a', 'b'),\n",
       " ('b', 'a', 'c'),\n",
       " ('b', 'b', 'a'),\n",
       " ('b', 'b', 'b'),\n",
       " ('b', 'b', 'c'),\n",
       " ('b', 'c', 'a'),\n",
       " ('b', 'c', 'b'),\n",
       " ('b', 'c', 'c'),\n",
       " ('c', 'a', 'a'),\n",
       " ('c', 'a', 'b'),\n",
       " ('c', 'a', 'c'),\n",
       " ('c', 'b', 'a'),\n",
       " ('c', 'b', 'b'),\n",
       " ('c', 'b', 'c'),\n",
       " ('c', 'c', 'a'),\n",
       " ('c', 'c', 'b'),\n",
       " ('c', 'c', 'c')]"
      ]
     },
     "execution_count": 12,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "list(product([\"a\",\"b\",\"c\"], repeat=3))"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "0ac7c8a9-81c2-4a53-9658-eace4112a396",
   "metadata": {},
   "source": [
    "The above example, using `repeat`, is the exact same as this next example, which explicitly lists the list three times."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 13,
   "id": "1c915af1",
   "metadata": {
    "tags": []
   },
   "outputs": [
    {
     "data": {
      "text/plain": [
       "[('a', 'a', 'a'),\n",
       " ('a', 'a', 'b'),\n",
       " ('a', 'a', 'c'),\n",
       " ('a', 'b', 'a'),\n",
       " ('a', 'b', 'b'),\n",
       " ('a', 'b', 'c'),\n",
       " ('a', 'c', 'a'),\n",
       " ('a', 'c', 'b'),\n",
       " ('a', 'c', 'c'),\n",
       " ('b', 'a', 'a'),\n",
       " ('b', 'a', 'b'),\n",
       " ('b', 'a', 'c'),\n",
       " ('b', 'b', 'a'),\n",
       " ('b', 'b', 'b'),\n",
       " ('b', 'b', 'c'),\n",
       " ('b', 'c', 'a'),\n",
       " ('b', 'c', 'b'),\n",
       " ('b', 'c', 'c'),\n",
       " ('c', 'a', 'a'),\n",
       " ('c', 'a', 'b'),\n",
       " ('c', 'a', 'c'),\n",
       " ('c', 'b', 'a'),\n",
       " ('c', 'b', 'b'),\n",
       " ('c', 'b', 'c'),\n",
       " ('c', 'c', 'a'),\n",
       " ('c', 'c', 'b'),\n",
       " ('c', 'c', 'c')]"
      ]
     },
     "execution_count": 13,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "list(product([\"a\",\"b\",\"c\"], [\"a\",\"b\",\"c\"], [\"a\",\"b\",\"c\"]))"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "f6c13ad9-05dc-48ab-bd82-56c82dbb150c",
   "metadata": {},
   "source": [
    "We're now ready to use `product` to simulate every possible roll of four distinct six-sided dice."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 14,
   "id": "40dd3019",
   "metadata": {},
   "outputs": [],
   "source": [
    "temp_list = list(product(range(1,7), repeat=4))"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 15,
   "id": "4da6ad59",
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "1296"
      ]
     },
     "execution_count": 15,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "len(temp_list)"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "8734d64d-0701-4c1d-ab0b-d73db1a22dff",
   "metadata": {},
   "source": [
    "Let's convert this to a NumPy array, so we can use some of the earlier methods from this week."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 16,
   "id": "c86068dc",
   "metadata": {},
   "outputs": [],
   "source": [
    "arr = np.array(temp_list)"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "204de16b-f0e1-4c28-9629-41f603f8bcf2",
   "metadata": {},
   "source": [
    "The array `arr` has 1296 rows and 4 columns.  We think of each row as corresponding to one possible outcome."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 17,
   "id": "1955c6cc",
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "(1296, 4)"
      ]
     },
     "execution_count": 17,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "arr.shape"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "48343748-3bb9-4ec5-8c07-decfb24eafc1",
   "metadata": {},
   "source": [
    "We want to know, for what proportion of the rows, is the maximum value in that row equal to 5?  Because we want to get the maximum of each row, we use the `axis=1` keyword argument.  (If we wanted to get the maximum of each column, we would instead use `axis=0`.)  We compute the total number of \"successes\" by using `sum`, and then we divide by the number of rows, which is `arr.shape[0]`."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 19,
   "id": "9dcb7691",
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "0.2847222222222222"
      ]
     },
     "execution_count": 19,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "(arr.max(axis=1) == 5).sum()/arr.shape[0]"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "9c860c80-ca7d-4f7b-a402-77a2763587ca",
   "metadata": {},
   "source": [
    "An abbreviation is to apply the `mean` method to our Boolean array."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 20,
   "id": "01bd7a0c",
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "0.2847222222222222"
      ]
     },
     "execution_count": 20,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "(arr.max(axis=1) == 5).mean()"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "db32e37c-146d-4cee-a105-221d12cd5a0b",
   "metadata": {},
   "source": [
    "Just for fun, here is another computation of the exact probability.  The first number in the difference, $(5/6)^4$, is equal to the probability that none of the dice lands 6, and then we are subtracting the probability that none of the dice lands 5 or 6."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 21,
   "id": "a030e55e",
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "0.2847222222222223"
      ]
     },
     "execution_count": 21,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "(5/6)**4-(4/6)**4"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "1bc77440",
   "metadata": {},
   "source": [
    "## `any` and `all`\n",
    "\n",
    "<iframe width=\"560\" height=\"315\" src=\"https://www.youtube.com/embed/0GeviCLROaw\" title=\"YouTube video player\" frameborder=\"0\" allow=\"accelerometer; autoplay; clipboard-write; encrypted-media; gyroscope; picture-in-picture\" allowfullscreen></iframe>\n",
    "\n",
    "Make a 100 row, 4 column NumPy array `arr` of random real numbers between 0 and 1."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 2,
   "id": "02705721",
   "metadata": {},
   "outputs": [],
   "source": [
    "rng = np.random.default_rng()"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 4,
   "id": "15b70a08",
   "metadata": {},
   "outputs": [],
   "source": [
    "arr = rng.random(size=(100,4))"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "15951c21",
   "metadata": {},
   "source": [
    "* Find the sub-array of `arr` containing all rows in which at least one number is bigger than 0.9.\n",
    "\n",
    "Here are the first 5 rows of `arr`."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 6,
   "id": "d94d6cf3",
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "array([[0.02679582, 0.39964722, 0.38608334, 0.9557704 ],\n",
       "       [0.62903247, 0.17981028, 0.48643802, 0.16059557],\n",
       "       [0.49612872, 0.34270062, 0.00862007, 0.77873829],\n",
       "       [0.55550408, 0.37485681, 0.20417908, 0.82782464],\n",
       "       [0.51663663, 0.85479878, 0.48625127, 0.88475327]])"
      ]
     },
     "execution_count": 6,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "arr[:5]"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "7bc901a0-eb67-4bac-8f06-a01aa0982052",
   "metadata": {},
   "source": [
    "Here is a Boolean array corresponding to which elements are strictly greater than 5."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 7,
   "id": "8a5b4af5",
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "array([[False, False, False,  True],\n",
       "       [False, False, False, False],\n",
       "       [False, False, False, False],\n",
       "       [False, False, False, False],\n",
       "       [False, False, False, False]])"
      ]
     },
     "execution_count": 7,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "arr[:5] > 0.9"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "a9b1282f-8474-433b-bf8a-e90057286e3c",
   "metadata": {},
   "source": [
    "For each row, we want to know if any value in that row is `True`.  To compute this, we will use the `any` method, together with `axis=1`.  The reason we're using `axis=1` is because we are plugging in a full row at a time."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 8,
   "id": "59202760",
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "array([ True, False, False, False, False])"
      ]
     },
     "execution_count": 8,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "(arr[:5] > 0.9).any(axis=1)"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "13619869-31fc-4587-88fd-d0ea88b0413a",
   "metadata": {},
   "source": [
    "If we wanted to count how many of these first 5 rows contain a number bigger than 0.9, we could use `sum`."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 9,
   "id": "f7afaef9",
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "1"
      ]
     },
     "execution_count": 9,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "(arr[:5] > 0.9).any(axis=1).sum()"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "13706a8b-d97c-4dd0-ae1d-a4d7d84b5ae5",
   "metadata": {},
   "source": [
    "The question asked for us to find the rows which contain a number bigger than 0.9, so we will use Boolean indexing.  We are plugging in the `array([ True, False, False, False, False])` from above into the square brackets, which is like saying, keep the top row, discard the next four rows."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 10,
   "id": "c85609c7",
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "array([[0.02679582, 0.39964722, 0.38608334, 0.9557704 ]])"
      ]
     },
     "execution_count": 10,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "arr[:5][(arr[:5] > 0.9).any(axis=1)]"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "13e8e7b3-e51b-449c-b69b-32927cee4158",
   "metadata": {},
   "source": [
    "We now do the same thing to the full array.  This will be a little easier to read, because we can get rid of the `[:5]` slices."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 11,
   "id": "fe77d279",
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "array([[0.02679582, 0.39964722, 0.38608334, 0.9557704 ],\n",
       "       [0.89128322, 0.97335335, 0.1821295 , 0.52423414],\n",
       "       [0.4629412 , 0.71844233, 0.91362938, 0.04770196],\n",
       "       [0.61030793, 0.15565872, 0.15616296, 0.9572168 ],\n",
       "       [0.45523301, 0.85912337, 0.34660356, 0.91882733],\n",
       "       [0.14055923, 0.86443333, 0.95413845, 0.94380163],\n",
       "       [0.07850217, 0.96370185, 0.21801727, 0.22118187],\n",
       "       [0.10730651, 0.56976149, 0.95367251, 0.7782287 ],\n",
       "       [0.95705318, 0.11012904, 0.1380347 , 0.67057015],\n",
       "       [0.95930433, 0.06501316, 0.67658178, 0.20159313],\n",
       "       [0.2457492 , 0.67240127, 0.94358665, 0.90993476],\n",
       "       [0.37975889, 0.92498652, 0.99327127, 0.7283782 ],\n",
       "       [0.37093209, 0.45237422, 0.91160131, 0.96612184],\n",
       "       [0.52254037, 0.19969189, 0.94795525, 0.15420271],\n",
       "       [0.90339743, 0.59821255, 0.62045249, 0.54939576],\n",
       "       [0.48895101, 0.52105202, 0.96297772, 0.45230437],\n",
       "       [0.35246537, 0.32415082, 0.86599985, 0.98355888],\n",
       "       [0.32443071, 0.94130683, 0.86154932, 0.95131523],\n",
       "       [0.28175352, 0.71585491, 0.91062862, 0.47574106],\n",
       "       [0.75785393, 0.97896958, 0.89668326, 0.81597407],\n",
       "       [0.42821129, 0.43666654, 0.92245681, 0.6772787 ],\n",
       "       [0.69686621, 0.34335879, 0.91188883, 0.73999112],\n",
       "       [0.02840598, 0.96355532, 0.72067752, 0.77935551],\n",
       "       [0.85410091, 0.06666216, 0.66487804, 0.93493077],\n",
       "       [0.13820849, 0.59467061, 0.90928252, 0.64484179],\n",
       "       [0.08076356, 0.54348621, 0.97440544, 0.7990639 ],\n",
       "       [0.90641341, 0.55333912, 0.33929642, 0.77887452],\n",
       "       [0.77605269, 0.45487112, 0.79606863, 0.90207317],\n",
       "       [0.83243102, 0.34853769, 0.48317369, 0.99294516],\n",
       "       [0.72748438, 0.95781736, 0.85863108, 0.78340871],\n",
       "       [0.71794935, 0.97886636, 0.51022616, 0.41182274],\n",
       "       [0.00766348, 0.94589262, 0.94978998, 0.86756495],\n",
       "       [0.97386912, 0.84335624, 0.54012798, 0.47553105],\n",
       "       [0.91223874, 0.48230536, 0.43958204, 0.51024251],\n",
       "       [0.29992039, 0.89336646, 0.95530599, 0.90846783],\n",
       "       [0.96276511, 0.46449629, 0.60265653, 0.55037618],\n",
       "       [0.04358133, 0.68861017, 0.9216942 , 0.00731241],\n",
       "       [0.57128587, 0.99787681, 0.77452267, 0.19917239],\n",
       "       [0.91106315, 0.49769224, 0.30259767, 0.13776197],\n",
       "       [0.76003629, 0.07852721, 0.97851938, 0.77227829]])"
      ]
     },
     "execution_count": 11,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "arr[(arr > 0.9).any(axis=1)]"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "81969a41",
   "metadata": {},
   "source": [
    "* Find the sub-array of `arr` containing all rows in which no numbers are between 0.4 and 0.6.\n",
    "\n",
    "One way to think about this is, we want the rows in which every element in that row is less than 0.4 or bigger than 0.6.  (We allow a single row to have both smaller and bigger elements; all we care about is that it does not contain any values that start with 0.4 or 0.5.)  Since we want a condition to be true for all the numbers in the row, we use `all(axis=1)`."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 12,
   "id": "3581c381",
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "array([ True, False, False, False, False, False, False, False, False,\n",
       "       False, False,  True, False,  True,  True, False,  True,  True,\n",
       "       False, False, False,  True,  True,  True,  True,  True,  True,\n",
       "        True,  True, False, False, False, False, False, False, False,\n",
       "       False, False,  True, False, False,  True, False,  True,  True,\n",
       "       False, False, False, False, False,  True,  True,  True, False,\n",
       "        True,  True, False,  True, False, False, False, False, False,\n",
       "        True,  True,  True, False, False, False,  True, False, False,\n",
       "        True, False,  True,  True, False, False, False, False, False,\n",
       "        True, False, False, False, False, False, False,  True, False,\n",
       "        True, False, False, False,  True,  True, False, False,  True,\n",
       "       False])"
      ]
     },
     "execution_count": 12,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "((arr < 0.4) | (arr > 0.6)).all(axis=1)"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "fba58ac2-a287-43bf-a7d3-37467ca550ae",
   "metadata": {},
   "source": [
    "As a reality check, our Boolean array here is length 100."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 13,
   "id": "9c0eb389",
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "100"
      ]
     },
     "execution_count": 13,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "len(((arr < 0.4) | (arr > 0.6)).all(axis=1))"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "b91e6514-9fc1-4798-8b76-05b8c5bba8c6",
   "metadata": {},
   "source": [
    "Here again we're using Boolean indexing.  We're keeping all the rows of `arr` which satisfy this condition.  As you scroll through this array, notice how all the values that appear are either less than 0.4 or bigger than 0.6."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 14,
   "id": "8f1d0b85",
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "array([[0.02679582, 0.39964722, 0.38608334, 0.9557704 ],\n",
       "       [0.61030793, 0.15565872, 0.15616296, 0.9572168 ],\n",
       "       [0.64463239, 0.62136197, 0.83285561, 0.69102624],\n",
       "       [0.19806438, 0.28789025, 0.16912325, 0.71827727],\n",
       "       [0.14055923, 0.86443333, 0.95413845, 0.94380163],\n",
       "       [0.07850217, 0.96370185, 0.21801727, 0.22118187],\n",
       "       [0.95705318, 0.11012904, 0.1380347 , 0.67057015],\n",
       "       [0.6703015 , 0.81869015, 0.31666259, 0.67068789],\n",
       "       [0.74644917, 0.06370154, 0.34252816, 0.06391344],\n",
       "       [0.06099061, 0.08149432, 0.29021873, 0.85693158],\n",
       "       [0.80698662, 0.31211537, 0.68117698, 0.78836747],\n",
       "       [0.95930433, 0.06501316, 0.67658178, 0.20159313],\n",
       "       [0.2457492 , 0.67240127, 0.94358665, 0.90993476],\n",
       "       [0.37975889, 0.92498652, 0.99327127, 0.7283782 ],\n",
       "       [0.35246537, 0.32415082, 0.86599985, 0.98355888],\n",
       "       [0.32443071, 0.94130683, 0.86154932, 0.95131523],\n",
       "       [0.75210216, 0.38678934, 0.19343926, 0.65172332],\n",
       "       [0.75785393, 0.97896958, 0.89668326, 0.81597407],\n",
       "       [0.69686621, 0.34335879, 0.91188883, 0.73999112],\n",
       "       [0.02840598, 0.96355532, 0.72067752, 0.77935551],\n",
       "       [0.81806092, 0.6881485 , 0.19411104, 0.05981003],\n",
       "       [0.10944381, 0.11567344, 0.78604289, 0.88719194],\n",
       "       [0.85410091, 0.06666216, 0.66487804, 0.93493077],\n",
       "       [0.17557637, 0.17629594, 0.32083318, 0.78378524],\n",
       "       [0.07667857, 0.75976036, 0.13388494, 0.8849134 ],\n",
       "       [0.07788747, 0.17609963, 0.82659974, 0.23594508],\n",
       "       [0.83519757, 0.04403135, 0.76341093, 0.12392983],\n",
       "       [0.88621369, 0.82607382, 0.24463174, 0.02825251],\n",
       "       [0.85579081, 0.00571833, 0.24021269, 0.70925784],\n",
       "       [0.07239563, 0.0329126 , 0.23356791, 0.25781394],\n",
       "       [0.72748438, 0.95781736, 0.85863108, 0.78340871],\n",
       "       [0.00766348, 0.94589262, 0.94978998, 0.86756495],\n",
       "       [0.29992039, 0.89336646, 0.95530599, 0.90846783],\n",
       "       [0.72087445, 0.00735632, 0.66339639, 0.33424491],\n",
       "       [0.04358133, 0.68861017, 0.9216942 , 0.00731241],\n",
       "       [0.36901017, 0.06002681, 0.32674171, 0.26870498],\n",
       "       [0.76003629, 0.07852721, 0.97851938, 0.77227829]])"
      ]
     },
     "execution_count": 14,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "arr[((arr < 0.4) | (arr > 0.6)).all(axis=1)]"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "c7fa809e",
   "metadata": {},
   "source": [
    "## From binary to decimal, version 1\n",
    "\n",
    "<iframe width=\"560\" height=\"315\" src=\"https://www.youtube.com/embed/bXyqvBQ4wP4\" title=\"YouTube video player\" frameborder=\"0\" allow=\"accelerometer; autoplay; clipboard-write; encrypted-media; gyroscope; picture-in-picture\" allowfullscreen></iframe>\n",
    "\n",
    "$$\n",
    "\\begin{pmatrix} 1 & 0 & 1 & 0 \\\\ 0 & 1 & 0 & 0 \\\\ 1 & 1 & 1 & 1 \\end{pmatrix} \\mapsto \\begin{pmatrix} 10 \\\\ 4 \\\\ 15 \\end{pmatrix}\n",
    "$$\n",
    "\n",
    "* Write a function `to_bin` which takes in an m-by-n NumPy array of 0s and 1s, and as output returns a length m NumPy array of the corresponding integers, where we think of each row as representing the binary digits of an integer.\n",
    "\n",
    "For example, we think of the top row as representing $1 \\cdot 2^3 + 0 \\cdot 2^2 + 1 \\cdot 2^1 + 0 \\cdot 2^0 = 10$.\n",
    "\n",
    "(If I were writing this again, I would call the function `from_bin` instead of `to_bin`, but I'll stick with `to_bin` to match what's in the video.)\n",
    "\n",
    "Let's start by getting a random array that can be our test input."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 2,
   "id": "c3822fee",
   "metadata": {},
   "outputs": [],
   "source": [
    "rng = np.random.default_rng()"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 3,
   "id": "16aeaadc",
   "metadata": {},
   "outputs": [],
   "source": [
    "arr = rng.integers(2, size=(10,4))"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "87a9cec8-8f6d-4ef4-8f95-838ebe75b805",
   "metadata": {},
   "source": [
    "We assign `m` to be the number of rows and `n` to be the number of columns, using what is called tuple unpacking."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 4,
   "id": "0900a5a0",
   "metadata": {},
   "outputs": [],
   "source": [
    "m,n = arr.shape"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 5,
   "id": "c6bbb73c",
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "10"
      ]
     },
     "execution_count": 5,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "m"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 6,
   "id": "a111a9f1",
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "4"
      ]
     },
     "execution_count": 6,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "n"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "1c5dc6d2-e305-4890-9303-6e3251866f16",
   "metadata": {},
   "source": [
    "We want to multiply the left-most column by $2^3$, the next column by $2^2$, and so on.  Here are the exponents.  The middle `-1` is telling NumPy where to stop (stop before -1), and the right-most `-1` is telling NumPy what the step size should be (go down by 1 each step)."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 7,
   "id": "c9451531",
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "array([3, 2, 1, 0])"
      ]
     },
     "execution_count": 7,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "np.arange(n-1, -1, -1)"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "270dfd80-2924-4b63-949e-6a3f4bba63e6",
   "metadata": {},
   "source": [
    "Here are the coefficients we want to multiply the columns by."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 8,
   "id": "c7377cbd",
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "array([8, 4, 2, 1])"
      ]
     },
     "execution_count": 8,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "2**np.arange(n-1, -1, -1)"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "c46be7c2-8eb7-410a-a86b-9ea140724fd2",
   "metadata": {},
   "source": [
    "Using broadcasting, it's very easy to make the multiplication.  And to add up along the rows, we use `sum(axis=1)`."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 12,
   "id": "ab56a291",
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "array([12,  7, 11, 15,  4,  1,  0, 12, 14,  9])"
      ]
     },
     "execution_count": 12,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "(arr*(2**np.arange(n-1, -1, -1))).sum(axis=1)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 13,
   "id": "864a18ad",
   "metadata": {},
   "outputs": [],
   "source": [
    "def to_bin(arr):\n",
    "    _,n = arr.shape\n",
    "    return (arr*(2**np.arange(n-1, -1, -1))).sum(axis=1)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 14,
   "id": "cfd08803",
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "array([12,  7, 11, 15,  4,  1,  0, 12, 14,  9])"
      ]
     },
     "execution_count": 14,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "to_bin(arr)"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "4afeba26-84bd-42fc-905c-529fc5deb586",
   "metadata": {},
   "source": [
    "Here we check on a smaller array."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 15,
   "id": "b1140c46",
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "array([2, 3])"
      ]
     },
     "execution_count": 15,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "to_bin(np.array([[1,0],[1,1]]))"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "09081a7a",
   "metadata": {},
   "source": [
    "## From binary to decimal, version 2\n",
    "\n",
    "<iframe width=\"560\" height=\"315\" src=\"https://www.youtube.com/embed/AzN2i8NaSRY\" title=\"YouTube video player\" frameborder=\"0\" allow=\"accelerometer; autoplay; clipboard-write; encrypted-media; gyroscope; picture-in-picture\" allowfullscreen></iframe>\n",
    "\n",
    "$$\n",
    "\\begin{pmatrix} 1 & 0 & 1 & 0 \\\\ 0 & 1 & 0 & 0 \\\\ 1 & 1 & 1 & 1 \\end{pmatrix} \\mapsto \\begin{pmatrix} 10 \\\\ 4 \\\\ 15 \\end{pmatrix}\n",
    "$$\n",
    "\n",
    "* Write a new function, `to_bin2`, which takes in an m-by-n NumPy array of 0s and 1s, and as output returns a length m NumPy array of the corresponding integers, where we think of each row as representing the binary digits of an integer."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 2,
   "id": "8a767851",
   "metadata": {},
   "outputs": [],
   "source": [
    "rng = np.random.default_rng()\n",
    "arr = rng.integers(2, size=(10,4))"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 3,
   "id": "6033b3b8",
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "array([[0, 1, 1, 1],\n",
       "       [0, 0, 1, 0],\n",
       "       [1, 0, 0, 1],\n",
       "       [1, 0, 1, 1],\n",
       "       [0, 1, 1, 1],\n",
       "       [1, 0, 0, 1],\n",
       "       [0, 1, 0, 1],\n",
       "       [0, 0, 1, 0],\n",
       "       [1, 1, 0, 0],\n",
       "       [0, 0, 1, 0]])"
      ]
     },
     "execution_count": 3,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "arr"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "0b7833e5-ab43-42b1-82b6-20c691baf999",
   "metadata": {},
   "source": [
    "Here is the \"usual\" way of converting from a string to an integer."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 4,
   "id": "5ea1569f",
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "111"
      ]
     },
     "execution_count": 4,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "int(\"0111\")"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "281fdb80-dde7-4973-8d93-ccec15ac8c64",
   "metadata": {},
   "source": [
    "But we can also tell Python that the string should be thought of as being written in binary.  For example, 0111 in binary should be thought of as $4+2+1 = 7$.  In the following, we're specifying that the number is being written in \"base-2\"."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 5,
   "id": "41a01630",
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "7"
      ]
     },
     "execution_count": 5,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "int(\"0111\", 2)"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "4639b87e-5530-434b-9206-e5dd8b8faec1",
   "metadata": {},
   "source": [
    "Our \"usual\" number system is written in base-10."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 6,
   "id": "3b81e981",
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "111"
      ]
     },
     "execution_count": 6,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "int(\"0111\", 10)"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "6bb10cd8-7087-42b3-a0ba-fd5a9b0b0659",
   "metadata": {},
   "source": [
    "Here we make a length-4 NumPy array."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 7,
   "id": "2902b86f",
   "metadata": {},
   "outputs": [],
   "source": [
    "z = np.array([0,1,1,1])"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "781d00df-8cb6-4879-bbe5-c5744743413a",
   "metadata": {},
   "source": [
    "Or it's probably more elegant to just take the top row of `arr`."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 8,
   "id": "fb973531",
   "metadata": {},
   "outputs": [],
   "source": [
    "z = arr[0]"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 9,
   "id": "983395bb",
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "array([0, 1, 1, 1])"
      ]
     },
     "execution_count": 9,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "z"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "e215c277-fc56-4ebf-99b2-80f6373a1708",
   "metadata": {},
   "source": [
    "How can we convert that into the string \"0111\"?  I feel like there might be an easier way that I'm missing, but this is what I've come up with.  As a preliminary step, here is a reminder of list comprehension which we won't officially cover in Math 9 until [next week](list-comp).  In the following, we use list comprehension to put the integers 0, 1, 1, 1 into a list."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 10,
   "id": "37344ae3",
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "[0, 1, 1, 1]"
      ]
     },
     "execution_count": 10,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "[x for x in z]"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "fc285502-b517-4353-ab1e-1f4663970b0f",
   "metadata": {},
   "source": [
    "Here we use list comprehension to put the strings \"0\", \"1\", \"1\", \"1\" into a list.  It is the same as the previous command, except that we convert each integer to a string using `str`."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 11,
   "id": "e23c1fb4",
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "['0', '1', '1', '1']"
      ]
     },
     "execution_count": 11,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "[str(x) for x in z]"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "82922f5b-0fe6-4da4-8026-43453a0f9e64",
   "metadata": {},
   "source": [
    "I had initially thought the following would concatenate these strings (which would make sense, because `\"0\"+\"1\"` concatenates the strings to produce the string `\"01\"`), but it doesn't work."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 12,
   "id": "47203a81",
   "metadata": {},
   "outputs": [
    {
     "ename": "TypeError",
     "evalue": "unsupported operand type(s) for +: 'int' and 'str'",
     "output_type": "error",
     "traceback": [
      "\u001b[0;31m---------------------------------------------------------------------------\u001b[0m",
      "\u001b[0;31mTypeError\u001b[0m                                 Traceback (most recent call last)",
      "Input \u001b[0;32mIn [12]\u001b[0m, in \u001b[0;36m<cell line: 1>\u001b[0;34m()\u001b[0m\n\u001b[0;32m----> 1\u001b[0m \u001b[38;5;28;43msum\u001b[39;49m\u001b[43m(\u001b[49m\u001b[43m[\u001b[49m\u001b[38;5;28;43mstr\u001b[39;49m\u001b[43m(\u001b[49m\u001b[43mx\u001b[49m\u001b[43m)\u001b[49m\u001b[43m \u001b[49m\u001b[38;5;28;43;01mfor\u001b[39;49;00m\u001b[43m \u001b[49m\u001b[43mx\u001b[49m\u001b[43m \u001b[49m\u001b[38;5;129;43;01min\u001b[39;49;00m\u001b[43m \u001b[49m\u001b[43mz\u001b[49m\u001b[43m]\u001b[49m\u001b[43m)\u001b[49m\n",
      "\u001b[0;31mTypeError\u001b[0m: unsupported operand type(s) for +: 'int' and 'str'"
     ]
    }
   ],
   "source": [
    "sum([str(x) for x in z])"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "0ed3687e-2b26-47f2-9de4-36aaafbf3348",
   "metadata": {},
   "source": [
    "The following is the suggested way in Python to concatenate all the strings in a list together."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 13,
   "id": "5222dd82",
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "'0111'"
      ]
     },
     "execution_count": 13,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "''.join([str(x) for x in z])"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "db43c43b-fec7-457e-a462-ad66d27d3a1c",
   "metadata": {},
   "source": [
    "We want to apply that idea to every row in `arr`.  Let's define a helper function to use.  Later we will see a way to write this sort of short function in a more concise way, using \"lambda functions\".  (Caution.  A common programming mistake is to use something like `print` instead of `return`.  That's very incorrect.  If you want your function to have an output, you need to use `return`.)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 14,
   "id": "156991c0",
   "metadata": {},
   "outputs": [],
   "source": [
    "def helper(z):\n",
    "    return ''.join([str(x) for x in z])"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "34ac27f1-6930-4816-9f4e-59823f2d3df7",
   "metadata": {},
   "source": [
    "Let's test out our `helper` function on the 3rd row of `arr`."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 15,
   "id": "99302ebe",
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "'1011'"
      ]
     },
     "execution_count": 15,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "helper(arr[3])"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 16,
   "id": "d11c7bc7",
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "array([1, 0, 1, 1])"
      ]
     },
     "execution_count": 16,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "arr[3]"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 17,
   "id": "1a91ed67",
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "array([[0, 1, 1, 1],\n",
       "       [0, 0, 1, 0],\n",
       "       [1, 0, 0, 1],\n",
       "       [1, 0, 1, 1],\n",
       "       [0, 1, 1, 1],\n",
       "       [1, 0, 0, 1],\n",
       "       [0, 1, 0, 1],\n",
       "       [0, 0, 1, 0],\n",
       "       [1, 1, 0, 0],\n",
       "       [0, 0, 1, 0]])"
      ]
     },
     "execution_count": 17,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "arr"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "abe8815f-d56f-4593-9f1f-b47c823a616b",
   "metadata": {},
   "source": [
    "Here is a version `helper2` that treats the row as if it corresponds to binary digits.  We could do this all in one line, but it is more readable to break it up into two steps."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 18,
   "id": "ad97e360",
   "metadata": {},
   "outputs": [],
   "source": [
    "def helper2(z):\n",
    "    temp = ''.join([str(x) for x in z])\n",
    "    return int(temp, 2)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 19,
   "id": "48528476",
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "11"
      ]
     },
     "execution_count": 19,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "helper2(arr[3])"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "6821ceeb-e54e-4054-86e5-145eb799a847",
   "metadata": {},
   "source": [
    "Here we're using `apply_along_axis` again.  The function we want to apply is `helper2`, and we are applying along rows, so we use `axis=1`."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 20,
   "id": "133ec871",
   "metadata": {},
   "outputs": [],
   "source": [
    "def to_bin2(A):\n",
    "    return np.apply_along_axis(helper2, axis=1, arr=A)"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "67ca9e6f-9586-4770-9f04-783f8409652d",
   "metadata": {},
   "source": [
    "This doesn't work because `A` is not defined."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 21,
   "id": "fe19273f",
   "metadata": {},
   "outputs": [
    {
     "ename": "NameError",
     "evalue": "name 'A' is not defined",
     "output_type": "error",
     "traceback": [
      "\u001b[0;31m---------------------------------------------------------------------------\u001b[0m",
      "\u001b[0;31mNameError\u001b[0m                                 Traceback (most recent call last)",
      "Input \u001b[0;32mIn [21]\u001b[0m, in \u001b[0;36m<cell line: 1>\u001b[0;34m()\u001b[0m\n\u001b[0;32m----> 1\u001b[0m to_bin2(\u001b[43mA\u001b[49m)\n",
      "\u001b[0;31mNameError\u001b[0m: name 'A' is not defined"
     ]
    }
   ],
   "source": [
    "to_bin2(A)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 22,
   "id": "10d7fa45",
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "array([[0, 1, 1, 1],\n",
       "       [0, 0, 1, 0],\n",
       "       [1, 0, 0, 1],\n",
       "       [1, 0, 1, 1],\n",
       "       [0, 1, 1, 1],\n",
       "       [1, 0, 0, 1],\n",
       "       [0, 1, 0, 1],\n",
       "       [0, 0, 1, 0],\n",
       "       [1, 1, 0, 0],\n",
       "       [0, 0, 1, 0]])"
      ]
     },
     "execution_count": 22,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "arr"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "acc45292-0cb5-4a76-bc22-9f304a38592a",
   "metadata": {},
   "source": [
    "Notice how, for example, the top row corresponds to 7, the next row corresponds to 2, and so on."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 23,
   "id": "20d16063",
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "array([ 7,  2,  9, 11,  7,  9,  5,  2, 12,  2])"
      ]
     },
     "execution_count": 23,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "to_bin2(arr)"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "68e2a84d",
   "metadata": {},
   "source": [
    "## Raising errors\n",
    "\n",
    "<iframe width=\"560\" height=\"315\" src=\"https://www.youtube.com/embed/1F9A0K7A6ak\" title=\"YouTube video player\" frameborder=\"0\" allow=\"accelerometer; autoplay; clipboard-write; encrypted-media; gyroscope; picture-in-picture\" allowfullscreen></iframe>\n",
    "\n",
    "* Edit the `to_bin` function so that it raises an error if the input is not a NumPy array and it also raises an error if an entry is not 0 or 1."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 2,
   "id": "b19744a1",
   "metadata": {},
   "outputs": [],
   "source": [
    "rng = np.random.default_rng()\n",
    "arr = rng.integers(2, size=(10,4))"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 4,
   "id": "086efa9d",
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "array([[1, 1, 1, 1],\n",
       "       [0, 0, 1, 1],\n",
       "       [1, 0, 1, 1],\n",
       "       [1, 1, 1, 0],\n",
       "       [0, 0, 1, 1],\n",
       "       [0, 1, 0, 1],\n",
       "       [1, 1, 0, 1],\n",
       "       [1, 1, 1, 1],\n",
       "       [1, 1, 0, 0],\n",
       "       [0, 0, 1, 1]])"
      ]
     },
     "execution_count": 4,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "arr"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 5,
   "id": "1be331eb",
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "numpy.ndarray"
      ]
     },
     "execution_count": 5,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "type(arr)"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "fc799f33-7187-4552-94c0-9ade37a91fe8",
   "metadata": {},
   "source": [
    "Here is the usual way to check the `type` of a variable, using the function `isinstance`.  It doesn't literally check that the type is exactly a NumPy array, but what this checks is usually good enough.  (Technically, it checks if `arr` is a NumPy array or is a subclass of the class NumPy array.)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 6,
   "id": "ed213f8b",
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "True"
      ]
     },
     "execution_count": 6,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "isinstance(arr, np.ndarray)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 7,
   "id": "d5a3b2b8",
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "False"
      ]
     },
     "execution_count": 7,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "isinstance(arr, list)"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "527b88a1-9fac-4161-8237-8aa3467a9f0d",
   "metadata": {},
   "source": [
    "Here is how we raise an error in Python.  In this case, we will raise a TypeError.  Don't worry about learning the many different error types in Python; for Math 9, the important thing is to know the general syntax of how to raise an error."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 8,
   "id": "16fddd9a",
   "metadata": {},
   "outputs": [],
   "source": [
    "def to_bin(arr):\n",
    "    if not isinstance(arr, np.ndarray):\n",
    "        raise TypeError(\"Input should be a NumPy array\")\n",
    "    _,n = arr.shape\n",
    "    return (arr*(2**np.arange(n-1, -1, -1))).sum(axis=1)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 9,
   "id": "940a7f94",
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "array([15,  3, 11, 14,  3,  5, 13, 15, 12,  3])"
      ]
     },
     "execution_count": 9,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "to_bin(arr)"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "3e854f16-c674-491b-be55-00f1ac9ef333",
   "metadata": {},
   "source": [
    "Notice how the error message we wrote, \"Input should be a NumPy array\", shows up in the following error message."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 10,
   "id": "9cf247e7",
   "metadata": {},
   "outputs": [
    {
     "ename": "TypeError",
     "evalue": "Input should be a NumPy array",
     "output_type": "error",
     "traceback": [
      "\u001b[0;31m---------------------------------------------------------------------------\u001b[0m",
      "\u001b[0;31mTypeError\u001b[0m                                 Traceback (most recent call last)",
      "Input \u001b[0;32mIn [10]\u001b[0m, in \u001b[0;36m<cell line: 1>\u001b[0;34m()\u001b[0m\n\u001b[0;32m----> 1\u001b[0m \u001b[43mto_bin\u001b[49m\u001b[43m(\u001b[49m\u001b[38;5;28;43mlist\u001b[39;49m\u001b[43m(\u001b[49m\u001b[43marr\u001b[49m\u001b[43m)\u001b[49m\u001b[43m)\u001b[49m\n",
      "Input \u001b[0;32mIn [8]\u001b[0m, in \u001b[0;36mto_bin\u001b[0;34m(arr)\u001b[0m\n\u001b[1;32m      1\u001b[0m \u001b[38;5;28;01mdef\u001b[39;00m \u001b[38;5;21mto_bin\u001b[39m(arr):\n\u001b[1;32m      2\u001b[0m     \u001b[38;5;28;01mif\u001b[39;00m \u001b[38;5;129;01mnot\u001b[39;00m \u001b[38;5;28misinstance\u001b[39m(arr, np\u001b[38;5;241m.\u001b[39mndarray):\n\u001b[0;32m----> 3\u001b[0m         \u001b[38;5;28;01mraise\u001b[39;00m \u001b[38;5;167;01mTypeError\u001b[39;00m(\u001b[38;5;124m\"\u001b[39m\u001b[38;5;124mInput should be a NumPy array\u001b[39m\u001b[38;5;124m\"\u001b[39m)\n\u001b[1;32m      4\u001b[0m     _,n \u001b[38;5;241m=\u001b[39m arr\u001b[38;5;241m.\u001b[39mshape\n\u001b[1;32m      5\u001b[0m     \u001b[38;5;28;01mreturn\u001b[39;00m (arr\u001b[38;5;241m*\u001b[39m(\u001b[38;5;241m2\u001b[39m\u001b[38;5;241m*\u001b[39m\u001b[38;5;241m*\u001b[39mnp\u001b[38;5;241m.\u001b[39marange(n\u001b[38;5;241m-\u001b[39m\u001b[38;5;241m1\u001b[39m, \u001b[38;5;241m-\u001b[39m\u001b[38;5;241m1\u001b[39m, \u001b[38;5;241m-\u001b[39m\u001b[38;5;241m1\u001b[39m)))\u001b[38;5;241m.\u001b[39msum(axis\u001b[38;5;241m=\u001b[39m\u001b[38;5;241m1\u001b[39m)\n",
      "\u001b[0;31mTypeError\u001b[0m: Input should be a NumPy array"
     ]
    }
   ],
   "source": [
    "to_bin(list(arr))"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "c6d6aa93-7e9a-40e8-bbda-35609990092d",
   "metadata": {},
   "source": [
    "Now we will work on the second portion, namely, checking that all of the entries are 0 or 1."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 11,
   "id": "231ef563",
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "array([[False, False, False, False],\n",
       "       [ True,  True, False, False],\n",
       "       [False,  True, False, False],\n",
       "       [False, False, False,  True],\n",
       "       [ True,  True, False, False],\n",
       "       [ True, False,  True, False],\n",
       "       [False, False,  True, False],\n",
       "       [False, False, False, False],\n",
       "       [False, False,  True,  True],\n",
       "       [ True,  True, False, False]])"
      ]
     },
     "execution_count": 11,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "arr == 0"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 12,
   "id": "744a2d4d",
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "array([[ True,  True,  True,  True],\n",
       "       [False, False,  True,  True],\n",
       "       [ True, False,  True,  True],\n",
       "       [ True,  True,  True, False],\n",
       "       [False, False,  True,  True],\n",
       "       [False,  True, False,  True],\n",
       "       [ True,  True, False,  True],\n",
       "       [ True,  True,  True,  True],\n",
       "       [ True,  True, False, False],\n",
       "       [False, False,  True,  True]])"
      ]
     },
     "execution_count": 12,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "arr == 1"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "66b0ee88-6576-4b6e-9059-1efa51f15531",
   "metadata": {},
   "source": [
    "The array is acceptable if each entry is zero or one, so we use the vertical line `|` for \"or\"."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 13,
   "id": "fd45b8f8",
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "array([[ True,  True,  True,  True],\n",
       "       [ True,  True,  True,  True],\n",
       "       [ True,  True,  True,  True],\n",
       "       [ True,  True,  True,  True],\n",
       "       [ True,  True,  True,  True],\n",
       "       [ True,  True,  True,  True],\n",
       "       [ True,  True,  True,  True],\n",
       "       [ True,  True,  True,  True],\n",
       "       [ True,  True,  True,  True],\n",
       "       [ True,  True,  True,  True]])"
      ]
     },
     "execution_count": 13,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "(arr == 0) | (arr == 1)"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "71d3af5b-5399-44e3-a385-d797619a5d6a",
   "metadata": {},
   "source": [
    "Because we are checking each entry (not each entry in a given row), we use the `all` method with no `axis` argument."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 14,
   "id": "45753e84",
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "True"
      ]
     },
     "execution_count": 14,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "((arr == 0) | (arr == 1)).all()"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 15,
   "id": "0336d296",
   "metadata": {},
   "outputs": [],
   "source": [
    "def to_bin(arr):\n",
    "    if not isinstance(arr, np.ndarray):\n",
    "        raise TypeError(\"Input should be a NumPy array\")\n",
    "    if not ((arr == 0) | (arr == 1)).all():\n",
    "        raise ValueError(\"All entries should be 0 or 1\")\n",
    "    _,n = arr.shape\n",
    "    return (arr*(2**np.arange(n-1, -1, -1))).sum(axis=1)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 16,
   "id": "ce963a05",
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "array([15,  3, 11, 14,  3,  5, 13, 15, 12,  3])"
      ]
     },
     "execution_count": 16,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "to_bin(arr)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 17,
   "id": "d4919b24",
   "metadata": {},
   "outputs": [],
   "source": [
    "arr2 = arr"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "b8d44e0a-4b08-4188-9534-e140012950c7",
   "metadata": {},
   "source": [
    "We haven't emphasized the following type of assignment much, but here is how you set the 5th row, 2nd column to be 6."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 18,
   "id": "781d99ee",
   "metadata": {},
   "outputs": [],
   "source": [
    "arr2[5,2] = 6"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 19,
   "id": "35578676",
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "array([[1, 1, 1, 1],\n",
       "       [0, 0, 1, 1],\n",
       "       [1, 0, 1, 1],\n",
       "       [1, 1, 1, 0],\n",
       "       [0, 0, 1, 1],\n",
       "       [0, 1, 6, 1],\n",
       "       [1, 1, 0, 1],\n",
       "       [1, 1, 1, 1],\n",
       "       [1, 1, 0, 0],\n",
       "       [0, 0, 1, 1]])"
      ]
     },
     "execution_count": 19,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "arr2"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "23b2f9d6-88ad-41ec-803c-fb57184fb13f",
   "metadata": {},
   "source": [
    "Here this raises the error we chose, because one of the entries is 6."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 20,
   "id": "2e1f09d0",
   "metadata": {},
   "outputs": [
    {
     "ename": "ValueError",
     "evalue": "All entries should be 0 or 1",
     "output_type": "error",
     "traceback": [
      "\u001b[0;31m---------------------------------------------------------------------------\u001b[0m",
      "\u001b[0;31mValueError\u001b[0m                                Traceback (most recent call last)",
      "Input \u001b[0;32mIn [20]\u001b[0m, in \u001b[0;36m<cell line: 1>\u001b[0;34m()\u001b[0m\n\u001b[0;32m----> 1\u001b[0m \u001b[43mto_bin\u001b[49m\u001b[43m(\u001b[49m\u001b[43marr2\u001b[49m\u001b[43m)\u001b[49m\n",
      "Input \u001b[0;32mIn [15]\u001b[0m, in \u001b[0;36mto_bin\u001b[0;34m(arr)\u001b[0m\n\u001b[1;32m      3\u001b[0m     \u001b[38;5;28;01mraise\u001b[39;00m \u001b[38;5;167;01mTypeError\u001b[39;00m(\u001b[38;5;124m\"\u001b[39m\u001b[38;5;124mInput should be a NumPy array\u001b[39m\u001b[38;5;124m\"\u001b[39m)\n\u001b[1;32m      4\u001b[0m \u001b[38;5;28;01mif\u001b[39;00m \u001b[38;5;129;01mnot\u001b[39;00m ((arr \u001b[38;5;241m==\u001b[39m \u001b[38;5;241m0\u001b[39m) \u001b[38;5;241m|\u001b[39m (arr \u001b[38;5;241m==\u001b[39m \u001b[38;5;241m1\u001b[39m))\u001b[38;5;241m.\u001b[39mall():\n\u001b[0;32m----> 5\u001b[0m     \u001b[38;5;28;01mraise\u001b[39;00m \u001b[38;5;167;01mValueError\u001b[39;00m(\u001b[38;5;124m\"\u001b[39m\u001b[38;5;124mAll entries should be 0 or 1\u001b[39m\u001b[38;5;124m\"\u001b[39m)\n\u001b[1;32m      6\u001b[0m _,n \u001b[38;5;241m=\u001b[39m arr\u001b[38;5;241m.\u001b[39mshape\n\u001b[1;32m      7\u001b[0m \u001b[38;5;28;01mreturn\u001b[39;00m (arr\u001b[38;5;241m*\u001b[39m(\u001b[38;5;241m2\u001b[39m\u001b[38;5;241m*\u001b[39m\u001b[38;5;241m*\u001b[39mnp\u001b[38;5;241m.\u001b[39marange(n\u001b[38;5;241m-\u001b[39m\u001b[38;5;241m1\u001b[39m, \u001b[38;5;241m-\u001b[39m\u001b[38;5;241m1\u001b[39m, \u001b[38;5;241m-\u001b[39m\u001b[38;5;241m1\u001b[39m)))\u001b[38;5;241m.\u001b[39msum(axis\u001b[38;5;241m=\u001b[39m\u001b[38;5;241m1\u001b[39m)\n",
      "\u001b[0;31mValueError\u001b[0m: All entries should be 0 or 1"
     ]
    }
   ],
   "source": [
    "to_bin(arr2)"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "495ef8cf-9ec1-488e-85c2-87b02ca73a8d",
   "metadata": {},
   "source": [
    "A big \"gotcha\" in Python is that our assignment above also changed the original `arr` array.  (NumPy does this to save memory space.)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 21,
   "id": "139c8f07",
   "metadata": {},
   "outputs": [
    {
     "ename": "ValueError",
     "evalue": "All entries should be 0 or 1",
     "output_type": "error",
     "traceback": [
      "\u001b[0;31m---------------------------------------------------------------------------\u001b[0m",
      "\u001b[0;31mValueError\u001b[0m                                Traceback (most recent call last)",
      "Input \u001b[0;32mIn [21]\u001b[0m, in \u001b[0;36m<cell line: 1>\u001b[0;34m()\u001b[0m\n\u001b[0;32m----> 1\u001b[0m \u001b[43mto_bin\u001b[49m\u001b[43m(\u001b[49m\u001b[43marr\u001b[49m\u001b[43m)\u001b[49m\n",
      "Input \u001b[0;32mIn [15]\u001b[0m, in \u001b[0;36mto_bin\u001b[0;34m(arr)\u001b[0m\n\u001b[1;32m      3\u001b[0m     \u001b[38;5;28;01mraise\u001b[39;00m \u001b[38;5;167;01mTypeError\u001b[39;00m(\u001b[38;5;124m\"\u001b[39m\u001b[38;5;124mInput should be a NumPy array\u001b[39m\u001b[38;5;124m\"\u001b[39m)\n\u001b[1;32m      4\u001b[0m \u001b[38;5;28;01mif\u001b[39;00m \u001b[38;5;129;01mnot\u001b[39;00m ((arr \u001b[38;5;241m==\u001b[39m \u001b[38;5;241m0\u001b[39m) \u001b[38;5;241m|\u001b[39m (arr \u001b[38;5;241m==\u001b[39m \u001b[38;5;241m1\u001b[39m))\u001b[38;5;241m.\u001b[39mall():\n\u001b[0;32m----> 5\u001b[0m     \u001b[38;5;28;01mraise\u001b[39;00m \u001b[38;5;167;01mValueError\u001b[39;00m(\u001b[38;5;124m\"\u001b[39m\u001b[38;5;124mAll entries should be 0 or 1\u001b[39m\u001b[38;5;124m\"\u001b[39m)\n\u001b[1;32m      6\u001b[0m _,n \u001b[38;5;241m=\u001b[39m arr\u001b[38;5;241m.\u001b[39mshape\n\u001b[1;32m      7\u001b[0m \u001b[38;5;28;01mreturn\u001b[39;00m (arr\u001b[38;5;241m*\u001b[39m(\u001b[38;5;241m2\u001b[39m\u001b[38;5;241m*\u001b[39m\u001b[38;5;241m*\u001b[39mnp\u001b[38;5;241m.\u001b[39marange(n\u001b[38;5;241m-\u001b[39m\u001b[38;5;241m1\u001b[39m, \u001b[38;5;241m-\u001b[39m\u001b[38;5;241m1\u001b[39m, \u001b[38;5;241m-\u001b[39m\u001b[38;5;241m1\u001b[39m)))\u001b[38;5;241m.\u001b[39msum(axis\u001b[38;5;241m=\u001b[39m\u001b[38;5;241m1\u001b[39m)\n",
      "\u001b[0;31mValueError\u001b[0m: All entries should be 0 or 1"
     ]
    }
   ],
   "source": [
    "to_bin(arr)"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "94508729-c15e-439d-b80a-2476f7389b0b",
   "metadata": {},
   "source": [
    "Notice how `arr` got changed, even though we never changed it ourselves, we only changed `arr2`."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 22,
   "id": "050a3ca9",
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "array([[1, 1, 1, 1],\n",
       "       [0, 0, 1, 1],\n",
       "       [1, 0, 1, 1],\n",
       "       [1, 1, 1, 0],\n",
       "       [0, 0, 1, 1],\n",
       "       [0, 1, 6, 1],\n",
       "       [1, 1, 0, 1],\n",
       "       [1, 1, 1, 1],\n",
       "       [1, 1, 0, 0],\n",
       "       [0, 0, 1, 1]])"
      ]
     },
     "execution_count": 22,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "arr"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "a129684b-1e90-4114-84df-2e48a5d54f70",
   "metadata": {},
   "source": [
    "If you want to make sure the original array doesn't get changed, use the `copy` method."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 23,
   "id": "f49223d1",
   "metadata": {},
   "outputs": [],
   "source": [
    "arr3 = arr.copy()"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 24,
   "id": "8165578e",
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "array([[1, 1, 1, 1],\n",
       "       [0, 0, 1, 1],\n",
       "       [1, 0, 1, 1],\n",
       "       [1, 1, 1, 0],\n",
       "       [0, 0, 1, 1],\n",
       "       [0, 1, 6, 1],\n",
       "       [1, 1, 0, 1],\n",
       "       [1, 1, 1, 1],\n",
       "       [1, 1, 0, 0],\n",
       "       [0, 0, 1, 1]])"
      ]
     },
     "execution_count": 24,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "arr3"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "babd169c-6495-428d-9bb0-d89b732f8841",
   "metadata": {},
   "source": [
    "Here we set all the even-indexed columns in row 6 to be equal to 99."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 25,
   "id": "bbd81560",
   "metadata": {},
   "outputs": [],
   "source": [
    "arr3[6,::2] = 99"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 26,
   "id": "b3141fa8",
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "array([[ 1,  1,  1,  1],\n",
       "       [ 0,  0,  1,  1],\n",
       "       [ 1,  0,  1,  1],\n",
       "       [ 1,  1,  1,  0],\n",
       "       [ 0,  0,  1,  1],\n",
       "       [ 0,  1,  6,  1],\n",
       "       [99,  1, 99,  1],\n",
       "       [ 1,  1,  1,  1],\n",
       "       [ 1,  1,  0,  0],\n",
       "       [ 0,  0,  1,  1]])"
      ]
     },
     "execution_count": 26,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "arr3"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "08775d3b-15e5-49fd-bed3-f71f85b4139b",
   "metadata": {},
   "source": [
    "Because we used the `copy` method when we created `arr3`, the original array `arr` did not get changed by our assignment."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 27,
   "id": "5e7005ec",
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "array([[1, 1, 1, 1],\n",
       "       [0, 0, 1, 1],\n",
       "       [1, 0, 1, 1],\n",
       "       [1, 1, 1, 0],\n",
       "       [0, 0, 1, 1],\n",
       "       [0, 1, 6, 1],\n",
       "       [1, 1, 0, 1],\n",
       "       [1, 1, 1, 1],\n",
       "       [1, 1, 0, 0],\n",
       "       [0, 0, 1, 1]])"
      ]
     },
     "execution_count": 27,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "arr"
   ]
  }
 ],
 "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.10.5"
  }
 },
 "nbformat": 4,
 "nbformat_minor": 5
}