IdentifyingSpecialMatrices.ipynb

{
 "cells": [
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "# Identifying special matrices\n",
    "## Instructions\n",
    "In this assignment, you shall write a function that will test if a 4×4 matrix is singular, i.e. to determine if an inverse exists, before calculating it.\n",
    "\n",
    "You shall use the method of converting a matrix to echelon form, and testing if this fails by leaving zeros that can’t be removed on the leading diagonal.\n",
    "\n",
    "Don't worry if you've not coded before, a framework for the function has already been written.\n",
    "Look through the code, and you'll be instructed where to make changes.\n",
    "We'll do the first two rows, and you can use this as a guide to do the last two.\n",
    "\n",
    "### Matrices in Python\n",
    "In the *numpy* package in Python, matrices are indexed using zero for the top-most column and left-most row.\n",
    "I.e., the matrix structure looks like this:\n",
    "```python\n",
    "A[0, 0]  A[0, 1]  A[0, 2]  A[0, 3]\n",
    "A[1, 0]  A[1, 1]  A[1, 2]  A[1, 3]\n",
    "A[2, 0]  A[2, 1]  A[2, 2]  A[2, 3]\n",
    "A[3, 0]  A[3, 1]  A[3, 2]  A[3, 3]\n",
    "```\n",
    "You can access the value of each element individually using,\n",
    "```python\n",
    "A[n, m]\n",
    "```\n",
    "which will give the n'th row and m'th column (starting with zero).\n",
    "You can also access a whole row at a time using,\n",
    "```python\n",
    "A[n]\n",
    "```\n",
    "Which you will see will be useful when calculating linear combinations of rows.\n",
    "\n",
    "A final note - Python is sensitive to indentation.\n",
    "All the code you should complete will be at the same level of indentation as the instruction comment.\n",
    "\n",
    "### How to submit\n",
    "Edit the code in the cell below to complete the assignment.\n",
    "Once you are finished and happy with it, press the *Submit Assignment* button at the top of this notebook.\n",
    "\n",
    "Please don't change any of the function names, as these will be checked by the grading script.\n",
    "\n",
    "If you have further questions about submissions or programming assignments, here is a [list](https://www.coursera.org/learn/linear-algebra-machine-learning/discussions/weeks/1/threads/jB4klkn5EeibtBIQyzFmQg) of Q&A. You can also raise an issue on the discussion forum. Good luck!"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 27,
   "metadata": {},
   "outputs": [],
   "source": [
    "# GRADED FUNCTION\n",
    "import numpy as np\n",
    "\n",
    "# Our function will go through the matrix replacing each row in order turning it into echelon form.\n",
    "# If at any point it fails because it can't put a 1 in the leading diagonal,\n",
    "# we will return the value True, otherwise, we will return False.\n",
    "# There is no need to edit this function.\n",
    "def isSingular(A) :\n",
    "    B = np.array(A, dtype=np.float_) # Make B as a copy of A, since we're going to alter it's values.\n",
    "    try:\n",
    "        fixRowZero(B)\n",
    "        fixRowOne(B)\n",
    "        fixRowTwo(B)\n",
    "        fixRowThree(B)\n",
    "    except MatrixIsSingular:\n",
    "        return True\n",
    "    return False\n",
    "\n",
    "# This next line defines our error flag. For when things go wrong if the matrix is singular.\n",
    "# There is no need to edit this line.\n",
    "class MatrixIsSingular(Exception): pass\n",
    "\n",
    "# For Row Zero, all we require is the first element is equal to 1.\n",
    "# We'll divide the row by the value of A[0, 0].\n",
    "# This will get us in trouble though if A[0, 0] equals 0, so first we'll test for that,\n",
    "# and if this is true, we'll add one of the lower rows to the first one before the division.\n",
    "# We'll repeat the test going down each lower row until we can do the division.\n",
    "# There is no need to edit this function.\n",
    "def fixRowZero(A) :\n",
    "    if A[0,0] == 0 :\n",
    "        A[0] = A[0] + A[1]\n",
    "    if A[0,0] == 0 :\n",
    "        A[0] = A[0] + A[2]\n",
    "    if A[0,0] == 0 :\n",
    "        A[0] = A[0] + A[3]\n",
    "    if A[0,0] == 0 :\n",
    "        raise MatrixIsSingular()\n",
    "    A[0] = A[0] / A[0,0]\n",
    "    return A\n",
    "\n",
    "# First we'll set the sub-diagonal elements to zero, i.e. A[1,0].\n",
    "# Next we want the diagonal element to be equal to one.\n",
    "# We'll divide the row by the value of A[1, 1].\n",
    "# Again, we need to test if this is zero.\n",
    "# If so, we'll add a lower row and repeat setting the sub-diagonal elements to zero.\n",
    "# There is no need to edit this function.\n",
    "def fixRowOne(A) :\n",
    "    A[1] = A[1] - A[1,0] * A[0]\n",
    "    if A[1,1] == 0 :\n",
    "        A[1] = A[1] + A[2]\n",
    "        A[1] = A[1] - A[1,0] * A[0]\n",
    "    if A[1,1] == 0 :\n",
    "        A[1] = A[1] + A[3]\n",
    "        A[1] = A[1] - A[1,0] * A[0]\n",
    "    if A[1,1] == 0 :\n",
    "        raise MatrixIsSingular()\n",
    "    A[1] = A[1] / A[1,1]\n",
    "    return A\n",
    "\n",
    "# This is the first function that you should complete.\n",
    "# Follow the instructions inside the function at each comment.\n",
    "def fixRowTwo(A) :\n",
    "    # Insert code below to set the sub-diagonal elements of row two to zero (there are two of them).\n",
    "    A[2] = A[2] - A[0]*A[2,0]\n",
    "    A[2] = A[2] - A[1]*(A[2,1]-A[0,1]*A[2,0])\n",
    "    \n",
    "    # Next we'll test that the diagonal element is not zero.\n",
    "    if A[2,2] == 0 :\n",
    "        # Insert code below that adds a lower row to row 2.\n",
    "        A[2] = A[2] + A[3]\n",
    "        A[2] = A[2] - A[0]*A[2,0]\n",
    "        A[2] = A[2] - A[1]*(A[2,1]-A[0,1]*A[2,0])       \n",
    "\n",
    "        # Now repeat your code which sets the sub-diagonal elements to zero.\n",
    "    if A[2,2] == 0 :\n",
    "        # Insert code below that adds a lower row to row 2.\n",
    "        A[2] = A[2] + A[3]\n",
    "        A[2] = A[2] - A[0]*A[2,0]\n",
    "        A[2] = A[2] - A[1]*(A[2,1]-A[0,1]*A[2,0])      \n",
    "        \n",
    "    if A[2,2] == 0 :\n",
    "        raise MatrixIsSingular()\n",
    "    # Finally set the diagonal element to one by dividing the whole row by that element.\n",
    "    A[2] = A[2] / A[2,2]\n",
    "    return A\n",
    "\n",
    "# You should also complete this function\n",
    "# Follow the instructions inside the function at each comment.\n",
    "def fixRowThree(A) :\n",
    "    # Insert code below to set the sub-diagonal elements of row three to zero.\n",
    "    A[3] = A[3] - A[0]*A[3,0]\n",
    "    A[3] = A[3] - A[1]*(A[3,1]-A[0,1]*A[3,0])\n",
    "    A[3] = A[3] - A[2]*(A[3,2]-A[0,2]*A[3,0]- A[3,1]*A[1,2])\n",
    "    \n",
    "    # Complete the if statement to test if the diagonal element is zero.\n",
    "    if A[3,3] == 0 :\n",
    "        A[3] = A[3] - A[0]*A[3,0]\n",
    "        A[3] = A[3] - A[1]*(A[3,1]-A[0,1]*A[3,0])\n",
    "        A[3] = A[3] - A[2]*(A[3,2]-A[0,2]*A[3,0]- A[3,1]*A[1,2])\n",
    "    if A[3,3] == 0 :\n",
    "        A[3] = A[3] - A[0]*A[3,0]\n",
    "        A[3] = A[3] - A[1]*(A[3,1]-A[0,1]*A[3,0])\n",
    "        A[3] = A[3] - A[2]*(A[3,2]-A[0,2]*A[3,0]- A[3,1]*A[1,2])    \n",
    "    \n",
    "    if A[3,3] == 0 : \n",
    "        raise MatrixIsSingular()\n",
    "    # Transform the row to set the diagonal element to one.\n",
    "    A[3] = A[3] / A[3,3]\n",
    "    return A"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Test your code before submission\n",
    "To test the code you've written above, run the cell (select the cell above, then press the play button [ ▶| ] or press shift-enter).\n",
    "You can then use the code below to test out your function.\n",
    "You don't need to submit this cell; you can edit and run it as much as you like.\n",
    "\n",
    "Try out your code on tricky test cases!"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 28,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "True"
      ]
     },
     "execution_count": 28,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "A = np.array([\n",
    "        [2, 0, 0, 0],\n",
    "        [0, 3, 0, 0],\n",
    "        [0, 0, 4, 4],\n",
    "        [0, 0, 5, 5]\n",
    "    ], dtype=np.float_)\n",
    "isSingular(A)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 29,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "array([[  1. ,   7.5,  -2.5,   3.5],\n",
       "       [  2. ,   8. ,   0. ,   4. ],\n",
       "       [  3. ,  12. ,   0. ,   5. ],\n",
       "       [  1. ,   3. ,   1. ,   3. ]])"
      ]
     },
     "execution_count": 29,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "A = np.array([\n",
    "        [0, 7, -5, 3],\n",
    "        [2, 8, 0, 4],\n",
    "        [3, 12, 0, 5],\n",
    "        [1, 3, 1, 3]\n",
    "    ], dtype=np.float_)\n",
    "fixRowZero(A)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 30,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "array([[  1.        ,   7.5       ,  -2.5       ,   3.5       ],\n",
       "       [ -0.        ,   1.        ,  -0.71428571,   0.42857143],\n",
       "       [  3.        ,  12.        ,   0.        ,   5.        ],\n",
       "       [  1.        ,   3.        ,   1.        ,   3.        ]])"
      ]
     },
     "execution_count": 30,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "fixRowOne(A)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 31,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "array([[ 1.        ,  7.5       , -2.5       ,  3.5       ],\n",
       "       [-0.        ,  1.        , -0.71428571,  0.42857143],\n",
       "       [ 0.        ,  0.        ,  1.        ,  1.5       ],\n",
       "       [ 1.        ,  3.        ,  1.        ,  3.        ]])"
      ]
     },
     "execution_count": 31,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "fixRowTwo(A)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 32,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "array([[ 1.        ,  7.5       , -2.5       ,  3.5       ],\n",
       "       [-0.        ,  1.        , -0.71428571,  0.42857143],\n",
       "       [ 0.        ,  0.        ,  1.        ,  1.5       ],\n",
       "       [ 0.        ,  0.        ,  0.        ,  1.        ]])"
      ]
     },
     "execution_count": 32,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "fixRowThree(A)"
   ]
  }
 ],
 "metadata": {
  "coursera": {
   "course_slug": "linear-algebra-machine-learning",
   "graded_item_id": "vhy4M",
   "launcher_item_id": "3vbW4"
  },
  "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.6.0"
  }
 },
 "nbformat": 4,
 "nbformat_minor": 1
}