5.1-Numpy1D.ipynb

{
 "cells": [
  {
   "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": [
    "<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": [
    "<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": 7,
   "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": 8,
   "metadata": {
    "collapsed": false,
    "jupyter": {
     "outputs_hidden": false
    }
   },
   "outputs": [
    {
     "data": {
      "text/plain": [
       "array([0, 1, 2, 3, 4])"
      ]
     },
     "execution_count": 8,
     "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": 9,
   "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": 10,
   "metadata": {
    "collapsed": false,
    "jupyter": {
     "outputs_hidden": false
    }
   },
   "outputs": [
    {
     "data": {
      "text/plain": [
       "numpy.ndarray"
      ]
     },
     "execution_count": 10,
     "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": 11,
   "metadata": {
    "collapsed": false,
    "jupyter": {
     "outputs_hidden": false
    }
   },
   "outputs": [
    {
     "data": {
      "text/plain": [
       "dtype('int64')"
      ]
     },
     "execution_count": 11,
     "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": 12,
   "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": 13,
   "metadata": {
    "collapsed": false,
    "jupyter": {
     "outputs_hidden": false
    }
   },
   "outputs": [
    {
     "data": {
      "text/plain": [
       "numpy.ndarray"
      ]
     },
     "execution_count": 13,
     "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": 14,
   "metadata": {
    "collapsed": false,
    "jupyter": {
     "outputs_hidden": false
    }
   },
   "outputs": [
    {
     "data": {
      "text/plain": [
       "dtype('float64')"
      ]
     },
     "execution_count": 14,
     "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": 15,
   "metadata": {
    "collapsed": false,
    "jupyter": {
     "outputs_hidden": false
    }
   },
   "outputs": [
    {
     "data": {
      "text/plain": [
       "array([20,  1,  2,  3,  4])"
      ]
     },
     "execution_count": 15,
     "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": 16,
   "metadata": {
    "collapsed": false,
    "jupyter": {
     "outputs_hidden": false
    }
   },
   "outputs": [
    {
     "data": {
      "text/plain": [
       "array([100,   1,   2,   3,   4])"
      ]
     },
     "execution_count": 16,
     "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": 17,
   "metadata": {
    "collapsed": false,
    "jupyter": {
     "outputs_hidden": false
    }
   },
   "outputs": [
    {
     "data": {
      "text/plain": [
       "array([100,   1,   2,   3,   0])"
      ]
     },
     "execution_count": 17,
     "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": 18,
   "metadata": {
    "collapsed": false,
    "jupyter": {
     "outputs_hidden": false
    }
   },
   "outputs": [
    {
     "data": {
      "text/plain": [
       "array([1, 2, 3])"
      ]
     },
     "execution_count": 18,
     "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": 19,
   "metadata": {
    "collapsed": false,
    "jupyter": {
     "outputs_hidden": false
    }
   },
   "outputs": [
    {
     "data": {
      "text/plain": [
       "array([100,   1,   2, 300, 400])"
      ]
     },
     "execution_count": 19,
     "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": 20,
   "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": 21,
   "metadata": {
    "collapsed": false,
    "jupyter": {
     "outputs_hidden": false
    }
   },
   "outputs": [
    {
     "data": {
      "text/plain": [
       "array([100,   2, 300])"
      ]
     },
     "execution_count": 21,
     "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": 22,
   "metadata": {
    "collapsed": false,
    "jupyter": {
     "outputs_hidden": false
    }
   },
   "outputs": [
    {
     "data": {
      "text/plain": [
       "array([100000,      1, 100000, 100000,    400])"
      ]
     },
     "execution_count": 22,
     "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": 23,
   "metadata": {
    "collapsed": false,
    "jupyter": {
     "outputs_hidden": false
    }
   },
   "outputs": [
    {
     "data": {
      "text/plain": [
       "array([0, 1, 2, 3, 4])"
      ]
     },
     "execution_count": 23,
     "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": 24,
   "metadata": {
    "collapsed": false,
    "jupyter": {
     "outputs_hidden": false
    }
   },
   "outputs": [
    {
     "data": {
      "text/plain": [
       "5"
      ]
     },
     "execution_count": 24,
     "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": 25,
   "metadata": {
    "collapsed": false,
    "jupyter": {
     "outputs_hidden": false
    }
   },
   "outputs": [
    {
     "data": {
      "text/plain": [
       "1"
      ]
     },
     "execution_count": 25,
     "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": 26,
   "metadata": {
    "collapsed": false,
    "jupyter": {
     "outputs_hidden": false
    }
   },
   "outputs": [
    {
     "data": {
      "text/plain": [
       "(5,)"
      ]
     },
     "execution_count": 26,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "# Get the shape/size of numpy array\n",
    "\n",
    "a.shape"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 27,
   "metadata": {},
   "outputs": [],
   "source": [
    "# Create a numpy array\n",
    "\n",
    "a = np.array([1, -1, 1, -1])"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 28,
   "metadata": {
    "collapsed": false,
    "jupyter": {
     "outputs_hidden": false
    }
   },
   "outputs": [
    {
     "data": {
      "text/plain": [
       "0.0"
      ]
     },
     "execution_count": 28,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "# Get the mean of numpy array\n",
    "\n",
    "mean = a.mean()\n",
    "mean"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 29,
   "metadata": {
    "collapsed": false,
    "jupyter": {
     "outputs_hidden": false
    }
   },
   "outputs": [
    {
     "data": {
      "text/plain": [
       "1.0"
      ]
     },
     "execution_count": 29,
     "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": 30,
   "metadata": {
    "collapsed": false,
    "jupyter": {
     "outputs_hidden": false
    }
   },
   "outputs": [
    {
     "data": {
      "text/plain": [
       "array([-1,  2,  3,  4,  5])"
      ]
     },
     "execution_count": 30,
     "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": 31,
   "metadata": {
    "collapsed": false,
    "jupyter": {
     "outputs_hidden": false
    }
   },
   "outputs": [
    {
     "data": {
      "text/plain": [
       "5"
      ]
     },
     "execution_count": 31,
     "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": 32,
   "metadata": {
    "collapsed": false,
    "jupyter": {
     "outputs_hidden": false
    }
   },
   "outputs": [
    {
     "data": {
      "text/plain": [
       "-1"
      ]
     },
     "execution_count": 32,
     "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": 33,
   "metadata": {
    "collapsed": false,
    "jupyter": {
     "outputs_hidden": false
    }
   },
   "outputs": [
    {
     "data": {
      "text/plain": [
       "array([1, 0])"
      ]
     },
     "execution_count": 33,
     "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": 34,
   "metadata": {
    "collapsed": false,
    "jupyter": {
     "outputs_hidden": false
    }
   },
   "outputs": [
    {
     "data": {
      "text/plain": [
       "array([0, 1])"
      ]
     },
     "execution_count": 34,
     "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": 35,
   "metadata": {
    "collapsed": false,
    "jupyter": {
     "outputs_hidden": false
    }
   },
   "outputs": [
    {
     "data": {
      "text/plain": [
       "array([1, 1])"
      ]
     },
     "execution_count": 35,
     "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": 36,
   "metadata": {
    "collapsed": false,
    "jupyter": {
     "outputs_hidden": false
    }
   },
   "outputs": [
    {
     "data": {
      "image/png": "iVBORw0KGgoAAAANSUhEUgAAAYQAAAD8CAYAAAB3u9PLAAAAOXRFWHRTb2Z0d2FyZQBNYXRwbG90bGliIHZlcnNpb24zLjUuMiwgaHR0cHM6Ly9tYXRwbG90bGliLm9yZy8qNh9FAAAACXBIWXMAAAsTAAALEwEAmpwYAAAYpklEQVR4nO3de5BV5Z3u8e/TdAMKqCgXuYslOYqZDGoHNTGWqDOjjBEzo0FjJTpqUM+YaHkqM06YY6hUmTEONalY6BiCiuZ4QfGG2sjFG5oJhga5CUZbAoGmkQYEYVDk8jt/7CXpabvpy1691+7u51O1q9fl7fX+XL3l2e+6bUUEZmZmJVkXYGZmxcGBYGZmgAPBzMwSDgQzMwMcCGZmlnAgmJkZkEIgSBoi6VVJqyS9I+nmBtpI0t2SqiQtl3Rqvv2amVm6SlPYxj7g/0TEEkm9gMWS5kXEqjptLgRGJK/Tgf9MfpqZWZHIe4QQETURsSSZ3gmsBgbVazYOeDhyFgJHSRqQb99mZpaeNEYIB0k6DjgFeKveqkHA+jrzG5JlNQ1sYwIwAaBHjx6nnXjiiWmWaGbWoS1evHhLRPRtze+mFgiSegJPAbdExMet3U5ETAWmApSXl0dlZWVKFZqZdXyS1rX2d1O5ykhSGbkweCQinm6gSTUwpM784GSZmZkViTSuMhJwP7A6Iv6jkWazgO8lVxudAeyIiC8cLjIzs+ykccjo68B3gRWSlibLfgwMBYiI+4AKYCxQBewG/iGFfs3MLEV5B0JEvAmoiTYB/GO+fZmZWdvxncpmZgY4EMzMLOFAMDMzwIFgZmYJB4KZmQEOBDMzSzgQzMwMcCCYmVnCgWBmZoADwczMEg4EMzMDHAhmZpZwIJiZGeBAMDOzhAPBzMwAB4KZmSUcCGZmBjgQzMwskUogSHpA0mZJKxtZf46kHZKWJq/b0+jXzMzSk/d3KiemA1OAhw/R5o2IuCil/szMLGWpjBAiYgGwLY1tmZlZNgp5DuFMScskzZZ0cgH7NTOzZkjrkFFTlgDDImKXpLHAs8CIhhpKmgBMABg6dGiByjMzs4KMECLi44jYlUxXAGWS+jTSdmpElEdEed++fQtRnpmZUaBAkHSsJCXTo5N+txaibzMza55UDhlJegw4B+gjaQPwE6AMICLuAy4FbpS0D/gEuDwiIo2+zcwsHakEQkRc0cT6KeQuSzUzsyLlO5XNzAxwIJiZWcKBYGZmgAPBzMwSDgQzMwMcCGZmlnAgmJkZ4EAwM7OEA8HMzAAHgpmZJRwIZmYGOBDM2sxtt93GPffcc3B+0qRJTJ48OcOK2q/77ruPUaNGMWrUKIYPH86YMWOyLqlDciCYtZHx48fzxBNPHJx/4oknGD9+fIYVtV833HADS5cuZdGiRQwePJhbb70165I6pEJ9Y5pZp3PKKaewefNmNm7cSG1tLb1792bIkCFZl9Wu3XzzzZx77rl885vfzLqUDsmBYNaGLrvsMmbOnMmmTZs8OsjT9OnTWbduHVOm+En6bcWBYNaGxo8fz/e//322bNnC66+/nnU57dbixYuZPHkyb7zxBiUlPtLdVrxnzVroyivhxhub1/bkk09m586dDBo0iAEDBrRtYR3YlClT2LZtG2PGjGHUqFFcd911WZfUIamYv8myvLw8Kisrsy7D7KCPPoIBA6CkBLZsgcMPz7qijiciePPNN6neuJHLfZitxSQtjojy1vyuRwhmLfDII9ClS+41c2bW1XQsH374IXf+/C6GHD+Cs88+m0dnPJl1SZ1OKoEg6QFJmyWtbGS9JN0tqUrSckmnptGvWaH98pewezfs2pWbtvzs37+fiooK/uZvL+a4E77E5Bkvs22POP3rZ/PEo/8v6/I6nbRGCNOBCw6x/kJgRPKaAPxnSv2aFczbb8PGjX+eX7UKqqqyq6e927t3LwMGD+U7E35I5f5h9L1uGvQ4muP69GRuxfN079496xI7nVQCISIWANsO0WQc8HDkLASOkuQzbNauvPQS7N375/n9+2Hu3Ozqae8kMaB/P3ZUf0BJ18P4ZOVcDq9exOsvz+WII47IurxOqVCXnQ4C1teZ35Asq6nfUNIEcqMIhg4dWpDizJrjhz+EMWPgzDNz8wsWwKhRmZbUbn3yyScMHDiQ7du3069fPw5fPYtdO3fy5u9/R9++fbMur9MqupPKETE1IsojotxvDCsmPXrAGWfkpnv2zE37qEbLTZ8+ncMPP5zt27fzyiuv8OGHH/LeqhWsX/uBPwRmrFAjhGqg7j37g5NlZtZJbN++nd69ewPwjW+czWuvvXrwJrOysjLKysqyLM8o3AhhFvC95GqjM4AdEfGFw0Vm1jHdddddB8NgyZIlLFjwuu84LkKpjBAkPQacA/SRtAH4CVAGEBH3ARXAWKAK2A38Qxr9mllxq6mpYeDAgQCMH385jz32KJIyrsoak0ogRMQVTawP4B/T6MvM2odbb72VX/ziFwC8//77nHDCCRlXZE3xw+3MLFVVVVWMGDECgFtuueVgKFjxcyCYWSoigu9850oef/wxADZu3OgH+rUzPqtjZnl7++23KSkp4fHHH+POO+8kIhwG7ZBHCGbWagcOHGDMmHNZsCD3XQ8fffQRRx11VLZFWat5hGBmrfLaa6/RpUsXFix4nfvvv5+IcBi0cx4hmFmL7N27l5EjR1JVVcWRRx5JTU0Nhx12WNZlWQo8QjCzZnv66afp2rUrVVVVPPfcc2zfvt1h0IF4hGBmTdq9ezd9+/Zl9+7dnHjSSaxYvpzSUv/z0dF4hGBmh/TrX/+aHj16sHv3bl5//XVWr1rlMOig/Fc1swZt27aNY445BoDzzjufuXPn+PlDHZz/umb2BXfcccfBMFi2bBnz589zGHQCHiGY2UHV1dUMHjwYgO9+93s89NB0P4yuE3HkmxkAP/jBDw6GwQcffMDDDz/kMOhkHAhmndx7772HJKZMmcKPfvQjIoLjjz8+67IsAz5kZNZJRQSXXfZtnnpqJgCbNm2if//+GVdlWfIIwawTqqyspKSkhKeemsnkyZOJCIeBeYRg1pns37+fs876BgsX/g6AHTt2cMQRR2RclRULjxDMOon58+dTWlrKwoW/4+GHHyYiHAb2P6T1ncoXAL8EugDTIuLOeuuvBv4dqE4WTYmIaWn0bWaH9tlnn/GlL32JdevW0adPH9avX0/37t2zLsuKUN4jBEldgHuAC4GRwBWSRjbQdEZEjEpeDgOzAnjyySfp1q0b69at44UXXqC2ttZhYI1KY4QwGqiKiDUAkh4HxgGrUti2mbXCrl27OProo9m7dy9/8ZWvsGTxYj9/yJqUxjmEQcD6OvMbkmX1/b2k5ZJmShrS2MYkTZBUKamytrY2hfLMOpd7772XXr16sXfvXt58802WL1vmMLBmKdS75HngsYjYI+l64CHg3IYaRsRUYCpAeXl5FKg+s3Zv69at9OnTB4ALLriQiooXfaextUgaI4RqoO4n/sH8+eQxABGxNSL2JLPTgNNS6NfMEpMmTToYBitWrGD27AqHgbVYGiOERcAIScPJBcHlwHfqNpA0ICJqktmLgdUp9GvW6a1fv56hQ4cCcM011zBt2jQHgbVa3oEQEfsk3QTMIXfZ6QMR8Y6knwKVETEL+KGki4F9wDbg6nz7NevMIoIbb7yRX/3qVwD88Y9/5Ljjjsu2KGv3FFG8h+nLy8ujsrIy6zLM/gcJevaEnTuz6X/16tWMHJm7svvHP/4xd9xxRzaFWFGStDgiylvzu770wKydiAjGjbuE55+fBcDmzZvp27dvxlVZR+JHV5i1A2+99RYlJSU8//ws7r77biLCYWCp8wjBrIjt37+f0884g8XJodOPP/6YXr16ZVyVdVQeIZgVqTlz5lBaWsriykoeffRRIsJhYG3KIwSzIrNnzx6GDx9OTU0NAwcOZM2aNXTr1i3rsqwT8AjBrIg8+uijdO/enZqaGmbPnk11dbXDwArGIwSzIrBz586D301QXv5VFi78HV26dMm4KutsPEIwy9jdd999MAwWLlzIokW/dxhYJjxCMMtIbW0t/fr1A+Dii8fx7LPP+LETlimPEMwyMHHixINhsGrVKp577lmHgWXOgWBWQOvWrUMSP/vZz7j++us5cOAAJ510UtZltQtr167ly1/+8sH5yZMnM2nSpOwK6oB8yMisACKCa6+9lgcffBCAP/3pTwwZ0uj3RJllwiMEsza2cuVKSkpKePDBB7n99tuJCIeBFSWPEMzaSEQwduzf8tJLswHYsmULxxxzTMZVtV+lpaUcOHDg4Pynn36aYTUdk0cIZm3gt7/9LSUlJbz00mzuvfdeIsJhkKf+/fuzefNmtm7dyp49e3jhhReyLqnD8QjBLEX79u3j1NNOY8Xy5ZSVlbFt2zZ69uyZdVkdQllZGbfffjujR49m0KBBnHjiiVmX1OH4C3LMWqixL8h58cUXueiiiwCYMWMG3/72tzOozjo7f0GOWYY+/fRTBg8ezNatWxk2bBjvvfceXbt2zbossxZL5RyCpAsk/UFSlaTbGljfTdKMZP1bko5Lo1+zrP3mN7/hsMMOY+vWrcybN4+1a9c6DKzdynuEIKkLcA/wV8AGYJGkWRGxqk6za4GPIuIESZcDPwfG59u3WVYidiAdBcCZZ36NN95Y4OcPtdY//zOsXAlf/SqcfDKMHAkjRoCDteDSOGQ0GqiKiDUAkh4HxgF1A2EcMCmZnglMkaQo5hMYZo0oLV3Gf//3KAAWDRtG+UfboM4dtNZC776b+/nSS9CjR276k0+gXz846SQ47TSYOBGSBwBa20kjEAYB6+vMbwBOb6xNROyTtAM4BthSf2OSJgATAIYOHZpCeWbpmv6Tdbz8f/tyP7Vo3bqsy+k4DhyA3btzodC1K2zalDuDX1ICn32WdXWdQtGdVI6IqcBUyF1llHE5Zl9w5b9ezJX/ujnrMjqOSy+FJUtyh4vqHjY64QQoK8u6uk4ljUCoBurehz84WdZQmw2SSoEjga0p9G1m7d3MmVlXYIk0rjJaBIyQNFxSV+ByYFa9NrOAq5LpS4FXfP7AzKy45D1CSM4J3ATMAboAD0TEO5J+ClRGxCzgfuA3kqqAbeRCw8zMikgq5xAiogKoqLfs9jrTnwKXpdGXmZm1DT/czszMAAeCmZklHAhmZgY4EMzMLOFAMDMzwIFgZmYJB4KZmQEOBDMzSzgQzMwMcCCYmVnCgWBmZoADwczMEg4EMzMDHAhmZpZwIJiZGeBAMDOzhAPBzMwAB4KZmSXyCgRJR0uaJ+n95GfvRtrtl7Q0ec3Kp08zM2sb+Y4QbgNejogRwMvJfEM+iYhRyeviPPs0M7M2kG8gjAMeSqYfAi7Jc3tmZpaRfAOhf0TUJNObgP6NtOsuqVLSQkmXHGqDkiYkbStra2vzLM/MzJqrtKkGkuYDxzawamLdmYgISdHIZoZFRLWk44FXJK2IiA8aahgRU4GpAOXl5Y1tz8zMUtZkIETE+Y2tk/ShpAERUSNpALC5kW1UJz/XSHoNOAVoMBDMzCwb+R4ymgVclUxfBTxXv4Gk3pK6JdN9gK8Dq/Ls18zMUpZvINwJ/JWk94Hzk3kklUualrQ5CaiUtAx4FbgzIhwIZmZFpslDRocSEVuB8xpYXglcl0z/F/AX+fRjZmZtz3cqm5kZ4EAwM7OEA8HMzAAHgpmZJRwIZmYGOBDMzCzhQDAzM8CBYGZmCQeCmZkBDgQzM0s4EMzMDHAgmJlZwoFgZmaAA8HMzBIOBDMzAxwIZmaWcCCYmRngQDAzs0RegSDpMknvSDogqfwQ7S6Q9AdJVZJuy6dPMzNrG/mOEFYCfwcsaKyBpC7APcCFwEjgCkkj8+zXzMxSVprPL0fEagBJh2o2GqiKiDVJ28eBccCqfPo2M7N0FeIcwiBgfZ35DcmyBkmaIKlSUmVtbW2bF2dmZjlNjhAkzQeObWDVxIh4Lu2CImIqMBWgvLw80t6+mZk1rMlAiIjz8+yjGhhSZ35wsszMzIpIIQ4ZLQJGSBouqStwOTCrAP2amVkL5HvZ6bckbQDOBF6UNCdZPlBSBUBE7ANuAuYAq4EnIuKd/Mo2M7O05XuV0TPAMw0s3wiMrTNfAVTk05eZmbUt36lsZmaAA8HMzBIOBDMzAxwIZmaWcCCYmRngQDAzs4QDwczMAAeCmZklHAhmZgY4EMzMLOFAMDMzwIFgZmYJB4KZmQEOBDMzSzgQzMwMcCCYmVnCgWBmZoADwczMEvl+p/Jlkt6RdEBS+SHarZW0QtJSSZX59GlmZm0jr+9UBlYCfwf8qhltx0TEljz7MzOzNpJXIETEagBJ6VRjZmaZKdQ5hADmSlosaUKB+jQzsxZocoQgaT5wbAOrJkbEc83s56yIqJbUD5gn6d2IWNBIfxOACQBDhw5t5ubNzCxfTQZCRJyfbycRUZ383CzpGWA00GAgRMRUYCpAeXl55Nu3mZk1T5sfMpLUQ1Kvz6eBvyZ3MtrMzIpIvpedfkvSBuBM4EVJc5LlAyVVJM36A29KWgb8HngxIl7Kp18zM0tfvlcZPQM808DyjcDYZHoN8Jf59GNmZm3PdyqbmRngQDAzs4QDwczMAAeCmZklHAhmZgY4EMzMLOFAMDMzwIFgZmYJB4KZmQEOBDMzSzgQzMwMcCCYmVnCgWBmZoADwczMEg4EMzMDHAhmZpZwIJiZGeBAMDOzhAPBzMyAPANB0r9LelfScknPSDqqkXYXSPqDpCpJt+XTp5mZtY18RwjzgC9HxFeA94B/qd9AUhfgHuBCYCRwhaSRefZrZmYpyysQImJuROxLZhcCgxtoNhqoiog1EfEZ8DgwLp9+zcwsfaUpbusaYEYDywcB6+vMbwBOb2wjkiYAE5LZPZJWplZh2+gDbMm6iGZwnelynelynen5X639xSYDQdJ84NgGVk2MiOeSNhOBfcAjrS3kcxExFZiabLcyIsrz3WZbag81gutMm+tMl+tMj6TK1v5uk4EQEec30fnVwEXAeRERDTSpBobUmR+cLDMzsyKS71VGFwD/BFwcEbsbabYIGCFpuKSuwOXArHz6NTOz9OV7ldEUoBcwT9JSSfcBSBooqQIgOel8EzAHWA08ERHvNHP7U/OsrxDaQ43gOtPmOtPlOtPT6hrV8FEeMzPrbHynspmZAQ4EMzNLFFUgtIdHYUi6TNI7kg5IavTyM0lrJa1Izq20+jKw1mpBnZk+VkTS0ZLmSXo/+dm7kXb7k325VFLBLkpoav9I6iZpRrL+LUnHFaq2enU0VefVkmrr7MPrMqjxAUmbG7u3SDl3J/8NyyWdWugakzqaqvMcSTvq7MvbM6hxiKRXJa1K/j+/uYE2Ld+fEVE0L+CvgdJk+ufAzxto0wX4ADge6AosA0YWsMaTyN348RpQfoh2a4E+Ge7LJuvMel8mNdwF3JZM39bQ3zxZtyuDfdjk/gH+N3BfMn05MKNI67wamFLo2urVcDZwKrCykfVjgdmAgDOAt4q0znOAFzLelwOAU5PpXuQeHVT/b97i/VlUI4RoB4/CiIjVEfGHQvXXWs2ssxgeKzIOeCiZfgi4pMD9H0pz9k/d+mcC50lSAWuE4vg7NikiFgDbDtFkHPBw5CwEjpI0oDDV/Vkz6sxcRNRExJJkeie5KzgH1WvW4v1ZVIFQzzXk0q2+hh6FUX9HFIMA5kpanDyOoxgVw77sHxE1yfQmoH8j7bpLqpS0UNIlhSmtWfvnYJvkw8wO4JiCVNdADYnG/o5/nxw6mClpSAPrs1YM78fmOlPSMkmzJZ2cZSHJYcpTgLfqrWrx/kzzWUbNUuhHYbRGc2pshrMiolpSP3L3abybfPJITUp1trlD1Vl3JiJCUmPXQQ9L9ufxwCuSVkTEB2nX2oE9DzwWEXskXU9uVHNuxjW1V0vIvR93SRoLPAuMyKIQST2Bp4BbIuLjfLdX8ECIdvAojKZqbOY2qpOfmyU9Q25Yn2ogpFBnQR4rcqg6JX0oaUBE1CTD2c2NbOPz/blG0mvkPhG1dSA0Z/983maDpFLgSGBrG9dVX5N1RkTdmqaRO3dTbNrFY27q/sMbERWS7pXUJyIK+tA7SWXkwuCRiHi6gSYt3p9FdchIHeRRGJJ6SOr1+TS5k+XF+NTWYtiXs4CrkumrgC+MbCT1ltQtme4DfB1YVYDamrN/6tZ/KfBKIx9k2lKTddY7dnwxuWPOxWYW8L3k6pgzgB11DicWDUnHfn6eSNJocv+OFvRDQNL//cDqiPiPRpq1fH9meaa8gTPnVeSOeS1NXp9fvTEQqKh39vw9cp8QJxa4xm+ROxa3B/gQmFO/RnJXeyxLXu8Uusbm1pn1vkz6PwZ4GXgfmA8cnSwvB6Yl018DViT7cwVwbQHr+8L+AX5K7kMLQHfgyeS9+3vg+ELvw2bW+W/Je3EZ8CpwYgY1PgbUAHuT9+a1wA3ADcl6kfsyrQ+Sv3OjV/FlXOdNdfblQuBrGdR4FrnzlMvr/Hs5Nt/96UdXmJkZUGSHjMzMLDsOBDMzAxwIZmaWcCCYmRngQDAzs4QDwczMAAeCmZkl/j+OzqUYzOa1yQAAAABJRU5ErkJggg==\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": 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",
    "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": 38,
   "metadata": {
    "collapsed": false,
    "jupyter": {
     "outputs_hidden": false
    }
   },
   "outputs": [
    {
     "data": {
      "text/plain": [
       "array([2, 4])"
      ]
     },
     "execution_count": 38,
     "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": 39,
   "metadata": {
    "collapsed": false,
    "jupyter": {
     "outputs_hidden": false
    }
   },
   "outputs": [
    {
     "data": {
      "text/plain": [
       "array([1, 2])"
      ]
     },
     "execution_count": 39,
     "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": 40,
   "metadata": {
    "collapsed": false,
    "jupyter": {
     "outputs_hidden": false
    }
   },
   "outputs": [
    {
     "data": {
      "text/plain": [
       "array([3, 2])"
      ]
     },
     "execution_count": 40,
     "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": 41,
   "metadata": {
    "collapsed": false,
    "jupyter": {
     "outputs_hidden": false
    }
   },
   "outputs": [
    {
     "data": {
      "text/plain": [
       "array([3, 4])"
      ]
     },
     "execution_count": 41,
     "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": 42,
   "metadata": {
    "collapsed": false,
    "jupyter": {
     "outputs_hidden": false
    }
   },
   "outputs": [
    {
     "data": {
      "text/plain": [
       "7"
      ]
     },
     "execution_count": 42,
     "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": 43,
   "metadata": {
    "collapsed": false,
    "jupyter": {
     "outputs_hidden": false
    }
   },
   "outputs": [
    {
     "data": {
      "text/plain": [
       "array([ 1,  2,  3, -1])"
      ]
     },
     "execution_count": 43,
     "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": 44,
   "metadata": {
    "collapsed": false,
    "jupyter": {
     "outputs_hidden": false
    }
   },
   "outputs": [
    {
     "data": {
      "text/plain": [
       "array([2, 3, 4, 0])"
      ]
     },
     "execution_count": 44,
     "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": 45,
   "metadata": {
    "collapsed": false,
    "jupyter": {
     "outputs_hidden": false
    }
   },
   "outputs": [
    {
     "data": {
      "text/plain": [
       "3.141592653589793"
      ]
     },
     "execution_count": 45,
     "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": 46,
   "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": 47,
   "metadata": {
    "collapsed": false,
    "jupyter": {
     "outputs_hidden": false
    }
   },
   "outputs": [
    {
     "data": {
      "text/plain": [
       "array([0.0000000e+00, 1.0000000e+00, 1.2246468e-16])"
      ]
     },
     "execution_count": 47,
     "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": 48,
   "metadata": {
    "collapsed": false,
    "jupyter": {
     "outputs_hidden": false
    }
   },
   "outputs": [
    {
     "data": {
      "text/plain": [
       "array([-2., -1.,  0.,  1.,  2.])"
      ]
     },
     "execution_count": 48,
     "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": 49,
   "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": 49,
     "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": 50,
   "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": 51,
   "metadata": {},
   "outputs": [],
   "source": [
    "# Calculate the sine of x list\n",
    "\n",
    "y = np.sin(x)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 52,
   "metadata": {
    "collapsed": false,
    "jupyter": {
     "outputs_hidden": false
    }
   },
   "outputs": [
    {
     "data": {
      "text/plain": [
       "[<matplotlib.lines.Line2D at 0x7fe7423f9790>]"
      ]
     },
     "execution_count": 52,
     "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": 53,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "array([ 1, -1])"
      ]
     },
     "execution_count": 53,
     "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",
    "u-v"
   ]
  },
  {
   "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": 54,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "array([-4, -8])"
      ]
     },
     "execution_count": 54,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "# Write your code below and press Shift+Enter to execute\n",
    "\n",
    "z = np.array([2, 4])\n",
    "z*-2"
   ]
  },
  {
   "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": 55,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "array([1, 0, 3, 0, 5])"
      ]
     },
     "execution_count": 55,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "# Write your code below and press Shift+Enter to execute\n",
    "x=np.array([1,2,3,4,5])\n",
    "y=np.array([1,0,1,0,1])\n",
    "x*y"
   ]
  },
  {
   "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": 60,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "0"
      ]
     },
     "execution_count": 60,
     "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": [
    "# 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",
    "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": 62,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "0"
      ]
     },
     "execution_count": 62,
     "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": [
    "# 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",
    "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": 64,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "1"
      ]
     },
     "execution_count": 64,
     "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": [
    "# 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",
    "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": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "# Write your code below and press Shift+Enter to execute"
   ]
  },
  {
   "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 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.10"
  }
 },
 "nbformat": 4,
 "nbformat_minor": 4
}