Tutorial013_NumpyExercises.ipynb

{
 "cells": [
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## EXERCISES\n",
    "\n",
    "### Vector Multiplication\n",
    "1. Produce 2 vectors, one with integers in the range [5,10] and the other [15,20] using the np.arange function\n",
    "1. Without using any functions from the numpy module\n",
    "    1. Compute the outer product of those vectors \n",
    "    1. Compute the \"trace\" of the resulting matrix\n",
    "    \n",
    "    ![trace](https://wikimedia.org/api/rest_v1/media/math/render/svg/3e5b6e82272fc5eeca6d510388e0a2bd0a6c6463)\n",
    "    \n",
    "    \n",
    "Complete the same items using numpy operations"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 1,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "605"
      ]
     },
     "execution_count": 1,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "import numpy as np\n",
    "a = np.arange(5,10)\n",
    "b = np.arange(15,20)\n",
    "a.dot(b.T)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 2,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Outer Product:\n"
     ]
    },
    {
     "data": {
      "text/plain": [
       "[[75, 80, 85, 90, 95],\n",
       " [90, 96, 102, 108, 114],\n",
       " [105, 112, 119, 126, 133],\n",
       " [120, 128, 136, 144, 152],\n",
       " [135, 144, 153, 162, 171]]"
      ]
     },
     "execution_count": 2,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "# outer product\n",
    "p_out = [] # initialize empty list\n",
    "\n",
    "assert (len(a)==len(b)), 'Lists must be the same length!' #what happened if a =! b in the first place?\n",
    "\n",
    "for i in range(len(a)): # iterate through indicies of vectors\n",
    "    row = [] # initialize sub list\n",
    "    for j in range(len(b)):\n",
    "        row.append(a[i]*b[j])\n",
    "        \n",
    "    p_out.append(row)\n",
    "\n",
    "print('Outer Product:') # Print Output\n",
    "p_out"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 3,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Trace: 605\n"
     ]
    }
   ],
   "source": [
    "# trace\n",
    "p_trace = []\n",
    "\n",
    "assert (len(a)==len(b)), 'Lists must be the same length!'\n",
    "\n",
    "for i in range(len(a)):\n",
    "    p_trace.append(a[i]*b[i])\n",
    "\n",
    "print('Trace: %d' %sum(p_trace)) \n",
    "\n",
    "# for i in range(len(a)):\n",
    "#     for j in range(len(b)):\n",
    "#             while i == j:\n",
    "#                 p_trace.append(a[i]*b[j])\n",
    "\n",
    "# print('Trace: %d' %sum(p_trace)) "
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 4,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Trace: 605\n",
      "Trace: 605\n",
      "Outer Product:\n"
     ]
    },
    {
     "data": {
      "text/plain": [
       "array([[ 75,  80,  85,  90,  95],\n",
       "       [ 90,  96, 102, 108, 114],\n",
       "       [105, 112, 119, 126, 133],\n",
       "       [120, 128, 136, 144, 152],\n",
       "       [135, 144, 153, 162, 171]])"
      ]
     },
     "execution_count": 4,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "p_trace = [a[i]*b[i] for i in range(len(a))]\n",
    "print('Trace: %d' %sum(p_trace)) # Print trace\n",
    "\n",
    "p_trace = np.inner(a, b)\n",
    "print('Trace: %d' %p_trace)\n",
    "#vector inner product = trace\n",
    "\n",
    "p_outer = np.outer(a, b)\n",
    "print('Outer Product:')\n",
    "p_outer"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Matrix Multiplication\n",
    "* Two matricies can be multiplied if their inner dimensions match (eg. 2x3 * 3x5 -> 2x5). The best rule for working with and mutliplying matricies is to remember (rows x columns). This applies to both the dimensions of a matrix (a 2x3 matrix has 2 rows and 3 columns) as well as multiplication (you multiply the rows of the first matrix by the columns of the second). \n",
    "\n",
    "* When multiplying two matricies of dimension (M x N)*(N x P) the resulting matrix is (M x P). The upper element of the reslting matrix is the inner (or dot) product of the first row of the first matrix and the first column of the second matrix\n",
    "\n",
    "![two matrices](https://wikimedia.org/api/rest_v1/media/math/render/svg/16b1644351bc2041175b19cbc65da03ef78130c7)\n",
    "\n",
    "![store product in matrix C](https://wikimedia.org/api/rest_v1/media/math/render/svg/00ac0c831c365b7424cc43239aae8cebea27c56c)\n",
    "\n",
    "![matrix multiply](https://wikimedia.org/api/rest_v1/media/math/render/svg/3cfeccef1c8c7e6da0ddf08daed8dbf3c6f50c5e)\n",
    "\n",
    "for i = 1, ..., n and j = 1, ..., p.\n",
    "\n",
    "1. Make two matrices of random numbers (A and B). A should be a 4x3 matrix and B should be a 3x4 matrix. Multiply A by B using (to a resulting matrix C) using:\n",
    "    1. a conventional for-loop\n",
    "    1. list comprehension\n",
    "    1. numpy operator\n",
    "    \n",
    "2. After you have C, pull out the upper quadrant using fancy indexing, and then replace the main diagonal (upper left to lower right) with 0s. "
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 5,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "[[ 0  1  2]\n",
      " [ 3  4  5]\n",
      " [ 6  7  8]\n",
      " [ 9 10 11]]\n",
      "[[13. 14. 15. 16.]\n",
      " [17. 18. 19. 20.]\n",
      " [21. 22. 23. 24.]]\n"
     ]
    }
   ],
   "source": [
    "A = np.arange(12).reshape(4,3)\n",
    "B = np.linspace(13,24,12).reshape(3,4)\n",
    "print(A)\n",
    "print(B)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 6,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "resulting matrix:\n"
     ]
    },
    {
     "data": {
      "text/plain": [
       "[[59.0, 62.0, 65.0, 68.0],\n",
       " [212.0, 224.0, 236.0, 248.0],\n",
       " [365.0, 386.0, 407.0, 428.0],\n",
       " [518.0, 548.0, 578.0, 608.0]]"
      ]
     },
     "execution_count": 6,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "C = []\n",
    "\n",
    "for i in range(A.shape[0]):\n",
    "    row = []\n",
    "    for j in range(B.shape[1]):\n",
    "        row.append(sum(A[i,:]*B[:,j]))\n",
    "    \n",
    "    C.append(row)\n",
    "    \n",
    "print('resulting matrix:')\n",
    "C"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 7,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "resulting matrix\n"
     ]
    },
    {
     "data": {
      "text/plain": [
       "dtype('int32')"
      ]
     },
     "execution_count": 7,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "C = [[sum(A[i,:]*B[:,j]) for j in range(B.shape[1])] for i in range(A.shape[0])]\n",
    "print('resulting matrix') # Print trace\n",
    "C\n",
    "A.dtype\n",
    "#the second dimension is internal to the first dim"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 8,
   "metadata": {},
   "outputs": [],
   "source": [
    "C = A.dot(B)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 16,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "<class 'numpy.ndarray'>\n",
      "the main diagonal with zeros:\n"
     ]
    },
    {
     "data": {
      "text/plain": [
       "array([[  0.,  62.,  65.,  68.],\n",
       "       [212.,   0., 236., 248.],\n",
       "       [365., 386.,   0., 428.],\n",
       "       [518., 548., 578.,   0.]])"
      ]
     },
     "execution_count": 16,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "np.array(C)\n",
    "print(type(C))\n",
    "\n",
    "\n",
    "for i in range(len(C)):\n",
    "    C[i][i]=0\n",
    "\n",
    "print('the main diagonal with zeros:')\n",
    "C"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 17,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "array([[ 65.,  68.],\n",
       "       [236., 248.]])"
      ]
     },
     "execution_count": 17,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "#C[[0,2],[2,4]]\n",
    "upper_quadrant = C[:2,2:4]\n",
    "(C[0:2])[:, 2:4] #column indexing doesn't work for list, it should work for numpy.ndarray"
   ]
  }
 ],
 "metadata": {
  "kernelspec": {
   "display_name": "Python 3",
   "language": "python",
   "name": "python3"
  },
  "language_info": {
   "codemirror_mode": {
    "name": "ipython",
    "version": 3
   },
   "file_extension": ".py",
   "mimetype": "text/x-python",
   "name": "python",
   "nbconvert_exporter": "python",
   "pygments_lexer": "ipython3",
   "version": "3.7.1"
  }
 },
 "nbformat": 4,
 "nbformat_minor": 2
}