week-1-numpy.ipynb

{
 "cells": [
  {
   "attachments": {},
   "cell_type": "markdown",
   "id": "4d2c698f",
   "metadata": {},
   "source": [
    "# 1. Numpy \n",
    "Numpy is a powerful Python module that should be in the toolbelt of any AI/Deep learning practitioner. It provides functions and data structures that allow fast, efficient manipulation of mathematical structures like matrices and vectors. It represents these structures internally using Numpy arrays, which are like Python Lists, but highly optimised for calculations on large amounts of numerical data. Let's import this module now.\n",
    "\n",
    "Numpy arrays are almost the exact same as Pytorch Tensors, which you will have heard about by now. The only difference is that Pytorch Tensors can be operated on by the GPU; Numpy array operations are always performed by the CPU.  "
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 102,
   "id": "a352c02e",
   "metadata": {},
   "outputs": [],
   "source": [
    "import numpy as np"
   ]
  },
  {
   "attachments": {},
   "cell_type": "markdown",
   "id": "fe0a2fda",
   "metadata": {},
   "source": [
    "### 1.1.1 Array creation\n",
    "Numpy arrays can be created in a few different ways. Common ones are:\n",
    "1. Instantiated using values from a normal Python list\n",
    "2. Filled with sequential values upto a target number\n",
    "3. Filled with a specific value\n",
    "4. Filled with random values (various random distributions available) - see https://numpy.org/doc/stable/reference/random/index.html\n",
    "\n",
    "For a full list of array creation routines, please see: https://numpy.org/doc/stable/reference/routines.array-creation.html\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 103,
   "id": "cc36ef32",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "[ 2  4  8 16 32]\n"
     ]
    }
   ],
   "source": [
    "#Array creation from python list\n",
    "python_list = [2, 4, 8, 16, 32]\n",
    "np_from_list = np.array(python_list)\n",
    "print(np_from_list)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 104,
   "id": "0ccacf1d",
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "array([10, 15, 20, 25, 30, 35, 40, 45])"
      ]
     },
     "execution_count": 104,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "#Array creation with sequential values \n",
    "seq_array = np.arange(start=10, stop=50, step=5)\n",
    "seq_array"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 105,
   "id": "3b4a7775",
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "array([0.0558312 , 0.55795473, 0.85109954, 0.89719848, 0.81816223,\n",
       "       0.99459988, 0.81678427, 0.68479151, 0.69150509, 0.08798084,\n",
       "       0.33840512, 0.74235266, 0.75673493, 0.96929529, 0.393403  ,\n",
       "       0.38768088, 0.67991731, 0.92771085, 0.16915778, 0.7987478 ])"
      ]
     },
     "execution_count": 105,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "#Array creation with random values \n",
    "random_array = np.random.rand(20)\n",
    "random_array"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 106,
   "id": "68a1cf04",
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "array([256, 256, 256, 256, 256, 256, 256, 256, 256, 256])"
      ]
     },
     "execution_count": 106,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "#Array filled with the same specific value\n",
    "filled_array = np.full(10, 256)\n",
    "filled_array"
   ]
  },
  {
   "attachments": {},
   "cell_type": "markdown",
   "id": "e92f617f",
   "metadata": {},
   "source": [
    "### 1.1.2 Reshaping arrays\n",
    "\n",
    "One of the many things that set Numpy arrays apart from Python lists is their `reshape` method. This allows you to define the number of dimensions that the structure represented by the array has. For example, the array `np_from_list` that we have just defined is just a flat list of numbers at the moment. `reshape` helps us represent it as a 2D data structure (a matrix). Keep in mind that the shape that you put into this method must agree with the number of elements in the array. In our example, the array has 10 elements, so acceptable shapes include:\n",
    "* 5, 2\n",
    "* 2, 5\n",
    "* 1, 10\n",
    "* 10, 1"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 107,
   "id": "e5e2f39c",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "[[256 256]\n",
      " [256 256]\n",
      " [256 256]\n",
      " [256 256]\n",
      " [256 256]]\n",
      "matrix has shape: (5, 2)\n"
     ]
    }
   ],
   "source": [
    "matrix_5_2 = filled_array.reshape(5, 2)\n",
    "print(matrix_5_2)\n",
    "print(f\"matrix has shape: {matrix_5_2.shape}\")"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 108,
   "id": "440acb3f",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "[[0.0558312  0.55795473 0.85109954 0.89719848 0.81816223 0.99459988\n",
      "  0.81678427 0.68479151 0.69150509 0.08798084]\n",
      " [0.33840512 0.74235266 0.75673493 0.96929529 0.393403   0.38768088\n",
      "  0.67991731 0.92771085 0.16915778 0.7987478 ]]\n",
      "matrix has shape: (2, 10)\n"
     ]
    }
   ],
   "source": [
    "matrix_2_10 = random_array.reshape(2, 10)\n",
    "print(matrix_2_10)\n",
    "print(f\"matrix has shape: {matrix_2_10.shape}\")"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 109,
   "id": "5b7ecc7c",
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "array([[32, 32],\n",
       "       [32, 32],\n",
       "       [32, 32],\n",
       "       [32, 32],\n",
       "       [32, 32]])"
      ]
     },
     "execution_count": 109,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "# You can also pass a desired shape into the array creation function to instantiate\n",
    "# an array with a pre-defined shape\n",
    "array_from_shape = np.full(matrix_5_2.shape, 32)\n",
    "array_from_shape\n"
   ]
  },
  {
   "attachments": {},
   "cell_type": "markdown",
   "id": "e5f458bc",
   "metadata": {},
   "source": [
    "### 1.1.3 Exercises"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 110,
   "id": "f97ac428",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "[ 0  1  2  3  4  5  6  7  8  9 10 11 12 13 14 15 16 17 18 19 20 21 22 23\n",
      " 24 25 26 27 28 29 30 31]\n"
     ]
    }
   ],
   "source": [
    "# Create a Numpy array A that contains the integers from 0 - 31 (32 elements long)\n",
    "A = np.arange(32)\n",
    "print(A)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 111,
   "id": "4c06fa53",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "[0.99899732 0.26085224 0.69718724 0.04511611 0.66449267 0.34984788\n",
      " 0.37932433 0.53465679 0.67605431 0.61273308 0.07041292 0.20024893]\n"
     ]
    }
   ],
   "source": [
    "# Create a Numpy array B that contains 12 random numbers between 0 and 1\n",
    "B = np.random.rand(12)\n",
    "print(B)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 112,
   "id": "b5ad76b4",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "[[ 0  1  2  3]\n",
      " [ 4  5  6  7]\n",
      " [ 8  9 10 11]\n",
      " [12 13 14 15]\n",
      " [16 17 18 19]\n",
      " [20 21 22 23]\n",
      " [24 25 26 27]\n",
      " [28 29 30 31]]\n"
     ]
    }
   ],
   "source": [
    "# Turn A into a 2d matrix of shape (8, 4) - 8 rows, 4 columns\n",
    "A = A.reshape(8, 4)\n",
    "print(A)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 113,
   "id": "f28e3f39",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "[[0.99899732 0.26085224 0.69718724]\n",
      " [0.04511611 0.66449267 0.34984788]\n",
      " [0.37932433 0.53465679 0.67605431]\n",
      " [0.61273308 0.07041292 0.20024893]]\n"
     ]
    }
   ],
   "source": [
    "# Turn B into a 2d matrix of shape (4, 3)\n",
    "B = B.reshape(4, 3)\n",
    "print(B)"
   ]
  },
  {
   "attachments": {},
   "cell_type": "markdown",
   "id": "e3e3ea19",
   "metadata": {},
   "source": [
    "## 1.2 Array operations\n",
    "Once you have created an array, there are various operations you may want to perform on them. We'll go through some of the most common ones in the next few cells.\n",
    "\n",
    "### 1.2.1 Binary operators\n",
    "Similar to normal counting numbers, Numpy arrays can be used as arguments to binary arithmetic operators like `*` (multiplication), `+` (addition), `-`(subtraction) and `/`(division). However, these can only be applied to arrays under certain conditions:\n",
    "1. The arrays have the same shape, OR\n",
    "2. The operation is between an array and a scalar, OR\n",
    "3. The operations is between 2 arrays of different shapes that can be \"broadcast\" together - more on this later\n",
    "\n",
    "These operations are applied **element-wise** meaning each element in the array is combined with its corresponding element at the same position in the other array"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 114,
   "id": "d630c356",
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "array([[11.90374858, 11.13704644, 11.99761466, 11.58659545],\n",
       "       [11.93997586, 11.25169205, 11.39017383, 11.887816  ],\n",
       "       [11.15400018, 11.14766971, 11.18396393, 11.79222709],\n",
       "       [11.96812249, 11.44261924, 11.57567083, 11.15782329],\n",
       "       [11.31233315, 11.90362521, 11.53315133, 11.74771463],\n",
       "       [11.55444117, 11.1325504 , 11.29449117, 11.97480948],\n",
       "       [11.60965251, 11.82979361, 11.56039823, 11.33596708],\n",
       "       [11.35541464, 11.46476937, 11.86548446, 11.57900587]])"
      ]
     },
     "execution_count": 114,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "# Addition with a scalar\n",
    "arr = np.random.rand(32).reshape(A.shape)\n",
    "scalar_add = arr + 11\n",
    "scalar_add"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 115,
   "id": "b729a52e",
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "array([[  0.90374858,  -0.86295356,  -1.00238534,  -2.41340455],\n",
       "       [ -3.06002414,  -4.74830795,  -5.60982617,  -6.112184  ],\n",
       "       [ -7.84599982,  -8.85233029,  -9.81603607, -10.20777291],\n",
       "       [-11.03187751, -12.55738076, -13.42432917, -14.84217671],\n",
       "       [-15.68766685, -16.09637479, -17.46684867, -18.25228537],\n",
       "       [-19.44555883, -20.8674496 , -21.70550883, -22.02519052],\n",
       "       [-23.39034749, -24.17020639, -25.43960177, -26.66403292],\n",
       "       [-27.64458536, -28.53523063, -29.13451554, -30.42099413]])"
      ]
     },
     "execution_count": 115,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "# Subtraction with another array of same shape\n",
    "sub_array = arr - A\n",
    "sub_array"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 116,
   "id": "d3454d04",
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "array([[ 0.        ,  0.13704644,  1.99522933,  1.75978636],\n",
       "       [ 3.75990345,  1.25846026,  2.341043  ,  6.21471202],\n",
       "       [ 1.23200144,  1.32902735,  1.83963933,  8.71449799],\n",
       "       [11.61746987,  5.75405017,  8.0593916 ,  2.36734931],\n",
       "       [ 4.99733037, 15.36162865,  9.59672399, 14.20657793],\n",
       "       [11.08882332,  2.7835583 ,  6.4788058 , 22.42061797],\n",
       "       [14.63166026, 20.74484037, 14.57035406,  9.07111113],\n",
       "       [ 9.95160993, 13.47831168, 25.96453369, 17.94918188]])"
      ]
     },
     "execution_count": 116,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "# Multiplication with another array of same shape\n",
    "mul_array = arr * A\n",
    "mul_array"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 117,
   "id": "9ae00ef0",
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "array([[12.17152675, 80.2647599 , 11.02630144, 18.75227627],\n",
       "       [11.70242817, 43.70420096, 28.19256207, 12.38995464],\n",
       "       [71.42848803, 74.49056644, 59.79432937, 13.88490768],\n",
       "       [11.36219861, 24.85205997, 19.10814212, 69.69820614],\n",
       "       [35.21880424, 12.17318842, 20.6320407 , 14.71149498],\n",
       "       [19.83979667, 82.98730437, 37.35256272, 11.28425632],\n",
       "       [18.04306519, 13.25630832, 19.62889844, 32.74130323],\n",
       "       [30.94976614, 23.66765271, 12.70964478, 18.99808037]])"
      ]
     },
     "execution_count": 117,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "# Division by a scalar\n",
    "div_array = 11 / arr\n",
    "div_array"
   ]
  },
  {
   "attachments": {},
   "cell_type": "markdown",
   "id": "2e285677",
   "metadata": {},
   "source": [
    "### 1.2.2 Broadcasting\n",
    "As long as an array's dimensions are compatible with their counterparts in the other array, they can be \"broadcasted\" together. This means that numpy will 'stretch' the smaller dimension along its axis so that element-wise operations can be applied between them. In general, 2 arrays can be broadcast together if each dimension in one array is compatible with its counterpart in the other array. Dimensions are compatible if they are equal or one of them is equal to 1. The dimension of size 1 is expanded to fit the size of its counterpart [https://numpy.org/doc/stable/user/basics.broadcasting.html]"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 118,
   "id": "be491c00",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "[[0]\n",
      " [1]\n",
      " [2]\n",
      " [3]]\n",
      "--------\n",
      "[[ 0  1  2]\n",
      " [ 3  4  5]\n",
      " [ 6  7  8]\n",
      " [ 9 10 11]]\n",
      "--------\n",
      "[[ 0  1  2]\n",
      " [ 4  5  6]\n",
      " [ 8  9 10]\n",
      " [12 13 14]]\n"
     ]
    }
   ],
   "source": [
    "B = np.arange(12).reshape(4, 3)\n",
    "array_4_1 = np.arange(4).reshape(4, 1)\n",
    "print(array_4_1)\n",
    "print(\"--------\")\n",
    "print(B)\n",
    "print(\"--------\")\n",
    "\n",
    "broadcasted = array_4_1 + B\n",
    "print(broadcasted)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 119,
   "id": "8af7f502",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "[[0 1 2]]\n",
      "-------------\n",
      "[[ 0  1  2]\n",
      " [ 3  4  5]\n",
      " [ 6  7  8]\n",
      " [ 9 10 11]]\n",
      "-------------\n"
     ]
    },
    {
     "data": {
      "text/plain": [
       "array([[ 0,  2,  4],\n",
       "       [ 3,  5,  7],\n",
       "       [ 6,  8, 10],\n",
       "       [ 9, 11, 13]])"
      ]
     },
     "execution_count": 119,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "# Similarly, we can also broadcast an array of shape (1, 3) along B's vertical axis\n",
    "array_1_3 = np.arange(3).reshape(1, 3)\n",
    "print(array_1_3)\n",
    "print(\"-------------\")\n",
    "print(B)\n",
    "print(\"-------------\")\n",
    "broadcasted = B + array_1_3\n",
    "broadcasted\n"
   ]
  },
  {
   "attachments": {},
   "cell_type": "markdown",
   "id": "5cfde7f5",
   "metadata": {},
   "source": [
    "### 1.2.3 Array products\n",
    "Contrary to the `*` operator, which performs element-wise multiplication between the arrays, `np.matmul` is the matrix product of the arrays."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 120,
   "id": "4a8b3147",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "A: (8, 4), B: (4, 3), A.B: (8, 3)\n",
      "[[ 42  48  54]\n",
      " [114 136 158]\n",
      " [186 224 262]\n",
      " [258 312 366]\n",
      " [330 400 470]\n",
      " [402 488 574]\n",
      " [474 576 678]\n",
      " [546 664 782]]\n"
     ]
    }
   ],
   "source": [
    "matmul_matrix = np.matmul(A, B)\n",
    "print(f\"A: {A.shape}, B: {B.shape}, A.B: {matmul_matrix.shape}\")\n",
    "print(matmul_matrix)"
   ]
  },
  {
   "attachments": {},
   "cell_type": "markdown",
   "id": "f70b44ed",
   "metadata": {},
   "source": [
    "### 1.2.4 Exercises"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 121,
   "id": "9db105a1",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "[[0.  0.4 0.8]\n",
      " [1.2 1.6 2. ]\n",
      " [2.4 2.8 3.2]\n",
      " [3.6 4.  4.4]]\n"
     ]
    }
   ],
   "source": [
    "# Divide your array B by the number 2.5. Store the result in a variable C\n",
    "C = B / 2.5\n",
    "print(C)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 122,
   "id": "69a4a760",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "[[-1 -1 -1]\n",
      " [-1 -1 -1]\n",
      " [-1 -1 -1]\n",
      " [-1 -1 -1]]\n"
     ]
    }
   ],
   "source": [
    "# Create a new array filled with -1. The array must have the same shape as B. Store the result in a variable D\n",
    "D = np.full(B.shape, -1)\n",
    "print(D)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 123,
   "id": "27789dc5",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "[[  0  -1  -2]\n",
      " [ -3  -4  -5]\n",
      " [ -6  -7  -8]\n",
      " [ -9 -10 -11]]\n"
     ]
    }
   ],
   "source": [
    "# Multiply this new array ELEMENT-WISE with B and store the result in a variable called E.\n",
    "E = D* B\n",
    "print(E)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 124,
   "id": "9e7d9a92",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "[[0 1]\n",
      " [2 3]]\n"
     ]
    }
   ],
   "source": [
    "# Consider the intermediate array below. \n",
    "intermediate_arr = np.arange(4).reshape(2, 2)\n",
    "print(intermediate_arr)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 125,
   "id": "bf5bb2bd",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "[[-42 -48 -54]]\n"
     ]
    }
   ],
   "source": [
    "# Try and multiply it with D element-wise. What happens? What could \n",
    "# you do to make this multiplication work? (hint: try and make\n",
    "# the intermediate array broadcastable to C)\n",
    "intermediate_arr = intermediate_arr.reshape(1, 4)\n",
    "F = np.matmul(intermediate_arr, E)\n",
    "print(F)"
   ]
  },
  {
   "attachments": {},
   "cell_type": "markdown",
   "id": "5f4be63d",
   "metadata": {},
   "source": [
    "## 1.3 Functions\n",
    "Another useful thing we might want to do with an array is to apply a function to each element. Generally speaking, it is best to use the built-in Numpy functions to work on numpy arrays instead of defining your own. This is because Numpy functions are highly optimised for speed, which is important when working with large amounts of data. Chances are, whatever kind of mathematical operation you want to perform on a Numpy array is already built in. See below for a full list:  \n",
    "https://numpy.org/doc/stable/reference/routines.math.html  \n",
    "\n",
    "### 1.3.1 Element-wise functions\n",
    "Common uses are applying trig functions to an array of values:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 126,
   "id": "0d99a1ba",
   "metadata": {},
   "outputs": [
    {
     "data": {
      "image/png": "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",
      "text/plain": [
       "<Figure size 252x252 with 1 Axes>"
      ]
     },
     "metadata": {
      "needs_background": "light"
     },
     "output_type": "display_data"
    },
    {
     "data": {
      "image/png": "iVBORw0KGgoAAAANSUhEUgAAAPQAAAD6CAYAAACWJWqOAAAAOXRFWHRTb2Z0d2FyZQBNYXRwbG90bGliIHZlcnNpb24zLjMuMiwgaHR0cHM6Ly9tYXRwbG90bGliLm9yZy8vihELAAAACXBIWXMAAAsTAAALEwEAmpwYAAAbrklEQVR4nO3de3hV9Z3v8fd3504IhECAkAQCclFQuRjQaj3aasVaLc708RwcbWlrpWeOvTjtsVVnOtPODKf2TJ+2zpzaDtW2eB/GS0Vr6yCWatUKQS4aIBAlkLADuUAuhNz23t/zx15btzGQTbJX1r58X8+TZ63122ut/V2VT9d1/5aoKsaY1ODzugBjTPxYoI1JIRZoY1KIBdqYFGKBNiaFWKCNSSEW6DQlIo+JyPUxzjtFRPaISI7LZZkRskCnIRE5H1gIPONMf1VE3haR7Kh5bheR7SKSqapHgT8Aq72p2MTKAp2evgw8ou8/VfRToA34WwARmQV8D7hFVQPOPI84y5kEZoFOcCIyTUSeFJFmETkgIl8TkSIRaRCR65x5xopIrYh8zpn+tYj8XEQ2ikiniPxRRGZErfaTwB8jE6oaAm4B/sbZe/8CuE9V34xa5g1g1oD1mARjgU5gIuIDngV2AqXAFcDtwFLgi8AvRGQy8GNgh6o+GLX4TcA/AZOAHYT3sIhIPjATqIn+LlWtAb4PvASUEd5DR38eAGoJH6qbBJXpdQHmtJYCxar6j870uyLyC2Clqn5BRP4T2ARMBM4bsOxvVfVlABH5W6BdRMqBkPN55yDf9wrwf4B/V9WeQT7vBApHskHGXbaHTmwzgGki0hb5A+4GpjifrwXOBX6lqq0Dlq2PjKjqCeAYMI3wuTJAQfTMzgWxfwf+DfiKcx49UEHU8iYB2R46sdUDB1R1zsAPRCSDcAAfBP5aRH6lqrVRs5RHzTsWKAL8qtolIu8Ac4HmqPm/AzQBXwe6nXV/ImodmcBswof/JkHZHjqxbQE6ROTbIpInIhkicq6ILCW8p4bwufQPgQedkEdcIyIfdfa8/wS8oaqRvfbzwGWRGUVkIfA14Fbnyvd3gQoR+ULU+pYBdap60IXtNHFigU5gqhoErgMWAQeAFuB+4OPAN4DPOfP8AFDgzqjFHwX+gfCh9gWEL5JFrAVukrAM4AFgTWQPr6rdwK3Av4hI5PD+JuDnLmymiSOxDg5Sj4j8GmhQ1b87zTyPAutV9TcxrG8y4dtci09xscwkCDuHTlOq+ldnMG8TcI6L5Zg4sUNuY1KIHXIbk0JsD21MCrFAG5NCLNDGpBALtDEpxAJtTAqxQBuTQizQxqQQC7QxKcQCbUwKsUAbk0Is0MakEAu0MSnEAm1MCrFAG5NCLNDGpJCE6LFk0qRJWlFR4XUZxiSNbdu2tahq8cD2hAh0RUUFVVVVXpdhTNIQkUF7X7VDbmNSSEyBFpE6EXlLRHaISJXTVuS8DG2/M5wQNf9dzsvTakRkuVvFG2M+6Ez20B9T1UWqWulM3wlsct7qsMmZRkTmAyuBBcDVwH0DOoA3xrhkJIfcK4B1zvg64Pqo9sdVtVdVDxB+Y+GyEXyPMSZGsQZagf8SkW0istppm6KqjQDOcLLTXkrUi9KABqftA0RktYhUiUhVc3PzwI+NMcMQ61XuS1TV77xBYaOI7D3NvDJI24f6ClbVtYRfyUJlZaX1JWzSXjCk+AREBotQbGLaQ6uq3xk2AU8TPoQ+KiIlAM6wyZm9gag3HxJ+ebh/2BUakyb+s6qeyn9+kabO4b9taMhAi0i+iBRExoGrgLeBDcAqZ7ZVwDPO+AZgpYjkiMhMYA7htygaY06j2t9BXyDEpPycYa8jlkPuKcDTzmFAJvCoqv5eRLYC60XkFuAQcAOAqlaLyHpgNxAAbnPekGiMOY1qfzvnTBuHzzf8Q+4hA62q7wILB2lvBa44xTJrgDXDrsqYNBMMKXsaO1m5rHzomU/DnhQzJgEcaOmiuz/I/JJxI1qPBdqYBFDtbwdgwbTxI1qPBdqYBLDb30F2ho85U8aOaD0WaGMSQLW/g7lTx5KVMbJIWqCN8ZiqUu1vZ0HJyA63wQJtjOca23s4frKfBaUjuyAGFmhjPFft7wBgwTQLtDFJr9rfjgicPdUCbUzSq/Z3MHNSPvk5I+8RzAJtjMd2+ztGfP85wgJtjIeOd/VxuK07LufPYIE2xlO7G+N3QQws0MZ4Kl6PfEZYoI3xULW/g5LxuRTlZ8dlfRZoYzxU7e+I2+E2WKCN8Ux3X5B3m08wP06H22CBNsYze450ENL4XRADC7QxnonnI58RFmhjPLLb3874vCxKC/Pitk4LtDEeiVwQG0k/3ANZoI3xQH8wxN4jnXE93AYLtDGeeKf5BH2BUNweKImwQBvjgerD8b8gBhZoYzxR7e8gN8vHrOKRdQo4kAXaGA9U+9s5e+o4MkbwlozBWKCNGWWqyu7G+D7yGRFzoEUkQ0S2i8hzznSRiGwUkf3OcELUvHeJSK2I1IjI8rhXbUwSqz/WTWdPIO4XxODM9tBfB/ZETd8JbFLVOcAmZxoRmQ+sBBYAVwP3iUhGfMo1Jvm9/5NJj/bQIlIGfAq4P6p5BbDOGV8HXB/V/riq9qrqAaCW8PukjTHAjoY2sjKEeVML4r7uWPfQPwG+BYSi2qaoaiOAM5zstJcC9VHzNThtHyAiq0WkSkSqmpubz7RuY5JWVd1xzisdT25W/A9cY3nh+7VAk6pui3Gdg1220w81qK5V1UpVrSwuLo5x1cYkt57+ILsa2lhaUeTK+mPpN/QS4NMicg2QC4wTkYeBoyJSoqqNIlICNDnzNwDRL7ktA/zxLNqYZLWroZ3+oFLpUqCH3EOr6l2qWqaqFYQvdr2kqjcDG4BVzmyrgGec8Q3AShHJEZGZwBxgS9wrNyYJba07BsAFMyYMMefwjKRn73uA9SJyC3AIuAFAVatFZD2wGwgAt6lqcMSVGpMCth08zuzJY+PWh9hAZxRoVd0MbHbGW4ErTjHfGmDNCGszJqWEQkpV3TE+dX6Ja99hT4oZM0r2N52goyfABTPcOX8GC7QxoyZy/ry0wp3zZ7BAGzNqquqOUVyQw/SiMa59hwXamFFSdfA4SysmxLXLoYEs0MaMgsb2bhqOd1Pp4vkzWKCNGRVVdccBXHtCLMICbcwoqKo7xpjsDM4pif8PMqJZoI0ZBVvrjrN4eiGZGe5GzgJtjMs6e/rZe6TD9fNnsEAb47rth9oIqfvnz2CBNsZ1VXXHyPAJi6YXuv5dFmhjXLa17jjzS8YxNmckv4WKjQXaGBf1B0Nsrz9OpYuPe0azQBvjot3+Dnr6Q6Ny/gwWaGNcFflBRqVLHRoMZIE2xkVVdceZXjSGyeNyR+X7LNDGuERVqTp4bNTOn8ECbYxr6lpP0nKib9TOn8ECbYxrth4Y3fNnsEAb45o/7m9mckEOsyfH95Wxp2OBNsYFgWCIV/Y1c/m8Ylc7NBjIAm2MC3bUt9HRE+DyeZOHnjmOLNDGuGBzTTMZPuGS2ZNG9Xst0Ma4YPO+Ji6YPoHxeVmj+r0WaGPirKmzh7cPd3DZvNF/CaMF2pg4e3lfCwCXJ2KgRSRXRLaIyE4RqRaR7zntRSKyUUT2O8MJUcvcJSK1IlIjIsvd3ABjEs3mmiYmF+Qwv2TcqH93LHvoXuDjqroQWARcLSIXAXcCm1R1DrDJmUZE5hN+S+UC4GrgPhGJ/5utjUlAgWCIl/c1c9nc0b1dFRHL62RVVU84k1nOnwIrgHVO+zrgemd8BfC4qvaq6gGgFlgWz6KNSVRe3a6KiOkcWkQyRGQH4Ze6b1TVN4ApqtoI4AwjW1AK1Ect3uC0DVznahGpEpGq5ubmEWyCMYkjcrvqo3NG93ZVREyBVtWgqi4CyoBlInLuaWYf7DhDB1nnWlWtVNXK4uLRv3hgjBs272tiyfTCUb9dFXFGV7lVtY3w+6GvBo6KSAmAM2xyZmsAyqMWKwP8Iy3UmEQXuV3l1eE2xHaVu1hECp3xPOBKYC+wAVjlzLYKeMYZ3wCsFJEcEZkJzAG2xLluYxJO5HbVZXO9O+KMpRvCEmCdc6XaB6xX1edE5HVgvYjcAhwCbgBQ1WoRWQ/sBgLAbaoadKd8YxLH5pomigtyWDBt9G9XRQwZaFXdBSwepL0VuOIUy6wB1oy4OmOSRCAY4pX9LXxi/hRPbldF2JNixsTBzoY22rv7PXk6LJoF2pg42FzTjE/g0tkWaGOS3uaaZpZMn8D4Md7croqwQBszQs2dvbx1uN3zw22wQBszYptrwo9geHn/OcICbcwIPberkbIJeZ7eroqwQBszAq0nevlTbQvXLZzm6e2qCAu0MSPw/FuNBEPKikXTvC4FsEAbMyIbdvqZO2UsZ0/1/nAbLNDGDNvhtm621h3n0wsTY+8MFmhjhu3ZneEfEV5ngTYm+W3Y4WdheSEzJuZ7Xcp7LNDGDENtUye7GztYkUB7Z7BAGzMsG3b48Qlce36J16V8gAXamDOkqmzY6eeiWROZPC7X63I+wAJtzBl663A7da0nE+rqdoQF2pgztGGHn6wM4ZPnJtbhNligjTkjwZDy7C4/l82d7PlPJQdjgTbmDGw5cIyjHb18OkEe9RzIAm3MGdiw009eVgZXnuP9TyUHY4E2JkZ9gRDPv9XIVQumMCY7lg5zR58F2pgYvbyvmfbu/oS8uh1hgTYmRg+/cZDighwuneN9V0OnYoE2JgYHWrrYXNPMXy2bTnZm4sYmcSszJoE8+HodmT7hpgune13KaVmgjRlCV2+AJ6oauOa8koR71HOgWF5WVy4ifxCRPSJSLSJfd9qLRGSjiOx3hhOilrlLRGpFpEZElru5Aca47ak3G+jsDbDq4gqvSxlSLHvoAPBNVT0HuAi4TUTmA3cCm1R1DrDJmcb5bCWwgPBrZ+9zXnRnTNJRVda9fpDzSsezZHqh1+UMachAq2qjqr7pjHcCe4BSYAWwzpltHXC9M74CeFxVe1X1AFALLItz3caMildrW6ltOsGqiysSolfPoZzRObSIVBB+E+UbwBRVbYRw6IHIozOlQH3UYg1O28B1rRaRKhGpam5uHkbpxrjv16/VUZSfnXC/ez6VmAMtImOBJ4HbVbXjdLMO0qYfalBdq6qVqlpZXJy49/VM+qo/dpJNe49y47JycrOS46wxpkCLSBbhMD+iqk85zUdFpMT5vARoctobgPKoxcsAf3zKNWb0PPTng/hEuPmiGV6XErNYrnIL8ACwR1V/FPXRBmCVM74KeCaqfaWI5IjITGAOsCV+JRvjvu6+IP+xtZ7lC6ZQMj7P63JiFssT5pcAnwXeEpEdTtvdwD3AehG5BTgE3ACgqtUish7YTfgK+W2qGox34ca46Tc7DtPe3c+qj1R4XcoZGTLQqvonBj8vBrjiFMusAdaMoC5jPKOqrHutjrOnFrBsZpHX5ZwRe1LMmAH+/O4x9h7p5PNJcqsqmgXamCiqyk9e3MeksTmsWPShu60JzwJtTJQ/1bbwxoFjfOVjZ5GXnRy3qqJZoI1xqCo/fKGG0sI8bkzwX1WdigXaGMfG3UfZ2dDO166YTU5m8u2dwQJtDAChkPKjjfuYOSmfzywp87qcYbNAGwM8u8vP3iOd3H7lHDIzkjcWyVu5MXHSHwzx4437OHtqAdedn7gdAMbCAm3S3pPbGqhrPck3r5qHz5dc950HskCbtNYbCPKvm/azsLwwYTvPPxMWaJPWHn3jEP72Hu64al7SPRU2GAu0SVsn+wL89A+1XDSriEtmT/S6nLiwQJu09bPN79Byoo87lqfG3hks0CZN1Rzp5Geb3+EvF5dywYzk+kXV6VigTdoJhZQ7n9pFQW4mf3ftfK/LiSsLtEk7D79xkO2H2vjOtfMpys/2upy4skCbtNLY3s3//X0Nl86ZxF8sTr6fRw7FAm3Shqrynd9UEwiFWHP9eSlzISyaBdqkjd+/fYQX9xzlb66cy/SJY7wuxxUWaJMW2rv7+fsN1cwvGcctH53pdTmuiaXXT2OS3j2/20vriV5+uWppUv+aaiipu2XGOF57p4XHthzii5fM5Lyy8V6X4yoLtElpRzt6+NpjO5g1KZ9vXDXX63JcZ4fcJmX1B0Pc9sibdPUGePTWCxmTnfr/3FN/C03a+v7ze6k6eJx7Vy5i7pQCr8sZFXbIbVLSc7v8/PLVA3z+4oqk7F97uGJ5Wd0vRaRJRN6OaisSkY0ist8ZToj67C4RqRWRGhFZ7lbhxpxKbVMn33piF0umF3L3Ned4Xc6oimUP/Wvg6gFtdwKbVHUOsMmZRkTmAyuBBc4y94lIcvaHapLSid4AX35oG3lZGdx30wVkZ6bXQeiQW6uqLwPHBjSvANY54+uA66PaH1fVXlU9ANQCy+JTqjGnp6p8+8ldHGjp4t9uXMzU8blelzTqhvt/X1NUtRHAGUY6YyoF6qPma3DaPkREVotIlYhUNTc3D7MMY95376b9/HZXI3csP5uLZ0/yuhxPxPt4ZLCn3XWwGVV1rapWqmplcXFxnMsw6eb+V97lJy/u5zNLyvifl83yuhzPDDfQR0WkBMAZNjntDUB51HxlgH/45RkztMe2HOKff7uHT547lR98JjV/RRWr4QZ6A7DKGV8FPBPVvlJEckRkJjAH2DKyEo05tWd2HObup9/i8nnF3LtycUo/px2LIR8sEZHHgMuBSSLSAPwDcA+wXkRuAQ4BNwCoarWIrAd2AwHgNlUNulS7SXMbdx/lG+t3sqyiiJ/fnH5XtAczZKBV9cZTfHTFKeZfA6wZSVHGDOXV2hZue/RNzp02jvtXVZKbZXdHwZ4UM0notXdauPXBKmZOzGfdF5dRkJvldUkJwwJtksoT2xr43ANbKJuQx0NfWkbhmNTq5G+k7McZJimoKj9+cT//umk/H509iftuXsI42zN/iAXaJLzeQJA7n3yLp7cf5r9XlrHmL84jK82vZp+KBdoktLaTfax+aBtbDhzjjuXz+F+Xn5XW95mHYoE2Cau26QSrH6qi4Vg3965clFY/gxwuC7RJOKrKw38+yJrn9zAmO5OHv3Qhy2amzvun3GSBNgmlubOXbz+5i5f2NnHZ3GL+5YbzmVyQfr+aGi4LtEkYm/Yc5VtP7KKzN8B3r5vPqosr7Hz5DFmgjee6egN8/3d7ePjPhzh7agGPrb4obfoAizcLtPFMKKT8Zsdh7vndXpo6e7n10pn87+XzyMm0xziHywJtPLH90HG+9+xudtS3sbC8kJ9/9gKWTJ8w9ILmtCzQZlQ1dfTwg9/X8OSbDRQX5PDDGxbyl4tL8fnsXDkeLNBmVDR39vLAnw7w0Ot19AeVv778LG772GzG5tg/wXiy/zWNq+qPnWTty++yvqqe/mCIa84r4Y7l85gxMd/r0lKSBdq4Yv/RTn62+R2e2enHJ/CZJWV8+bKzmDnJguwmC7SJm57+IC9UH+E/ttbz2jut5GVl8PmLK/jSpTMpGZ/ndXlpwQJtRqza3876rfU8vf0wHT0Byovy+OYn5nLTRTMoyrffK48mC7QZlgMtXbxQfYTndvl5+3AH2Zk+rl4wlf+xtJyPzJpoV609YoE2MVFVqv0d/Ff1EV6oPkrN0U4Azi0dx3evm8/1i0ut95AEYIE2p9R6opfX323l1dpWXtnfTMPxbnwCSyuK+Ptr53PVgimUTRjjdZkmigXavOdYVx/bDx3ntXdaebW2hb1HwnvhgpxMLpw1ka9+fDZXnjOFiWNzPK7UnIoFOk319AfZ3djBjkNt7KhvY2dDGwdbTwKQnemjcsYE7lg+j4vPmsh5pePTvgP7ZGGBTnGhkHK4rZuaI53UHO1k75FO9h3p5J3mEwRC4deOTR2Xy6LyQlYunc6i8kIWTy+0fq6TlAU6BagqzSd6Odh6kgMtXRxs7aKu5SR1rV3UtXTR1ff+y0tKC/M4e2oBV5wzmfPLCllUXpiWr11NVRboBBcIhjjW1UdTZy/Nnb0c7ejB396Dv637/b/2HvoCofeWyfAJ5RPyqJiUz9KKIuZOKWDe1ALmThlrndKnONcCLSJXA/cCGcD9qnqPW9+VLPoCITp6+uno7qejJ0B7dz/t3f20nezjWFcfx7v6OHayn+NdfbR29dHc2UtrVy864IW8PoHJBblMK8zl3NLxLF8wlWmFeUyfOIaZE/MpnZBn3dymKVcCLSIZwE+BTxB+xexWEdmgqrvd+L54UFX6giH6AiF6A+8PewNBevtD9PQH6Qk4w/5w28m+ACf7g3T3BTnp/HX3BTjRG+REbz9dvUFO9AbCfz0BuvtP/96+8XlZFOVnM2FMFqWFuSwqH09xQS7FBTlMLsh5bzhlXK4F1gzKrT30MqBWVd8FEJHHgRWE30p5xlpO9PL/XqolGFICISUUUoIaHgac8UAw9N7nwZDS70z3B5VAKEQgGG4LhJRAMBze/mCI/kCIfmd6uERgTFYGedmZjMnOID8nk4KcTCaNzWbGxDEU5GaSn53JuLwsxudlMS4vMzzMDU9PyM+mMC/LriSbEXMr0KVAfdR0A3DhcFfW3RfkqTcbyPAJGT4fGT7IEMHnEzJ8QqZPyPT5yPAJWRnizBduy80SsjJ8ZPqcYUZ4mJXhIzsynukjyyfkZGWQk+kjO9P33jA7I4PcLB+5WeFhTmbGe+NjnADnZPqsMzuTENwK9GD/uj9wJigiq4HVANOnTz/tysqLxrDru8vjVpwxqcqtY7wGoDxqugzwR8+gqmtVtVJVK4uLi10qw5j04lagtwJzRGSmiGQDK4ENLn2XMcbhyiG3qgZE5CvAC4RvW/1SVavd+C5jzPtcuw+tqs8Dz7u1fmPMh9l9EmNSiAXamBRigTYmhYgOfFDYiyJEmoGDMcw6CWhxuZxEkk7bm07bCiPf3hmq+qH7vQkR6FiJSJWqVnpdx2hJp+1Np20F97bXDrmNSSEWaGNSSLIFeq3XBYyydNredNpWcGl7k+oc2hhzesm2hzbGnEZSBFpErhaRGhGpFZE7va7HTSJSLiJ/EJE9IlItIl/3uqbRICIZIrJdRJ7zuha3iUihiDwhInud/84fidu6E/2Q2+nOaB9R3RkBNyZyd0YjISIlQImqvikiBcA24PpU3d4IEfkGUAmMU9Vrva7HTSKyDnhFVe93fo04RlXb4rHuZNhDv9edkar2AZHujFKSqjaq6pvOeCewh3APMClLRMqATwH3e12L20RkHPDfgAcAVLUvXmGG5Aj0YN0ZpfQ/8AgRqQAWA294XIrbfgJ8Cxh+x27JYxbQDPzKOcW4X0Ty47XyZAj0kN0ZpSIRGQs8Cdyuqh1e1+MWEbkWaFLVbV7XMkoygSXAz1R1MdAFxO26UDIEesjujFKNiGQRDvMjqvqU1/W47BLg0yJSR/h06uMi8rC3JbmqAWhQ1chR1xOEAx4XyRDotOrOSMLdhz4A7FHVH3ldj9tU9S5VLVPVCsL/bV9S1Zs9Lss1qnoEqBeReU7TFQyze+vBJPyrcNKwO6NLgM8Cb4nIDqftbqcHGJMavgo84uyg3gW+EK8VJ/xtK2NM7JLhkNsYEyMLtDEpxAJtTAqxQBuTQizQxqQQC7QxKcQCbUwKsUAbk0L+P4Qf9Y5XSQ5SAAAAAElFTkSuQmCC",
      "text/plain": [
       "<Figure size 252x252 with 1 Axes>"
      ]
     },
     "metadata": {
      "needs_background": "light"
     },
     "output_type": "display_data"
    }
   ],
   "source": [
    "import matplotlib.pyplot as plt\n",
    "\n",
    "def simple_plot(x, y, label):\n",
    "    plt.plot(x, y)\n",
    "    plt.suptitle(label)\n",
    "    plt.show()\n",
    "\n",
    "    \n",
    "\n",
    "# Element-wise functions: \n",
    "X = np.arange(0, 2*np.pi, 0.2)\n",
    "Y = np.sin(X)\n",
    "simple_plot(X, Y, \"sin(X)\")\n",
    "\n",
    "Y_1  = np.exp(X)\n",
    "simple_plot(X, Y_1, \"exp(X)\")\n"
   ]
  },
  {
   "attachments": {},
   "cell_type": "markdown",
   "id": "abc97f70",
   "metadata": {},
   "source": [
    "### 1.3.2 Reduce functions\n",
    "These are applied along the selected axis, consume all the elements and reduce the axis down to 1 element. If no axis is specified, the function is applied to the whole array, and reduces it to a scalar"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 127,
   "id": "5d79e457",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "[[ 0  1  2  3]\n",
      " [ 4  5  6  7]\n",
      " [ 8  9 10 11]\n",
      " [12 13 14 15]\n",
      " [16 17 18 19]\n",
      " [20 21 22 23]\n",
      " [24 25 26 27]\n",
      " [28 29 30 31]]\n",
      "-----------\n",
      "max: 31\n",
      "[[ 1.5]\n",
      " [ 5.5]\n",
      " [ 9.5]\n",
      " [13.5]\n",
      " [17.5]\n",
      " [21.5]\n",
      " [25.5]\n",
      " [29.5]]\n"
     ]
    }
   ],
   "source": [
    "# Max, mean minimun functions:\n",
    "A = np.arange(32).reshape(8, 4)\n",
    "print(A)\n",
    "print(\"-----------\")\n",
    "I = A.max()\n",
    "print(f\"max: {I}\")\n",
    "\n",
    "I_2 = np.mean(A, axis=1, keepdims=True)\n",
    "print(I_2)"
   ]
  },
  {
   "attachments": {},
   "cell_type": "markdown",
   "id": "c796c03c",
   "metadata": {},
   "source": [
    "### 1.3.3 Exercises\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 128,
   "id": "bfef5c5f",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "[-0.99999303 -0.99999148 -0.9999896  -0.99998729 -0.99998448 -0.99998104\n",
      " -0.99997684 -0.99997172 -0.99996545 -0.99995781 -0.99994846 -0.99993706\n",
      " -0.99992312 -0.9999061  -0.99988531 -0.99985992 -0.99982891 -0.99979103\n",
      " -0.99974477 -0.99968827 -0.99961927 -0.99953499 -0.99943207 -0.99930637\n",
      " -0.99915286 -0.9989654  -0.99873648 -0.99845695 -0.99811564 -0.99769892\n",
      " -0.99719016 -0.99656913 -0.99581111 -0.99488605 -0.99375734 -0.99238047\n",
      " -0.99070133 -0.98865425 -0.98615966 -0.98312123 -0.97942267 -0.97492392\n",
      " -0.96945679 -0.96282015 -0.95477457 -0.94503671 -0.93327368 -0.91909789\n",
      " -0.90206306 -0.88166254 -0.85733128 -0.82845337 -0.79437734 -0.75444149\n",
      " -0.70801148 -0.65453119 -0.59358628 -0.52497672 -0.44879099 -0.36547052\n",
      " -0.27585058 -0.1811634  -0.08299396  0.01681311  0.11628624  0.21348\n",
      "  0.30662392  0.39424359  0.47523785  0.54890634  0.61493237  0.67333244\n",
      "  0.72438705  0.76856596  0.80645811  0.83871205  0.8659896   0.88893254\n",
      "  0.90814095  0.92416076  0.93747833  0.94851987  0.95765405  0.96519649\n",
      "  0.97141513  0.9765359   0.98074828  0.98421047  0.9870541   0.98938834\n",
      "  0.99130355  0.99287433  0.99416222  0.9952179   0.99608305  0.99679194\n",
      "  0.9973727   0.99784843  0.9982381   0.99855725  0.99881862  0.99903267\n",
      "  0.99920794  0.99935147  0.999469    0.99956523  0.99964403  0.99970855\n",
      "  0.99976137  0.99980462  0.99984004  0.99986903  0.99989277  0.99991221\n",
      "  0.99992812  0.99994115  0.99995182  0.99996055  0.9999677   0.99997356\n",
      "  0.99997835  0.99998227  0.99998549  0.99998812  0.99999027  0.99999204]\n"
     ]
    }
   ],
   "source": [
    "# Have a look at the trigonometric functions listed in the official numpy documentation: \n",
    "# https://numpy.org/doc/stable/reference/routines.math.html\n",
    "# Pick any element-wise function that takes 1 numpy array as an argument and apply it to the following\n",
    "# array. store the result in a variable called Ys\n",
    "Xs = np.arange(-2*np.pi, 2*np.pi, 0.1)\n",
    "Ys = np.tanh(Xs)\n",
    "print(Ys)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 129,
   "id": "0158d8c2",
   "metadata": {},
   "outputs": [
    {
     "data": {
      "image/png": "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",
      "text/plain": [
       "<Figure size 252x252 with 1 Axes>"
      ]
     },
     "metadata": {
      "needs_background": "light"
     },
     "output_type": "display_data"
    }
   ],
   "source": [
    "# Call our previously-defined simple plot function and display your result! Give the plot a suitable title\n",
    "simple_plot(Xs, Ys, \"tanh(Xs)\")"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 130,
   "id": "cb7444e7",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "0.9999920352594386\n"
     ]
    }
   ],
   "source": [
    "# Use a suitable Numpy reduce function to find the maximum value of your function's result\n",
    "max_val = Ys.max()\n",
    "print(max_val)"
   ]
  },
  {
   "attachments": {},
   "cell_type": "markdown",
   "id": "bd2d92ce",
   "metadata": {},
   "source": [
    "## 1.4 numpy.where\n",
    "This allows us to conditionally modify the elements of an array, which can be useful for tasks like thresholding or masking."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 131,
   "id": "25e1bea8",
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "array([[ 0. ,  0. ,  0. ,  0. ,  0. ,  0. ,  0. ,  0. ,  0. ,  0. ],\n",
       "       [ 0. ,  0. ,  0. ,  0. ,  0. ,  0. ,  0. ,  0. ,  0. ,  0. ],\n",
       "       [ 0. ,  0. ,  0. ,  0. ,  0. ,  0. ,  0. ,  0. ,  0. ,  0. ],\n",
       "       [ 0. ,  0. ,  0. ,  0. ,  0. ,  0. ,  0. ,  0. ,  0. ,  0. ],\n",
       "       [ 0. ,  0. ,  0. ,  0. ,  0. ,  0. ,  0. ,  0. ,  0. ,  0. ],\n",
       "       [25. , 25.5, 26. , 26.5, 27. , 27.5, 28. , 28.5, 29. , 29.5],\n",
       "       [30. , 30.5, 31. , 31.5, 32. , 32.5, 33. , 33.5, 34. , 34.5],\n",
       "       [35. , 35.5, 36. , 36.5, 37. , 37.5, 38. , 38.5, 39. , 39.5],\n",
       "       [40. , 40.5, 41. , 41.5, 42. , 42.5, 43. , 43.5, 44. , 44.5],\n",
       "       [45. , 45.5, 46. , 46.5, 47. , 47.5, 48. , 48.5, 49. , 49.5]])"
      ]
     },
     "execution_count": 131,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "big_image = np.arange(10*10).reshape(10, 10)\n",
    "big_image_thresh = np.where(big_image < 50, 0, big_image / 2)\n",
    "big_image_thresh"
   ]
  },
  {
   "attachments": {},
   "cell_type": "markdown",
   "id": "21cba204",
   "metadata": {},
   "source": [
    "### 1.4.1 Exercises\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 132,
   "id": "b0c50f34",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "[[0.87163067 0.29510891 0.75165945 0.55135109 0.09569675]\n",
      " [0.46090516 0.9579623  0.12648068 0.03449916 0.08861705]\n",
      " [0.97053682 0.63324143 0.35074232 0.98733841 0.81142608]\n",
      " [0.04222029 0.04999845 0.98029201 0.47929151 0.26781435]\n",
      " [0.61451358 0.48327363 0.62592263 0.64631053 0.04889921]\n",
      " [0.57206565 0.44718355 0.77988358 0.9708396  0.95868845]\n",
      " [0.4571169  0.08733939 0.83149753 0.79123784 0.03567614]\n",
      " [0.56933149 0.24462318 0.75180903 0.55798355 0.15373791]\n",
      " [0.59352978 0.32623847 0.74664981 0.27790879 0.25384295]\n",
      " [0.38577662 0.50372145 0.6600113  0.24711904 0.61008507]]\n"
     ]
    }
   ],
   "source": [
    "# Create a Numpy array of shape (10, 5) and fill it with random values between 0 and 1. Store it in a variable called J\n",
    "J = np.random.rand(10* 5).reshape(10, 5)\n",
    "print(J)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 133,
   "id": "36292d54",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "[[1 0 1 1 0]\n",
      " [0 1 0 0 0]\n",
      " [1 1 0 1 1]\n",
      " [0 0 1 0 0]\n",
      " [1 0 1 1 0]\n",
      " [1 0 1 1 1]\n",
      " [0 0 1 1 0]\n",
      " [1 0 1 1 0]\n",
      " [1 0 1 0 0]\n",
      " [0 1 1 0 1]]\n"
     ]
    }
   ],
   "source": [
    "# Conditionally modify the array such that numbers below 0.5 are replaced with 0 and numbers above \n",
    "# or equal to 0.5 are replaced with 1. Store the result in a variable called K\n",
    "K = np.where(J < 0.5, 0, 1)\n",
    "print(K)"
   ]
  },
  {
   "attachments": {},
   "cell_type": "markdown",
   "id": "1e67bef4",
   "metadata": {},
   "source": [
    "## 1.5 Practical example\n",
    "\n",
    "Putting everything together for a practical example, and visulalise the output of some Numpy operations"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 134,
   "id": "053dfac8",
   "metadata": {},
   "outputs": [],
   "source": [
    "# Defining some helper functions\n",
    "def plot_point(point):\n",
    "    plt.rcParams[\"figure.figsize\"] = [3.50, 3.50]\n",
    "    plt.rcParams[\"figure.autolayout\"] = True\n",
    "    x = point[0]\n",
    "    y = point[1]\n",
    "    \n",
    "    lims = 3\n",
    "    fig = plt.figure()\n",
    "    ax = fig.add_subplot(111)\n",
    "    plt.xlim(-lims, lims)\n",
    "    plt.ylim(-lims, lims)\n",
    "    plt.grid()\n",
    "    ax.plot(x, y, marker=\"o\", markersize=7, markeredgecolor=\"black\", markerfacecolor=\"red\")\n",
    "    ax.spines['left'].set_position('zero')\n",
    "    ax.spines['right'].set_color('none')\n",
    "    ax.spines['bottom'].set_position('zero')\n",
    "    ax.spines['top'].set_color('none')\n",
    "    plt.show()\n",
    "\n",
    "\n",
    "\n",
    "# This function returns an np array that describes a 2d rotation \n",
    "# matrix [https://www1.udel.edu/biology/rosewc/kaap686/notes/matrices_rotations.pdf]. \n",
    "# These kinds of structures are often used in computer graphics to rotate and translate points in space\n",
    "def get_rot_clockwise_matrix(angle):\n",
    "    return np.array([\n",
    "        [ np.cos(angle), np.sin(angle)],\n",
    "        [-np.sin(angle), np.cos(angle)]\n",
    "    ])"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 135,
   "id": "e5bedc69",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "[0.95283504 0.43576252]\n"
     ]
    }
   ],
   "source": [
    "# Create a random 2-element array containing values from 0 - 1. Assign this array to a variable `p`\n",
    "p = np.random.rand(2)\n",
    "print(p)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 136,
   "id": "d3454cb0",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "[1.90567007 0.87152504]\n"
     ]
    }
   ],
   "source": [
    "# Use scalar multiplication to double the value of the elements in `p`. Assign the result back to `p`\n",
    "p = 2 * p\n",
    "print(p)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 137,
   "id": "00655ac8",
   "metadata": {},
   "outputs": [
    {
     "data": {
      "image/png": "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",
      "text/plain": [
       "<Figure size 252x252 with 1 Axes>"
      ]
     },
     "metadata": {
      "needs_background": "light"
     },
     "output_type": "display_data"
    }
   ],
   "source": [
    "# Reshape `p` to be (2, 1), assign the result to `p` and plot the point.\n",
    "p = p.reshape(2, 1)\n",
    "plot_point(p)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 138,
   "id": "1937533d",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "126.41757241179826\n"
     ]
    }
   ],
   "source": [
    "# We will now rotate this point about the origin of the plot using the funciton we defined above\n",
    "# This cell is just some setup for the rest of the exercise, just run it once\n",
    "min_angle = np.pi/2 # 90 degrees\n",
    "max_angle = np.pi   # 180 degrees\n",
    "angle = np.random.uniform(min_angle, max_angle) # get a random angle between 90 and 180 degrees\n",
    "print(np.degrees(angle)) # print the angle in degrees so we can check the rotation is correct!"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 139,
   "id": "0ea1d746",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "[[-0.59366572  0.80471176]\n",
      " [-0.80471176 -0.59366572]]\n"
     ]
    }
   ],
   "source": [
    "# Call the previously-defined roation matrix function with the angle. Assign the result to \n",
    "# a variable called `rot90`\n",
    "rot = get_rot_clockwise_matrix(angle)\n",
    "print(rot)\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 140,
   "id": "350ff0ba",
   "metadata": {},
   "outputs": [
    {
     "data": {
      "image/png": "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",
      "text/plain": [
       "<Figure size 252x252 with 1 Axes>"
      ]
     },
     "metadata": {
      "needs_background": "light"
     },
     "output_type": "display_data"
    }
   ],
   "source": [
    "# Apply a matrix multiplication operation between rot90 and p. assign the result back to p and plot it.\n",
    "p = np.matmul(rot, p)\n",
    "plot_point(p)\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 141,
   "id": "65e93aeb",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "[[2]\n",
      " [2]]\n"
     ]
    }
   ],
   "source": [
    "# Create an array named `translation` which has the same shape as `p`, and fill it with 2's\n",
    "translation = np.full(p.shape, 2)\n",
    "print(translation)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 142,
   "id": "0fff9269",
   "metadata": {},
   "outputs": [
    {
     "data": {
      "image/png": "iVBORw0KGgoAAAANSUhEUgAAAPQAAAD0CAYAAACsLwv+AAAAOXRFWHRTb2Z0d2FyZQBNYXRwbG90bGliIHZlcnNpb24zLjMuMiwgaHR0cHM6Ly9tYXRwbG90bGliLm9yZy8vihELAAAACXBIWXMAAAsTAAALEwEAmpwYAAAOeUlEQVR4nO3dbWzTdb/H8c9POoR1IuHBLm5Kjm5YVrqbZmaKic4usHKEiWwkBFlyiZBcM9HExGQkStQ4AeWBiSQkJznRmV3GaDAyYK1OHVbi3aVjQSYYvF1OdsOuw4NN1gVkbN/zYLLAYYNu7fr797vPK2ni7H/Lh5X32v1bNiMiICIdbrE9gIiSh0ETKcKgiRRh0ESKMGgiRRg0kSIMOs0ZY+YYY74zxpw0xpw2xrxkexPZY/g8dHozxhgAbhGJGWMyAHwJ4GkR+ZflaWSBy/YASoyMfkWO/fVmxl8XfpWeoRK6h/7oo49k7ty5SZyTmMHBQbjdbtszrpGKTcPDw6ipqUF3dzc2bNiAmpqaa65vampCOBwGAFy8eBENDQ3TumeyZurtNhnBYNDEdaCITPkSjUbFSZy2RyS1m/r6+iQYDMoPP/ww4TFerzdle+I102+3OMXVJE+KKTJ//nwEg0E0NzfbnkKWMOg0d+7cOfT39wMALly4gJaWFuTl5dkdRdbwpFiaO3v2LB577DEMDw9jZGQEmzZtQkVFhe1ZZAmDTnOFhYU4ceKE7RnkEHzITaQIgyZShEETKcKgiRRh0ESKMGgiRRg0kSIMmkgRBk2kCIMmUoRBEynCoIkUYdBEijBoIkUYNJEiDJpIEQZNpAiDJlKEQRMpwqCJFGHQRIowaCJFGDSRIgyaSBEGTaQIgyZShEETKcKgiRRh0Gmus7MTZWVl8Pl88Pv92Ldvn+1JZBF/+2Sac7lceO2111BcXIyBgQHcfffdKC8vx4oVK2xPIwt4D53mFi1ahOLiYgDAbbfdBp/Ph+7ubsuryBYjIlN+50gkIm63O4lzEhOLxZCVlWV7xjVSuam3txdPP/006uvrcfXt0tTUhHA4DADo6+vDgQMHUrInXjP9dotHMBg0cR0oIlO+RKNRcRKn7RFJ3aaBgQEpLi6WDz744IbHeb3elOyZjJl8u01CXE3yIbcCQ0ND2LhxI6qrq1FVVWV7DlnEoNOciGD79u3w+Xx45plnbM8hyxh0mvvqq6/w9ttv47PPPkMgEEAgEMCHH35oexZZwqet0tz9998PSeDEJunCe2giRRg0kSIMmkgRBk2kCIMmUoRBEynCoIkUYdBEijBoIkUYNJEiDJpIEQZNpAiDJlKEQRMpwqCJFGHQRIowaCJFGDSRIgyaSBEGTaQIgyZShEETKcKgiRRh0ESKMGgiRRg0kSIMmkgRBk2kCINOc9u2bUN2djby8/NtTyEHYNBpbuvWrWhubrY9gxyCQae50tJSLFiwwPYMcgiTyO8WjkQi4na7kzgnMbFYDFlZWbZnXCMVm3p7e/Hss8/irbfeGvf6pqYmhMNhAEBfXx8OHDgwrXsma6bebpMRDAZNXAeKyJQv0WhUnMRpe0RSs6mjo0P8fn9cx3q93mleM3kz9XabpLia5ENuIkUYNJEiDDrNPfroo7jvvvvw008/wePx4M0337Q9iSxy2R5AiXn33XdtTyAH4T00kSIMmkgRBk2kCIMmUoRBEynCoIkUYdBEijBoIkUYNJEiDJpIEQZNpAiDJlKEQRMpwqCJFGHQRIowaCJFGDSRIgyaSBEGTaQIgyZShEETKcKgiRRh0ESKMGgiRRg0kSIMmkgRBk2kCINWoLm5GcuXL8eyZcvw6quv2p5DFvGX1aW54eFhPPnkk/j000/h8XhQUlKC9evXY8WKFbanWXHhwgU0Njbit99+Q25uLqqqqjBnzhzbs1KG99Bp7rvvvsOyZcuQk5OD2bNnY/PmzTh8+LDtWVa0trYid/Fi/LOmBn+++CL+WVODnEWL0NraantayvAeOs11d3dj6dKlY297PB58++23FhfZceHCBTwSCuG/+vvxyJX/GYvhMIBHQiH8fvbsjLinNiIy5XcuKCiQS5cuJXFOYoaGhpCRkWF7xjWme9PAwAAGBwexcOFCAMD58+dx8eJFZGdnjx3zxx9/oL+/HwBw+fJl5ObmTtueqUjG5+j8+fMY/Pe/4R3n7/PPxsD9t79h3rx5Kd2UTD///PNpEcm/6YEiMuWL1+sVJ3HaHpHp3/T1119LKBQae3vPnj2yZ8+eCY+/9dZbp3XPVCTjc1RXVyc7jREBrrs8Z4y8/PLLKd+UTACOSxxN8nvoNFdSUoJffvkFHR0duHTpEt577z2sX7/e9qyUy83NxXG3e9zr2txu5OTkpHiRHQw6zblcLuzfvx9r1qyBz+fDpk2b4Pf7bc9KuaqqKrS7XPj/pwMPA2h3uVBVVWVjVsoldFKsoqIiWTuSwml7gNRsWrt2LdauXRvXsfPnz5/eMVOQjM/RnDlzcPiTT0ZPjF2+jLsHB9Hmdo9G/sknkz4h5sC/S/8dz0EJBf3www8n8u5J57Q9gPM23X777bYnXCdZn6OSkhL81tODxsZG/P777/h7Ts6Un4d22u0mItMfNJHTzJ07F1u2bLE9w5qEvoeur69HYWEhAoEAQqEQenp6krVrympra5GXl4fCwkJUVlaOPV1j0/vvvw+/349bbrkFx48ft7ajubkZHR0djnmJ6LZt25CdnY3HH3/c9hQAQGdnJ8rKyuDz+bB161bs27fP9iRcvHgR99xzD4wxJ40xp40xL93wHeI5FT7RJRwOj51W37dvn9TU1Ez/+fsbiEaj8vHHH8vQ0JCIiOzYsUN27NhhfdOPP/4oZ86ckQcffFBaW1ut7Lh8+bLk5OTInXfeKX/++acUFhbK6dOnrWy54tixY9LW1iZ33HGH1R1X9PT0SFtbm4iIRCIRueuuu6x/jkZGRmRgYEBk9Pn1DADfAlgp0/G0lfuqpwkGBwdhjEnkwyVFKBSCyzX6ncTKlSvR1dVleRHg8/mwfPlyqxuuvEQ0IyPDMS8RLS0txYIFC6xuuNqiRYtQXFwMAMjMzITP50N3d7fVTcYYZGVlXXkz46/LhK8GS/hpq507d2Lp0qV45513UFdXl+iHS6r6+no89NBDtmc4wngvEbX9l9XJent7ceLECdx77722p2B4eBjGmO8B/C+AT0Vkwtf23jRoY0yLMebUOJdHAGD37t3o7OxEdXU19u/fn7Q/xI2sXr0a+fn5112+/PLLsWN2794Nl8uF6upqx2yyScZ5SaQTHlE5USwWwwsvvIDXX399Ui8XnS6zZs2CiAQAeADcY4yZ8CWgNz3LLSKrJ7ru888/H/vvLVu2YN26dXjppRt/z54MLS0tN9zT0NCAcDiMo0ePpuwv7c022ebxeNDZ2Tn2dldXFxYvXmxxkTMNDQ1h48aNWL16teNejCIi/caYzwH8J4BT4x2T0EPuq78/PXLkCPLy8hL5cEnR3NyMvXv34siRI8jMzLQ9xzGuvER0aGhoRr9E9EZEBNu3bx97xZ0TnDt3buyZGmPMXACrAZyZ8B0mOlsWz+WBBx4Qv98vBQUFUlFRIV1dXSk58zeRaDQqubm54vF4pKioSIqKihxx5v3gwYOyZMkSmT17tmRnZ1/zjylSKRKJSEZGhuTk5MiuXbusbLja5s2bZeHChTJr1ixZsmSJvPHGG1b3fPHFFwJACgoKJDc3V4qKiiQSiVjddPLkSQkEAgKgHaP3yi/IDZpMKOhoNJrCP9rNOW2PiPM2Oe1fEYk473Mk4shNcTXJf5xBpAiDJlKEQRMpwqCJFGHQRIowaCJFGDSRIgyaSBEGTaQIgyZShEETKcKgiRRh0ESKMGgiRRg0kSIMmkgRBk2kCINOY075jRzkHAw6jeXn5+PgwYMoLS21PYUcgr+sLo35fD7bE8hhEgp6cHDQMT93Ghj9AelO2gOkZlN/fz/a2toQi8XGvb6pqQnhcBgA0NfXNyM/R5PltE3BYDC+A+P9aYLjXZz2kxGdtkck8U2rVq0Sv99/3eXQoUNjx0zml+Dxp37Gx4Gb4mqSD7kdbqLfyEE0Hp4UI1KEQaexxsZGeDwefPPNN1i3bh3WrFljexJZxofcaayyshKVlZW2Z5CD8B6aSBEGTaQIgyZShEETKcKgiRRh0ESKMGgiRRg0kSIMmkgRBk2kCIMmUoRBEynCoIkUYdBEijBoIkUYNJEiDJpIEQZNpAiDJlKEQRMpwqCJFGHQRIowaCJFGDSRIgyaSBEGTaQIgyZShEETKcKg01htbS3y8vJQWFiIyspK9Pf3255EljHoNFZeXo5Tp06hvb0dXq8Xr7zyiu1JZBmDTmOhUAgu1+hvBF65ciW6urosLyLbjIhM+Z0jkYi43e4kzklMLBZDVlaW7RnXSNWm5557DmVlZSgvL7/uuqamJoTDYQBAX18fDhw4MO17JmMm327xCgaDJq4DRWTKl2g0Kk7itD0iiW9atWqV+P3+6y6HDh0aO2bXrl2yYcMGGRkZuenH83q9Ce2ZDhpvt2kQV5Ouaf7CQglqaWm54fUNDQ0Ih8M4evQojInvizjpxaDTWHNzM/bu3Ytjx44hMzPT9hxyAJ4US2NPPfUUBgYGUF5ejkAggCeeeML2JLKM99Bp7Ndff7U9gRyG99BEijBoIkUYNJEiDJpIEQZNpAiDJlKEQRMpwqCJFGHQRIowaCJFGDSRIgyaSBEGTaQIgyZShEETKcKgiRRh0ESKMGgiRRg0kSIMmkgRBk2kCIMmUoRBEynCoIkUYdBEijBoIkUYNJEiDJpIEQadxp5//nkUFhYiEAggFAqhp6fH9iSyjEGnsdraWrS3t+P7779HRUUF6urqbE8iyxh0Gps3b97Yfw8ODsIYY3ENOYEREdsbKAHGmN0A/g7gDwBlInJunGP+AeAff705R0TyUziRUohBO5wxpgXAwnGu2ikih6867lmMxvpiysaR4zBoJYwx/wEgwnvfmY3fQ6cxY8xdV725HsAZW1vIGXgPncaMMR8AWA5gBMD/AHhCRLrtriKbGDSRInzITaQIgyZShEETKcKgiRRh0ESKMGgiRRg0kSL/BxO5fIaLrQz/AAAAAElFTkSuQmCC",
      "text/plain": [
       "<Figure size 252x252 with 1 Axes>"
      ]
     },
     "metadata": {
      "needs_background": "light"
     },
     "output_type": "display_data"
    }
   ],
   "source": [
    "# Add this result to p and plot it!\n",
    "p = p + translation\n",
    "plot_point(p)\n"
   ]
  }
 ],
 "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.4"
  }
 },
 "nbformat": 4,
 "nbformat_minor": 5
}