lab1_numpy_matrix.ipynb

{
 "cells": [
  {
   "cell_type": "markdown",
   "metadata": {
    "slideshow": {
     "slide_type": "slide"
    }
   },
   "source": [
    "## <center> Matrix Algebra with Numpy </center> ##"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "slideshow": {
     "slide_type": "slide"
    }
   },
   "source": [
    "### What is a matrix? ###\n",
    "\n",
    "A matrix is a two-dimensional data structure where numbers are arranged into rows and columns. For example:\n",
    "\n",
    " ![](img/matrix.jpg)\n",
    "\n",
    "This matrix is a $3\\times 4$ (three-by-four) matrix because it has 3 rows and\n",
    "4 columns."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "slideshow": {
     "slide_type": "slide"
    }
   },
   "source": [
    "### [NumPy]((https://docs.scipy.org/doc/numpy-1.10.1/user/whatisnumpy.html)) Array ###\n",
    "\n",
    "[`NumPy`](https://docs.scipy.org/doc/numpy-1.10.1/user/whatisnumpy.html) is a Python module that supports vectors and matrices in an optimized way. Using the built-in data structures of the Python programming language, we just implemented examples of vectors and matrices, but NumPy gives us a better way. Because NumPy is written in C code, it’s also incredibly fast to do. \n",
    "\n",
    "**Remark:** Linear algebra makes a distinction between \"row vectors\" and \"column vectors\". There is no such distinction in NumPy. There are only n-dimensional arrays. Keep in mind that NumPy was built around a desire to generalize array-like containers to N dimensions where N is bigger than 2. So NumPy operations are defined in ways that generalize to higher dimensions. 1-dimensional NumPy arrays are often used to (approximately) represent vectors however."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "slideshow": {
     "slide_type": "slide"
    }
   },
   "source": [
    "Let's take some examples:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 3,
   "metadata": {
    "slideshow": {
     "slide_type": "slide"
    }
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "[1 2 3] <class 'numpy.ndarray'> int64 (3,) \n",
      "\n",
      "[[0 4 1]\n",
      " [2 0 1]] <class 'numpy.ndarray'> int64 (2, 3) \n",
      "\n",
      "[[[ 0  1 -2  3]\n",
      "  [ 2  3  0  1]\n",
      "  [-1  2  4  1]]\n",
      "\n",
      " [[ 4  5  0  2]\n",
      "  [ 6  7  0  1]\n",
      "  [ 2  1  0  8]]] <class 'numpy.ndarray'> int64 (2, 3, 4)\n"
     ]
    }
   ],
   "source": [
    "import numpy as np\n",
    "\n",
    "# A 1D array, shape-(3,)\n",
    "vector1 = np.array([1,2,3]) \n",
    "\n",
    "# A 2D array, shape-(2,3)\n",
    "matrix1 = np.array( [[0,4,1], [2,0,1]] ) \n",
    "\n",
    "# A 3D array, shape-(2, 3, 4): two two-dimensional arrays of shape 3×4\n",
    "matrix2 = np.array([[[0, 1, -2, 3],\n",
    "                     [2, 3, 0, 1],\n",
    "                     [-1, 2, 4, 1]],\n",
    "                    [[4, 5, 0, 2],\n",
    "                     [6, 7, 0, 1],\n",
    "                     [2, 1, 0, 8]]])\n",
    "\n",
    "print(vector1, type(vector1), vector1.dtype, vector1.shape, '\\n')\n",
    "print(matrix1, type(matrix1), matrix1.dtype, matrix1.shape, '\\n')\n",
    "print(matrix2, type(matrix2), matrix2.dtype, matrix2.shape)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "slideshow": {
     "slide_type": "slide"
    }
   },
   "source": [
    "As you can see, NumPy's array class is called `ndarray`. "
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "slideshow": {
     "slide_type": "slide"
    }
   },
   "source": [
    "### Array of integers, floats and complex Numbers ###"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 2,
   "metadata": {
    "slideshow": {
     "slide_type": "slide"
    }
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "[[1 2 3]\n",
      " [3 4 5]]\n",
      "[[1.1 2.  3. ]\n",
      " [3.  4.  5. ]]\n",
      "[[1.+0.j 2.+0.j 3.+0.j]\n",
      " [3.+0.j 4.+0.j 5.+0.j]]\n",
      "[1.+4.j 2.+5.j 3.+6.j]\n",
      "[-2. +9.j -1.+12.j  0.+15.j]\n"
     ]
    }
   ],
   "source": [
    "B1 = np.array([[1, 2, 3], [3, 4, 5]])\n",
    "print(B1)\n",
    "\n",
    "B2 = np.array([[1.1, 2, 3], [3, 4, 5]]) # Array of floats\n",
    "print(B2)\n",
    "\n",
    "B3 = np.array([[1, 2, 3], [3, 4, 5]], dtype = complex) # Array of complex numbers\n",
    "print(B3)                                              # j = sqrt(-1)\n",
    "\n",
    "a = np.array([1,2,3])\n",
    "b = np.array([4,5,6])\n",
    "B4 = a + 1j*b # Note that the imaginary part is `1j` but not 'j'\n",
    "print(B4)\n",
    "print(B4*(2+1j))"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "slideshow": {
     "slide_type": "slide"
    }
   },
   "source": [
    "### Array of zeros and ones ###"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 8,
   "metadata": {
    "slideshow": {
     "slide_type": "slide"
    }
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "[[0. 0. 0.]\n",
      " [0. 0. 0.]]\n",
      "[[1 1 1 1 1]]\n"
     ]
    }
   ],
   "source": [
    "zeors_array = np.zeros( (2, 3) )\n",
    "print(zeors_array)\n",
    "\n",
    "ones_array = np.ones( (1, 5), dtype=np.int32 ) # specifying dtype\n",
    "print(ones_array)      "
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "slideshow": {
     "slide_type": "slide"
    }
   },
   "source": [
    "Here, we have specified `dtype` to 32 bits (4 bytes). Hence, this array can take values from $-2^{31}$ to $2^{31}-1$."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "slideshow": {
     "slide_type": "slide"
    }
   },
   "source": [
    "### Manipulating arrays with **reshape()** ###\n",
    "\n",
    "NumPy provides an assortment of functions that allow us manipulate the way that an array’s element can be accessed. These permit us to reshape an array, change its dimensionality, and swap the positions of its elements. \n",
    "\n",
    "A complete listing of the available array-manipulation functions can be found in the offocial Numpy documentation [Array manipulation routines](https://docs.scipy.org/doc/numpy/reference/routines.array-manipulation.html). Among these functions, the `reshape()` function is especially useful.\n",
    "\n",
    "The `reshape()` function allows you to change the dimensionality and layout of a given array. Let’s take a shape-(6,) array, and reshape it to a shape-(2, 3) array:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 7,
   "metadata": {
    "slideshow": {
     "slide_type": "slide"
    }
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "x =  [0 1 2 3 4 5] \n",
      " x_reshaped =  [[0 1 2]\n",
      " [3 4 5]]\n"
     ]
    }
   ],
   "source": [
    "x = np.array([0, 1, 2, 3, 4, 5])\n",
    "\n",
    "# Reshape a shape-(6,) array into a shape-(2,3) array\n",
    "x.reshape(2,3) # This doesn't cahnge 'x'\n",
    "print('x = ', x, '\\n', 'x_reshaped = ', x.reshape(2,3))"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "slideshow": {
     "slide_type": "slide"
    }
   },
   "source": [
    "You can also conveniently reshape an array by “setting” its shape via assignment:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 10,
   "metadata": {
    "slideshow": {
     "slide_type": "slide"
    }
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "[[0 1 2]\n",
      " [3 4 5]]\n"
     ]
    }
   ],
   "source": [
    "# equivalent to: x = x.reshape(2, 3)\n",
    "x.shape = (2, 3) #This change 'x'\n",
    "print(x)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "slideshow": {
     "slide_type": "slide"
    }
   },
   "source": [
    "Of course, the size the the initial array must match the size of the to-be reshaped array:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 12,
   "metadata": {
    "slideshow": {
     "slide_type": "slide"
    }
   },
   "outputs": [
    {
     "ename": "ValueError",
     "evalue": "cannot reshape array of size 5 into shape (3,2)",
     "output_type": "error",
     "traceback": [
      "\u001b[0;31m---------------------------------------------------------------------------\u001b[0m",
      "\u001b[0;31mValueError\u001b[0m                                Traceback (most recent call last)",
      "\u001b[0;32m<ipython-input-12-a225c0082d80>\u001b[0m in \u001b[0;36m<module>\u001b[0;34m\u001b[0m\n\u001b[1;32m      1\u001b[0m \u001b[0;31m# an array with 5 numbers are cannot be reshaped\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[1;32m      2\u001b[0m \u001b[0;31m# into a (3, 2) array, which needs 3*2=6 numbers.\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0;32m----> 3\u001b[0;31m \u001b[0mnp\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0marray\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0;34m[\u001b[0m\u001b[0;36m0\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0;36m1\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0;36m2\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0;36m3\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0;36m4\u001b[0m\u001b[0;34m]\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0mreshape\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0;36m3\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0;36m2\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0m",
      "\u001b[0;31mValueError\u001b[0m: cannot reshape array of size 5 into shape (3,2)"
     ]
    }
   ],
   "source": [
    "# an array with 5 numbers are cannot be reshaped\n",
    "# into a (3, 2) array, which needs 3*2=6 numbers.\n",
    "np.array([0, 1, 2, 3, 4]).reshape(3, 2)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "slideshow": {
     "slide_type": "slide"
    }
   },
   "source": [
    "Multidimensional arrays can be reshaped too:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 8,
   "metadata": {
    "slideshow": {
     "slide_type": "slide"
    }
   },
   "outputs": [
    {
     "data": {
      "text/plain": [
       "array([[[ 0,  1],\n",
       "        [ 2,  3],\n",
       "        [ 4,  5]],\n",
       "\n",
       "       [[ 6,  7],\n",
       "        [ 8,  9],\n",
       "        [10, 11]]])"
      ]
     },
     "execution_count": 8,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "# reshaping a multidimensional array\n",
    "y = np.array([[ 0,  1,  2,  3],\n",
    "              [ 4,  5,  6,  7],\n",
    "              [ 8,  9, 10, 11]])\n",
    "\n",
    "# reshape from (3, 4) to (2, 3, 2)\n",
    "y.reshape(2, 3, 2)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "slideshow": {
     "slide_type": "slide"
    }
   },
   "source": [
    "**Remark.** Because the size of an input array and the resulting reshaped array must agree, you can specify one of the dimension-sizes in the reshape function to be -1, and this will cue NumPy to compute that dimension’s size for you. For example, if you are reshaping a shape-(36,) array into a shape-(3, 4, 3) array. The following are valid:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 9,
   "metadata": {
    "slideshow": {
     "slide_type": "slide"
    }
   },
   "outputs": [
    {
     "data": {
      "text/plain": [
       "array([[[ 0,  1,  2],\n",
       "        [ 3,  4,  5],\n",
       "        [ 6,  7,  8],\n",
       "        [ 9, 10, 11]],\n",
       "\n",
       "       [[12, 13, 14],\n",
       "        [15, 16, 17],\n",
       "        [18, 19, 20],\n",
       "        [21, 22, 23]],\n",
       "\n",
       "       [[24, 25, 26],\n",
       "        [27, 28, 29],\n",
       "        [30, 31, 32],\n",
       "        [33, 34, 35]]])"
      ]
     },
     "execution_count": 9,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "# Equivalent ways of specifying a reshape\n",
    "# np.arange(36) produces the shape-(36,) array ([0, 1, 2, ..., 35])\n",
    "np.arange(36).reshape(3, 4, 3)   # (36,) --reshape--> (3, 4, 3)\n",
    "np.arange(36).reshape(3, 4, -1)  # NumPy replaces -1 with 36/(3*4) -> 3\n",
    "np.arange(36).reshape(3, -1, 3)  # NumPy replaces -1 with 36/(3*3) -> 4\n",
    "np.arange(36).reshape(-1, 4, 3)  # NumPy replaces -1 with 36/(3*4) -> 3"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "slideshow": {
     "slide_type": "slide"
    }
   },
   "source": [
    "**Caution!** You can use -1 to specify only one dimension:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 10,
   "metadata": {
    "slideshow": {
     "slide_type": "slide"
    }
   },
   "outputs": [
    {
     "ename": "ValueError",
     "evalue": "can only specify one unknown dimension",
     "output_type": "error",
     "traceback": [
      "\u001b[0;31m---------------------------------------------------------------------------\u001b[0m",
      "\u001b[0;31mValueError\u001b[0m                                Traceback (most recent call last)",
      "\u001b[0;32m/tmp/ipykernel_392104/12521861.py\u001b[0m in \u001b[0;36m<module>\u001b[0;34m\u001b[0m\n\u001b[0;32m----> 1\u001b[0;31m \u001b[0mnp\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0marange\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0;36m36\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0mreshape\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0;36m3\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0;34m-\u001b[0m\u001b[0;36m1\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0;34m-\u001b[0m\u001b[0;36m1\u001b[0m\u001b[0;34m)\u001b[0m  \u001b[0;31m# this is an ambiguous specification, and thus\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0m",
      "\u001b[0;31mValueError\u001b[0m: can only specify one unknown dimension"
     ]
    }
   ],
   "source": [
    "np.arange(36).reshape(3, -1, -1)  # this is an ambiguous specification, and thus"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "slideshow": {
     "slide_type": "slide"
    }
   },
   "source": [
    "For all straightforward applications of reshape, `NumPy` does not actually create a new copy of an array’s data when performing a reshape operation. Instead, the original array and the reshaped array reference the same underlying data. The reshaped array simply provides a new index-interface for accessing said data, and is thus referred to as a “view” of the original array"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "slideshow": {
     "slide_type": "slide"
    }
   },
   "source": [
    "### Matrix Operations ###"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "slideshow": {
     "slide_type": "slide"
    }
   },
   "source": [
    "**Addition of Two Matrics**: We use `+` operator to add corresponding elements of two NumPy matrices."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 11,
   "metadata": {
    "slideshow": {
     "slide_type": "slide"
    }
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "[[11  1]\n",
      " [ 8  0]]\n"
     ]
    }
   ],
   "source": [
    "D1 = np.array([[2, 4], [5, -6]])\n",
    "D2 = np.array([[9, -3], [3, 6]])\n",
    "D = D1 + D2      # element wise addition\n",
    "print(D)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "slideshow": {
     "slide_type": "slide"
    }
   },
   "source": [
    "**Multiplication of Two Matrics** To multiply two matrices, we use `dot()` method. Learn more about how [numpy.dot](https://docs.scipy.org/doc/numpy-1.15.0/reference/generated/numpy.dot.html) works."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 12,
   "metadata": {
    "slideshow": {
     "slide_type": "slide"
    }
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "[[ 36 -12]\n",
      " [ -1   2]]\n"
     ]
    }
   ],
   "source": [
    "E1 = np.array([[3, 6, 7], [5, -3, 0]])\n",
    "E2 = np.array([[1, 1], [2, 1], [3, -3]])\n",
    "E = E1.dot(E2)\n",
    "print(E)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "slideshow": {
     "slide_type": "slide"
    }
   },
   "source": [
    "On the other hand, as of Python 3.5, NumPy supports infix matrix multiplication using the\n",
    "`@` operator, so you can achieve the same convenience of matrix multiplication with ndarrays in Python >= 3.5."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 13,
   "metadata": {
    "slideshow": {
     "slide_type": "slide"
    }
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "[[ 36 -12]\n",
      " [ -1   2]]\n"
     ]
    }
   ],
   "source": [
    "print(E1 @ E2)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "slideshow": {
     "slide_type": "slide"
    }
   },
   "source": [
    "In contrast, numpy arrays consistently abide by the rule that operations are applied element-wise (except for the new `@` operator). Thus, \n",
    "if $A$ and $B$ are numpy arrays whose dimensions are the same, then $A*B$ is the array formed \n",
    "by multiplying element-wise:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 14,
   "metadata": {
    "slideshow": {
     "slide_type": "slide"
    }
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "[[4 6]\n",
      " [6 4]]\n"
     ]
    }
   ],
   "source": [
    "F1=np.array([[4, 3], [2, 1]])\n",
    "F2=np.array([[1, 2], [3, 4]])\n",
    "print(F1*F2)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "slideshow": {
     "slide_type": "slide"
    }
   },
   "source": [
    "If $A$ is a matrix of type ndarray, then`A**2` returns an ndarray with each component squared element-wise. "
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 15,
   "metadata": {
    "slideshow": {
     "slide_type": "slide"
    }
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "[[16  9]\n",
      " [ 4  1]]\n"
     ]
    }
   ],
   "source": [
    "print(F1**2)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "slideshow": {
     "slide_type": "slide"
    }
   },
   "source": [
    "**Transpose of a Matrix** We use `numpy.transpose` to compute transpose of a matrix."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 16,
   "metadata": {
    "slideshow": {
     "slide_type": "slide"
    }
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "[[ 1  2  3]\n",
      " [ 1  1 -3]]\n"
     ]
    }
   ],
   "source": [
    "G = np.array([[1, 1], [2, 1], [3, -3]])\n",
    "print(G.transpose())"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "slideshow": {
     "slide_type": "slide"
    }
   },
   "source": [
    "### Access matrix elements, rows and columns ###"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "slideshow": {
     "slide_type": "slide"
    }
   },
   "source": [
    "**Access matrix elements** Similar like lists, we can access matrix elements using index. Let's start with a one-dimensional NumPy array."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 17,
   "metadata": {
    "slideshow": {
     "slide_type": "slide"
    }
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "H[0] = 2\n",
      "H[2] = 6\n",
      "H[-1] = 10\n"
     ]
    }
   ],
   "source": [
    "H = np.array([2, 4, 6, 8, 10])\n",
    "\n",
    "print(\"H[0] =\", H[0])     # First element     \n",
    "print(\"H[2] =\", H[2])     # Third element \n",
    "print(\"H[-1] =\", H[-1])   # Last element "
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "slideshow": {
     "slide_type": "slide"
    }
   },
   "source": [
    "Notice that the index starts from $0$. Now, let's see how we can access elements of a two-dimensional array (which is basically a matrix)."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 18,
   "metadata": {
    "slideshow": {
     "slide_type": "slide"
    }
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "M[0, 0] = 1\n",
      "M[1, 2] = 9\n",
      "M[-1, -1] = 19\n"
     ]
    }
   ],
   "source": [
    "M = np.array([[1, 4, 5, 12],\n",
    "    [-5, 8, 9, 0],\n",
    "    [-6, 7, 11, 19]])\n",
    "\n",
    "#  First element of first row\n",
    "print(\"M[0, 0] =\", M[0,0])  \n",
    "# Third element of second row\n",
    "print(\"M[1, 2] =\", M[1,2])\n",
    "\n",
    "# Last element of last row\n",
    "print(\"M[-1, -1] =\", M[-1,-1])     "
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "slideshow": {
     "slide_type": "slide"
    }
   },
   "source": [
    "**Access rows of a Matrix** "
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 19,
   "metadata": {
    "slideshow": {
     "slide_type": "slide"
    }
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "M[0] = [ 1  4  5 12]\n",
      "M[2] = [-6  7 11 19]\n",
      "M[-1] = [-6  7 11 19]\n"
     ]
    }
   ],
   "source": [
    "print(\"M[0] =\", M[0]) # First Row\n",
    "print(\"M[2] =\", M[2]) # Third Row\n",
    "print(\"M[-1] =\", M[-1]) # Last Row (3rd row in this case)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "slideshow": {
     "slide_type": "slide"
    }
   },
   "source": [
    "**Access columns of a Matrix**"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 20,
   "metadata": {
    "slideshow": {
     "slide_type": "slide"
    }
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "M[:,0] = [ 1 -5 -6]\n",
      "M[:,3] = [12  0 19]\n",
      "M[:,-1] = [12  0 19]\n"
     ]
    }
   ],
   "source": [
    "print(\"M[:,0] =\",M[:,0]) # First Column\n",
    "print(\"M[:,3] =\", M[:,3]) # Fourth Column\n",
    "print(\"M[:,-1] =\", M[:,-1]) # Last Column (4th column in this case)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "slideshow": {
     "slide_type": "slide"
    }
   },
   "source": [
    "**Slicing of a Matrix** Slicing of a one-dimensional NumPy array is similar to a list. If you don't know how slicing for a list works, visit [Understanding Python's slice notation](https://stackoverflow.com/questions/509211/understanding-slice-notation)."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 21,
   "metadata": {
    "slideshow": {
     "slide_type": "slide"
    }
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "[5 7 9]\n",
      "[1 3 5 7 9 7]\n",
      "[7 5]\n",
      "[1 3 5 7 9 7 5]\n",
      "[5 7 9 7 5 3 1]\n"
     ]
    }
   ],
   "source": [
    "letters = np.array([1, 3, 5, 7, 9, 7, 5])\n",
    "\n",
    "# 3rd to 5th elements\n",
    "print(letters[2:5])        \n",
    "\n",
    "# 1st to 6th elements\n",
    "print(letters[:-1])           \n",
    "\n",
    "# 6th to last elements\n",
    "print(letters[5:])         \n",
    "\n",
    "# 1st to last elements\n",
    "print(letters[:])          \n",
    "\n",
    "# reversing a list\n",
    "print(letters[::-1])  "
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "slideshow": {
     "slide_type": "slide"
    }
   },
   "source": [
    "Now, let's see how we can slice a matrix."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 22,
   "metadata": {
    "slideshow": {
     "slide_type": "slide"
    }
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "[[ 1  4  5 12]\n",
      " [-5  8  9  0]]\n",
      " \n",
      "[ 1  4  5 12]\n",
      " \n",
      "[ 5  9 11]\n",
      " \n",
      "[[ 5 12]\n",
      " [ 9  0]\n",
      " [11 19]]\n"
     ]
    }
   ],
   "source": [
    "print(M[:2, :4])  # two rows (row-0 and row-1), four columns (column-0 through column-3)\n",
    "print(' ')\n",
    "\n",
    "print(M[0,:])  # first row, all columns\n",
    "print(' ')\n",
    "\n",
    "print(M[:,2])  # all rows, third column\n",
    "print(' ')\n",
    "\n",
    "print(M[:, 2:5])  # all rows, third to fifth column"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "slideshow": {
     "slide_type": "slide"
    }
   },
   "source": [
    "### N-dimensional Arrays ###\n",
    "\n",
    "Let’s build up some intuition for arrays with a dimensionality higher than 2. The following code creates a 3-dimensional array:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 23,
   "metadata": {
    "slideshow": {
     "slide_type": "slide"
    }
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "[[[0 1]\n",
      "  [2 3]]\n",
      "\n",
      " [[4 5]\n",
      "  [6 7]]]\n"
     ]
    }
   ],
   "source": [
    "# a 3D array, shape-(2, 2, 2)\n",
    "d3_array = np.array([[[0, 1],\n",
    "                      [2, 3]],\n",
    "                     [[4, 5],\n",
    "                      [6, 7]]])\n",
    "print(d3_array)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "slideshow": {
     "slide_type": "slide"
    }
   },
   "source": [
    "**Depicting the layout of a 3D array**\n",
    "\n",
    "\n",
    "   ![](img/3d_array.png) \n",
    "   \n",
    "You can think of `axis-0` denoting which of the 2x2 “sheets” to select from. \n",
    "Then `axis-1` specifies the row along the sheets, and `axis-2` the column within the row."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "slideshow": {
     "slide_type": "slide"
    }
   },
   "source": [
    "Thus `d3_array[0,1,0]` specifies the element residing in sheet-0, at row-1 (second row) and column-0 (first column):"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 24,
   "metadata": {
    "slideshow": {
     "slide_type": "slide"
    }
   },
   "outputs": [
    {
     "data": {
      "text/plain": [
       "2"
      ]
     },
     "execution_count": 24,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "# Retrieving a single element from a 3D array\n",
    "ex1 = d3_array[0,1,0]\n",
    "ex1"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "slideshow": {
     "slide_type": "slide"
    }
   },
   "source": [
    "`d3_array[:, 0, 0]` specifies the elements in row-0 and column-0 of both sheets:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 25,
   "metadata": {
    "slideshow": {
     "slide_type": "slide"
    }
   },
   "outputs": [
    {
     "data": {
      "text/plain": [
       "array([0, 4])"
      ]
     },
     "execution_count": 25,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "# retrieving a 1D sub-array from a 3D-array\n",
    "ex2 = d3_array[:,0,0]\n",
    "ex2"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "slideshow": {
     "slide_type": "slide"
    }
   },
   "source": [
    "`d3_array[1]`, which recall is shorthand for `d3_array[1, :, :]`, selects both rows and both columns of sheet-1:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 27,
   "metadata": {
    "slideshow": {
     "slide_type": "slide"
    }
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "[[4 5]\n",
      " [6 7]]\n"
     ]
    }
   ],
   "source": [
    "# retrieving a 2D sub-array from a 3D-array\n",
    "ex3 = d3_array[1]\n",
    "print(ex3)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "slideshow": {
     "slide_type": "slide"
    }
   },
   "source": [
    "In four dimensions, one can think of “stacks of sheets with rows and columns” where axis-0 selects the stack of sheets you are working with, axis-1 chooses the sheet, axis-2 chooses the row, and axis-3 chooses the column. Extrapolating to higher dimensions (“collections of stacks of sheets …”) continues in the same tedious fashion."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "slideshow": {
     "slide_type": "slide"
    }
   },
   "source": [
    "###  Exercises ###"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "slideshow": {
     "slide_type": "slide"
    }
   },
   "source": [
    "1. Create a null vector of size 10 but with the fifth value of 1. You should demonstrate the use of 'np.zeros' in your code. \n",
    "2. Create a 2D array of shape-(10,10) with 1 on the border and 0 inside. You should demonstrate the use of 'np.ones' in your code.\n",
    "3. Consider a (6,7,8) shape array, what is the index (x,y,z) of the 100th elements? Here you need to use 'np.arange().reshape()' function to create the (6,7,8)-array\n",
    "4. Given the 3D, shape-(3,3,3) array:\n",
    "\n",
    "   ![](img/nparray-pr1.png)\n",
    "   \n",
    "   Write a code of indexing into the array to produce the following results.   \n",
    "     \n",
    "    ![](img/nparray-pr1c.png) \n",
    "   "
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "slideshow": {
     "slide_type": "slide"
    }
   },
   "source": [
    "### NumPy Resources ###\n",
    "\n",
    "As you can see, using NumPy (instead of nested lists) makes it a lot easier to work with matrices, and we haven't even scratched the basics. We suggest you to explore NumPy package in detail especially if you trying to use Python for data science/analytics.\n",
    "\n",
    " * [Quickstart tutorial](https://docs.scipy.org/doc/numpy-1.15.1/user/quickstart.html)\n",
    " * [Numpy Array Basic A](https://www.bogotobogo.com/python/python_numpy_array_tutorial_basic_A.php)\n",
    "  and [Numpy Array Basic B](https://www.bogotobogo.com/python/python_numpy_array_tutorial_basic_B.php)\n",
    " * [Numpy tutorial](http://www.labri.fr/perso/nrougier/teaching/numpy/numpy.html)\n",
    " * [NumPy Reference](https://docs.scipy.org/doc/numpy-1.14.5/reference/)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": []
  }
 ],
 "metadata": {
  "celltoolbar": "Slideshow",
  "kernelspec": {
   "display_name": "SciML",
   "language": "python",
   "name": "sciml"
  },
  "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.6"
  },
  "toc": {
   "base_numbering": 1,
   "nav_menu": {},
   "number_sections": true,
   "sideBar": true,
   "skip_h1_title": false,
   "title_cell": "Table of Contents",
   "title_sidebar": "Contents",
   "toc_cell": false,
   "toc_position": {},
   "toc_section_display": true,
   "toc_window_display": false
  }
 },
 "nbformat": 4,
 "nbformat_minor": 4
}