PY0101EN-5-1-Numpy1D.ipynb

{
 "cells": [
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "<p style=\"text-align:center\">\n",
    "    <a href=\"https://skills.network/?utm_medium=Exinfluencer&utm_source=Exinfluencer&utm_content=000026UJ&utm_term=10006555&utm_id=NA-SkillsNetwork-Channel-SkillsNetworkCoursesIBMDeveloperSkillsNetworkPY0101ENSkillsNetwork19487395-2022-01-01\" target=\"_blank\">\n",
    "    <img src=\"https://cf-courses-data.s3.us.cloud-object-storage.appdomain.cloud/assets/logos/SN_web_lightmode.png\" width=\"200\" alt=\"Skills Network Logo\"  />\n",
    "    </a>\n",
    "</p>\n",
    "\n",
    "# 1D Numpy in Python\n",
    "\n",
    "Estimated time needed: **30** minutes\n",
    "\n",
    "## Objectives\n",
    "\n",
    "After completing this lab you will be able to:\n",
    "\n",
    "*   Import and use the `numpy` library\n",
    "*   Perform operations with `numpy`\n"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "<h2>Table of Contents</h2>\n",
    "<div class=\"alert alert-block alert-info\" style=\"margin-thttps://https://op/?utm_medium=Exinfluencer&utm_source=Exinfluencer&utm_content=000026UJ&utm_term=10006555&utm_id=NA-SkillsNetwork-Channel-SkillsNetworkCoursesIBMDeveloperSkillsNetworkPY0101ENSkillsNetwork19487395-2022-01-01/?utm_medium=Exinfluencer&utm_source=Exinfluencer&utm_content=000026UJ&utm_term=10006555&utm_id=NA-SkillsNetwork-Channel-SkillsNetworkCoursesIBMDeveloperSkillsNetworkPY0101ENSkillsNetwork19487395-2021-01-01: 20px\">\n",
    "    <ul>\n",
    "        <li><a href=\"https://pre/?utm_medium=Exinfluencer&utm_source=Exinfluencer&utm_content=000026UJ&utm_term=10006555&utm_id=NA-SkillsNetwork-Channel-SkillsNetworkCoursesIBMDeveloperSkillsNetworkPY0101ENSkillsNetwork19487395-2021-01-01\">List in Python</a></li>\n",
    "        <li>\n",
    "            <a href=\"https://numpy/?utm_medium=Exinfluencer&utm_source=Exinfluencer&utm_content=000026UJ&utm_term=10006555&utm_id=NA-SkillsNetwork-Channel-SkillsNetworkCoursesIBMDeveloperSkillsNetworkPY0101ENSkillsNetwork19487395-2021-01-01\">What is Numpy?</a>\n",
    "            <ul>\n",
    "                <li><a href=\"https://type/?utm_medium=Exinfluencer&utm_source=Exinfluencer&utm_content=000026UJ&utm_term=10006555&utm_id=NA-SkillsNetwork-Channel-SkillsNetworkCoursesIBMDeveloperSkillsNetworkPY0101ENSkillsNetwork19487395-2021-01-01\">Type</a></li>\n",
    "                <li><a href=\"https://val/?utm_medium=Exinfluencer&utm_source=Exinfluencer&utm_content=000026UJ&utm_term=10006555&utm_id=NA-SkillsNetwork-Channel-SkillsNetworkCoursesIBMDeveloperSkillsNetworkPY0101ENSkillsNetwork19487395-2021-01-01\">Assign Value</a></li>\n",
    "                <li><a href=\"https://slice/?utm_medium=Exinfluencer&utm_source=Exinfluencer&utm_content=000026UJ&utm_term=10006555&utm_id=NA-SkillsNetwork-Channel-SkillsNetworkCoursesIBMDeveloperSkillsNetworkPY0101ENSkillsNetwork19487395-2021-01-01\">Slicing</a></li>\n",
    "                <li><a href=\"https://list/?utm_medium=Exinfluencer&utm_source=Exinfluencer&utm_content=000026UJ&utm_term=10006555&utm_id=NA-SkillsNetwork-Channel-SkillsNetworkCoursesIBMDeveloperSkillsNetworkPY0101ENSkillsNetwork19487395-2021-01-01\">Assign Value with List</a></li>\n",
    "                <li><a href=\"https://other/?utm_medium=Exinfluencer&utm_source=Exinfluencer&utm_content=000026UJ&utm_term=10006555&utm_id=NA-SkillsNetwork-Channel-SkillsNetworkCoursesIBMDeveloperSkillsNetworkPY0101ENSkillsNetwork19487395-2021-01-01\">Other Attributes</a></li>\n",
    "            </ul>\n",
    "        </li>\n",
    "        <li>\n",
    "            <a href=\"op\">Numpy Array Operations</a>\n",
    "            <ul>\n",
    "                <li><a href=\"https://add/?utm_medium=Exinfluencer&utm_source=Exinfluencer&utm_content=000026UJ&utm_term=10006555&utm_id=NA-SkillsNetwork-Channel-SkillsNetworkCoursesIBMDeveloperSkillsNetworkPY0101ENSkillsNetwork19487395-2021-01-01\">Array Addition</a></li>\n",
    "                <li><a href=\"https://multi/?utm_medium=Exinfluencer&utm_source=Exinfluencer&utm_content=000026UJ&utm_term=10006555&utm_id=NA-SkillsNetwork-Channel-SkillsNetworkCoursesIBMDeveloperSkillsNetworkPY0101ENSkillsNetwork19487395-2021-01-01\">Array Multiplication</a></li>\n",
    "                <li><a href=\"https://prod/?utm_medium=Exinfluencer&utm_source=Exinfluencer&utm_content=000026UJ&utm_term=10006555&utm_id=NA-SkillsNetwork-Channel-SkillsNetworkCoursesIBMDeveloperSkillsNetworkPY0101ENSkillsNetwork19487395-2021-01-01\">Product of Two Numpy Arrays</a></li>\n",
    "                <li><a href=\"https://dot/?utm_medium=Exinfluencer&utm_source=Exinfluencer&utm_content=000026UJ&utm_term=10006555&utm_id=NA-SkillsNetwork-Channel-SkillsNetworkCoursesIBMDeveloperSkillsNetworkPY0101ENSkillsNetwork19487395-2021-01-01\">Dot Product</a></li>\n",
    "                <li><a href=\"https://cons/?utm_medium=Exinfluencer&utm_source=Exinfluencer&utm_content=000026UJ&utm_term=10006555&utm_id=NA-SkillsNetwork-Channel-SkillsNetworkCoursesIBMDeveloperSkillsNetworkPY0101ENSkillsNetwork19487395-2021-01-01\">Adding Constant to a Numpy Array</a></li>\n",
    "            </ul>\n",
    "        </li>\n",
    "        <li><a href=\"https://math/?utm_medium=Exinfluencer&utm_source=Exinfluencer&utm_content=000026UJ&utm_term=10006555&utm_id=NA-SkillsNetwork-Channel-SkillsNetworkCoursesIBMDeveloperSkillsNetworkPY0101ENSkillsNetwork19487395-2021-01-01\">Mathematical Functions</a></li>\n",
    "        <li><a href=\"https://lin/?utm_medium=Exinfluencer&utm_source=Exinfluencer&utm_content=000026UJ&utm_term=10006555&utm_id=NA-SkillsNetwork-Channel-SkillsNetworkCoursesIBMDeveloperSkillsNetworkPY0101ENSkillsNetwork19487395-2021-01-01\">Linspace</a></li>\n",
    "    </ul>\n",
    "\n",
    "</div>\n",
    "\n",
    "<hr>\n"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Create a Python List as follows:\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 1,
   "metadata": {},
   "outputs": [],
   "source": [
    "# Create a python list\n",
    "\n",
    "a = [\"0\", 1, \"two\", \"3\", 4]"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "We can access the data via an index:\n"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "<img src=\"https://cf-courses-data.s3.us.cloud-object-storage.appdomain.cloud/IBMDeveloperSkillsNetwork-PY0101EN-SkillsNetwork/labs/Module%205/images/NumOneList.png\" width=\"660\" />\n"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "We can access each element using a square bracket as follows:\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 2,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "a[0]: 0\n",
      "a[1]: 1\n",
      "a[2]: two\n",
      "a[3]: 3\n",
      "a[4]: 4\n"
     ]
    }
   ],
   "source": [
    "# Print each element\n",
    "\n",
    "print(\"a[0]:\", a[0])\n",
    "print(\"a[1]:\", a[1])\n",
    "print(\"a[2]:\", a[2])\n",
    "print(\"a[3]:\", a[3])\n",
    "print(\"a[4]:\", a[4])"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "<hr>\n"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "<h2 id=\"numpy\">What is Numpy?</h2>\n"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "NumPy is a Python library used for working with arrays, linear algebra, fourier transform, and matrices.A numpy array is similar to a list. NumPy stands for Numerical Python and it is an open source project.The array object in NumPy is called **ndarray**, it provides a lot of supporting functions that make working with ndarray very easy.\n",
    "\n",
    "Arrays are very frequently used in data science, where speed and resources are very important.\n",
    "\n",
    "NumPy is usually imported under the np alias.\n",
    "\n",
    "It's usually fixed in size and each element is of the same type. We can cast a list to a numpy array by first importing `numpy`:\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 3,
   "metadata": {},
   "outputs": [],
   "source": [
    "# import numpy library\n",
    "\n",
    "import numpy as np "
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "We then cast the list as follows:\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 4,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "array([0, 1, 2, 3, 4])"
      ]
     },
     "execution_count": 4,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "# Create a numpy array\n",
    "\n",
    "a = np.array([0, 1, 2, 3, 4])\n",
    "a"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Each element is of the same type, in this case integers:\n"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "<img src=\"https://cf-courses-data.s3.us.cloud-object-storage.appdomain.cloud/IBMDeveloperSkillsNetwork-PY0101EN-SkillsNetwork/labs/Module%205/images/NumOneNp.png\" width=\"500\" />\n"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "As with lists, we can access each element via a square bracket:\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 5,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "a[0]: 0\n",
      "a[1]: 1\n",
      "a[2]: 2\n",
      "a[3]: 3\n",
      "a[4]: 4\n"
     ]
    }
   ],
   "source": [
    "# Print each element\n",
    "\n",
    "print(\"a[0]:\", a[0])\n",
    "print(\"a[1]:\", a[1])\n",
    "print(\"a[2]:\", a[2])\n",
    "print(\"a[3]:\", a[3])\n",
    "print(\"a[4]:\", a[4])"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Checking NumPy Version\n",
    "\n",
    "The version string is stored under **version** attribute.\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 6,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "1.20.3\n"
     ]
    }
   ],
   "source": [
    "print(np.__version__)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "<h3 id=\"type\">Type</h3>\n"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "If we check the type of the array we get <b>numpy.ndarray</b>:\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 7,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "numpy.ndarray"
      ]
     },
     "execution_count": 7,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "# Check the type of the array\n",
    "\n",
    "type(a)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "As numpy arrays contain data of the same type, we can use the attribute \"dtype\" to obtain the data type of the array’s elements. In this case, it's a 64-bit integer:\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 8,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "dtype('int32')"
      ]
     },
     "execution_count": 8,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "# Check the type of the values stored in numpy array\n",
    "\n",
    "a.dtype"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Try it yourself\n",
    "\n",
    "Check the type of the array and Value type for the given array **c**\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 9,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "dtype('float64')"
      ]
     },
     "execution_count": 9,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "b = np.array([3.1, 11.02, 6.2, 213.2, 5.2])\n",
    "\n",
    "# Enter your code here\n",
    "type(b)\n",
    "b.dtype\n"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "<details><summary>Click here for the solution</summary>\n",
    "\n",
    "```python\n",
    "type(b)\n",
    "    \n",
    "b.dtype \n",
    "    \n",
    "If we examine the attribute dtype we see float 64, as the elements are not integers:\n",
    "```\n",
    "\n",
    "</details>\n"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "<h3 id=\"val\">Assign value</h3>\n"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "We can change the value of the array. Consider the array <code>c</code>:\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 10,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "array([20,  1,  2,  3,  4])"
      ]
     },
     "execution_count": 10,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "# Create numpy array\n",
    "\n",
    "c = np.array([20, 1, 2, 3, 4])\n",
    "c"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "We can change the first element of the array to 100 as follows:\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 12,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "array([100,   1,   2,   3,   4])"
      ]
     },
     "execution_count": 12,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "# Assign the first element to 100\n",
    "\n",
    "c[0] = 100\n",
    "c"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "We can change the 5th element of the array to 0 as follows:\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 13,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "array([100,   1,   2,   3,   0])"
      ]
     },
     "execution_count": 13,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "# Assign the 5th element to 0\n",
    "\n",
    "c[4] = 0\n",
    "c"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Try it yourself\n",
    "\n",
    "Assign the value 20 for the second element in the given array.\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 14,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "array([100,  20,   2,   3,   0])"
      ]
     },
     "execution_count": 14,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "a = np.array([10, 2, 30, 40,50])\n",
    "\n",
    "# Enter your code here\n",
    "c[1]=20\n",
    "c\n"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "<details><summary>Click here for the solution</summary>\n",
    "\n",
    "```python\n",
    "a[1]=20\n",
    "a\n",
    "   \n",
    "```\n",
    "\n",
    "</details>\n"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "<h3 id=\"slice\">Slicing</h3>\n"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Like lists, we can slice the numpy array. Slicing in python means taking the elements from the given index to another given index.\n",
    "\n",
    "We pass slice like this: \\[start:end].The element at end index is not being included in the output.\n",
    "\n",
    "We can select the elements from 1 to 3 and assign it to a new numpy array <code>d</code> as follows:\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 15,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "array([20,  2,  3])"
      ]
     },
     "execution_count": 15,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "# Slicing the numpy array\n",
    "\n",
    "d = c[1:4]\n",
    "d"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "We can assign the corresponding indexes to new values as follows:\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 16,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "array([100,  20,   2, 300, 400])"
      ]
     },
     "execution_count": 16,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "# Set the fourth element and fifth element to 300 and 400\n",
    "\n",
    "c[3:5] = 300, 400\n",
    "c"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "We can also define the steps in slicing, like this: \\[start\\:end:step].\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 17,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "[2 4]\n"
     ]
    }
   ],
   "source": [
    "arr = np.array([1, 2, 3, 4, 5, 6, 7])\n",
    "\n",
    "print(arr[1:5:2])"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "If we don't pass start its considered 0\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 18,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "[1 2 3 4]\n"
     ]
    }
   ],
   "source": [
    "print(arr[:4])"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "If we don't pass end it considers till the length of array.\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 19,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "[5 6 7]\n"
     ]
    }
   ],
   "source": [
    "print(arr[4:])"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "If we don't pass step its considered 1\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 20,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "[2 3 4 5]\n"
     ]
    }
   ],
   "source": [
    "print(arr[1:5:])"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Try it yourself\n",
    "\n",
    "Print the even elements in the given array.\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 22,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "[2 4 6 8]\n"
     ]
    }
   ],
   "source": [
    "arr = np.array([1, 2, 3, 4, 5, 6, 7, 8])\n",
    "\n",
    "# Enter your code here\n",
    "print(arr[1:8:2])"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "<details><summary>Click here for the solution</summary>\n",
    "\n",
    "```python\n",
    "print(arr[1:8:2])\n",
    "\n",
    "    \n",
    "```\n",
    "\n",
    "</details>\n"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "<h3 id=\"list\">Assign Value with List</h3>\n"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Similarly, we can use a list to select more than one specific index.\n",
    "The list `select` contains several values:\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 23,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "[0, 2, 3, 4]"
      ]
     },
     "execution_count": 23,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "# Create the index list\n",
    "\n",
    "select = [0, 2, 3, 4]\n",
    "select"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "We can use the list as an argument in the brackets. The output is the elements corresponding to the particular indexes:\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 24,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "array([100,   2, 300, 400])"
      ]
     },
     "execution_count": 24,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "# Use List to select elements\n",
    "\n",
    "d = c[select]\n",
    "d"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "We can assign the specified elements to a new value. For example, we can assign the values to 100 000 as follows:\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 25,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "array([100000,     20, 100000, 100000, 100000])"
      ]
     },
     "execution_count": 25,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "# Assign the specified elements to new value\n",
    "\n",
    "c[select] = 100000\n",
    "c"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "<h3 id=\"other\">Other Attributes</h3>\n"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Let's review some basic array attributes using the array <code>a</code>:\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 26,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "array([0, 1, 2, 3, 4])"
      ]
     },
     "execution_count": 26,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "# Create a numpy array\n",
    "\n",
    "a = np.array([0, 1, 2, 3, 4])\n",
    "a"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "The attribute <code>size</code> is the number of elements in the array:\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 27,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "5"
      ]
     },
     "execution_count": 27,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "# Get the size of numpy array\n",
    "\n",
    "a.size"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "The next two attributes will make more sense when we get to higher dimensions but let's review them. The attribute <code>ndim</code> represents the number of array dimensions, or the rank of the array. In this case, one:\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 28,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "1"
      ]
     },
     "execution_count": 28,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "# Get the number of dimensions of numpy array\n",
    "\n",
    "a.ndim"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "The attribute <code>shape</code> is a tuple of integers indicating the size of the array in each dimension:\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 29,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "(5,)"
      ]
     },
     "execution_count": 29,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "# Get the shape/size of numpy array\n",
    "\n",
    "a.shape"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Try it yourself\n",
    "\n",
    "Find the size ,dimension and shape for the given array **b**\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 30,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "(7,)"
      ]
     },
     "execution_count": 30,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "b = np.array([10, 20, 30, 40, 50, 60, 70])\n",
    "b.size\n",
    "b.ndim\n",
    "b.shape\n",
    "\n",
    "# Enter your code here"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "<details><summary>Click here for the solution</summary>\n",
    "\n",
    "```python\n",
    "b.size\n",
    "\n",
    "b.ndim\n",
    "\n",
    "b.shape\n",
    "\n",
    "    \n",
    "```\n",
    "\n",
    "</details>\n"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Numpy Statistical Functions\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 31,
   "metadata": {},
   "outputs": [],
   "source": [
    "# Create a numpy array\n",
    "\n",
    "a = np.array([1, -1, 1, -1])"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 33,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "0.0"
      ]
     },
     "execution_count": 33,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "# Get the mean of numpy array\n",
    "\n",
    "mean = a.mean()\n",
    "mean"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 34,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "1.0"
      ]
     },
     "execution_count": 34,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "# Get the standard deviation of numpy array\n",
    "\n",
    "standard_deviation=a.std()\n",
    "standard_deviation"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 35,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "array([-1,  2,  3,  4,  5])"
      ]
     },
     "execution_count": 35,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "# Create a numpy array\n",
    "\n",
    "b = np.array([-1, 2, 3, 4, 5])\n",
    "b"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 36,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "5"
      ]
     },
     "execution_count": 36,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "# Get the biggest value in the numpy array\n",
    "\n",
    "max_b = b.max()\n",
    "max_b"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 37,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "-1"
      ]
     },
     "execution_count": 37,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "# Get the smallest value in the numpy array\n",
    "\n",
    "min_b = b.min()\n",
    "min_b"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Try it yourself\n",
    "\n",
    "Find the sum of maximum and minimum value in the given numpy array\n"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "<hr>\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 41,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "492"
      ]
     },
     "execution_count": 41,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "c = np.array([-10, 201, 43, 94, 502])\n",
    "max_c=c.max()\n",
    "max_c\n",
    "\n",
    "min_c=c.min()\n",
    "min_c\n",
    "\n",
    "sum = (max_c + min_c)\n",
    "sum\n",
    "# Enter your code here\n"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "<details><summary>Click here for the solution</summary>\n",
    "\n",
    "```python\n",
    "max_c = c.max()\n",
    "max_c\n",
    "    \n",
    "min_c = c.min()\n",
    "min_c\n",
    "    \n",
    "    \n",
    "Sum = (max_c +min_c)\n",
    "Sum\n",
    "\n",
    "    \n",
    "```\n",
    "\n",
    "</details>\n"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "<h2 id=\"op\">Numpy Array Operations</h2>\n",
    "\n",
    "You could use arithmetic operators directly between NumPy arrays\n"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "<h3 id=\"add\">Array Addition</h3>\n"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Consider the numpy array <code>u</code>:\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 42,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "array([1, 0])"
      ]
     },
     "execution_count": 42,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "u = np.array([1, 0])\n",
    "u"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Consider the numpy array <code>v</code>:\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 43,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "array([0, 1])"
      ]
     },
     "execution_count": 43,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "v = np.array([0, 1])\n",
    "v"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "We can add the two arrays and assign it to z:\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 44,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "array([1, 1])"
      ]
     },
     "execution_count": 44,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "# Numpy Array Addition\n",
    "\n",
    "z = np.add(u, v)\n",
    "z"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "The operation is equivalent to vector addition:\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 45,
   "metadata": {},
   "outputs": [],
   "source": [
    "# Plotting functions\n",
    "\n",
    "\n",
    "import time \n",
    "import sys\n",
    "import numpy as np \n",
    "\n",
    "import matplotlib.pyplot as plt\n",
    "%matplotlib inline  \n",
    "\n",
    "def Plotvec1(u, z, v):\n",
    "    \n",
    "    ax = plt.axes() # to generate the full window axes\n",
    "    ax.arrow(0, 0, *u, head_width=0.05, color='r', head_length=0.1)# Add an arrow to the  U Axes with arrow head width 0.05, color red and arrow head length 0.1\n",
    "    plt.text(*(u + 0.1), 'u')#Adds the text u to the Axes \n",
    "    \n",
    "    ax.arrow(0, 0, *v, head_width=0.05, color='b', head_length=0.1)# Add an arrow to the  v Axes with arrow head width 0.05, color red and arrow head length 0.1\n",
    "    plt.text(*(v + 0.1), 'v')#Adds the text v to the Axes \n",
    "    \n",
    "    ax.arrow(0, 0, *z, head_width=0.05, head_length=0.1)\n",
    "    plt.text(*(z + 0.1), 'z')#Adds the text z to the Axes \n",
    "    plt.ylim(-2, 2)#set the ylim to bottom(-2), top(2)\n",
    "    plt.xlim(-2, 2)#set the xlim to left(-2), right(2)\n",
    "\n",
    "  \n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 46,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "image/png": "iVBORw0KGgoAAAANSUhEUgAAAYQAAAD8CAYAAAB3u9PLAAAAOXRFWHRTb2Z0d2FyZQBNYXRwbG90bGliIHZlcnNpb24zLjQuMywgaHR0cHM6Ly9tYXRwbG90bGliLm9yZy/MnkTPAAAACXBIWXMAAAsTAAALEwEAmpwYAAAYDklEQVR4nO3deZBdZbnv8e/TGRhCkCEJZCAQi3gheD0RW4ajUkTRCzlq9BRo1FLLKUI5FrcsuHIuUrcKC714LClEjCKDVyYZIySMCgHLYDqRQEgQGkxM6EBCQkI4Ycjw3D96mdMn7E53Z6/utbv7+6na1Wvt9e71PvXS9C/vmnZkJpIkNVVdgCSpMRgIkiTAQJAkFQwESRJgIEiSCgaCJAkoIRAi4rCI+ENELI+IJyLiWzXaRERcEhGtEfFYRBxbb7+SpHINLWEf24D/mZmLI2IksCgi7s3MZR3anAZMLl7HAz8rfkqSGkTdM4TMXJOZi4vlzcByYPwuzWYA12S7BcABETG23r4lSeUpY4awU0QcAbwTeGSXTeOBVR3WVxfvramxj1nALIARI0a866ijjiqzREka0BYtWvRiZo7ek8+WFggRsR9wM/DtzHx51801PlLzmRmZORuYDdDc3JwtLS1llShJA15ErNzTz5ZylVFEDKM9DH6TmbfUaLIaOKzD+gSgrYy+JUnlKOMqowCuAJZn5r930mwO8LniaqMTgE2Z+abDRZKk6pRxyOg9wGeBxyPi0eK97wITATLzcmAuMB1oBbYAXyihX0lSieoOhMx8mNrnCDq2SeBr9fYlSeo93qksSQIMBElSwUCQJAEGgiSpYCBIkgADQZJUMBAkSYCBIEkqGAiSJMBAkCQVDARJEmAgSJIKBoIkCTAQJEkFA0GSBBgIkqSCgSBJAgwESVKhlECIiF9FxNqIWNrJ9pMjYlNEPFq8zi+jX0lSeer+TuXCVcClwDW7afNQZn64pP4kSSUrZYaQmfOBDWXsS5JUjb48h3BiRCyJiHkRcUwf9itJ6oayDhl1ZTFweGa+EhHTgduAybUaRsQsYBbAxIkT+6g8SVKfzBAy8+XMfKVYngsMi4hRnbSdnZnNmdk8evTovihPkkQfBUJEHBoRUSwfV/S7vi/6liR1TymHjCLiOuBkYFRErAa+BwwDyMzLgdOBsyJiG/AqMDMzs4y+JUnlKCUQMvNTXWy/lPbLUiVJDco7lSVJgIEgSSoYCJIkwECQJBUMBEkSYCBIkgoGgiQJMBAkSQUDQZIEGAiSpIKBIEkCDASp15xzzjlcdtllO9cvuOACfvSjH1VYUf91+eWXM3XqVKZOncqkSZOYNm1a1SUNSAaC1EtmzpzJDTfcsHP9xhtv5Iwzzqiwov7rzDPP5NFHH2XhwoVMmDCBs88+u+qSBqS++sY0adB55zvfydq1a2lra2PdunUceOCBfgtgnb71rW/x/ve/n4985CNVlzIgGQhSLzr99NO56aabeP7555k5c2bV5fRrV111FStXruTSS32Sfm8xEKReNHPmTL7yla/w4osv8uCDD1ZdTr+1aNEiLr74Yh566CGamjzS3VscWamHPvMZOOus7rU95phj2Lx5M+PHj2fs2LG9W9gAdumll7JhwwamTZvG1KlT+fKXv1x1SQNSNPI3WTY3N2dLS0vVZUg7vfQSjB0LTU3w4ouw775VVzTwZCYPP/wwz7W1MfOTn6y6nH4nIhZlZvOefNYZgtQDv/kNDBnS/rrppqqrGVheeOEFLvrBDznsrZM56aSTuPaG31Zd0qBTSiBExK8iYm1ELO1ke0TEJRHRGhGPRcSxZfQr9bWf/AS2bIFXXmlfVn22b9/O3Llz+R//8lGOOPJtXHzD/Wx4PTj+PSdx47X/r+ryBp2yZghXAafuZvtpwOTiNQv4WUn9Sn3mL3+Btrb/XF+2DFpbq6unv9u6dStjJ0zk07O+Scv2wxn95V/CiIM4YtR+3DP3d+y9995VlzjolBIImTkf2LCbJjOAa7LdAuCAiPAMm/qVu+6CrVv/c337drjnnurq6e8igrGHjGHTc8/QNHwfXl16D/s+t5AH77+H/fffv+ryBqW+uux0PLCqw/rq4r01uzaMiFm0zyK8iUcN5ZvfhGnT4MQT29fnz4epUystqd969dVXGTduHBs3bmTMmDHsu3wOr2zezMN//hOjR4+uurxBq69OKkeN92pe3pSZszOzOTOb/cVQIxkxAk44oX15v/3alz2q0XNXXXUV++67Lxs3buT3v/89L7zwAk8te5xVK57xH4EV66sZwmrgsA7rE4C2TtpKGoA2btzIgQceCMD73ncSDzzwh503mQ0bNoxhw4ZVWZ7ouxnCHOBzxdVGJwCbMvNNh4skDUw//OEPd4bB4sWLmT//Qe84bkClzBAi4jrgZGBURKwGvgcMA8jMy4G5wHSgFdgCfKGMfiU1tjVr1jBu3DgAPvnJmVx33bVE1DqCrEZQSiBk5qe62J7A18roS1L/cPbZZ/PjH/8YgKeffpojjzyy4orUFR9uJ6lUra2tTJ48GYBvf/vbO0NBjc9AkFSKzOTTn/4M119/HQBtbW0+0K+f8ayOpLr95S9/oampieuvv46LLrqIzDQM+iFnCJL22I4dO5g27f3Mn9/+XQ8vvfQSBxxwQLVFaY85Q5C0Rx544AGGDBnC/PkPcsUVV5CZhkE/5wxBUo9s3bqVKVOm0Nraylve8hbWrFnDPvvsU3VZKoEzBEnddssttzB8+HBaW1u5/fbb2bhxo2EwgDhDkNSlLVu2MHr0aLZs2cJRRx/N4489xtCh/vkYaJwhSNqtX/ziF4wYMYItW7bw4IMPsnzZMsNggPK/qqSaNmzYwMEHHwzABz5wCvfcc7fPHxrg/K8r6U0uvPDCnWGwZMkS7rvvXsNgEHCGIGmn5557jgkTJgDw2c9+jquvvsqH0Q0iRr4kAL7xjW/sDINnnnmGa6652jAYZAwEaZB76qmniAguvfRSvvOd75CZvPWtb626LFXAQ0bSIJWZnHHGJ7j55psAeP755znkkEMqrkpVcoYgDUItLS00NTVx8803cfHFF5OZhoGcIUiDyfbt23nve9/HggV/AmDTpk3sv//+FVelRuEMQRok7rvvPoYOHcqCBX/immuuITMNA/0XZX2n8qnAT4AhwC8z86Jdtp8M3A78rXjrlsz8P2X0LWn33njjDd72trexcuVKRo0axapVq9h7772rLksNqO4ZQkQMAX4KnAZMAT4VEVNqNH0oM6cWL8NA6gO//e1v2WuvvVi5ciV33HEH69atMwzUqTJmCMcBrZn5LEBEXA/MAJaVsG9Je+CVV17hoIMOYuvWrfz3d7yDxYsW+fwhdamMcwjjgVUd1lcX7+3qxIhYEhHzIuKYznYWEbMioiUiWtatW1dCedLgctlllzFy5Ei2bt3Kww8/zGNLlhgG6pYyfktq3cqYu6wvBg7PzFciYjpwGzC51s4yczYwG6C5uXnX/UjqxPr16xk1ahQAp556GnPn3umdxuqRMmYIq4HDOqxPANo6NsjMlzPzlWJ5LjAsIkaV0Lck4IILLtgZBo8//jjz5s01DNRjZcwQFgKTI2IS8BwwE/h0xwYRcSjwQmZmRBxHexCtL6FvaVBbtWoVEydOBOCLX/wiv/zlLw0C7bG6AyEzt0XE14G7ab/s9FeZ+UREnFlsvxw4HTgrIrYBrwIzM9PDQdIeykzOOussfv7znwPwt7/9jSOOOKLaotTvRSP/XW5ubs6Wlpaqy5D+iwjYbz/YvLma/pcvX86UKe1Xdn/3u9/lwgsvrKYQNaSIWJSZzXvyWS89kPqJzGTGjI/xu9/NAWDt2rWMHj264qo0kPjoCqkfeOSRR2hqauJ3v5vDJZdcQmYaBiqdMwSpgW3fvp3jTziBRcWh05dffpmRI0dWXJUGKmcIUoO6++67GTp0KItaWrj22mvJTMNAvcoZgtRgXn/9dSZNmsSaNWsYN24czz77LHvttVfVZWkQcIYgNZBrr72WvffemzVr1jBv3jyee+45w0B9xhmC1AA2b96887sJmpvfzYIFf2LIkCEVV6XBxhmCVLFLLrlkZxgsWLCAhQv/bBioEs4QpIqsW7eOMWPGAPDRj87gtttu9bETqpQzBKkC55133s4wWLZsGbfffpthoMoZCFIfWrlyJRHB97//fb761a+yY8cOjj766KrL6hdWrFjB29/+9p3rF198MRdccEF1BQ1AHjKS+kBm8qUvfYkrr7wSgL///e8cdthhXXxK6lvOEKRetnTpUpqamrjyyis5//zzyUzDQA3JGYLUSzKT6dP/hbvumgfAiy++yMEHH1xxVf3X0KFD2bFjx8711157rcJqBiZnCFIv+OMf/0hTUxN33TWPyy67jMw0DOp0yCGHsHbtWtavX8/rr7/OHXfcUXVJA44zBKlE27Zt49h3vYvHH3uMYcOGsWHDBvbbb7+qyxoQhg0bxvnnn8/xxx/PpEmTOOqoo6ouacDxC3KkHursC3LuvPNOPvzhDwNwww038IlPfKKC6jTY+QU5UoVee+01JkyYwPr16zn88MN56qmnGD58eNVlST1WyjmEiDg1Iv4aEa0RcW6N7RERlxTbH4uIY8voV6rar3/9a/bZZx/Wr1/Pvffey4oVKwwD9Vt1zxAiYgjwU+CDwGpgYUTMycxlHZqdBkwuXscDPyt+Sv1S5iYiDgDgxBP/mYcemu/zh/bUOefA0qXw7nfDMcfAlCkweTIYrH2ujENGxwGtmfksQERcD8wAOgbCDOCabD9hsSAiDoiIsZm5poT+pT41dOgS/uM/pgKw8PDDaX5pA3S4g1Y99OST7T/vugtGjGhffvVVGDMGjj4a3vUuOO88KB4AqN5TRiCMB1Z1WF/Nm//1X6vNeOBNgRARs4BZABMnTiyhPKlcV31vJff/79FcwTpi5cqqyxk4duyALVvaQ2H4cHj++fYz+E1N8MYbVVc3KJQRCLWeyLXrpUvdadP+ZuZsYDa0X2VUX2lS+T7zbx/lM/+2tuoyBo7TT4fFi9sPF3U8bHTkkTBsWNXVDSplBMJqoON9+BOAtj1oI2kwuummqitQoYyrjBYCkyNiUkQMB2YCc3ZpMwf4XHG10QnAJs8fSFJjqXuGkJnbIuLrwN3AEOBXmflERJxZbL8cmAtMB1qBLcAX6u1XklSuUm5My8y5tP/R7/je5R2WE/haGX1JknqHD7eTJAEGgiSpYCBIkgADQZJUMBAkSYCBIEkqGAiSJMBAkCQVDARJEmAgSJIKBoIkCTAQJEkFA0GSBBgIkqSCgSBJAgwESVLBQJAkAQaCJKlQ11doRsRBwA3AEcAK4BOZ+VKNdiuAzcB2YFtmNtfTrySpfPXOEM4F7s/MycD9xXpnpmXmVMNAkhpTvYEwA7i6WL4a+Fid+5MkVaTeQDgkM9cAFD/HdNIugXsiYlFEzNrdDiNiVkS0RETLunXr6ixPktRdXZ5DiIj7gENrbDqvB/28JzPbImIMcG9EPJmZ82s1zMzZwGyA5ubm7EEfkqQ6dBkImXlKZ9si4oWIGJuZayJiLLC2k320FT/XRsStwHFAzUCQJFWj3kNGc4DPF8ufB27ftUFEjIiIkf9YBj4ELK2zX0lSyeoNhIuAD0bE08AHi3UiYlxEzC3aHAI8HBFLgD8Dd2bmXXX2K0kqWV33IWTmeuADNd5vA6YXy88C/1RPP5Kk3uedypIkwECQJBUMBEkSYCBIkgoGgiQJMBAkSQUDQZIEGAiSpIKBIEkCDARJUsFAkCQBBoIkqWAgSJIAA0GSVDAQJEmAgSBJKhgIkiTAQJAkFeoKhIg4IyKeiIgdEdG8m3anRsRfI6I1Is6tp09JUu+od4awFPhXYH5nDSJiCPBT4DRgCvCpiJhSZ7+SpJINrefDmbkcICJ21+w4oDUzny3aXg/MAJbV07ckqVx9cQ5hPLCqw/rq4r2aImJWRLRERMu6det6vThJUrsuZwgRcR9waI1N52Xm7d3oo9b0ITtrnJmzgdkAzc3NnbaTJJWry0DIzFPq7GM1cFiH9QlAW537lCSVrC8OGS0EJkfEpIgYDswE5vRBv5KkHqj3stOPR8Rq4ETgzoi4u3h/XETMBcjMbcDXgbuB5cCNmflEfWVLkspW71VGtwK31ni/DZjeYX0uMLeeviRJvcs7lSVJgIEgSSoYCJIkwECQJBUMBEkSYCBIkgoGgiQJMBAkSQUDQZIEGAiSpIKBIEkCDARJUsFAkCQBBoIkqWAgSJIAA0GSVDAQJEmAgSBJKtT7ncpnRMQTEbEjIpp3025FRDweEY9GREs9fUqSekdd36kMLAX+Ffh5N9pOy8wX6+xPktRL6gqEzFwOEBHlVCNJqkxfnUNI4J6IWBQRs/qoT0lSD3Q5Q4iI+4BDa2w6LzNv72Y/78nMtogYA9wbEU9m5vxO+psFzAKYOHFiN3cvSapXl4GQmafU20lmthU/10bErcBxQM1AyMzZwGyA5ubmrLdvSVL39Poho4gYEREj/7EMfIj2k9GSpAZS72WnH4+I1cCJwJ0RcXfx/riImFs0OwR4OCKWAH8G7szMu+rpV5JUvnqvMroVuLXG+23A9GL5WeCf6ulHktT7vFNZkgQYCJKkgoEgSQIMBElSwUCQJAEGgiSpYCBIkgADQZJUMBAkSYCBIEkqGAiSJMBAkCQVDARJEmAgSJIKBoIkCTAQJEkFA0GSBBgIkqSCgSBJAuoMhIj4vxHxZEQ8FhG3RsQBnbQ7NSL+GhGtEXFuPX1KknpHvTOEe4G3Z+Y7gKeA/7Vrg4gYAvwUOA2YAnwqIqbU2a8kqWR1BUJm3pOZ24rVBcCEGs2OA1oz89nMfAO4HphRT7+SpPINLXFfXwRuqPH+eGBVh/XVwPGd7SQiZgGzitXXI2JpaRX2jlHAi1UX0Q3WWS7rLJd1lue/7ekHuwyEiLgPOLTGpvMy8/aizXnANuA3tXZR473srL/MnA3MLvbbkpnNXdVYpf5QI1hn2ayzXNZZnoho2dPPdhkImXlKF51/Hvgw8IHMrPWHfjVwWIf1CUBbT4qUJPW+eq8yOhU4B/hoZm7ppNlCYHJETIqI4cBMYE49/UqSylfvVUaXAiOBeyPi0Yi4HCAixkXEXIDipPPXgbuB5cCNmflEN/c/u876+kJ/qBGss2zWWS7rLM8e1xi1j/JIkgYb71SWJAEGgiSp0DCB0F8egxERZ0TEExGxIyI6vfwsIlZExOPFuZU9vgxsT/WgzqrH86CIuDcini5+HthJu0rGs6vxiXaXFNsfi4hj+6q2HtR4ckRsKsbu0Yg4v69rLOr4VUSs7ezeokYYy6KOruqsfDwj4rCI+ENELC/+P/9WjTY9H8/MbIgX8CFgaLH8A+AHNdoMAZ4B3goMB5YAU/q4zqNpv/HjAaB5N+1WAKMqHM8u62yQ8fwhcG6xfG6t/+5VjWd3xgeYDsyj/X6bE4BHGrDGk4E7qvpd7FDHScCxwNJOtlc6lj2os/LxBMYCxxbLI2l/dFDdv5sNM0PIfvIYjMxcnpl/7cs+90Q366x8PIv+ri6WrwY+1sf97053xmcGcE22WwAcEBFjG6zGhpCZ84ENu2lS9VgC3aqzcpm5JjMXF8ubab+Cc/wuzXo8ng0TCLv4Iu3Jtqtaj8HYdRAaRQL3RMSi4nEcjagRxvOQzFwD7b/kwJhO2lUxnt0Zn6rHsLv9nxgRSyJiXkQc0zel9VjVY9kTDTOeEXEE8E7gkV029Xg8y3yWUZf6+jEYe6o7dXbDezKzLSLG0H6fxpPFvzxKU0KdlY9nD3bT6+NZQ3fGp0/GcDe60/9i4PDMfCUipgO3AZN7u7A9UPVYdlfDjGdE7AfcDHw7M1/edXONj+x2PPs0ELKfPAajqzq7uY+24ufaiLiV9ql9qX/ASqiz8vGMiBciYmxmrimms2s72Uevj2cN3Rmfqh/N0mX/Hf9QZObciLgsIkZlZqM9pK3qseyWRhnPiBhGexj8JjNvqdGkx+PZMIeMYgA9BiMiRkTEyH8s037CvBGf2toI4zkH+Hyx/HngTTObCsezO+MzB/hccUXHCcCmfxwC6yNd1hgRh0ZEFMvH0f7//fo+rLG7qh7LbmmE8Sz6vwJYnpn/3kmzno9nlWfKdzkj3kr78a5Hi9flxfvjgLm7nDl/ivYrK86roM6P0568rwMvAHfvWiftV3wsKV5PNGqdDTKeBwP3A08XPw9qpPGsNT7AmcCZxXLQ/gVQzwCPs5srzyqs8evFuC2h/YKNf+7rGos6rgPWAFuL380vNdpYdrPOyscTeC/th38e6/A3c3q94+mjKyRJQAMdMpIkVctAkCQBBoIkqWAgSJIAA0GSVDAQJEmAgSBJKvx/c5+2+a6YW2wAAAAASUVORK5CYII=\n",
      "text/plain": [
       "<Figure size 432x288 with 1 Axes>"
      ]
     },
     "metadata": {
      "needs_background": "light"
     },
     "output_type": "display_data"
    }
   ],
   "source": [
    "# Plot numpy arrays\n",
    "\n",
    "Plotvec1(u, z, v)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Try it yourself\n",
    "\n",
    "Perform addition operation on the given numpy array arr1 and arr2:\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 50,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "array([30, 32, 34, 36, 38, 40])"
      ]
     },
     "execution_count": 50,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "arr1 = np.array([10, 11, 12, 13, 14, 15])\n",
    "arr2 = np.array([20, 21, 22, 23, 24, 25])\n",
    "#z= (arr1+arr2)\n",
    "#z  \n",
    "\n",
    "#or\n",
    "aar3 = np.add(arr1,arr2)\n",
    "aar3\n",
    "\n",
    "# Enter your code here"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "<details><summary>Click here for the solution</summary>\n",
    "\n",
    "```python\n",
    "arr3 = np.add(arr1, arr2)\n",
    "arr3\n",
    "\n",
    "    \n",
    "```\n",
    "\n",
    "</details>\n"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Array Subtraction\n"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Consider the numpy array a:\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 58,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "array([10, 20, 30])"
      ]
     },
     "execution_count": 58,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "a = np.array([10, 20, 30])\n",
    "a"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Consider the numpy array b:\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 59,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "array([ 5, 10, 15])"
      ]
     },
     "execution_count": 59,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "b = np.array([5, 10, 15])\n",
    "b\n"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "We can subtract the two arrays and assign it to c:\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 60,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "[ 5 10 15]\n"
     ]
    }
   ],
   "source": [
    "c = np.subtract(a, b)\n",
    "print(c)\n",
    "\n"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Try it yourself\n",
    "\n",
    "Perform subtraction operation on the given numpy array arr1 and arr2:\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 57,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "array([-10,  -1,   8,  17,  26,  35])"
      ]
     },
     "execution_count": 57,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "arr1 = np.array([10, 20, 30, 40, 50, 60])\n",
    "arr2 = np.array([20, 21, 22, 23, 24, 25])\n",
    "arr3 = np.subtract(arr1, arr2)\n",
    "arr3\n",
    "# Enter your code here\n"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "<details><summary>Click here for the solution</summary>\n",
    "\n",
    "```python\n",
    "arr3 = np.subtract(arr1, arr2)\n",
    "arr3\n",
    "\n",
    "    \n",
    "```\n",
    "\n",
    "</details>\n"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "<h3 id=\"multi\">Array Multiplication</h3>\n"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Consider the vector numpy array <code>y</code>:\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 61,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "array([1, 2])"
      ]
     },
     "execution_count": 61,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "# Create a numpy array\n",
    "\n",
    "x = np.array([1, 2])\n",
    "x"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 62,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "array([2, 1])"
      ]
     },
     "execution_count": 62,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "# Create a numpy array\n",
    "\n",
    "y = np.array([2, 1])\n",
    "y"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "We can multiply every element in the array by 2:\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 63,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "array([2, 2])"
      ]
     },
     "execution_count": 63,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "# Numpy Array Multiplication\n",
    "\n",
    "z = np.multiply(x, y)\n",
    "z"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "This is equivalent to multiplying a vector by a scaler:\n"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Try it yourself\n",
    "\n",
    "Perform multiply operation on the given numpy array arr1 and arr2:\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 65,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "array([ 20,  20,  60, 120, 200, 300])"
      ]
     },
     "execution_count": 65,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "arr1 = np.array([10, 20, 30, 40, 50, 60])\n",
    "arr2 = np.array([2, 1, 2, 3, 4, 5])\n",
    "arr3 = np.multiply(arr1,arr2)\n",
    "arr3\n",
    "# Enter your code here\n"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "<details><summary>Click here for the solution</summary>\n",
    "\n",
    "```python\n",
    "arr3 = np.multiply(arr1, arr2)\n",
    "arr3\n",
    "\n",
    "    \n",
    "```\n",
    "\n",
    "</details>\n"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Array Division\n"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Consider the vector numpy array a:\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 66,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "array([10, 20, 30])"
      ]
     },
     "execution_count": 66,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "a = np.array([10, 20, 30])\n",
    "a"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Consider the vector numpy array b:\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 67,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "array([ 2, 10,  5])"
      ]
     },
     "execution_count": 67,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "b = np.array([2, 10, 5])\n",
    "b"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "We can divide the two arrays and assign it to c:\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 68,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "array([5., 2., 6.])"
      ]
     },
     "execution_count": 68,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "c = np.divide(a, b)\n",
    "c"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Try it yourself\n",
    "\n",
    "Perform division operation on the given numpy array arr1 and arr2:\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 70,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "array([ 3.33333333,  4.        ,  3.        ,  5.        , 25.        ,\n",
       "        1.81818182])"
      ]
     },
     "execution_count": 70,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "arr1 = np.array([10, 20, 30, 40, 50, 60])\n",
    "arr2 = np.array([3, 5, 10, 8, 2, 33])\n",
    "arr3 = np.divide(arr1,arr2)\n",
    "arr3\n",
    "\n",
    "# Enter your code here"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "<details><summary>Click here for the solution</summary>\n",
    "\n",
    "```python\n",
    "arr3 = np.divide(arr1, arr2)\n",
    "arr3\n",
    "\n",
    "    \n",
    "```\n",
    "\n",
    "</details>\n"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "<h3 id=\"dot\">Dot Product</h3>\n"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "The dot product of the two numpy arrays <code>u</code> and <code>v</code> is given by:\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 71,
   "metadata": {},
   "outputs": [],
   "source": [
    "X = np.array([1, 2])\n",
    "Y = np.array([3, 2])"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 72,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "7"
      ]
     },
     "execution_count": 72,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "# Calculate the dot product\n",
    "\n",
    "np.dot(X, Y)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 73,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "1\n",
      "2\n"
     ]
    }
   ],
   "source": [
    "#Elements of X\n",
    "print(X[0])\n",
    "print(X[1])"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 74,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "3\n",
      "2\n"
     ]
    }
   ],
   "source": [
    "#Elements of Y\n",
    "print(Y[0])\n",
    "print(Y[1])"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "We are performing the dot product which is shown as below\n"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "<img src=\"https://cf-courses-data.s3.us.cloud-object-storage.appdomain.cloud/IBMDeveloperSkillsNetwork-PY0101EN-SkillsNetwork/labs/Module%205/images/dot1.PNG\">\n"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Try it yourself\n",
    "\n",
    "Perform dot operation on the given numpy array ar1 and ar2:\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 76,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "26"
      ]
     },
     "execution_count": 76,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "arr1 = np.array([3, 5])\n",
    "arr2 = np.array([2, 4])\n",
    "arr3 = np.dot(arr1,arr2)\n",
    "arr3\n",
    "\n",
    "# Enter your code here\n"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "<details><summary>Click here for the solution</summary>\n",
    "\n",
    "```python\n",
    "arr3 = np.dot(arr1, arr2)\n",
    "arr3\n",
    "\n",
    "    \n",
    "```\n",
    "\n",
    "</details>\n"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "<h3 id=\"cons\">Adding Constant to a Numpy Array</h3>\n"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Consider the following array:\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 77,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "array([ 1,  2,  3, -1])"
      ]
     },
     "execution_count": 77,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "# Create a constant to numpy array\n",
    "\n",
    "u = np.array([1, 2, 3, -1]) \n",
    "u"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Adding the constant 1 to each element in the array:\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 78,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "array([2, 3, 4, 0])"
      ]
     },
     "execution_count": 78,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "# Add the constant to array\n",
    "\n",
    "u + 1"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "The process is summarised in the following animation:\n"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "<img src=\"https://cf-courses-data.s3.us.cloud-object-storage.appdomain.cloud/IBMDeveloperSkillsNetwork-PY0101EN-SkillsNetwork/labs/Module%205/images/NumOneAdd.gif\" width=\"500\" />\n"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Try it yourself\n",
    "\n",
    "Add Constant 5 to the given numpy array ar:\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 79,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "array([6, 7, 8, 4])"
      ]
     },
     "execution_count": 79,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "arr = np.array([1, 2, 3, -1]) \n",
    "arr1 = arr + 5\n",
    "arr1\n",
    "\n",
    "\n",
    "# Enter your code here\n"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "<details><summary>Click here for the solution</summary>\n",
    "\n",
    "```python\n",
    "arr + 5\n",
    "\n",
    "    \n",
    "```\n",
    "\n",
    "</details>\n"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "<hr>\n"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "<h2 id=\"math\">Mathematical Functions</h2>\n"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "We can access the value of <code>pi</code> in numpy as follows :\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 80,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "3.141592653589793"
      ]
     },
     "execution_count": 80,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "# The value of pi\n",
    "\n",
    "np.pi"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "We can create the following numpy array in Radians:\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 85,
   "metadata": {},
   "outputs": [],
   "source": [
    "# Create the numpy array in radians\n",
    "\n",
    "x = np.array([0, np.pi/2 , np.pi])\n"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "We can apply the function <code>sin</code> to the array <code>x</code> and assign the values to the array <code>y</code>; this applies the sine function to each element in the array:\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 87,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "array([0.0000000e+00, 1.0000000e+00, 1.2246468e-16])"
      ]
     },
     "execution_count": 87,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "# Calculate the sin of each elements\n",
    "\n",
    "y = np.sin(x)\n",
    "y"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "<hr>\n"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "<h2 id=\"lin\">Linspace</h2>\n"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "A useful function for plotting mathematical functions is <code>linspace</code>.   Linspace returns evenly spaced numbers over a specified interval.\n",
    "\n",
    "**numpy.linspace(start, stop, num = int value)**\n",
    "\n",
    "start  :  start of interval range\n",
    "\n",
    "stop   :  end of interval range\n",
    "\n",
    "num    :  Number of samples to generate.\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 88,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "array([-2., -1.,  0.,  1.,  2.])"
      ]
     },
     "execution_count": 88,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "# Makeup a numpy array within [-2, 2] and 5 elements\n",
    "\n",
    "np.linspace(-2, 2, num=5)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "If we change the parameter <code>num</code> to 9, we get 9 evenly spaced numbers over the interval from -2 to 2:\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 89,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "array([-2. , -1.5, -1. , -0.5,  0. ,  0.5,  1. ,  1.5,  2. ])"
      ]
     },
     "execution_count": 89,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "# Make a numpy array within [-2, 2] and 9 elements\n",
    "\n",
    "np.linspace(-2, 2, num=9)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "We can use the function <code>linspace</code> to generate 100 evenly spaced samples from the interval 0 to 2π:\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 94,
   "metadata": {},
   "outputs": [],
   "source": [
    "# Make a numpy array within [0, 2π] and 100 elements \n",
    "\n",
    "x = np.linspace(0, 2*np.pi, num=100)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "We can apply the sine function to each element in the array <code>x</code> and assign it to the array <code>y</code>:\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 93,
   "metadata": {},
   "outputs": [],
   "source": [
    "# Calculate the sine of x list\n",
    "\n",
    "y = np.sin(x)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 92,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "[<matplotlib.lines.Line2D at 0x18ff3b909d0>]"
      ]
     },
     "execution_count": 92,
     "metadata": {},
     "output_type": "execute_result"
    },
    {
     "data": {
      "image/png": "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\n",
      "text/plain": [
       "<Figure size 432x288 with 1 Axes>"
      ]
     },
     "metadata": {
      "needs_background": "light"
     },
     "output_type": "display_data"
    }
   ],
   "source": [
    "# Plot the result\n",
    "\n",
    "plt.plot(x, y)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Try it yourself\n",
    "\n",
    "Make a numpy array within \\[5, 4] and 6 elements\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 97,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "array([5. , 4.8, 4.6, 4.4, 4.2, 4. ])"
      ]
     },
     "execution_count": 97,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "# Enter your code here\n",
    "#np.linspace = (5,4, num = 6)\n",
    "np.linspace(5, 4, num=6)\n"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "<details><summary>Click here for the solution</summary>\n",
    "\n",
    "```python\n",
    "np.linspace(5, 4, num=6)\n",
    "\n",
    "    \n",
    "```\n",
    "\n",
    "</details>\n"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "<hr>\n"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Iterating 1-D Arrays\n",
    "\n",
    "Iterating means going through elements one by one.\n",
    "\n",
    "If we iterate on a 1-D array it will go through each element one by one.\n"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "If we execute the numpy array, we get in the array format\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 98,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "[1 2 3]\n"
     ]
    }
   ],
   "source": [
    "arr1 = np.array([1, 2, 3])\n",
    "print(arr1)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "But if you want to result in the form of the list, then you can use for loop:\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 99,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "1\n",
      "2\n",
      "3\n"
     ]
    }
   ],
   "source": [
    "for x in arr1:\n",
    "  print(x)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "<h2 id=\"quiz\">Quiz on 1D Numpy Array</h2>\n"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Implement the following vector subtraction in numpy: u-v\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 101,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "array([ 1, -1])"
      ]
     },
     "execution_count": 101,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "# Write your code below and press Shift+Enter to execute\n",
    "\n",
    "u = np.array([1, 0])\n",
    "v = np.array([0, 1])\n",
    "z = np.subtract(u,v)\n",
    "z"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "<details><summary>Click here for the solution</summary>\n",
    "\n",
    "```python\n",
    "u - v\n",
    "```\n",
    "\n",
    "</details>\n"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "<hr>\n"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Multiply the numpy array z with -2:\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 104,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "array([2, 4])"
      ]
     },
     "execution_count": 104,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "# Write your code below and press Shift+Enter to execute\n",
    "\n",
    "z = np.array([2, 4])\n",
    "-2*z\n",
    "z"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "<details><summary>Click here for the solution</summary>\n",
    "\n",
    "```python\n",
    "-2 * z\n",
    "```\n",
    "\n",
    "</details>\n"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "<hr>\n"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Consider the list <code>\\[1, 2, 3, 4, 5]</code> and <code>\\[1, 0, 1, 0, 1]</code>. Cast both lists to a numpy array then multiply them together:\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 105,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "array([1, 0, 3, 0, 5])"
      ]
     },
     "execution_count": 105,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "# Write your code below and press Shift+Enter to execute\n",
    "u =[1,2,3,4,5]\n",
    "v =[1,0,1,0,1]\n",
    "z =np.multiply(u,v)\n",
    "z\n"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "<details><summary>Click here for the solution</summary>\n",
    "\n",
    "```python\n",
    "a = np.array([1, 2, 3, 4, 5])\n",
    "b = np.array([1, 0, 1, 0, 1])\n",
    "a * b\n",
    "```\n",
    "\n",
    "</details>\n"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "<hr>\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 106,
   "metadata": {},
   "outputs": [],
   "source": [
    "# Import the libraries\n",
    "\n",
    "import time \n",
    "import sys\n",
    "import numpy as np \n",
    "\n",
    "import matplotlib.pyplot as plt\n",
    "%matplotlib inline  \n",
    "\n",
    "def Plotvec2(a,b):\n",
    "    ax = plt.axes()# to generate the full window axes\n",
    "    ax.arrow(0, 0, *a, head_width=0.05, color ='r', head_length=0.1)#Add an arrow to the  a Axes with arrow head width 0.05, color red and arrow head length 0.1\n",
    "    plt.text(*(a + 0.1), 'a')\n",
    "    ax.arrow(0, 0, *b, head_width=0.05, color ='b', head_length=0.1)#Add an arrow to the  b Axes with arrow head width 0.05, color blue and arrow head length 0.1\n",
    "    plt.text(*(b + 0.1), 'b')\n",
    "    plt.ylim(-2, 2)#set the ylim to bottom(-2), top(2)\n",
    "    plt.xlim(-2, 2)#set the xlim to left(-2), right(2)\n",
    "    \n",
    "    \n"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Convert the list <code>\\[-1, 1]</code> and <code>\\[1, 1]</code> to numpy arrays <code>a</code> and <code>b</code>. Then, plot the arrays as vectors using the fuction <code>Plotvec2</code> and find their dot product:\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 107,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "The dot product is 0\n"
     ]
    },
    {
     "data": {
      "image/png": "iVBORw0KGgoAAAANSUhEUgAAAYQAAAD8CAYAAAB3u9PLAAAAOXRFWHRTb2Z0d2FyZQBNYXRwbG90bGliIHZlcnNpb24zLjQuMywgaHR0cHM6Ly9tYXRwbG90bGliLm9yZy/MnkTPAAAACXBIWXMAAAsTAAALEwEAmpwYAAAaRElEQVR4nO3deZxV9X3/8dd7ADUgBJRFVjUNiStuE5ZIEtJEC9RGbdVos/AwaalG09j6aPUXo2nSJWnSxpa6UJpYNRqINkGpYhBsUEnFOFjZBAUJygjKZnDBhYHP74/vQcfxDjPDPXPPnZn38/GYx5xz73fu98N3hvu+Z/seRQRmZmY1RRdgZmbVwYFgZmaAA8HMzDIOBDMzAxwIZmaWcSCYmRmQQyBIGi7pl5JWSVop6Wsl2kjSNElrJS2TdHK5/ZqZWb665/AaDcDlEfG4pN7AEknzI+LJRm0mASOzrzHAjdl3MzOrEmVvIUTEpoh4PFt+BVgFDG3S7Ezg1kgWA30lDS63bzMzy08eWwhvk3QEcBLwaJOnhgIbGq3XZ49tKvEaU4GpAL169TrlqKOOyrNEM7NObcmSJVsjYsD+/GxugSDpYOBnwGUR8XLTp0v8SMk5MyJiBjADoLa2Nurq6vIq0cys05P07P7+bC5nGUnqQQqD2yPi5yWa1APDG60PAzbm0beZmeUjj7OMBPwIWBURP2im2Rzgi9nZRmOBHRHxnt1FZmZWnDx2GZ0KfAFYLumJ7LGvAyMAImI6MBeYDKwFdgIX5tCvmZnlqOxAiIhFlD5G0LhNAJeU25eZmbUfX6lsZmaAA8HMzDIOBDMzAxwIZmaWcSCYmRngQDAzs4wDwczMAAeCmZllHAhmZgY4EMzMLONAMDMzwIFgZmYZB4KZmQEOBDMzyzgQzMwMcCCYmVnGgWBmZoADwczMMrkEgqSbJG2WtKKZ5ydI2iHpiezrmjz6NTOz/JR9T+XMzcB1wK37aPNwRJyRU39mZpazXLYQIuIhYHser2VmZsWo5DGEcZKWSrpP0rEV7NfMzFohr11GLXkcODwiXpU0GbgLGFmqoaSpwFSAESNGVKg8MzOryBZCRLwcEa9my3OBHpL6N9N2RkTURkTtgAEDKlGemZlRoUCQdJgkZcujs363VaJvMzNrnVx2GUmaCUwA+kuqB74J9ACIiOnAOcDFkhqA14HzIyLy6NvMzPKRSyBExAUtPH8d6bRUMzOrUr5S2czMAAeCmZllHAhmZgY4EMzMLONAMDMzwIFgZmYZB4KZmQEOBDMzyzgQzMwMcCCYWQexfv16jjvuuKLL6NQcCGZmBjgQrImzzjqLU045hWOPPZYZM2YUXY7ZuzQ0NDBlyhRGjRrFOeecw86dO4suqVNxINi73HTTTSxZsoS6ujqmTZvGtm2epdyqx1NPPcXUqVNZtmwZffr04YYbbii6pE7FgWDvMm3aNE444QTGjh3Lhg0bWLNmTdElmb1t+PDhnHrqqQB8/vOfZ9GiRQVX1LlU6haa1gEsXLiQBQsW8Mgjj9CzZ08mTJjAG2+8UXRZZm/L7rPV7LqVx1sI9rYdO3bQr18/evbsyerVq1m8eHHRJZm9y3PPPccjjzwCwMyZMxk/fnzBFXUuDgR728SJE2loaGDUqFFcffXVjB07tuiSzN7l6KOP5pZbbmHUqFFs376diy++uOiSOhVV850sa2tro66urugyOpYf/xhGjoQxY8Cb09YBRcCiRfD883D++UVX0/FIWhIRtfvzs95C6Ewi4Ic/hHHj4Igj4J//GbZuLboqs1Z58UX47ndh2DD4+Mfh9tuLrqjrySUQJN0kabOkFc08L0nTJK2VtEzSyXn0a01IcO+9cNxxUF8PV1+d/nedcQbMnw979hRdodm77N4Nc+fC6afD4YfDt76VgmH0aLjzzqKr63ryOsvoZuA64NZmnp8EjMy+xgA3Zt8tbwcfDAsXwimnpFDYvTuFxC9/Cf36wYYN3pVkVWHXLhgyBF5/HV57LT3Wo0fa4zl/Phx0ULH1dUW5bCFExEPA9n00ORO4NZLFQF9Jg/Po20o49FD41a/S971v/jt3wgc+UGxdZo1IKRD2hkFNDQwaBA89BH36FFtbV1WpYwhDgQ2N1uuzx95D0lRJdZLqtmzZUpHiOqWhQ9ORuT594EMfSh+3Hn4Yfud34K23iq7OurjXX4cBA2DZMhg4MO0u6tcvfY4ZMKDo6rquSgVCqX0UJU9viogZEVEbEbUD/JdRnpEjYdMmWLky/Q+cMwd+8xs48ED4r/8qujrrom6+GXr2hN/+Fv7nf9IxgzVr0h7OESOKrq5rq9SVyvXA8Ebrw4CNFeq7a3vf+95Z/oM/SDtuTzwRzj03BcO2bdCrV2HlWdfx29+mrQCAj30sHeqqyT6S9uiRvqxYldpCmAN8MTvbaCywIyI2Vahva6x7d1ixIu0+evPNdBB6+vSiq7JO7nvfeycMHn88HSeo8UnvVSeXLQRJM4EJQH9J9cA3gR4AETEdmAtMBtYCO4EL8+jXyjB+fDoDadIkuPji9LV1azoQbZaTTZvSgWOAz34WZs70SW7VLJdAiIgLWng+gEvy6MtyVFMD8+bB8uUwahT0759OBL/mmqIrs07gL/8Srr02La9ZAx/8YLH1WMu80WZw/PHporUpU+Cb30wf4erri67KOqi1a9Of0LXXwmWXpQvoHQYdgwPBEimd/rFuXVofPhy+8pVCS7KOJQIuuCCd3AawceM7WwjWMTgQ7N2OPDL9z77ySrjxxhQUq1cXXZVVuf/7v7QHctasNB9RBAz2pacdjgPBSvvOd9IJ4gBHHw1nn53+l5s1smcPfOITcHI2O9lLL8EVVxRbk+0/B4I1b+DAFALXXgt33ZU+Av7610VXZVVi4ULo1i2dQvqjH6U/lb59i67KyuFAsJZddhns2JGWx4xJX7t3F1qSFWfXrnSc4JOfhPe/P02T9aUvFV2V5cGBYK3Tp0/6CHjbbWkroXt3uP/+oquyCvv5z+GAA9KZRHffna4+bnwxvHVsDgRrm899Ls2LNGgQ/N7vpbOR3nyz6Kqsne3cmWY4+aM/gqOOSlsJn/lM0VVZ3hwI1nYHHQQvvJDubFJfn9ZnzSq6Kmsn//EfKQx27oQHH4RVq9IGonU+DgTbf5MmQUMDnHRSOgG9pgZeeaXoqiwn27ens46nToVPfSodNvr4x4uuytqTA8HK061bmq3skUfSMYY+feD664uuysr093//zrRWS5fCggWejK4r8K/Y8jF2bDop/fd/Hy69NH203Lq16KqsjZ5/Pv3qvvEN+MIX0q901Kiiq7JKcSBYfiS45550Qx5It766+upia7JW++pXYdiwtPzMM3DrrZ6ZtKtxIFj+jjkmfbT8kz+Bv/u79K7y3HNFV2XNePrp9Cu67jr4q79Ke/58++2uyYFg7UNKp6c8+2xaP/zwFBCe/qJqRMA558CHP5zWX3gh3cjGui4HgrWvESPSO883vpHmN6ipgSefLLqqLq+uLv0qfvYz+Kd/Sr+iQYOKrsqK5kCwyvjbv4UtW9Lyscemg8/eWqi43bth3Dj4yEfS+o4dcPnlxdZk1cOBYJXTv38KgeuuSxe11dSk01WtIhYsSBeULV6cDhjvPUvYbK9cAkHSRElPSVor6coSz0+QtEPSE9mX79HYlV1ySbqAraYGPvpROPFET5bXjt56C444Ak47LWXy66+nU0rNmio7ECR1A64HJgHHABdIOqZE04cj4sTs69vl9msd3MEHpxCYNStd+dS9O9x3X9FVdTp33gkHHpiO7d9zT9prd9BBRVdl1SqPLYTRwNqIWBcRbwGzgDNzeF3rCj77WXjjjXQC/OTJ6cjmG28UXVWH9+qraVbS885Lt8zetSsdtjHblzwCYSiwodF6ffZYU+MkLZV0n6Rjm3sxSVMl1Umq27L3IKR1bgceCBs2wLx5sHlzmk/5ttuKrqrDuuEG6N07hcCiRbBsmSejs9bJIxBKXcvY9PSRx4HDI+IE4N+Au5p7sYiYERG1EVE7YMCAHMqzDuP009NkeWPGpJ3cErz8ctFVdRjbtqUhu+QSmDgxXRt46qlFV2UdSR6BUA8Mb7Q+DNjYuEFEvBwRr2bLc4Eekvrn0Ld1Nt26pdNg9t6q8/3vh3/5l0JL6gj+5m/SAWOA5cvT4RhPO2FtlUcgPAaMlHSkpAOA84E5jRtIOkxKf56SRmf9bsuhb+usPvKR9BH3rLPgL/4ivbtt3lx0VVVnw4Y0NN/6VrqN5Z49cNxxRVdlHVXZgRARDcClwDxgFXBHRKyUdJGki7Jm5wArJC0FpgHnR/iqJGuBBLNnpzuyQDrgfOV7zmrukiLgoovSheAAv/lNuhDcWwVWDlXz+3JtbW3U1dUVXYZVi698BW68MS2vWwdHHllsPQVZtSrNHwjw9a+nexeY7SVpSUTU7s/P+kpl6zhuuCHtI4E0HeeUKV1q+ouIdB/jvWGwebPDwPLlQLCOZdiw9M747W+n+RdqatJR1E7u0UfTP/W//xumTUtD4JPwLG8OBOuYrr46nWcJ6ZZep52Wjqh2Mrt3Q21tuiEdpLNwv/rVYmuyzsuBYB3XIYekj8rTp6eZ27p1S1didRLz5qULypYsgZ/8JP1Te/cuuirrzBwI1vH92Z+luRoOPBA+9rE0vXZDQ9FV7bc334QhQ9LFZUOGpJk8Lrig6KqsK3AgWOfQq1d657zzznQDnh490g73DuYnP0mTz23alC4ue/75lHNmleAZTqxzOeec9BH76KPTKTn9+qV31fe9r+jK9umVV965N0FtbbpYu1u3YmuyrsdbCNb5HHAAPPMMPPAAvPQS9OwJN99cdFXNmjbtnTBYvBgee8xhYMVwIFjn9bu/m07TGT8eLrwwXca7Y0fRVb1ty5ZU0te+ljZm9uxJ8/qZFcWBYJ1bTQ08/HC6qzxA377w/e8XWhLAVVfBwIFp+ckn4e67Pe2EFc+BYF3DKaekj+Dnngt//dfp3feFFypexrPPpq7/4R/SyVF79qTDHWbVwIFgXYcEd9wBTz+d1gcPhssvr0jXEWk20iOOSOvPPZcun/BWgVUTB4J1PSNHpnfoP/9z+MEP0rvyM8+0W3crVqQ9V//5n3DNNanr4cNb/jmzSnMgWNf1r/+aTkkF+OAH4Y//ONfJ8iJg0qR0T2OArVvTfQvMqpUDwbq2IUPSO/d3vgMzZ6aP8k88UfbL/upX6aV+8Ys0SWsEHHpo+eWatScHghmkG+9s356WTzoJJkzYr8nyGhrSXHvjx6eLpV95BS6+ON9SzdqLA8Fsr3790kf5H/4QHnwwXR324IOt/vF7700hsHw5/PSn8NZbcPDB7VivWc4cCGZNffnL8NpraWrRCRPgQx+CXbuabf7GG+kG92ecAYcfnmbOOO+8ypVrlpdcAkHSRElPSVor6T03vVUyLXt+maST8+jXrN307JluPjB7NqxZk6bDuOuu9zT78Y/TNEnbtsH8+bB+fWpq1hGVPbmdpG7A9cBpQD3wmKQ5EfFko2aTgJHZ1xjgxuy7WXU766y07+f44+Hss9Osqps3s2NXT/r2TU3GjUsXQ3v+Ievo8thCGA2sjYh1EfEWMAs4s0mbM4FbI1kM9JU0OIe+zdpfjx6wejUsXAivvcayXmPfDoPHHoP//V+HgXUOeQTCUGBDo/X67LG2tgFA0lRJdZLqtmzZkkN5Zjn5xCdg9270uc9xxZ9uZ8+eNFW1WWeRx/0QSl183/Tqnta0SQ9GzABmANTW1uZ3lZBZHmpqOP62K/hu0XWYtYM8thDqgcYX4g8DNu5HGzMzK1AegfAYMFLSkZIOAM4H5jRpMwf4Yna20VhgR0RsyqFvMzPLSdm7jCKiQdKlwDygG3BTRKyUdFH2/HRgLjAZWAvsBC4st18zM8tXLvdUjoi5pDf9xo9Nb7QcwCV59GVmZu3DVyqbmRngQDAzs4wDwczMAAeCmZllHAhmZgY4EMzMLONAMDMzwIFgZmYZB4KZmQEOBDMzyzgQzMwMcCCYmVnGgWBmZoADwczMMg4EMzMDHAhmZpZxIJiZGeBAMDOzTFm30JR0CPBT4AhgPXBeRLxUot164BVgN9AQEbXl9GtmZvkrdwvhSuCBiBgJPJCtN+eTEXGiw8DMrDqVGwhnArdky7cAZ5X5emZmVpByA2FQRGwCyL4PbKZdAPdLWiJp6r5eUNJUSXWS6rZs2VJmeWZm1lotHkOQtAA4rMRTV7Whn1MjYqOkgcB8Sasj4qFSDSNiBjADoLa2NtrQh5mZlaHFQIiITzf3nKQXJQ2OiE2SBgObm3mNjdn3zZJmA6OBkoFgZmbFKHeX0RxgSrY8Bbi7aQNJvST13rsMnA6sKLNfMzPLWbmB8F3gNElrgNOydSQNkTQ3azMIWCRpKfBr4N6I+EWZ/ZqZWc7Kug4hIrYBnyrx+EZgcra8DjihnH7MzKz9+UplMzMDHAhmZpZxIJiZGeBAMDOzjAPBzMwAB4KZmWUcCGZmBjgQzMws40AwMzPAgWBmZhkHgpmZAQ4EMzPLOBDMzAxwIJiZWcaBYGZmgAPBzMwyDgQzMwMcCGZmlikrECSdK2mlpD2SavfRbqKkpyStlXRlOX2amVn7KHcLYQXwh8BDzTWQ1A24HpgEHANcIOmYMvs1M7OcdS/nhyNiFYCkfTUbDayNiHVZ21nAmcCT5fRtZmb5qsQxhKHAhkbr9dljJUmaKqlOUt2WLVvavTgzM0ta3EKQtAA4rMRTV0XE3a3oo9TmQzTXOCJmADMAamtrm21nZmb5ajEQIuLTZfZRDwxvtD4M2Fjma5qZWc4qscvoMWCkpCMlHQCcD8ypQL9mZtYG5Z52erakemAccK+kednjQyTNBYiIBuBSYB6wCrgjIlaWV7aZmeWt3LOMZgOzSzy+EZjcaH0uMLecvszMrH35SmUzMwMcCGZmlnEgmJkZ4EAwM7OMA8HMzAAHgpmZZRwIZmYGOBDMzCzjQDAzM8CBYGZmGQeCmZkBDgQzM8s4EMzMDHAgmJlZxoFgZmaAA8HMzDIOBDMzAxwIZmaWKfeeyudKWilpj6TafbRbL2m5pCck1ZXTp5mZtY+y7qkMrAD+EPj3VrT9ZERsLbM/MzNrJ2UFQkSsApCUTzVmZlaYSh1DCOB+SUskTa1Qn2Zm1gYtbiFIWgAcVuKpqyLi7lb2c2pEbJQ0EJgvaXVEPNRMf1OBqQAjRoxo5cubmVm5WgyEiPh0uZ1ExMbs+2ZJs4HRQMlAiIgZwAyA2traKLdvMzNrnXbfZSSpl6Tee5eB00kHo83MrIqUe9rp2ZLqgXHAvZLmZY8PkTQ3azYIWCRpKfBr4N6I+EU5/ZqZWf7KPctoNjC7xOMbgcnZ8jrghHL6MTOz9ucrlc3MDHAgmJlZxoFgZmaAA8HMzDIOBDMzAxwIZmaWcSCYmRngQDAzs4wDwczMAAeCmZllHAhmZgY4EMzMLONAMDMzwIFgZmYZB4KZmQEOBDMzyzgQzMwMcCCYmVnGgWBmZkCZgSDp+5JWS1omabakvs20myjpKUlrJV1ZTp9mZtY+yt1CmA8cFxGjgKeB/9e0gaRuwPXAJOAY4AJJx5TZr5mZ5aysQIiI+yOiIVtdDAwr0Ww0sDYi1kXEW8As4Mxy+jUzs/x1z/G1vgT8tMTjQ4ENjdbrgTHNvYikqcDUbPVNSStyq7B99Ae2Fl1EK7jOfLnOfLnO/Hx4f3+wxUCQtAA4rMRTV0XE3Vmbq4AG4PZSL1HisWiuv4iYAczIXrcuImpbqrFIHaFGcJ15c535cp35kVS3vz/bYiBExKdb6HwKcAbwqYgo9UZfDwxvtD4M2NiWIs3MrP2Ve5bRROAK4DMRsbOZZo8BIyUdKekA4HxgTjn9mplZ/so9y+g6oDcwX9ITkqYDSBoiaS5AdtD5UmAesAq4IyJWtvL1Z5RZXyV0hBrBdebNdebLdeZnv2tU6b08ZmbW1fhKZTMzAxwIZmaWqZpA6CjTYEg6V9JKSXskNXv6maT1kpZnx1b2+zSw/dWGOosez0MkzZe0Jvver5l2hYxnS+OjZFr2/DJJJ1eqtjbUOEHSjmzsnpB0TaVrzOq4SdLm5q4tqoaxzOpoqc7Cx1PScEm/lLQq+3/+tRJt2j6eEVEVX8DpQPds+R+BfyzRphvwDPAB4ABgKXBMhes8mnThx0Kgdh/t1gP9CxzPFuuskvH8HnBltnxlqd97UePZmvEBJgP3ka63GQs8WoU1TgDuKepvsVEdHwdOBlY083yhY9mGOgsfT2AwcHK23Js0dVDZf5tVs4UQHWQajIhYFRFPVbLP/dHKOgsfz6y/W7LlW4CzKtz/vrRmfM4Ebo1kMdBX0uAqq7EqRMRDwPZ9NCl6LIFW1Vm4iNgUEY9ny6+QzuAc2qRZm8ezagKhiS+Rkq2pUtNgNB2EahHA/ZKWZNNxVKNqGM9BEbEJ0h85MLCZdkWMZ2vGp+gxbG3/4yQtlXSfpGMrU1qbFT2WbVE14ynpCOAk4NEmT7V5PPOcy6hFlZ4GY3+1ps5WODUiNkoaSLpOY3X2ySM3OdRZ+Hi24WXafTxLaM34VGQM96E1/T8OHB4Rr0qaDNwFjGzvwvZD0WPZWlUznpIOBn4GXBYRLzd9usSP7HM8KxoI0UGmwWipzla+xsbs+2ZJs0mb9rm+geVQZ+HjKelFSYMjYlO2Obu5mddo9/EsoTXjU/TULC323/iNIiLmSrpBUv+IqLZJ2ooey1aplvGU1IMUBrdHxM9LNGnzeFbNLiN1omkwJPWS1HvvMumAeTXO2loN4zkHmJItTwHes2VT4Hi2ZnzmAF/MzugYC+zYuwusQlqsUdJhkpQtjyb9v99WwRpbq+ixbJVqGM+s/x8BqyLiB800a/t4FnmkvMkR8bWk/V1PZF/Ts8eHAHObHDl/mnRmxVUF1Hk2KXnfBF4E5jWtk3TGx9Lsa2W11lkl43ko8ACwJvt+SDWNZ6nxAS4CLsqWRboB1DPAcvZx5lmBNV6ajdtS0gkbH610jVkdM4FNwK7sb/PL1TaWrayz8PEExpN2/yxr9J45udzx9NQVZmYGVNEuIzMzK5YDwczMAAeCmZllHAhmZgY4EMzMLONAMDMzwIFgZmaZ/w/tOhx1vepY5gAAAABJRU5ErkJggg==\n",
      "text/plain": [
       "<Figure size 432x288 with 1 Axes>"
      ]
     },
     "metadata": {
      "needs_background": "light"
     },
     "output_type": "display_data"
    }
   ],
   "source": [
    "# Write your code below and press Shift+Enter to execute\n",
    "a=np.array([-1,1])\n",
    "b=np.array([1,1])\n",
    "Plotvec2(a,b)\n",
    "print(\"The dot product is\", np.dot(a,b))\n"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "<details><summary>Click here for the solution</summary>\n",
    "\n",
    "```python\n",
    "\n",
    "\n",
    "a = np.array([-1, 1])\n",
    "b = np.array([1, 1])\n",
    "Plotvec2(a, b)\n",
    "print(\"The dot product is\", np.dot(a,b))\n",
    "\n",
    "```\n",
    "\n",
    "</details>\n"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "<hr>\n"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Convert the list <code>\\[1, 0]</code> and <code>\\[0, 1]</code> to numpy arrays <code>a</code> and <code>b</code>. Then, plot the arrays as vectors using the function <code>Plotvec2</code> and find their dot product:\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 110,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "The dot product is 0\n"
     ]
    },
    {
     "data": {
      "image/png": "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\n",
      "text/plain": [
       "<Figure size 432x288 with 1 Axes>"
      ]
     },
     "metadata": {
      "needs_background": "light"
     },
     "output_type": "display_data"
    }
   ],
   "source": [
    "\n",
    "# Write your code below and press Shift+Enter to execute\n",
    "a=np.array([1,0])\n",
    "b=np.array([0,1])\n",
    "Plotvec2(a,b)\n",
    "print('The dot product is',np.dot(a,b))\n"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "<details><summary>Click here for the solution</summary>\n",
    "\n",
    "```python\n",
    "a = np.array([1, 0])\n",
    "b = np.array([0, 1])\n",
    "Plotvec2(a, b)\n",
    "print(\"The dot product is\", np.dot(a, b))\n",
    "\n",
    "```\n",
    "\n",
    "</details>\n"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "<hr>\n"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Convert the list <code>\\[1, 1]</code> and <code>\\[0, 1]</code> to numpy arrays <code>a</code> and <code>b</code>. Then plot the arrays as vectors using the fuction <code>Plotvec2</code> and find their dot product:\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 111,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "The dot product is 1\n"
     ]
    },
    {
     "data": {
      "image/png": "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\n",
      "text/plain": [
       "<Figure size 432x288 with 1 Axes>"
      ]
     },
     "metadata": {
      "needs_background": "light"
     },
     "output_type": "display_data"
    }
   ],
   "source": [
    "# Write your code below and press Shift+Enter to execute\n",
    "a = np.array([1,1])\n",
    "b = np.array([0,1])\n",
    "Plotvec2(a,b)\n",
    "print('The dot product is', np.dot(a,b))\n"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "<details><summary>Click here for the solution</summary>\n",
    "\n",
    "```python\n",
    "a = np.array([1, 1])\n",
    "b = np.array([0, 1])\n",
    "Plotvec2(a, b)\n",
    "print(\"The dot product is\", np.dot(a, b))\n",
    "\n",
    "```\n",
    "\n",
    "</details>\n"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "<hr>\n"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Why are the results of the dot product for <code>\\[-1, 1]</code> and <code>\\[1, 1]</code> and the dot product for <code>\\[1, 0]</code> and <code>\\[0, 1]</code> zero, but not zero for the dot product for <code>\\[1, 1]</code> and <code>\\[0, 1]</code>? <p><i>Hint: Study the corresponding figures, pay attention to the direction the arrows are pointing to.</i></p>\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 112,
   "metadata": {},
   "outputs": [
    {
     "ename": "SyntaxError",
     "evalue": "invalid syntax (Temp/ipykernel_10364/1943077771.py, line 2)",
     "output_type": "error",
     "traceback": [
      "\u001b[1;36m  File \u001b[1;32m\"C:\\Users\\Sharon\\AppData\\Local\\Temp/ipykernel_10364/1943077771.py\"\u001b[1;36m, line \u001b[1;32m2\u001b[0m\n\u001b[1;33m    this is because, the vectors used for ([-1,1],[1,1]) and ([1,0],[0,1]) are perpendicular compared to the\u001b[0m\n\u001b[1;37m                                      ^\u001b[0m\n\u001b[1;31mSyntaxError\u001b[0m\u001b[1;31m:\u001b[0m invalid syntax\n"
     ]
    }
   ],
   "source": [
    "# Write your code below and press Shift+Enter to execute\n",
    "this is because, the vectors used for ([-1,1],[1,1]) and ([1,0],[0,1]) are perpendicular compared to the\n",
    "one used for ([1,1],[0,1])\n"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "<details><summary>Click here for the solution</summary>\n",
    "\n",
    "```python\n",
    "The vectors used for question 4 and 5 are perpendicular. As a result, the dot product is zero. \n",
    "\n",
    "```\n",
    "\n",
    "</details>\n"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Convert the list <code>\\[1, 2, 3]</code> and <code>\\[8, 9, 10]</code> to numpy arrays <code>arr1</code> and <code>arr2</code>. Then perform <code>Addition</code> , <code>Subtraction</code> , <code>Multiplication</code> , <code>Division</code> and <code>Dot Operation</code> on the <code>arr1</code> and <code>arr2</code>.\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 118,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "56"
      ]
     },
     "execution_count": 118,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "# Write your code below and press Shift+Enter to execute\n",
    "arr1 = np.array([1, 2, 3])\n",
    "arr2 = np.array([8, 9, 10])\n",
    "arr3 = np.add(arr1,arr2)\n",
    "arr3\n",
    "\n",
    "arr4 = np.subtract(arr1,arr2)\n",
    "arr4\n",
    "\n",
    "arr5 = np.multiply(arr1,arr2)\n",
    "arr5\n",
    "\n",
    "arr6 = np.divide(arr1,arr2)\n",
    "arr6\n",
    "\n",
    "arr7 = np.dot(arr1,arr2)\n",
    "arr7"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "<details><summary>Click here for the solution</summary>\n",
    "\n",
    "```python\n",
    "arr1 = np.array([1, 2, 3])\n",
    "arr2 = np.array([8, 9, 10])\n",
    "\n",
    "arr3 = np.add(arr1, arr2)\n",
    "arr3\n",
    "\n",
    "arr4 = np.subtract(arr1, arr2)\n",
    "arr4\n",
    "\n",
    "arr5 = np.multiply(arr1, arr2)\n",
    "arr5\n",
    "\n",
    "\n",
    "arr6 = np.divide(arr1, arr2)\n",
    "arr6\n",
    "\n",
    "arr7 = np.dot(arr1, arr2)\n",
    "arr7\n",
    "```\n",
    "\n",
    "</details>\n"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Convert the list <code>\\[1, 2, 3, 4, 5]</code> and <code>\\[6, 7, 8, 9, 10]</code> to numpy arrays <code>arr1</code> and <code>arr2</code>. Then find the even and odd numbers from <code>arr1</code> and <code>arr2</code>.\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 123,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "[2 4]\n",
      "[ 6  8 10]\n",
      "[1 3 5]\n",
      "[7 9]\n"
     ]
    }
   ],
   "source": [
    "# Write your code below and press Shift+Enter to execute\n",
    "arr1 = np.array([1, 2, 3, 4, 5])\n",
    "arr2 = np.array([6, 7, 8, 9, 10])\n",
    " ## print out the even from array1\n",
    "print(arr1[1:5:2]) \n",
    " ## print the even from array 2\n",
    "print (arr2[0:5:2])  \n",
    "\n",
    "## odd numbers from array1\n",
    "print(arr1[0:5:2])\n",
    "## odd number from array2\n",
    "print(arr2[1:5:2])\n",
    "\n",
    "\n",
    "    \n",
    "\n",
    " \n"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "<details><summary>Click here for the solution</summary>\n",
    "\n",
    "```python\n",
    "\n",
    "\n",
    "arr1 = np.array([1, 2, 3, 4, 5])\n",
    "arr2 = np.array([6, 7, 8, 9, 10])\n",
    "\n",
    "#Starting index in slice is 1 as first even element(2) in array1 is at index 1\n",
    "even_arr1 = arr1[1:5:2]\n",
    "print(\"even for array1\",even_arr1)\n",
    "    \n",
    "#Starting index in slice is 0 as first odd element(1) in array1 is at index 0\n",
    "odd_arr1=arr1[0:5:2]\n",
    "print(\"odd for array1\",odd_arr1)\n",
    "\n",
    "#Starting index in slice is 0 as first even element(6) in array2 is at index 0\n",
    "even_arr2 = arr2[0:5:2]\n",
    "print(\"even for array2\",even_arr2)\n",
    "    \n",
    "    \n",
    "#Starting index in slice is 1 as first odd element(7) in array2 is at index 1\n",
    "odd_arr2=arr2[1:5:2]\n",
    "print(\"odd for array2\",odd_arr2)\n",
    "\n",
    "```\n",
    "\n",
    "</details>\n"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "<hr>\n",
    "<h2>The last exercise!</h2>\n",
    "<p>Congratulations, you have completed your first lesson and hands-on lab in Python. \n",
    "<hr>\n"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Author\n",
    "\n",
    "<a href=\"https://www.linkedin.com/in/joseph-s-50398b136/?utm_medium=Exinfluencer&utm_source=Exinfluencer&utm_content=000026UJ&utm_term=10006555&utm_id=NA-SkillsNetwork-Channel-SkillsNetworkCoursesIBMDeveloperSkillsNetworkPY0101ENSkillsNetwork19487395-2021-01-01\" target=\"_blank\">Joseph Santarcangelo</a>\n",
    "\n",
    "## Other contributors\n",
    "\n",
    "<a href=\"https://www.linkedin.com/in/jiahui-mavis-zhou-a4537814a?utm_medium=Exinfluencer&utm_source=Exinfluencer&utm_content=000026UJ&utm_term=10006555&utm_id=NA-SkillsNetwork-Channel-SkillsNetworkCoursesIBMDeveloperSkillsNetworkPY0101ENSkillsNetwork19487395-2021-01-01\">Mavis Zhou</a>\n",
    "\n",
    "## Change Log\n",
    "\n",
    "| Date (YYYY-MM-DD) | Version | Changed By | Change Description                  |\n",
    "| ----------------- | ------- | ---------- | ----------------------------------- |\n",
    "| 2022-03-08        | 2.2     | Niveditha  | Modified and added practice problem |\n",
    "| 2022-01-10        | 2.1     | Malika     | Removed the readme for GitShare     |\n",
    "| 2020-08-26        | 2.0     | Lavanya    | Moved lab to course repo in GitLab  |\n",
    "|                   |         |            |                                     |\n",
    "|                   |         |            |                                     |\n",
    "\n",
    "<hr/>\n",
    "\n",
    "## <h3 align=\"center\"> © IBM Corporation 2020. All rights reserved. <h3/>\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": []
  }
 ],
 "metadata": {
  "kernelspec": {
   "display_name": "Python 3 (ipykernel)",
   "language": "python",
   "name": "python3"
  },
  "language_info": {
   "codemirror_mode": {
    "name": "ipython",
    "version": 3
   },
   "file_extension": ".py",
   "mimetype": "text/x-python",
   "name": "python",
   "nbconvert_exporter": "python",
   "pygments_lexer": "ipython3",
   "version": "3.9.7"
  }
 },
 "nbformat": 4,
 "nbformat_minor": 2
}