NLP_C1_W3_lecture_nb_01_linear_algebra.ipynb

{
 "cells": [
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "# Linear algebra in Python with NumPy\n"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "In this lab, you will have the opportunity to remember some basic concepts about linear algebra and how to use them in Python.\n",
    "\n",
    "Numpy is one of the most used libraries in Python for arrays manipulation. It adds to Python a set of functions that allows us to operate on large multidimensional arrays with just a few lines. So forget about writing nested loops for adding matrices! With NumPy, this is as simple as adding numbers.\n",
    "\n",
    "Let us import the `numpy` library and assign the alias `np` for it. We will follow this convention in almost every notebook in this course, and you'll see this in many resources outside this course as well."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 1,
   "metadata": {},
   "outputs": [],
   "source": [
    "import numpy as np  # The swiss knife of the data scientist."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Defining lists and numpy arrays"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 2,
   "metadata": {},
   "outputs": [],
   "source": [
    "alist = [1, 2, 3, 4, 5]   # Define a python list. It looks like an np array\n",
    "narray = np.array([1, 2, 3, 4]) # Define a numpy array"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Note the difference between a Python list and a NumPy array."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 3,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "[1, 2, 3, 4, 5]\n",
      "[1 2 3 4]\n",
      "<class 'list'>\n",
      "<class 'numpy.ndarray'>\n"
     ]
    }
   ],
   "source": [
    "print(alist)\n",
    "print(narray)\n",
    "\n",
    "print(type(alist))\n",
    "print(type(narray))"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Algebraic operators on NumPy arrays vs. Python lists\n",
    "\n",
    "One of the common beginner mistakes is to mix up the concepts of NumPy arrays and Python lists. Just observe the next example, where we add two objects of the two mentioned types. Note that the '+' operator on NumPy arrays perform an element-wise addition, while the same operation on Python lists results in a list concatenation. Be careful while coding. Knowing this can save many headaches."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 4,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "[2 4 6 8]\n",
      "[1, 2, 3, 4, 5, 1, 2, 3, 4, 5]\n"
     ]
    }
   ],
   "source": [
    "print(narray + narray)\n",
    "print(alist + alist)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "It is the same as with the product operator, `*`. In the first case, we scale the vector, while in the second case, we concatenate three times the same list."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 5,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "[ 3  6  9 12]\n",
      "[1, 2, 3, 4, 5, 1, 2, 3, 4, 5, 1, 2, 3, 4, 5]\n"
     ]
    }
   ],
   "source": [
    "print(narray * 3)\n",
    "print(alist * 3)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Be aware of the difference because, within the same function,  both types of arrays can appear. \n",
    "Numpy arrays are designed for numerical and matrix operations, while lists are for more general purposes."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Matrix or Array of Arrays\n",
    "\n",
    "In linear algebra, a matrix is a structure composed of n rows by m columns. That means each row must have the same number of columns. With NumPy, we have two ways to create a matrix:\n",
    "* Creating an array of arrays using `np.array` (recommended). \n",
    "* Creating a matrix using `np.matrix` (still available but might be removed soon).\n",
    "\n",
    "NumPy arrays or lists can be used to initialize a matrix, but the resulting matrix will be composed of NumPy arrays only."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 6,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "[[1 2 3 4]\n",
      " [1 2 3 4]\n",
      " [1 2 3 4]]\n",
      "[[1 2 3 4 5]\n",
      " [1 2 3 4 5]\n",
      " [1 2 3 4 5]]\n",
      "[[1 2 3 4]\n",
      " [1 1 1 1]\n",
      " [1 2 3 4]]\n"
     ]
    }
   ],
   "source": [
    "npmatrix1 = np.array([narray, narray, narray]) # Matrix initialized with NumPy arrays\n",
    "npmatrix2 = np.array([alist, alist, alist]) # Matrix initialized with lists\n",
    "npmatrix3 = np.array([narray, [1, 1, 1, 1], narray]) # Matrix initialized with both types\n",
    "\n",
    "print(npmatrix1)\n",
    "print(npmatrix2)\n",
    "print(npmatrix3)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "However, when defining a matrix, be sure that all the rows contain the same number of elements. Otherwise, the linear algebra operations could lead to unexpected results.\n",
    "\n",
    "Analyze the following two examples:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 7,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "[[1 2]\n",
      " [3 4]]\n",
      "[[2 4]\n",
      " [6 8]]\n"
     ]
    }
   ],
   "source": [
    "# Example 1:\n",
    "\n",
    "okmatrix = np.array([[1, 2], [3, 4]]) # Define a 2x2 matrix\n",
    "print(okmatrix) # Print okmatrix\n",
    "print(okmatrix * 2) # Print a scaled version of okmatrix"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 8,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "[list([1, 2]) list([3, 4]) list([5, 6, 7])]\n",
      "[list([1, 2, 1, 2]) list([3, 4, 3, 4]) list([5, 6, 7, 5, 6, 7])]\n"
     ]
    }
   ],
   "source": [
    "# Example 2:\n",
    "\n",
    "badmatrix = np.array([[1, 2], [3, 4], [5, 6, 7]]) # Define a matrix. Note the third row contains 3 elements\n",
    "print(badmatrix) # Print the malformed matrix\n",
    "print(badmatrix * 2) # It is supposed to scale the whole matrix"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Scaling and translating matrices\n",
    "\n",
    "Now that you know how to build correct NumPy arrays and matrices, let us see how easy it is to operate with them in Python using the regular algebraic operators like + and -. \n",
    "\n",
    "Operations can be performed between arrays and arrays or between arrays and scalars."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 9,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "[[3 5]\n",
      " [7 9]]\n"
     ]
    }
   ],
   "source": [
    "# Scale by 2 and translate 1 unit the matrix\n",
    "result = okmatrix * 2 + 1 # For each element in the matrix, multiply by 2 and add 1\n",
    "print(result)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 10,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "[[2 4]\n",
      " [6 8]]\n",
      "[[0 0]\n",
      " [0 0]]\n"
     ]
    }
   ],
   "source": [
    "# Add two compatible matrices\n",
    "result1 = okmatrix + okmatrix\n",
    "print(result1)\n",
    "\n",
    "# Subtract two compatible matrices. This is called the difference vector\n",
    "result2 = okmatrix - okmatrix\n",
    "print(result2)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "The product operator `*` when used on arrays or matrices indicates element-wise multiplications.\n",
    "Do not confuse it with the dot product."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 11,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "[[ 1  4]\n",
      " [ 9 16]]\n"
     ]
    }
   ],
   "source": [
    "result = okmatrix * okmatrix # Multiply each element by itself\n",
    "print(result)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Transpose a matrix\n",
    "\n",
    "In linear algebra, the transpose of a matrix is an operator that flips a matrix over its diagonal, i.e., the transpose operator switches the row and column indices of the matrix producing another matrix. If the original matrix dimension is n by m, the resulting transposed matrix will be m by n.\n",
    "\n",
    "**T** denotes the transpose operations with NumPy matrices."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 12,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Original matrix 3 x 2\n",
      "[[1 2]\n",
      " [3 4]\n",
      " [5 6]]\n",
      "Transposed matrix 2 x 3\n",
      "[[1 3 5]\n",
      " [2 4 6]]\n"
     ]
    }
   ],
   "source": [
    "matrix3x2 = np.array([[1, 2], [3, 4], [5, 6]]) # Define a 3x2 matrix\n",
    "print('Original matrix 3 x 2')\n",
    "print(matrix3x2)\n",
    "print('Transposed matrix 2 x 3')\n",
    "print(matrix3x2.T)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "However, note that the transpose operation does not affect 1D arrays."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 13,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Original array\n",
      "[1 2 3 4]\n",
      "Transposed array\n",
      "[1 2 3 4]\n"
     ]
    }
   ],
   "source": [
    "nparray = np.array([1, 2, 3, 4]) # Define an array\n",
    "print('Original array')\n",
    "print(nparray)\n",
    "print('Transposed array')\n",
    "print(nparray.T)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "perhaps in this case you wanted to do:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 14,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Original array\n",
      "[[1 2 3 4]]\n",
      "Transposed array\n",
      "[[1]\n",
      " [2]\n",
      " [3]\n",
      " [4]]\n"
     ]
    }
   ],
   "source": [
    "nparray = np.array([[1, 2, 3, 4]]) # Define a 1 x 4 matrix. Note the 2 level of square brackets\n",
    "print('Original array')\n",
    "print(nparray)\n",
    "print('Transposed array')\n",
    "print(nparray.T)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Get the norm of a nparray or matrix\n",
    "\n",
    "In linear algebra, the norm of an n-dimensional vector $\\vec a$   is defined as:\n",
    "\n",
    "$$ norm(\\vec a) = ||\\vec a|| = \\sqrt {\\sum_{i=1}^{n} a_i ^ 2}$$\n",
    "\n",
    "Calculating the norm of vector or even of a matrix is a general operation when dealing with data. Numpy has a set of functions for linear algebra in the subpackage **linalg**, including the **norm** function. Let us see how to get the norm a given array or matrix:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 15,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "5.477225575051661\n",
      "5.477225575051661\n"
     ]
    }
   ],
   "source": [
    "nparray1 = np.array([1, 2, 3, 4]) # Define an array\n",
    "norm1 = np.linalg.norm(nparray1)\n",
    "\n",
    "nparray2 = np.array([[1, 2], [3, 4]]) # Define a 2 x 2 matrix. Note the 2 level of square brackets\n",
    "norm2 = np.linalg.norm(nparray2) \n",
    "\n",
    "print(norm1)\n",
    "print(norm2)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Note that without any other parameter, the norm function treats the matrix as being just an array of numbers.\n",
    "However, it is possible to get the norm by rows or by columns. The **axis** parameter controls the form of the operation: \n",
    "* **axis=0** means get the norm of each column\n",
    "* **axis=1** means get the norm of each row. "
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 16,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "[3.74165739 3.74165739]\n",
      "[1.41421356 2.82842712 4.24264069]\n"
     ]
    }
   ],
   "source": [
    "nparray2 = np.array([[1, 1], [2, 2], [3, 3]]) # Define a 3 x 2 matrix. \n",
    "\n",
    "normByCols = np.linalg.norm(nparray2, axis=0) # Get the norm for each column. Returns 2 elements\n",
    "normByRows = np.linalg.norm(nparray2, axis=1) # get the norm for each row. Returns 3 elements\n",
    "\n",
    "print(normByCols)\n",
    "print(normByRows)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "However, there are more ways to get the norm of a matrix in Python.\n",
    "For that, let us see all the different ways of defining the dot product between 2 arrays."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## The dot product between arrays: All the flavors\n",
    "\n",
    "The dot product or scalar product or inner product between two vectors $\\vec a$ and $\\vec b$ of the same size is defined as:\n",
    "$$\\vec a \\cdot \\vec b = \\sum_{i=1}^{n} a_i b_i$$\n",
    "\n",
    "The dot product takes two vectors and returns a single number."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 18,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "flavor1 38\n",
      "flavor2 38\n",
      "flavor3 38\n",
      "flavor4 38\n"
     ]
    }
   ],
   "source": [
    "nparray1 = np.array([0, 1, 2, 3]) # Define an array\n",
    "nparray2 = np.array([4, 5, 6, 7]) # Define an array\n",
    "\n",
    "flavor1 = np.dot(nparray1, nparray2) # Recommended way\n",
    "print('flavor1',flavor1)\n",
    "\n",
    "flavor2 = np.sum(nparray1 * nparray2) # Ok way\n",
    "print('flavor2',flavor2)\n",
    "\n",
    "flavor3 = nparray1 @ nparray2         # Geeks way\n",
    "print('flavor3',flavor3)\n",
    "\n",
    "# As you never should do:             # Noobs way\n",
    "flavor4 = 0\n",
    "for a, b in zip(nparray1, nparray2):\n",
    "    flavor4 += a * b\n",
    "    \n",
    "print('flavor4',flavor4)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "**We strongly recommend using np.dot, since it is the only method that accepts arrays and lists without problems**"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 21,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "11 = 11\n"
     ]
    }
   ],
   "source": [
    "norm1 = np.dot(np.array([1, 2]), np.array([3, 4])) # Dot product on nparrays\n",
    "norm2 = np.dot([1, 2], [3, 4]) # Dot product on python lists\n",
    "\n",
    "print(norm1, '=', norm2 )"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Finally, note that the norm is the square root of the dot product of the vector with itself. That gives many options to write that function:\n",
    "\n",
    "$$ norm(\\vec a) = ||\\vec a|| = \\sqrt {\\sum_{i=1}^{n} a_i ^ 2} = \\sqrt {a \\cdot a}$$\n"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Sums by rows or columns\n",
    "\n",
    "Another general operation performed on matrices is the sum by rows or columns.\n",
    "Just as we did for the function norm, the **axis** parameter controls the form of the operation:\n",
    "* **axis=0** means to sum the elements of each column together. \n",
    "* **axis=1** means to sum the elements of each row together."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 22,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Sum by columns: \n",
      "[ 6 -6]\n",
      "Sum by rows:\n",
      "[0 0 0]\n"
     ]
    }
   ],
   "source": [
    "nparray2 = np.array([[1, -1], [2, -2], [3, -3]]) # Define a 3 x 2 matrix. \n",
    "\n",
    "sumByCols = np.sum(nparray2, axis=0) # Get the sum for each column. Returns 2 elements\n",
    "sumByRows = np.sum(nparray2, axis=1) # get the sum for each row. Returns 3 elements\n",
    "\n",
    "print('Sum by columns: ')\n",
    "print(sumByCols)\n",
    "print('Sum by rows:')\n",
    "print(sumByRows)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Get the mean by rows or columns\n",
    "\n",
    "As with the sums, one can get the **mean** by rows or columns using the **axis** parameter. Just remember that the mean is the sum of the elements divided by the length of the vector\n",
    "$$ mean(\\vec a) = \\frac {{\\sum_{i=1}^{n} a_i }}{n}$$"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 23,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Matrix mean: \n",
      "0.0\n",
      "Mean by columns: \n",
      "[ 2. -2.]\n",
      "Mean by rows:\n",
      "[0. 0. 0.]\n"
     ]
    }
   ],
   "source": [
    "nparray2 = np.array([[1, -1], [2, -2], [3, -3]]) # Define a 3 x 2 matrix. Chosen to be a matrix with 0 mean\n",
    "\n",
    "mean = np.mean(nparray2) # Get the mean for the whole matrix\n",
    "meanByCols = np.mean(nparray2, axis=0) # Get the mean for each column. Returns 2 elements\n",
    "meanByRows = np.mean(nparray2, axis=1) # get the mean for each row. Returns 3 elements\n",
    "\n",
    "print('Matrix mean: ')\n",
    "print(mean)\n",
    "print('Mean by columns: ')\n",
    "print(meanByCols)\n",
    "print('Mean by rows:')\n",
    "print(meanByRows)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Center the columns of a matrix\n",
    "\n",
    "Centering the attributes of a data matrix is another essential preprocessing step. Centering a matrix means to remove the column mean to each element inside the column. The mean by columns of a centered matrix is always 0.\n",
    "\n",
    "With NumPy, this process is as simple as this:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 25,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Original matrix\n",
      "[[1 1]\n",
      " [2 2]\n",
      " [3 3]]\n",
      "Centered by columns matrix\n",
      "[[-1. -1.]\n",
      " [ 0.  0.]\n",
      " [ 1.  1.]]\n",
      "New mean by column\n",
      "[0. 0.]\n"
     ]
    }
   ],
   "source": [
    "nparray2 = np.array([[1, 1], [2, 2], [3, 3]]) # Define a 3 x 2 matrix. \n",
    "\n",
    "nparrayCentered = nparray2 - np.mean(nparray2, axis=0) # Remove the mean for each column\n",
    "\n",
    "print('Original matrix')\n",
    "print(nparray2)\n",
    "print('Centered by columns matrix')\n",
    "print(nparrayCentered)\n",
    "\n",
    "print('New mean by column')\n",
    "print(nparrayCentered.mean(axis=0))"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "**Warning:** This process does not apply for row centering. In such cases, consider transposing the matrix, centering by columns, and then transpose back the result. \n",
    "\n",
    "See the example below:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 26,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Original matrix\n",
      "[[1 3]\n",
      " [2 4]\n",
      " [3 5]]\n",
      "Centered by rows matrix\n",
      "[[-1.  1.]\n",
      " [-1.  1.]\n",
      " [-1.  1.]]\n",
      "New mean by rows\n",
      "[0. 0. 0.]\n"
     ]
    }
   ],
   "source": [
    "nparray2 = np.array([[1, 3], [2, 4], [3, 5]]) # Define a 3 x 2 matrix. \n",
    "\n",
    "nparrayCentered = nparray2.T - np.mean(nparray2, axis=1) # Remove the mean for each row\n",
    "nparrayCentered = nparrayCentered.T # Transpose back the result\n",
    "\n",
    "print('Original matrix')\n",
    "print(nparray2)\n",
    "print('Centered by rows matrix')\n",
    "print(nparrayCentered)\n",
    "\n",
    "print('New mean by rows')\n",
    "print(nparrayCentered.mean(axis=1))"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 27,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "array([[1, 2, 3],\n",
       "       [3, 4, 5]])"
      ]
     },
     "execution_count": 27,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "nparray2.T"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 28,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "array([2., 3., 4.])"
      ]
     },
     "execution_count": 28,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "np.mean(nparray2, axis=1)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Note that some operations can be performed using static functions like `np.sum()` or `np.mean()`, or by using the inner functions of the array"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 30,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "3.0  ==  3.0\n"
     ]
    }
   ],
   "source": [
    "nparray2 = np.array([[1, 3], [2, 4], [3, 5]]) # Define a 3 x 2 matrix. \n",
    "\n",
    "mean1 = np.mean(nparray2) # Static way\n",
    "mean2 = nparray2.mean()   # Dynamic way\n",
    "\n",
    "print(mean1, ' == ', mean2)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Even if they are equivalent, we recommend the use of the static way always.\n",
    "\n",
    "**Congratulations! You have successfully reviewed vector and matrix operations with Numpy!**"
   ]
  }
 ],
 "metadata": {
  "kernelspec": {
   "display_name": "Python 3",
   "language": "python",
   "name": "python3"
  },
  "language_info": {
   "codemirror_mode": {
    "name": "ipython",
    "version": 3
   },
   "file_extension": ".py",
   "mimetype": "text/x-python",
   "name": "python",
   "nbconvert_exporter": "python",
   "pygments_lexer": "ipython3",
   "version": "3.7.6"
  }
 },
 "nbformat": 4,
 "nbformat_minor": 4
}