PY0101EN-5-1-Numpy1D.ipynb

{
 "cells": [
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "<a href=\"https://cognitiveclass.ai/\">\n",
    "    <img src=\"https://s3-api.us-geo.objectstorage.softlayer.net/cf-courses-data/CognitiveClass/PY0101EN/Ad/CCLog.png\" width=\"200\" align=\"center\">\n",
    "</a>"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "<h1>1D <code>Numpy</code> in Python</h1>"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "<p><strong>Welcome!</strong> This notebook will teach you about using <code>Numpy</code> in the Python Programming Language. By the end of this lab, you'll know what <code>Numpy</code> is and the <code>Numpy</code> operations.</p>"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "<div class=\"alert alert-block alert-info\" style=\"margin-top: 20px\">\n",
    "    <a href=\"https://cocl.us/NotebooksPython101\">\n",
    "         <img src=\"https://s3-api.us-geo.objectstorage.softlayer.net/cf-courses-data/CognitiveClass/PY0101EN/Ad/TopAd.png\" width=\"750\" align=\"center\">\n",
    "    </a>\n",
    "</div>"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "<h2>Table of Contents</h2>\n",
    "<div class=\"alert alert-block alert-info\" style=\"margin-top: 20px\">\n",
    "    <ul>\n",
    "        <li><a href=\"pre\">Preparation</a></li>\n",
    "        <li>\n",
    "            <a href=\"numpy\">What is Numpy?</a>\n",
    "            <ul>\n",
    "                <li><a href=\"type\">Type</a></li>\n",
    "                <li><a href=\"val\">Assign Value</a></li>\n",
    "                <li><a href=\"slice\">Slicing</a></li>\n",
    "                <li><a href=\"list\">Assign Value with List</a></li>\n",
    "                <li><a href=\"other\">Other Attributes</a></li>\n",
    "            </ul>\n",
    "        </li>\n",
    "        <li>\n",
    "            <a href=\"op\">Numpy Array Operations</a>\n",
    "            <ul>\n",
    "                <li><a href=\"add\">Array Addition</a></li>\n",
    "                <li><a href=\"multi\">Array Multiplication</a></li>\n",
    "                <li><a href=\"prod\">Product of Two Numpy Arrays</a></li>\n",
    "                <li><a href=\"dot\">Dot Product</a></li>\n",
    "                <li><a href=\"cons\">Adding Constant to a Numpy Array</a></li>\n",
    "            </ul>\n",
    "        </li>\n",
    "        <li><a href=\"math\">Mathematical Functions</a></li>\n",
    "        <li><a href=\"lin\">Linspace</a></li>\n",
    "    </ul>\n",
    "    <p>\n",
    "        Estimated time needed: <strong>30 min</strong>\n",
    "    </p>\n",
    "</div>\n",
    "\n",
    "<hr>"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "<h2 id=\"pre\">Preparation</h2>"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 1,
   "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  "
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 2,
   "metadata": {
    "collapsed": false,
    "jupyter": {
     "outputs_hidden": false
    }
   },
   "outputs": [],
   "source": [
    "# Plotting functions\n",
    "\n",
    "def Plotvec1(u, z, v):\n",
    "    \n",
    "    ax = plt.axes()\n",
    "    ax.arrow(0, 0, *u, head_width=0.05, color='r', head_length=0.1)\n",
    "    plt.text(*(u + 0.1), 'u')\n",
    "    \n",
    "    ax.arrow(0, 0, *v, head_width=0.05, color='b', head_length=0.1)\n",
    "    plt.text(*(v + 0.1), 'v')\n",
    "    ax.arrow(0, 0, *z, head_width=0.05, head_length=0.1)\n",
    "    plt.text(*(z + 0.1), 'z')\n",
    "    plt.ylim(-2, 2)\n",
    "    plt.xlim(-2, 2)\n",
    "\n",
    "def Plotvec2(a,b):\n",
    "    ax = plt.axes()\n",
    "    ax.arrow(0, 0, *a, head_width=0.05, color ='r', 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)\n",
    "    plt.text(*(b + 0.1), 'b')\n",
    "    plt.ylim(-2, 2)\n",
    "    plt.xlim(-2, 2)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Create a Python List as follows:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 3,
   "metadata": {
    "collapsed": false,
    "jupyter": {
     "outputs_hidden": false
    }
   },
   "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:"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "<img src=\"https://s3-api.us-geo.objectstorage.softlayer.net/cf-courses-data/CognitiveClass/PY0101EN/Chapter%205/Images/NumOneList.png\" width=\"660\" />"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "We can access each element using a square bracket as follows: "
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 4,
   "metadata": {
    "collapsed": false,
    "jupyter": {
     "outputs_hidden": false
    }
   },
   "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>"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "<h2 id=\"numpy\">What is Numpy?</h2>"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "A numpy array is similar to a list. 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: "
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 5,
   "metadata": {
    "collapsed": false,
    "jupyter": {
     "outputs_hidden": false
    }
   },
   "outputs": [],
   "source": [
    "# import numpy library\n",
    "\n",
    "import numpy as np "
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    " We then cast the list as follows:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 6,
   "metadata": {
    "collapsed": false,
    "jupyter": {
     "outputs_hidden": false
    }
   },
   "outputs": [
    {
     "data": {
      "text/plain": [
       "array([0, 1, 2, 3, 4])"
      ]
     },
     "execution_count": 6,
     "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: "
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "<img src=\"https://s3-api.us-geo.objectstorage.softlayer.net/cf-courses-data/CognitiveClass/PY0101EN/Chapter%205/Images/NumOneNp.png\" width=\"500\" />"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    " As with lists, we can access each element via a square bracket:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 7,
   "metadata": {
    "collapsed": false,
    "jupyter": {
     "outputs_hidden": false
    }
   },
   "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": [
    "<h3 id=\"type\">Type</h3>"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "If we check the type of the array we get <b>numpy.ndarray</b>:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 8,
   "metadata": {
    "collapsed": false,
    "jupyter": {
     "outputs_hidden": false
    }
   },
   "outputs": [
    {
     "data": {
      "text/plain": [
       "numpy.ndarray"
      ]
     },
     "execution_count": 8,
     "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 a 64-bit integer: \n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 9,
   "metadata": {
    "collapsed": false,
    "jupyter": {
     "outputs_hidden": false
    }
   },
   "outputs": [
    {
     "data": {
      "text/plain": [
       "dtype('int64')"
      ]
     },
     "execution_count": 9,
     "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": [
    "We can create a numpy array with real numbers:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 10,
   "metadata": {
    "collapsed": false,
    "jupyter": {
     "outputs_hidden": false
    }
   },
   "outputs": [],
   "source": [
    "# Create a numpy array\n",
    "\n",
    "b = np.array([3.1, 11.02, 6.2, 213.2, 5.2])"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "When we check the type of the array we get <b>numpy.ndarray</b>:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 11,
   "metadata": {
    "collapsed": false,
    "jupyter": {
     "outputs_hidden": false
    }
   },
   "outputs": [
    {
     "data": {
      "text/plain": [
       "numpy.ndarray"
      ]
     },
     "execution_count": 11,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "# Check the type of array\n",
    "\n",
    "type(b)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "If we examine the attribute <code>dtype</code> we see float 64, as the elements are not integers: "
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 12,
   "metadata": {
    "collapsed": false,
    "jupyter": {
     "outputs_hidden": false
    }
   },
   "outputs": [
    {
     "data": {
      "text/plain": [
       "dtype('float64')"
      ]
     },
     "execution_count": 12,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "# Check the value type\n",
    "\n",
    "b.dtype"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "<h3 id=\"val\">Assign value</h3>"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "We can change the value of the array, consider the array <code>c</code>:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 13,
   "metadata": {
    "collapsed": false,
    "jupyter": {
     "outputs_hidden": false
    }
   },
   "outputs": [
    {
     "data": {
      "text/plain": [
       "array([20,  1,  2,  3,  4])"
      ]
     },
     "execution_count": 13,
     "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:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 14,
   "metadata": {
    "collapsed": false,
    "jupyter": {
     "outputs_hidden": false
    }
   },
   "outputs": [
    {
     "data": {
      "text/plain": [
       "array([100,   1,   2,   3,   4])"
      ]
     },
     "execution_count": 14,
     "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:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 15,
   "metadata": {
    "collapsed": false,
    "jupyter": {
     "outputs_hidden": false
    }
   },
   "outputs": [
    {
     "data": {
      "text/plain": [
       "array([100,   1,   2,   3,   0])"
      ]
     },
     "execution_count": 15,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "# Assign the 5th element to 0\n",
    "\n",
    "c[4] = 0\n",
    "c"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "<h3 id=\"slice\">Slicing</h3>"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Like lists, we can slice the numpy array, and we can select the elements from 1 to 3 and assign it to a new numpy array <code>d</code> as follows:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 16,
   "metadata": {
    "collapsed": false,
    "jupyter": {
     "outputs_hidden": false
    }
   },
   "outputs": [
    {
     "data": {
      "text/plain": [
       "array([1, 2, 3])"
      ]
     },
     "execution_count": 16,
     "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: "
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 17,
   "metadata": {
    "collapsed": false,
    "jupyter": {
     "outputs_hidden": false
    }
   },
   "outputs": [
    {
     "data": {
      "text/plain": [
       "array([100,   1,   2, 300, 400])"
      ]
     },
     "execution_count": 17,
     "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": [
    "<h3 id=\"list\">Assign Value with List</h3>"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Similarly, we can use a list to select a specific index.\n",
    "The list ' select ' contains several values:\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 18,
   "metadata": {},
   "outputs": [],
   "source": [
    "# Create the index list\n",
    "\n",
    "select = [0, 2, 3]"
   ]
  },
  {
   "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 index:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 19,
   "metadata": {
    "collapsed": false,
    "jupyter": {
     "outputs_hidden": false
    }
   },
   "outputs": [
    {
     "data": {
      "text/plain": [
       "array([100,   2, 300])"
      ]
     },
     "execution_count": 19,
     "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:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 20,
   "metadata": {
    "collapsed": false,
    "jupyter": {
     "outputs_hidden": false
    }
   },
   "outputs": [
    {
     "data": {
      "text/plain": [
       "array([100000,      1, 100000, 100000,    400])"
      ]
     },
     "execution_count": 20,
     "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>"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Let's review some basic array attributes using the array <code>a</code>:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 21,
   "metadata": {
    "collapsed": false,
    "jupyter": {
     "outputs_hidden": false
    }
   },
   "outputs": [
    {
     "data": {
      "text/plain": [
       "array([0, 1, 2, 3, 4])"
      ]
     },
     "execution_count": 21,
     "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:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 22,
   "metadata": {
    "collapsed": false,
    "jupyter": {
     "outputs_hidden": false
    }
   },
   "outputs": [
    {
     "data": {
      "text/plain": [
       "5"
      ]
     },
     "execution_count": 22,
     "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:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 23,
   "metadata": {
    "collapsed": false,
    "jupyter": {
     "outputs_hidden": false
    }
   },
   "outputs": [
    {
     "data": {
      "text/plain": [
       "1"
      ]
     },
     "execution_count": 23,
     "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:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 24,
   "metadata": {
    "collapsed": false,
    "jupyter": {
     "outputs_hidden": false
    }
   },
   "outputs": [
    {
     "data": {
      "text/plain": [
       "(5,)"
      ]
     },
     "execution_count": 24,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "# Get the shape/size of numpy array\n",
    "\n",
    "a.shape"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 25,
   "metadata": {},
   "outputs": [],
   "source": [
    "# Create a numpy array\n",
    "\n",
    "a = np.array([1, -1, 1, -1])"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 26,
   "metadata": {
    "collapsed": false,
    "jupyter": {
     "outputs_hidden": false
    }
   },
   "outputs": [
    {
     "data": {
      "text/plain": [
       "0.0"
      ]
     },
     "execution_count": 26,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "# Get the mean of numpy array\n",
    "\n",
    "mean = a.mean()\n",
    "mean"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 27,
   "metadata": {
    "collapsed": false,
    "jupyter": {
     "outputs_hidden": false
    }
   },
   "outputs": [
    {
     "data": {
      "text/plain": [
       "1.0"
      ]
     },
     "execution_count": 27,
     "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": 28,
   "metadata": {
    "collapsed": false,
    "jupyter": {
     "outputs_hidden": false
    }
   },
   "outputs": [
    {
     "data": {
      "text/plain": [
       "array([-1,  2,  3,  4,  5])"
      ]
     },
     "execution_count": 28,
     "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": 29,
   "metadata": {
    "collapsed": false,
    "jupyter": {
     "outputs_hidden": false
    }
   },
   "outputs": [
    {
     "data": {
      "text/plain": [
       "5"
      ]
     },
     "execution_count": 29,
     "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": 30,
   "metadata": {
    "collapsed": false,
    "jupyter": {
     "outputs_hidden": false
    }
   },
   "outputs": [
    {
     "data": {
      "text/plain": [
       "-1"
      ]
     },
     "execution_count": 30,
     "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": [
    "<hr>"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "<h2 id=\"op\">Numpy Array Operations</h2>"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "<h3 id=\"add\">Array Addition</h3>"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Consider the numpy array <code>u</code>:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 31,
   "metadata": {
    "collapsed": false,
    "jupyter": {
     "outputs_hidden": false
    }
   },
   "outputs": [
    {
     "data": {
      "text/plain": [
       "array([1, 0])"
      ]
     },
     "execution_count": 31,
     "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>:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 32,
   "metadata": {
    "collapsed": false,
    "jupyter": {
     "outputs_hidden": false
    }
   },
   "outputs": [
    {
     "data": {
      "text/plain": [
       "array([0, 1])"
      ]
     },
     "execution_count": 32,
     "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:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 33,
   "metadata": {
    "collapsed": false,
    "jupyter": {
     "outputs_hidden": false
    }
   },
   "outputs": [
    {
     "data": {
      "text/plain": [
       "array([1, 1])"
      ]
     },
     "execution_count": 33,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "# Numpy Array Addition\n",
    "\n",
    "z = u + v\n",
    "z"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    " The operation is equivalent to vector addition:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 34,
   "metadata": {
    "collapsed": false,
    "jupyter": {
     "outputs_hidden": false
    }
   },
   "outputs": [
    {
     "data": {
      "image/png": "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\n",
      "text/plain": [
       "<Figure size 432x288 with 1 Axes>"
      ]
     },
     "metadata": {
      "needs_background": "light"
     },
     "output_type": "display_data"
    }
   ],
   "source": [
    "# Plot numpy arrays\n",
    "\n",
    "Plotvec1(u, z, v)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "<h3 id=\"multi\">Array Multiplication</h3>"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Consider the vector numpy array <code>y</code>:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 35,
   "metadata": {
    "collapsed": false,
    "jupyter": {
     "outputs_hidden": false
    }
   },
   "outputs": [
    {
     "data": {
      "text/plain": [
       "array([1, 2])"
      ]
     },
     "execution_count": 35,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "# Create a numpy array\n",
    "\n",
    "y = np.array([1, 2])\n",
    "y"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "We can multiply every element in the array by 2:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 36,
   "metadata": {
    "collapsed": false,
    "jupyter": {
     "outputs_hidden": false
    }
   },
   "outputs": [
    {
     "data": {
      "text/plain": [
       "array([2, 4])"
      ]
     },
     "execution_count": 36,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "# Numpy Array Multiplication\n",
    "\n",
    "z = 2 * y\n",
    "z"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    " This is equivalent to multiplying a vector by a scaler: "
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "<h3 id=\"prod\">Product of Two Numpy Arrays</h3>"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Consider the following array <code>u</code>:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 37,
   "metadata": {
    "collapsed": false,
    "jupyter": {
     "outputs_hidden": false
    }
   },
   "outputs": [
    {
     "data": {
      "text/plain": [
       "array([1, 2])"
      ]
     },
     "execution_count": 37,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "# Create a numpy array\n",
    "\n",
    "u = np.array([1, 2])\n",
    "u"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Consider the following array <code>v</code>:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 38,
   "metadata": {
    "collapsed": false,
    "jupyter": {
     "outputs_hidden": false
    }
   },
   "outputs": [
    {
     "data": {
      "text/plain": [
       "array([3, 2])"
      ]
     },
     "execution_count": 38,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "# Create a numpy array\n",
    "\n",
    "v = np.array([3, 2])\n",
    "v"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    " The product of the two numpy arrays <code>u</code> and <code>v</code> is given by:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 39,
   "metadata": {
    "collapsed": false,
    "jupyter": {
     "outputs_hidden": false
    }
   },
   "outputs": [
    {
     "data": {
      "text/plain": [
       "array([3, 4])"
      ]
     },
     "execution_count": 39,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "# Calculate the production of two numpy arrays\n",
    "\n",
    "z = u * v\n",
    "z"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "<h3 id=\"dot\">Dot Product</h3>"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "The dot product of the two numpy arrays <code>u</code> and <code>v</code> is given by:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 40,
   "metadata": {
    "collapsed": false,
    "jupyter": {
     "outputs_hidden": false
    }
   },
   "outputs": [
    {
     "data": {
      "text/plain": [
       "7"
      ]
     },
     "execution_count": 40,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "# Calculate the dot product\n",
    "\n",
    "np.dot(u, v)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "<h3 id=\"cons\">Adding Constant to a Numpy Array</h3>"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Consider the following array: "
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 41,
   "metadata": {
    "collapsed": false,
    "jupyter": {
     "outputs_hidden": false
    }
   },
   "outputs": [
    {
     "data": {
      "text/plain": [
       "array([ 1,  2,  3, -1])"
      ]
     },
     "execution_count": 41,
     "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:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 42,
   "metadata": {
    "collapsed": false,
    "jupyter": {
     "outputs_hidden": false
    }
   },
   "outputs": [
    {
     "data": {
      "text/plain": [
       "array([2, 3, 4, 0])"
      ]
     },
     "execution_count": 42,
     "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:"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "<img src=\"https://s3-api.us-geo.objectstorage.softlayer.net/cf-courses-data/CognitiveClass/PY0101EN/Chapter%205/Images/NumOneAdd.gif\" width=\"500\" />"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "<hr>"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "<h2 id=\"math\">Mathematical Functions</h2>"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    " We can access the value of pie in numpy as follows :"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 43,
   "metadata": {
    "collapsed": false,
    "jupyter": {
     "outputs_hidden": false
    }
   },
   "outputs": [
    {
     "data": {
      "text/plain": [
       "3.141592653589793"
      ]
     },
     "execution_count": 43,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "# The value of pie\n",
    "\n",
    "np.pi"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    " We can create the following numpy array in Radians:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 44,
   "metadata": {
    "collapsed": false,
    "jupyter": {
     "outputs_hidden": false
    }
   },
   "outputs": [],
   "source": [
    "# Create the numpy array in radians\n",
    "\n",
    "x = np.array([0, np.pi/2 , np.pi])"
   ]
  },
  {
   "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:  "
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 45,
   "metadata": {
    "collapsed": false,
    "jupyter": {
     "outputs_hidden": false
    }
   },
   "outputs": [
    {
     "data": {
      "text/plain": [
       "array([0.0000000e+00, 1.0000000e+00, 1.2246468e-16])"
      ]
     },
     "execution_count": 45,
     "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>"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "<h2 id=\"lin\">Linspace</h2>"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    " A useful function for plotting mathematical functions is \"linespace\".   Linespace returns evenly spaced numbers over a specified interval. We specify the starting point of the sequence and the ending point of the sequence. The parameter \"num\" indicates the Number of samples to generate, in this case 5:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 46,
   "metadata": {
    "collapsed": false,
    "jupyter": {
     "outputs_hidden": false
    }
   },
   "outputs": [
    {
     "data": {
      "text/plain": [
       "array([-2., -1.,  0.,  1.,  2.])"
      ]
     },
     "execution_count": 46,
     "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: "
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 47,
   "metadata": {
    "collapsed": false,
    "jupyter": {
     "outputs_hidden": false
    }
   },
   "outputs": [
    {
     "data": {
      "text/plain": [
       "array([-2. , -1.5, -1. , -0.5,  0. ,  0.5,  1. ,  1.5,  2. ])"
      ]
     },
     "execution_count": 47,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "# Makeup 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 line space to generate 100 evenly spaced samples from the interval 0 to 2π: "
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 48,
   "metadata": {
    "collapsed": false,
    "jupyter": {
     "outputs_hidden": false
    }
   },
   "outputs": [],
   "source": [
    "# Makeup 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>: "
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 49,
   "metadata": {},
   "outputs": [],
   "source": [
    "# Calculate the sine of x list\n",
    "\n",
    "y = np.sin(x)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 50,
   "metadata": {
    "collapsed": false,
    "jupyter": {
     "outputs_hidden": false
    }
   },
   "outputs": [
    {
     "data": {
      "text/plain": [
       "[<matplotlib.lines.Line2D at 0x7fd7f0dd5f28>]"
      ]
     },
     "execution_count": 50,
     "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": [
    "<hr>"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "<h2 id=\"quiz\">Quiz on 1D Numpy Array</h2>"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Implement the following vector subtraction in numpy: u-v"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 56,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "array([ 1, -1])"
      ]
     },
     "execution_count": 56,
     "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",
    "X = u-v\n",
    "X"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Double-click __here__ for the solution.\n",
    "\n",
    "<!-- Your answer is below:\n",
    "u - v\n",
    "-->"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "<hr>"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Multiply the numpy array z with -2:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 60,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "array([-4, -8])"
      ]
     },
     "execution_count": 60,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "# Write your code below and press Shift+Enter to execute\n",
    "\n",
    "z = np.array([2, 4])\n",
    "x = -2 * z\n",
    "x"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Double-click __here__ for the solution.\n",
    "\n",
    "<!-- Your answer is below:\n",
    "-2 * z\n",
    "-->"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "<hr>"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Consider the list <code>[1, 2, 3, 4, 5]</code> and <code>[1, 0, 1, 0, 1]</code>, and cast both lists to a numpy array then multiply them together:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 64,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "array([1, 0, 3, 0, 5])"
      ]
     },
     "execution_count": 64,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "# Write your code below and press Shift+Enter to execute\n",
    "a = np.array([1,2,3,4,5])\n",
    "b = np.array([1,0,1,0,1])\n",
    "c = a * b\n",
    "c"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Double-click __here__ for the solution.\n",
    "\n",
    "<!-- Your answer is below:\n",
    "a = np.array([1, 2, 3, 4, 5])\n",
    "b = np.array([1, 0, 1, 0, 1])\n",
    "a * b\n",
    "-->"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "<hr>"
   ]
  },
  {
   "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 the dot product:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 67,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "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": [
    "# 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(np.dot(a, b))"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Double-click __here__ for the solution.\n",
    "\n",
    "<!-- Your answer is below:\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": [
    "<hr>"
   ]
  },
  {
   "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 the dot product:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 68,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "0\n"
     ]
    },
    {
     "data": {
      "image/png": "iVBORw0KGgoAAAANSUhEUgAAAYQAAAD8CAYAAAB3u9PLAAAABHNCSVQICAgIfAhkiAAAAAlwSFlzAAALEgAACxIB0t1+/AAAADh0RVh0U29mdHdhcmUAbWF0cGxvdGxpYiB2ZXJzaW9uMy4xLjEsIGh0dHA6Ly9tYXRwbG90bGliLm9yZy8QZhcZAAASdUlEQVR4nO3dbYyd5X3n8e8PsBNhQIRggjF2kqrWBoicLQyOWaKVqyaRsaI1aUhF1GzcpNIoKKittC/CLkr6drsrVSqbB3ZWRQUJkVZpnVgb8xg1cpEgZUzBsbFdXMTGlt3YhMgBmZQ4/PfFudJMhzOeGZ97zhmb70c6OvfDde7rr4vx+XE/nlQVkiSdM+oCJEmLg4EgSQIMBElSYyBIkgADQZLUGAiSJKCDQEiyKsnfJtmbZE+SP+zTJknuSnIgya4k1w7arySpW+d1sI2TwH+pqqeTXAjsTPJoVT03pc1NwJr2+iDw9fYuSVokBt5DqKojVfV0m34F2AusnNZsM3Bf9TwJXJxkxaB9S5K608Uewr9K8h7gN4DvT1u1Ejg4Zf5QW3akzzbGgXGAZcuWXfe+972vyxIl6ay2c+fOl6pq+el8trNASHIB8NfAH1XVT6ev7vORvs/MqKoJYAJgbGysJicnuypRks56Sf7f6X62k6uMkiyhFwb3V9Xf9GlyCFg1Zf5K4HAXfUuSutHFVUYB/hzYW1V/OkOzbcBn2tVG64HjVfWmw0WSpNHp4pDRjcB/Bn6Q5Jm27L8BqwGq6m5gO7AJOACcAD7bQb+SpA4NHAhV9Tj9zxFMbVPAFwbtS5K0cLxTWZIEGAiSpMZAkCQBBoIkqTEQJEmAgSBJagwESRJgIEiSGgNBkgQYCJKkxkCQJAEGgiSpMRAkSYCBIElqDARJEmAgSJIaA0GSBBgIkqSmk0BIck+So0l2z7B+Q5LjSZ5pry930a8kqTsD/6Zy8xfAV4D7TtHm76rqYx31J0nqWCd7CFW1A3i5i21JkkZjmOcQbkjybJIHk1wzxH4lSXPQ1SGj2TwNvLuqXk2yCfgWsKZfwyTjwDjA6tWrh1SeJGkoewhV9dOqerVNbweWJLl0hrYTVTVWVWPLly8fRnmSJIYUCEkuT5I2va71++Nh9C1JmptODhkleQDYAFya5BDwx8ASgKq6G7gFuC3JSeA14Naqqi76liR1o5NAqKpPzbL+K/QuS5UkLVLeqSxJAgwESVJjIEiSAANBktQYCJIkwECQJDUGgiQJMBAkSY2BIEkCDARpwbz44ou8//3vH3UZ0pwZCJIkwECQFtTJkyfZsmULa9eu5ZZbbuHEiROjLkmakYEgLaD9+/czPj7Orl27uOiii/ja17426pKkGRkI0gJatWoVN954IwCf/vSnefzxx0dckTQzA0FaQO13oWaclxYTA0FaQD/84Q954oknAHjggQf40Ic+NOKKpJkZCNI8/e7vwm23za3tVVddxb333svatWt5+eWXuW2uH5RGIIv5lyzHxsZqcnJy1GVI/+onP4EVK+Ccc+Cll+D880ddkfRvJdlZVWOn81n3EKR5uP9+OPfc3uub3xx1NVK3OgmEJPckOZpk9wzrk+SuJAeS7EpybRf9SsP2Z38GJ07Aq6/2pqWzSVd7CH8BbDzF+puANe01Dny9o36lofmHf4DDh381/9xzcODA6OqRutZJIFTVDuDlUzTZDNxXPU8CFydZ0UXf0rA89BD8/Oe/mv/FL+CRR0ZXj9S1YZ1DWAkcnDJ/qC17kyTjSSaTTB47dmwoxUlz8Qd/ADt2/Gp+xw743OdGV4/UtWEFQr+7cfpe3lRVE1U1VlVjy5cvX+CypLlbtgzWr+9NX3BBb/rtbx9tTVKXhhUIh4BVU+avBA7P0FaSNALDCoRtwGfa1UbrgeNVdWRIfUuS5uC8LjaS5AFgA3BpkkPAHwNLAKrqbmA7sAk4AJwAPttFv5Kk7nQSCFX1qVnWF/CFLvqSJC0M71SWJAEGgiSpMRAkSYCBIElqDARJEmAgSJIaA0GSBBgIkqTGQJAkAQaCJKkxECRJgIEgSWoMBEkSYCBIkhoDQZIEGAiSpMZAkCQBBoIkqekkEJJsTLI/yYEkd/RZvyHJ8STPtNeXu+hXktSdgX9TOcm5wFeBjwCHgKeSbKuq56Y1/buq+tig/UmSFkYXewjrgANV9UJVvQ58A9jcwXYlSUPURSCsBA5OmT/Ulk13Q5JnkzyY5JqZNpZkPMlkksljx451UJ4kaS66CIT0WVbT5p8G3l1VHwD+F/CtmTZWVRNVNVZVY8uXL++gPEnSXHQRCIeAVVPmrwQOT21QVT+tqlfb9HZgSZJLO+hbktSRLgLhKWBNkvcmWQrcCmyb2iDJ5UnSpte1fn/cQd+SpI4MfJVRVZ1McjvwMHAucE9V7Uny+bb+buAW4LYkJ4HXgFuravphJUnSCGUxfy+PjY3V5OTkqMuQ/o0ELrgAXnll1JVIb5ZkZ1WNnc5nvVNZkgQYCJKkxkCQJAEGgiSpMRAkSYCBIElqDARJEmAgSJIaA0GSBBgIkqTGQJB0xrj55pu57rrruOaaa5iYmBh1OWedgR9uJ0nDcs8993DJJZfw2muvcf311/OJT3yCd77znaMu66xhIEg6Y9x1111s3boVgIMHD/L8888bCB0yECSdEb73ve/x2GOP8cQTT3D++eezYcMGfvazn426rLOK5xAknRGOHz/OO97xDs4//3z27dvHk08+OeqSzjoGgqQzwsaNGzl58iRr167lS1/6EuvXrx91SWcdDxlJOiO87W1v48EHHxx1GWc19xAkSUBHgZBkY5L9SQ4kuaPP+iS5q63fleTaLvqVJHVn4ENGSc4Fvgp8BDgEPJVkW1U9N6XZTcCa9vog8PX2Lumt7otfhN274frr4Zpr4OqrYc0aWLp01JW95XRxDmEdcKCqXgBI8g1gMzA1EDYD91VVAU8muTjJiqo60kH/0lAtXVJc/PpRuGrDqEs5O+zb13t/6CFYtqw3/dprcNllcNVVcN11cOedcNFFo6vxLaKLQFgJHJwyf4g3/99/vzYrgTcFQpJxYBxg9erVHZQndWvH/9nP23/vd371RaZuvPEGnDjRC4WlS+Gf/xkSOOcceP31UVf3ltBFIKTPsjqNNr2FVRPABMDY2FjfNtIofXDL+2DLrlGXcfa45RZ4+une4aKph41+/ddhyZJRV/eW0kUgHAJWTZm/Ejh8Gm0kvRV985ujrkBNF1cZPQWsSfLeJEuBW4Ft09psAz7TrjZaDxz3/IEkLS4D7yFU1ckktwMPA+cC91TVniSfb+vvBrYDm4ADwAngs4P2K0nqVid3KlfVdnpf+lOX3T1luoAvdNGXJGlheKeyJAkwECRJjYEgSQIMBElSYyBIkgADQZLUGAiSJMBAkCQ1BoIkCTAQJEmNgSBJAgwESVJjIEiSAANBktQYCJIkwECQJDUGgiQJMBAkSc1AP6GZ5BLgL4H3AC8Cv1NVP+nT7kXgFeAXwMmqGhukX0lS9wbdQ7gD+G5VrQG+2+Zn8ptV9e8NA0lanAYNhM3AvW36XuDmAbcnSRqRQQPhXVV1BKC9XzZDuwIeSbIzyfipNphkPMlkksljx44NWJ4kaa5mPYeQ5DHg8j6r7pxHPzdW1eEklwGPJtlXVTv6NayqCWACYGxsrObRhyRpALMGQlV9eKZ1SX6UZEVVHUmyAjg6wzYOt/ejSbYC64C+gSBJGo1BDxltA7a06S3At6c3SLIsyYW/nAY+CuwesF9JUscGDYT/DnwkyfPAR9o8Sa5Isr21eRfweJJngb8HvlNVDw3YrySpYwPdh1BVPwZ+q8/yw8CmNv0C8IFB+pEkLTzvVJYkAQaCJKkxECRJgIEgSWoMBEkSYCBIkhoDQZIEGAiSpMZAkCQBBoIkqTEQJEmAgSBJagwESRJgIEiSGgNBkgQYCJKkxkCQJAEGgiSpGSgQknwyyZ4kbyQZO0W7jUn2JzmQ5I5B+pQkLYxB9xB2A78N7JipQZJzga8CNwFXA59KcvWA/UqSOnbeIB+uqr0ASU7VbB1woKpeaG2/AWwGnhukb0lSt4ZxDmElcHDK/KG2rK8k40kmk0weO3ZswYuTJPXMuoeQ5DHg8j6r7qyqb8+hj367DzVT46qaACYAxsbGZmwnSerWrIFQVR8esI9DwKop81cChwfcpiSpY8M4ZPQUsCbJe5MsBW4Ftg2hX0nSPAx62enHkxwCbgC+k+ThtvyKJNsBquokcDvwMLAX+Kuq2jNY2ZKkrg16ldFWYGuf5YeBTVPmtwPbB+lLkrSwvFNZkgQYCJKkxkCQJAEGgiSpMRAkSYCBIElqDARJEmAgSJIaA0GSBBgIkqTGQJAkAQaCJKkxECRJgIEgSWoMBEkSYCBIkhoDQZIEGAiSpGbQ31T+ZJI9Sd5IMnaKdi8m+UGSZ5JMDtKnJGlhDPSbysBu4LeB/z2Htr9ZVS8N2J8kaYEMFAhVtRcgSTfVSJJGZljnEAp4JMnOJOND6lOSNA+z7iEkeQy4vM+qO6vq23Ps58aqOpzkMuDRJPuqascM/Y0D4wCrV6+e4+YlSYOaNRCq6sODdlJVh9v70SRbgXVA30CoqglgAmBsbKwG7VuSNDcLfsgoybIkF/5yGvgovZPRkqRFZNDLTj+e5BBwA/CdJA+35Vck2d6avQt4PMmzwN8D36mqhwbpV5LUvUGvMtoKbO2z/DCwqU2/AHxgkH4kSQvPO5UlSYCBIElqDARJEmAgSJIaA0GSBBgIkqTGQJAkAQaCJKkxECRJgIEgSWoMBEkSYCBIkhoDQZIEGAiSpMZAkCQBBoIkqTEQJEmAgSBJagwESRIwYCAk+Z9J9iXZlWRrkotnaLcxyf4kB5LcMUifkqSFMegewqPA+6tqLfCPwH+d3iDJucBXgZuAq4FPJbl6wH4lSR0bKBCq6pGqOtlmnwSu7NNsHXCgql6oqteBbwCbB+lXktS98zrc1ueAv+yzfCVwcMr8IeCDM20kyTgw3mb/JcnuzipcGJcCL426iDmwzm5ZZ7esszv/7nQ/OGsgJHkMuLzPqjur6tutzZ3ASeD+fpvos6xm6q+qJoCJtt3JqhqbrcZROhNqBOvsmnV2yzq7k2TydD87ayBU1Ydn6XwL8DHgt6qq3xf9IWDVlPkrgcPzKVKStPAGvcpoI/BF4D9V1YkZmj0FrEny3iRLgVuBbYP0K0nq3qBXGX0FuBB4NMkzSe4GSHJFku0A7aTz7cDDwF7gr6pqzxy3PzFgfcNwJtQI1tk16+yWdXbntGtM/6M8kqS3Gu9UliQBBoIkqVk0gXCmPAYjySeT7EnyRpIZLz9L8mKSH7RzK6d9Gdjpmkedox7PS5I8muT59v6OGdqNZDxnG5/03NXW70py7bBqm0eNG5Icb2P3TJIvD7vGVsc9SY7OdG/RYhjLVsdsdY58PJOsSvK3Sfa2f+d/2KfN/MezqhbFC/gocF6b/hPgT/q0ORf4J+DXgKXAs8DVQ67zKno3fnwPGDtFuxeBS0c4nrPWuUjG838Ad7TpO/r9dx/VeM5lfIBNwIP07rdZD3x/Eda4Afi/o/pbnFLHfwSuBXbPsH6kYzmPOkc+nsAK4No2fSG9RwcN/Le5aPYQ6gx5DEZV7a2q/cPs83TMsc6Rj2fr7942fS9w85D7P5W5jM9m4L7qeRK4OMmKRVbjolBVO4CXT9Fk1GMJzKnOkauqI1X1dJt+hd4VnCunNZv3eC6aQJjmc/SSbbp+j8GYPgiLRQGPJNnZHsexGC2G8XxXVR2B3h85cNkM7UYxnnMZn1GP4Vz7vyHJs0keTHLNcEqbt1GP5XwsmvFM8h7gN4DvT1s17/Hs8llGsxr2YzBO11zqnIMbq+pwksvo3aexr/2fR2c6qHPk4zmPzSz4ePYxl/EZyhiewlz6fxp4d1W9mmQT8C1gzYJXNn+jHsu5WjTjmeQC4K+BP6qqn05f3ecjpxzPoQZCnSGPwZitzjlu43B7P5pkK71d+06/wDqoc+TjmeRHSVZU1ZG2O3t0hm0s+Hj2MZfxGfWjWWbtf+oXRVVtT/K1JJdW1WJ7SNuox3JOFst4JllCLwzur6q/6dNk3uO5aA4Z5Sx6DEaSZUku/OU0vRPmi/GprYthPLcBW9r0FuBNezYjHM+5jM824DPtio71wPFfHgIbkllrTHJ5krTpdfT+3f94iDXO1ajHck4Ww3i2/v8c2FtVfzpDs/mP5yjPlE87I36A3vGuZ9rr7rb8CmD7tDPn/0jvyoo7R1Dnx+kl778APwIenl4nvSs+nm2vPYu1zkUynu8Evgs8394vWUzj2W98gM8Dn2/TofcDUP8E/IBTXHk2whpvb+P2LL0LNv7DsGtsdTwAHAF+3v42f3+xjeUc6xz5eAIfonf4Z9eU78xNg46nj66QJAGL6JCRJGm0DARJEmAgSJIaA0GSBBgIkqTGQJAkAQaCJKn5/6zAqxiW9oYdAAAAAElFTkSuQmCC\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, 0])\n",
    "b = np.array([0, 1])\n",
    "Plotvec2(a, b)\n",
    "print(np.dot(a, b))"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Double-click __here__ for the solution.\n",
    "\n",
    "<!-- \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": [
    "<hr>"
   ]
  },
  {
   "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 the dot product:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 69,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "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(np.dot(a, b))"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Double-click __here__ for the solution.\n",
    "\n",
    "<!-- \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",
    "print(\"The dot product is\", np.dot(a, b))\n",
    " -->"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "<hr>"
   ]
  },
  {
   "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>"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Write your code below and press Shift+Enter to execute\n",
    "\n",
    "vector 4 & 5 are perpendicular. As a result , dot product is zero"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Double-click __here__ for the solution.\n",
    "\n",
    "<!-- \n",
    "The vectors used for question 4 and 5 are perpendicular. As a result, the dot product is zero. \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. However, there is one more thing you need to do. The Data Science community encourages sharing work. The best way to share and showcase your work is to share it on GitHub. By sharing your notebook on GitHub you are not only building your reputation with fellow data scientists, but you can also show it off when applying for a job. Even though this was your first piece of work, it is never too early to start building good habits. So, please read and follow <a href=\"https://cognitiveclass.ai/blog/data-scientists-stand-out-by-sharing-your-notebooks/\" target=\"_blank\">this article</a> to learn how to share your work.\n",
    "<hr>"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "<div class=\"alert alert-block alert-info\" style=\"margin-top: 20px\">\n",
    "<h2>Get IBM Watson Studio free of charge!</h2>\n",
    "    <p><a href=\"https://cocl.us/NotebooksPython101bottom\"><img src=\"https://s3-api.us-geo.objectstorage.softlayer.net/cf-courses-data/CognitiveClass/PY0101EN/Ad/BottomAd.png\" width=\"750\" align=\"center\"></a></p>\n",
    "</div>"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "<h3>About the Authors:</h3>  \n",
    "<p><a href=\"https://www.linkedin.com/in/joseph-s-50398b136/\" target=\"_blank\">Joseph Santarcangelo</a> is a Data Scientist at IBM, and holds a PhD in Electrical Engineering. His research focused on using Machine Learning, Signal Processing, and Computer Vision to determine how videos impact human cognition. Joseph has been working for IBM since he completed his PhD.</p>"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Other contributors: <a href=\"www.linkedin.com/in/jiahui-mavis-zhou-a4537814a\">Mavis Zhou</a>"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "<hr>"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "<p>Copyright &copy; 2018 IBM Developer Skills Network. This notebook and its source code are released under the terms of the <a href=\"https://cognitiveclass.ai/mit-license/\">MIT License</a>.</p>"
   ]
  }
 ],
 "metadata": {
  "kernelspec": {
   "display_name": "Python",
   "language": "python",
   "name": "conda-env-python-py"
  },
  "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.6.10"
  }
 },
 "nbformat": 4,
 "nbformat_minor": 4
}