190206_arrays.ipynb

{
 "cells": [
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "This notebook accompanies __[this blog post](http://emilygraceripka.com/blog/19)__ on the importance of arrays in programming "
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 1,
   "metadata": {
    "collapsed": true
   },
   "outputs": [],
   "source": [
    "import numpy as np\n",
    "import matplotlib.pyplot as plt\n",
    "from matplotlib import gridspec\n",
    "%matplotlib inline"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## (I) Images as Arrays\n",
    "As illustrated in the blog post, we can use NumPy to create, manipulate, and visualize images."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 2,
   "metadata": {
    "collapsed": true
   },
   "outputs": [],
   "source": [
    "A_nRows = 5\n",
    "A_nColumns = 5\n",
    "A = np.zeros((A_nRows,A_nColumns))"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 3,
   "metadata": {
    "collapsed": true
   },
   "outputs": [],
   "source": [
    "A_row_1 = [2,14,15,12,4]\n",
    "A_row_2 = [3,14,8,6,3]\n",
    "A_row_3 = [6,13,12,11,6]\n",
    "A_row_4 = [5,3,4,13,5]\n",
    "A_row_5 = [4,14,12,11,4]"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 4,
   "metadata": {
    "collapsed": true
   },
   "outputs": [],
   "source": [
    "for i in range(A.shape[0]):\n",
    "    A[0][i] = A_row_1[i]\n",
    "    A[1][i] = A_row_2[i]\n",
    "    A[2][i] = A_row_3[i]\n",
    "    A[3][i] = A_row_4[i]\n",
    "    A[4][i] = A_row_5[i]"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 5,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "[[ 2. 14. 15. 12.  4.]\n",
      " [ 3. 14.  8.  6.  3.]\n",
      " [ 6. 13. 12. 11.  6.]\n",
      " [ 5.  3.  4. 13.  5.]\n",
      " [ 4. 14. 12. 11.  4.]]\n"
     ]
    }
   ],
   "source": [
    "print A"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 6,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "image/png": "iVBORw0KGgoAAAANSUhEUgAAAPEAAADQCAYAAADWO4eaAAAABHNCSVQICAgIfAhkiAAAAAlwSFlz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\n",
      "text/plain": [
       "<matplotlib.figure.Figure at 0x80df3c8>"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    }
   ],
   "source": [
    "fig = plt.figure(figsize=(4,3))\n",
    "gs = gridspec.GridSpec(1,1)\n",
    "ax1 = fig.add_subplot(gs[0])\n",
    "\n",
    "im = ax1.imshow(A, cmap='Greys')\n",
    "fig.colorbar(im, ax=ax1)\n",
    "\n",
    "ax1.set_xlabel(\"Columns\",family=\"serif\",  fontsize=12)\n",
    "ax1.set_ylabel(\"Rows\",family=\"serif\",  fontsize=12)\n",
    "\n",
    "fig.tight_layout()\n",
    "#fig.savefig(\"imshow_S.png\", format=\"png\",dpi=1000)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## (II) Array of Dictionaries\n",
    "Generate an array of dictionaries <font color=red>employeeArray</font> at a set number of employees, designated by the variable <font color=red>numberEmployees</font>. \n",
    "<br><br>\n",
    "We can use the NumPy function <font color=green>array()</font> to create an array with whatever we want inside, in this case it is several dictionaries. <br>\n",
    "Specifically, we can use a for loop inside of the array to create separate dictionaries for each employee."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 7,
   "metadata": {
    "collapsed": true
   },
   "outputs": [],
   "source": [
    "numberEmployees = 3\n",
    "employeeArray = np.array([{'LastName':'lName',\n",
    "                           'FirstName':'fName',\n",
    "                           'HourlyPayRate':8.00} for i in range(numberEmployees)])"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 8,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "lName\n",
      "lName\n",
      "lName\n"
     ]
    }
   ],
   "source": [
    "for i in range(employeeArray.shape[0]):\n",
    "    print employeeArray[i]['LastName']"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "The array has a _shape_ which is controlled by <font color=red>numberEmployees</font> and has a _type_ which is controlled by the <font color=green>array()</font> function."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 9,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Shape of numberEmployees array: (3L,)\n",
      "Type of numberEmployees array: <type 'numpy.ndarray'>\n"
     ]
    }
   ],
   "source": [
    "print \"Shape of numberEmployees array:\", np.shape(employeeArray)\n",
    "print \"Type of numberEmployees array:\", type(employeeArray)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "If we think of this array as a matrix, it would look something like this:<br>\n",
    "$\\begin{bmatrix}\n",
    "Employee_{1}\n",
    "\\\\\n",
    "Employee_{2}\n",
    "\\\\\n",
    "Employee_{3}\n",
    "\\end{bmatrix}$\n",
    "<br>\n",
    "\n",
    "This is a 1D matrix, otherwise known as a vector, and a general matrix for n employees (<font color=red>numberEmployees</font>) can be written as:<br>\n",
    "__E__ = \n",
    "$\\begin{bmatrix}\n",
    "E_{1}\n",
    "\\\\\n",
    "E_{2}\n",
    "\\\\\n",
    ".\n",
    "\\\\\n",
    ".\n",
    "\\\\\n",
    ".\n",
    "\\\\\n",
    "E_{n}\n",
    "\\end{bmatrix}$\n",
    "<br>Where $E_{i}$ is the dictionary for the $i^{th}$ employee.\n",
    "<br><br>\n",
    "The most powerful aspect of arrays is that we can call small portions of it to work with or visualize. <br>\n",
    "For example, we can print out the dictionary for the first employee in the array by adding _[0]_ after the name of the array.<br>\n",
    "This is like calling the first element of the __E__ matrix, __E__[0] = $E_{1}$<br>\n",
    "Here, _0_ is an _index_ of the array."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 10,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "E_1 = E[0] = {'LastName': 'lName', 'HourlyPayRate': 8.0, 'FirstName': 'fName'}\n"
     ]
    }
   ],
   "source": [
    "print\"E_1 = E[0] =\", employeeArray[0]"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "As you can see, the values of the dictionary keys are all the standard values which we initiated at the start.\n",
    "<br><br>\n",
    "We can change each of the values by adding the name of the key after the _[0]_ index, and then assigning it to a new string or float."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 11,
   "metadata": {
    "collapsed": true
   },
   "outputs": [],
   "source": [
    "employeeArray[0]['LastName'] = 'Smith'\n",
    "employeeArray[0]['FirstName'] = 'Roger'\n",
    "employeeArray[0]['HourlyPayRate'] = 15.00"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "If we print out the dictionary again for $E_{1}$:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 12,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "E_1 = E[0] = {'LastName': 'Smith', 'HourlyPayRate': 15.0, 'FirstName': 'Roger'}\n"
     ]
    }
   ],
   "source": [
    "print \"E_1 = E[0] =\", employeeArray[0]"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "We see that the values have changed for each key of the dictionary to the new values we assigned by indexing each individual key.\n",
    "<br><br>\n",
    "This is how we edit/assign values of dictionaries inside an array. \n",
    "<br><br>\n",
    "Another powerful use for arrays is that we can change several values simultaneously; an operation which would prove tedious to do to individual variables for large arrays. \n",
    "<br><br>\n",
    "For example, we can first print the <font color=red>'HourlyPayRate'</font> for each employee, $E_{i}$, in the array."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 13,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Employee #1's pay rate is $ 15.0 per hour\n",
      "Employee #2's pay rate is $ 8.0 per hour\n",
      "Employee #3's pay rate is $ 8.0 per hour\n"
     ]
    }
   ],
   "source": [
    "for i in range(numberEmployees):\n",
    "    j = i+1\n",
    "    print \"Employee #%d's\" % j, \"pay rate is $\", employeeArray[i]['HourlyPayRate'], \"per hour\""
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Then we can change all of the employees <font color=red>'HourlyPayRate'</font> simultaneously, for example if there was a standard 5% pay raise. <br>\n",
    "Mathematically, this operation would look something like: <br>\n",
    "__E__ = \n",
    "$\\begin{bmatrix}\n",
    "E_{1}['HourlyPayRate']\n",
    "\\\\\n",
    "E_{2}['HourlyPayRate']\n",
    "\\\\\n",
    ".\n",
    "\\\\\n",
    ".\n",
    "\\\\\n",
    ".\n",
    "\\\\\n",
    "E_{n}['HourlyPayRate']\n",
    "\\end{bmatrix}$ + $0.05$ $\\times$\n",
    "$\\begin{bmatrix}\n",
    "E_{1}['HourlyPayRate']\n",
    "\\\\\n",
    "E_{2}['HourlyPayRate']\n",
    "\\\\\n",
    ".\n",
    "\\\\\n",
    ".\n",
    "\\\\\n",
    ".\n",
    "\\\\\n",
    "E_{n}['HourlyPayRate']\n",
    "\\end{bmatrix}$"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 14,
   "metadata": {
    "collapsed": true
   },
   "outputs": [],
   "source": [
    "for i in range(numberEmployees):\n",
    "    employeeArray[i]['HourlyPayRate'] += 0.05*employeeArray[i]['HourlyPayRate']"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "If we print the <font color=red>'HourlyPayRate'</font> for each employee, $E_{i}$, in the array again"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 15,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Employee #1's pay rate is $ 15.75 per hour\n",
      "Employee #2's pay rate is $ 8.4 per hour\n",
      "Employee #3's pay rate is $ 8.4 per hour\n"
     ]
    }
   ],
   "source": [
    "for i in range(numberEmployees):\n",
    "    j = i+1\n",
    "    print \"Employee #%d's\" % j, \"pay rate is $\", employeeArray[i]['HourlyPayRate'], \"per hour\""
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "we see that each of $E_{i}$'s <font color=red>HourlyPayRate</font> have increased by 5%."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## (III) Array operations \n",
    "So far, we have performed one _operation_ on arrays called __scalar multiplication__. This is when you multiply an element of the array (or the entire array) by a number to change its value. \n",
    "\n",
    "Some other important operations for working with arrays are: \n",
    " - addition/subtraction  \n",
    " - stacking \n",
    " - multiplication/dot products\n",
    "\n",
    "To illustrate these operations, we will start with a new array, $A$.\n",
    "It is helpful to use the NumPy function <font color=green>zeros()</font> to create an empty array with the desired dimensions.\n",
    "Here, we create a $3$ $\\times$ $5$ array."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 16,
   "metadata": {
    "collapsed": true
   },
   "outputs": [],
   "source": [
    "A_nRows = 3\n",
    "A_nColumns = 5\n",
    "A = np.zeros((A_nRows, A_nColumns))"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "$A$ has a _type_ determined by the NumPy <font color=green>zeros()</font> function, <br>\n",
    "and a _shape_ determined by the variables for the number of rows (<font color=red>A_nRows</font>) and the number of columns (<font color=red>A_nColumns</font>)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 17,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Type of A: <type 'numpy.ndarray'>\n",
      "Shape of A: (3L, 5L)\n"
     ]
    }
   ],
   "source": [
    "print \"Type of A:\", type(A)\n",
    "print \"Shape of A:\", np.shape(A)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "If we print $A$, we see there are 3 rows (<font color=red>A_nRows</font> = 3), and 5 columns (<font color=red>A_nColumns</font> = 5):"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 18,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "[[0. 0. 0. 0. 0.]\n",
      " [0. 0. 0. 0. 0.]\n",
      " [0. 0. 0. 0. 0.]]\n"
     ]
    }
   ],
   "source": [
    "print A"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "$A$ is a 2D matrix, with a general matrix representation written as:\n",
    "\n",
    "__A__ = \n",
    "$\\begin{bmatrix}\n",
    "A_{11} & A_{12} & A_{13} & A_{14} & A_{15}\n",
    "\\\\\n",
    "A_{21} & A_{22} & A_{23} & A_{24} & A_{25}\n",
    "\\\\\n",
    "A_{31} & A_{32} & A_{33} & A_{34} & A_{35}\n",
    "\\end{bmatrix}$\n",
    "\n",
    "Where $A_{ij}$ is the index for the $i^{th}$ row and th $j^{th}$ column of $A$. \n",
    "\n",
    "For example, $A_{23}$ is the index for the $2^{nd}$ row and the $3^{rd}$ column of $A$.\n",
    "\n",
    "Further, we can index $A$ as an array just like with our <font color=red>employeeArray</font>, <br>\n",
    "> where the $i^{th}$ (i.e. row) index is placed in the first $[i]$ after $A$, <br>\n",
    "> and the $j^{th}$ (i.e. column) index is placed in the second $[j]$ after $A$: <br>\n",
    "> > $A[i][j]$\n",
    "\n",
    "For example, we can print the $1^{st}$ row and $1^{st}$ column of $A$:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 19,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "The 1st row and 1st column value of A = 0.0\n"
     ]
    }
   ],
   "source": [
    "print \"The 1st row and 1st column value of A =\", A[0][0]"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "We can change the values of the elements of $A$ directly several ways:\n",
    " - Through direct assignment of an element; treating it like a single variable"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 20,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "[[1. 0. 0. 0. 0.]\n",
      " [0. 0. 0. 0. 0.]\n",
      " [0. 0. 0. 0. 0.]]\n"
     ]
    }
   ],
   "source": [
    "A[0][0] = 1\n",
    "print A"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    " - Using a for loop we can change an entire column"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 21,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "[[2. 0. 0. 0. 0.]\n",
      " [2. 0. 0. 0. 0.]\n",
      " [2. 0. 0. 0. 0.]]\n"
     ]
    }
   ],
   "source": [
    "for i in range(A.shape[0]):\n",
    "    A[i][0] = 2\n",
    "print A"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    " - Or Using a for loop we can change an entire row"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 22,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "[[4. 4. 4. 4. 4.]\n",
      " [2. 0. 0. 0. 0.]\n",
      " [2. 0. 0. 0. 0.]]\n"
     ]
    }
   ],
   "source": [
    "for j in range(A.shape[1]):\n",
    "    A[0][j] = 4\n",
    "print A"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "There are three important aspects of these for loop assignments to note:\n",
    " > (1) to choose if you change the row or column elements, write \"$A.shape[0]$\" or \"$A.shape[1]$\" respectively, inside the <font color=green>range()</font> function <br>\n",
    " > (2) choose which column to change by changing the $j$ index in $A[i][j]$ to a number, and leave $i$ alone <br>\n",
    " > (3) choose which row to change by changing the $i$ index in $A[i][j]$ to a number, and leave $j$ alone  \n",
    "\n",
    "These methods to change the elements of an array are extremely powerful and will be used moving forward."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### (III a) Array operations - addition/subtraction\n",
    "The same way we created our $A$ matrix, let's create a matrix $B$."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 23,
   "metadata": {
    "collapsed": true
   },
   "outputs": [],
   "source": [
    "B_nRows = A_nRows\n",
    "B_nColumns = 1\n",
    "B = np.zeros((B_nRows, B_nColumns))"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 24,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "[[0.]\n",
      " [0.]\n",
      " [0.]]\n"
     ]
    }
   ],
   "source": [
    "print B"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 25,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Type of B: <type 'numpy.ndarray'>\n",
      "Shape of B: (3L, 1L)\n"
     ]
    }
   ],
   "source": [
    "print \"Type of B:\", type(B)\n",
    "print \"Shape of B:\", np.shape(B)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "$B$ is a $3$ $\\times$ $1$ matrix, otherwise known as a column vector, with a general matrix representation written as:\n",
    "\n",
    "__B__ = \n",
    "$\\begin{bmatrix}\n",
    "B_{11} \n",
    "\\\\\n",
    "B_{21} \n",
    "\\\\\n",
    "B_{31} \n",
    "\\end{bmatrix}$\n",
    "\n",
    "Where $B_{ij}$ is the index for the $i^{th}$ row and th $j^{th}$ column of $B$. "
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 26,
   "metadata": {
    "collapsed": true
   },
   "outputs": [],
   "source": [
    "j = 1\n",
    "for i in range(B.shape[0]):\n",
    "    B[i] = j\n",
    "    j += 1"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "After assigning some values to $B$ using a for loop:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 27,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "[[1.]\n",
      " [2.]\n",
      " [3.]]\n"
     ]
    }
   ],
   "source": [
    "print B"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Because $A$ and $B$ have the same number of rows, we can add the two and assign the result to a new matrix, $C$. <br>\n",
    "Each column of $C$ is the corresponding column in $A$ plus the $B$ vector, thus $C$ has the same shape as $A$."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 28,
   "metadata": {
    "collapsed": true
   },
   "outputs": [],
   "source": [
    "C = A + B"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 29,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Type of C: <type 'numpy.ndarray'>\n",
      "Shape of C: (3L, 5L)\n"
     ]
    }
   ],
   "source": [
    "print \"Type of C:\", type(C)\n",
    "print \"Shape of C:\", np.shape(C)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 30,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "[[5. 5. 5. 5. 5.]\n",
      " [4. 2. 2. 2. 2.]\n",
      " [5. 3. 3. 3. 3.]]\n"
     ]
    }
   ],
   "source": [
    "print C"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "We can similarly subtract $B$ from $A$ and assign it to a new matrix, $D$, with the same shape as $A$."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 31,
   "metadata": {
    "collapsed": true
   },
   "outputs": [],
   "source": [
    "D = A - B"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 32,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Type of D: <type 'numpy.ndarray'>\n",
      "Shape of D: (3L, 5L)\n"
     ]
    }
   ],
   "source": [
    "print \"Type of D:\", type(D)\n",
    "print \"Shape of D:\", np.shape(D)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 33,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "[[ 3.  3.  3.  3.  3.]\n",
      " [ 0. -2. -2. -2. -2.]\n",
      " [-1. -3. -3. -3. -3.]]\n"
     ]
    }
   ],
   "source": [
    "print D"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### (III b) Array operations - stacking\n",
    "Another very powerful way to work with arrays is by stacking arrays on top or next to one another to make new arrays."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 34,
   "metadata": {
    "collapsed": true
   },
   "outputs": [],
   "source": [
    "hStack_preArray_nRows = A_nRows\n",
    "hStack_preArray_nColumns = 1\n",
    "hStack_preArray = np.zeros((hStack_preArray_nRows, hStack_preArray_nColumns))"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 35,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "[[0.]\n",
      " [0.]\n",
      " [0.]]\n"
     ]
    }
   ],
   "source": [
    "print hStack_preArray"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 36,
   "metadata": {
    "collapsed": true
   },
   "outputs": [],
   "source": [
    "j = 1\n",
    "for i in range(hStack_preArray.shape[0]):\n",
    "    hStack_preArray[i] = j\n",
    "    j += 1"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 37,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "[[1.]\n",
      " [2.]\n",
      " [3.]]\n"
     ]
    }
   ],
   "source": [
    "print hStack_preArray"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 38,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "[[4. 4. 4. 4. 4. 1.]\n",
      " [2. 0. 0. 0. 0. 2.]\n",
      " [2. 0. 0. 0. 0. 3.]]\n"
     ]
    }
   ],
   "source": [
    "hStack_array = np.hstack((A,hStack_preArray))\n",
    "print hStack_array"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 39,
   "metadata": {
    "collapsed": true
   },
   "outputs": [],
   "source": [
    "vStack_preArray_nRows = 1\n",
    "vStack_preArray_nColumns = A_nColumns\n",
    "vStack_preArray = np.zeros((vStack_preArray_nRows, vStack_preArray_nColumns))"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 40,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "[[0. 0. 0. 0. 0.]]\n"
     ]
    }
   ],
   "source": [
    "print vStack_preArray"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 41,
   "metadata": {
    "collapsed": true
   },
   "outputs": [],
   "source": [
    "j = 1\n",
    "for i in range(vStack_preArray.shape[1]):\n",
    "    vStack_preArray[0][i] = j\n",
    "    j += 1"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 42,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "[[1. 2. 3. 4. 5.]]\n"
     ]
    }
   ],
   "source": [
    "print vStack_preArray"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 43,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "(3L, 5L)\n",
      "(1L, 5L)\n"
     ]
    }
   ],
   "source": [
    "print A.shape\n",
    "print vStack_preArray.shape"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 44,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "[[4. 4. 4. 4. 4.]\n",
      " [2. 0. 0. 0. 0.]\n",
      " [2. 0. 0. 0. 0.]\n",
      " [1. 2. 3. 4. 5.]]\n"
     ]
    }
   ],
   "source": [
    "vStack_array = np.vstack((A,vStack_preArray))\n",
    "print vStack_array"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### (III c) Array operations - dot products"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 45,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "[[4. 4. 4. 4. 4.]\n",
      " [2. 0. 0. 0. 0.]\n",
      " [2. 0. 0. 0. 0.]]\n"
     ]
    }
   ],
   "source": [
    "print A"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 46,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "[[1.]\n",
      " [2.]\n",
      " [3.]]\n"
     ]
    }
   ],
   "source": [
    "print B"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 47,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "[[14.]\n",
      " [ 4.]\n",
      " [ 4.]\n",
      " [ 4.]\n",
      " [ 4.]]\n"
     ]
    }
   ],
   "source": [
    "print np.dot(A.T,B)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 48,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "(3L, 5L)\n"
     ]
    }
   ],
   "source": [
    "print np.shape(A)"
   ]
  }
 ],
 "metadata": {
  "kernelspec": {
   "display_name": "Python 2",
   "language": "python",
   "name": "python2"
  },
  "language_info": {
   "codemirror_mode": {
    "name": "ipython",
    "version": 2
   },
   "file_extension": ".py",
   "mimetype": "text/x-python",
   "name": "python",
   "nbconvert_exporter": "python",
   "pygments_lexer": "ipython2",
   "version": "2.7.14"
  }
 },
 "nbformat": 4,
 "nbformat_minor": 2
}