04_Vectors_and_Matrices.ipynb

{
 "cells": [
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "# Vectors"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "scrolled": true
   },
   "outputs": [],
   "source": [
    "import sympy\n",
    "import matplotlib\n",
    "import matplotlib.pyplot as plt\n",
    "import numpy as np\n",
    "import matplotlib.cm as cm\n",
    "my_cmap = cm.Pastel2\n",
    "\n",
    "# Versions: So you know which documentation to look at\n",
    "print(\"Version of sympy: \\t\" + str(sympy.__version__)) \n",
    "print(\"Version of matplotlib: \\t\" + str(matplotlib.__version__)) \n",
    "print(\"Version of numpy: \\t\" + str(np.__version__))\n",
    "\n",
    "# Make things from sympy print nicely.\n",
    "sympy.init_printing() \n",
    "\n",
    "# Output of this cell may change depending on which computer you run it on."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "from sympy.vector import CoordSys3D\n",
    "# Create our coordinate system, call it N.\n",
    "N = CoordSys3D('N') \n",
    "\n",
    "# Make a vector\n",
    "v1 = 3*N.i + 4*N.j\n",
    "# Print it out\n",
    "v1"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Find the magnitude of the vector\n",
    "\n",
    "$$\n",
    "    \\| \\mathbf{v} \\| = \\sqrt{ v^2_1 + v^2_2 + \\ldots + v^2_n}\n",
    "$$"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "v1.magnitude()"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Finding the unit-vector\n",
    "\n",
    "$$\n",
    "    \\hat{\\mathbf{v}} = \\frac{\\mathbf{v}}{\\| \\mathbf{v} \\|}\n",
    "$$"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "v_hat = v1 / v1.magnitude()\n",
    "v_hat"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "This is also called 'normalising' and can be done using the `normalize()` method."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "v_normalised = v1.normalize()\n",
    "v_normalised"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "You can even use python to check that they are the same:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "if v_normalised == v_hat:\n",
    "    print(\"They're the same!\")\n",
    "else:\n",
    "    print(\"They're NOT the same!\")"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "(v1.components)[N.i]"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Function to plot vectors at origin in 2D"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "\"\"\"\n",
    "Takes in a list of vectors and plots them on a 2D cartesian plane with starting points at the origin.\n",
    "Colour will be different for each vector.\n",
    "\"\"\"\n",
    "def plot_vecs_2D(v_list):\n",
    "    x = [int(vec.components[N.i]) for vec in v_list]\n",
    "    y = [int(vec.components[N.j]) for vec in v_list]\n",
    "    x_pos = [0 for el in x]\n",
    "    y_pos = [0 for el in y]\n",
    "    # soa = np.array([[0, 0, 3, 2], [0, 0, 1, 1], [0, 0, 9, 9]])\n",
    "    # X, Y, U, V = zip(*soa) # unzipping\n",
    "    plt.figure()\n",
    "    ax = plt.gca()\n",
    "    colours = np.linspace(1,2,len(x))\n",
    "    ax.quiver(x_pos, y_pos, x, y, [colours], angles='xy', scale_units='xy', scale=1, cmap=my_cmap)\n",
    "    lower_x = min([0, 1.2*min(x)])\n",
    "    lower_y = min([0, 1.2*min(y)])\n",
    "    upper_x = max([10, 1.2*max(x)])\n",
    "    upper_y = max([10, 1.2*max(y)])\n",
    "    ax.set_xlim([lower_x, upper_x])\n",
    "    ax.set_ylim([lower_y, upper_y])\n",
    "    plt.xlabel(\"$x$-component\")\n",
    "    plt.ylabel(\"$y$-component\")\n",
    "    plt.grid()\n",
    "    plt.show()"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "scrolled": true
   },
   "outputs": [],
   "source": [
    "v2 = -5*N.i + -7*N.j\n",
    "v3 = 6*N.i + -100*N.j\n",
    "v4 = -1 * v3\n",
    "plot_vecs_2D([v1, v2,v3, v4])"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Graphically proving the parallelogram law"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "\"\"\"\n",
    "Pass in two vectors, 2D..\n",
    "\"\"\"\n",
    "def parallelogram_law(v_1, v_2):\n",
    "    x =    [float(v1.components[N.i]),\n",
    "            float(v2.components[N.i]),\n",
    "            float(v1.components[N.i]),\n",
    "            float(v2.components[N.i])]\n",
    "    y =    [float(v1.components[N.j]),\n",
    "            float(v2.components[N.j]),\n",
    "            float(v1.components[N.j]),\n",
    "            float(v2.components[N.j])]\n",
    "    x_pos = [0,0,float(v2.components[N.i]),float(v1.components[N.i])]\n",
    "    y_pos = [0,0,float(v2.components[N.j]),float(v1.components[N.j])]\n",
    "    # soa = np.array([[0, 0, 3, 2], [0, 0, 1, 1], [0, 0, 9, 9]])\n",
    "    # X, Y, U, V = zip(*soa) # unzipping\n",
    "    plt.figure()\n",
    "    ax = plt.gca()\n",
    "    \n",
    "    ax.quiver(x_pos, y_pos, x, y, [1,2,1,2], angles='xy', scale_units='xy', scale=1, cmap=my_cmap)\n",
    "    lower_x = min([0,  1.2 * (v1.components[N.i]+v2.components[N.i]) ])\n",
    "    lower_y = min([0,  1.2 * (v1.components[N.j]+v2.components[N.j]) ])\n",
    "    upper_x = max([10, 1.2 * (v1.components[N.i]+v2.components[N.i]) ])\n",
    "    upper_y = max([10, 1.2 * (v1.components[N.j]+v2.components[N.j]) ])\n",
    "    print(lower_x, lower_y, upper_x, upper_y)\n",
    "    ax.set_xlim([int(lower_x), int(upper_x)])\n",
    "    ax.set_ylim([int(lower_y), int(upper_y)])\n",
    "    plt.xlabel(\"$x$-component\")\n",
    "    plt.ylabel(\"$y$-component\")\n",
    "    plt.grid()\n",
    "    plt.show()"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "scrolled": false
   },
   "outputs": [],
   "source": [
    "v1 = 3*N.i + 4*N.j\n",
    "v2 = 2*N.i + 100*N.j\n",
    "parallelogram_law(v1, v2)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "# Matrices"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "from sympy import init_printing, Matrix, eye, zeros, diag, Symbol\n",
    "init_printing() # Pretty printing"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Make a Vector"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "\n",
    "\n",
    "# Column vector\n",
    "\n",
    "\n",
    "v = Matrix([\n",
    "    [1],\n",
    "    [2],\n",
    "    [3]\n",
    "])\n",
    "\n",
    "# Row vector\n",
    "u = Matrix([    [4,5,6]  ])\n",
    "\n",
    "\n",
    "display(v, u)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Make a Matrix"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "A = Matrix([\n",
    "    [1,2,3],\n",
    "    [4,5,6],\n",
    "    [7,8,9]\n",
    "])\n",
    "\n",
    "A"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Identity Matrices"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "eye(2)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "eye(5)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Zero Matrices"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "zeros(3)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "zeros(6)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Diagonal Matrices\n",
    "\n",
    "You can pass in a series of values that will be positioned along the diagonal of a square matrix."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "diag(1,2,3)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "diag(4,5,6,7)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "diag(3.14, 2.71, 6.626)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Access Rows/Columns at a Time\n",
    "\n",
    "Once you have created a `Matrix`, you can access it's rows and columns with the appropriate method for that object.\n",
    "\n",
    "There are however two caveats to indexing matrices in python. \n",
    "1. Python is 'column-major', meaning if you access a two-dimensional array you specify **column first and then row**. This is the opposite way around as the way we do it with matrices.\n",
    "2. Numbering starts from `0` in python. So what we would usually refer to as row 1, we will from here on in refer to as row 0."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "A = Matrix([\n",
    "    [1,2,3],\n",
    "    [4,5,6],\n",
    "    [7,8,9]\n",
    "])\n",
    "\n",
    "# Row access\n",
    "display(A.row(0))\n",
    "\n",
    "# Column access\n",
    "display(A.col(0))\n",
    "\n",
    "# Element-specific indexing\n",
    "display(A[0,2]) # See, row first, then column!\n",
    "display(A[2,2])\n",
    "\n",
    "# You can also access the n-th element in the matrix if you fancy.\n",
    "display(A[4])"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Want reduced-row-echelon-form (rref)?"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "scrolled": true
   },
   "outputs": [],
   "source": [
    "A = Matrix([\n",
    "    [1,2,3],\n",
    "    [4,5,6],\n",
    "    [7,8,9]\n",
    "])\n",
    "\n",
    "A.rref() # As simple as that!"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "We can see that two elements were returned. The first is the row-reduced form of $\\mathbf{A}$, the other is a `tuple` of the columns of $\\mathbf{A}$ that contain pivots."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Want the inverse of a matrix?"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "# Resetting A (in case of unordered use of cells)\n",
    "A = Matrix([\n",
    "    [1,2,-1],\n",
    "    [2,-1,-1],\n",
    "    [-1,-1,3]\n",
    "])\n",
    "\n",
    "A.inv() # One-liner!"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Transpose of a matrix?"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "# Resetting A (in case of unordered use of cells)\n",
    "A = Matrix([\n",
    "    [1,2,3],\n",
    "    [4,5,6],\n",
    "    [7,8,9]\n",
    "])\n",
    "\n",
    "display(A)\n",
    "display(A.T) # Note that this is an attribute and not a method (no need for parantheses to call a function)."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Now with row-reductions:\n",
    "\n",
    "Because `sympy` has automated a lot of the matrix processes, it seems that row operations are not particularly intuitive operations for whatever reason that may be.\n",
    "\n",
    "The best way to learn this is likely to closely follow the example below and ask questions."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "# Resetting A (in case of unordered use of cells)\n",
    "A = Matrix([\n",
    "    [1,2,-1],\n",
    "    [2,-1,-1],\n",
    "    [-1,-1,3]\n",
    "])\n",
    "\n",
    "display(A)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "# R1 = R1 - 2*R0                          .  < That dot is above the row number you're subtracting.\n",
    "A.row_op(1, lambda one, row_el: one - 2*A[0,row_el])\n",
    "#                                            ^ This is a varaible to allow sympy to iterate over all row elements\n",
    "display(A)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "# R2 = R2 + R0\n",
    "A.row_op(2, lambda two, row_el: two + A[0,row_el])\n",
    "display(A)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "# R1 <--> R2\n",
    "A.row_swap(1,2)\n",
    "display(A)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "# R2 = R2 + 5*R1\n",
    "A.row_op(2, lambda two, row_el: two + 5*A[1, row_el])\n",
    "display(A)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "# R2 = (1/11)*R2\n",
    "A.row_op(2, lambda two, row_el: int((1/11)*A[2,row_el]))\n",
    "display(A)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "# R1 = R1 - 2*R2\n",
    "A.row_op(1, lambda one, row_el: one - 2*A[2,row_el])\n",
    "display(A)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "# R0 = R0 + R2\n",
    "A.row_op(0, lambda zero, row_el: zero+ A[2, row_el])\n",
    "display(A)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "# R0 = R0 -2*R1\n",
    "A.row_op(0, lambda zero, row_el: zero -2*A[1, row_el])\n",
    "display(A)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Invert a Matrix to Solve \n",
    "$$\n",
    "\\mathbf{Ax}=\\mathbf{b} \\quad \\Rightarrow \\quad \n",
    "\\mathbf{x}=\\mathbf{A^{-1}b}\n",
    "$$"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "# Changing A\n",
    "A = Matrix([\n",
    "    [1,2,-1],\n",
    "    [2,-1,-1],\n",
    "    [-1,-1,3]\n",
    "])\n",
    "\n",
    "# Right-hand side of the equation\n",
    "b = Matrix([\n",
    "    5,\n",
    "    0,\n",
    "    8\n",
    "])\n",
    "\n",
    "# Solving the equation.\n",
    "x = A.inv()*b\n",
    "\n",
    "display(x)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Symbolic Matrices\n",
    "\n",
    "The useful thing about some calculations is specifying a value in your matrix so that some property is true.\n",
    "\n",
    "E.g.\n",
    "\n",
    "Determine the value of $c$ so that $\\mathbf{A}$ has a determinant of 0.\n",
    "\n",
    "$$\n",
    "\\mathbf{A} = \n",
    "\\begin{bmatrix}\n",
    "    c & 2 & 1 \\\\\n",
    "    5      & -1 & 2 \\\\\n",
    "    -3     & 1 & -1 \\\\\n",
    "\\end{bmatrix}\n",
    "$$"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "c = Symbol('c')\n",
    "\n",
    "A = Matrix([\n",
    "    [c,2,1],\n",
    "    [5,-1,2],\n",
    "    [-3,1,-1]\n",
    "])\n",
    "\n",
    "display('A is: ', A)\n",
    "\n",
    "\n",
    "display('Det(A) = ', A.det())"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "So if:\n",
    "$$\\text{det}(\\mathbf{A}) = 0$$\n",
    "then $$-c=0 \\quad \\text{ and so } \\quad c=0$$ \n",
    "\n",
    "for the matrix to have a determinant of zero.\n",
    "\n",
    "A matrix with a zero determinant is called a 'singular' matrix."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Eigenvalues & Eigenvectors\n",
    "\n",
    "An eigenvalue and eigenvector are solutions to the following equation:\n",
    "\n",
    "$$\n",
    "\\mathbf{Ax}\n",
    "=\n",
    "\\lambda\n",
    "\\mathbf{x}\n",
    "$$\n",
    "\n",
    "Where $\\lambda$ is an _eigen**value**_ and $\\mathbf{x}$ is an _eigen**vector**_.\n",
    "\n"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "* The direction of an _eigen**vector**_ is unchanged, but its magnitude may not be.\n",
    "\n",
    "* So we can say that $\\mathbf{x}$ is a vector who's direction is unchanged by the linear transformation, $\\mathbf{A}$.\n",
    "\n",
    "* The _eigen**value**_ is how much the magnitude of the _eigen**vector**_ is changed."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "The approach is to:\n",
    "\n",
    "1. Find the _eigen**values**_.\n",
    "2. Use each _eigen**value** to find one _eigen**vector**_."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Eigenvalues"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "A = Matrix([\n",
    "    [1,2],\n",
    "    [2,4]\n",
    "])\n",
    "\n",
    "e_vals = A.eigenvals()\n",
    "\n",
    "print('Type of object: \\t' + str(type(e_vals)))"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "So the `eigenval` method has returned us a `dictionary` object. So, what are the `keys` and `values`?"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "e_vals.keys()"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "e_vals.values()"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "display(e_vals)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "The eigenvalues: $\\lambda_1 = 0$ and $\\lambda_2=5$ are the `keys` of the `dictionary`. The `values` in that `dictionary` are the 'multiplicity' of that eigenvalue, meaning how many times that eigenvalue occurred. For both values, their multiplicity is one."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Eigenvectors"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "# Resetting A (in case of unordered cells).\n",
    "A = Matrix([\n",
    "    [1,2],\n",
    "    [2,4]\n",
    "])\n",
    "\n",
    "A.eigenvects()"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "From the `eigenvects` method we are returned a `list` containing `tuples`.\n",
    "\n",
    "We also have the information we previously gathered (the eigenvalues) as well as the requested eigenvectors.\n",
    "\n",
    "Interpretting the first element of the `list`:\n",
    "\n",
    "The eigenvalue $\\lambda_1 = 0$ with multiplicity $1$ is used to obtain the vector $\\begin{bmatrix} -2 \\\\ 1 \\end{bmatrix}$.\n",
    "\n",
    "And interpretting the second value in the `list`:\n",
    "\n",
    "The eigenvalue $\\lambda_2 = 5$ with multiplicity $1$ is used to obtain the vector $\\begin{bmatrix} 1/2 \\\\ 1 \\end{bmatrix}$."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "# -------- Questions --------"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "# Question 0:\n",
    "\n",
    "Display the transpose of the following matrix:\n",
    "\n",
    "(Run the cell to obtain the matrix)\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "from sympy import init_printing, Matrix, eye, zeros, diag, Symbol, randMatrix\n",
    "init_printing()\n",
    "\n",
    "A = randMatrix(5,5)\n",
    "display(A)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "# Answer 0:\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": []
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Question 1:\n",
    "\n",
    "If you have a matrix:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "A = randMatrix(3,3)\n",
    "display(A)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Find the `rref` and determine if it has an inverse."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Answer 1:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": []
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Question 2:\n",
    "\n",
    "\n",
    "$$\n",
    "    \\begin{bmatrix} \n",
    "        4 & 3 \\\\\n",
    "\t\t-10 & -2 \\\\\t\t\n",
    "    \\end{bmatrix}\n",
    "    \\begin{bmatrix} \n",
    "        x \\\\\n",
    "\t\ty \\\\\t\t\n",
    "    \\end{bmatrix}\n",
    "    =\n",
    "    \\begin{bmatrix} \n",
    "        -13 \\\\\n",
    "        5 \\\\\n",
    "    \\end{bmatrix}\n",
    "$$\n",
    "\n",
    "Solve for $x$ and $y$."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Answer 2:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": []
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Question 3:\n",
    "\n",
    "Determine the eigenvalues and eigenvectors of:\n",
    "\n",
    "$$\n",
    "\\mathbf{Q}\n",
    "=\n",
    "\\begin{bmatrix}\n",
    "0 & 1 \\\\\n",
    "-1 & 0 \\\\\n",
    "\\end{bmatrix}\n",
    "$$"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Answer 3:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": []
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "# Question 4:\n",
    "\n",
    "Show, using `if` statements and comparisons, that the following matrix is equal itself after being multiplied by an appropriately sized identity matrix.\n",
    "\n",
    "# Answer 4:\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "from sympy import randMatrix\n",
    "\n",
    "A = randMatrix(6,6)\n",
    "display(A)\n",
    "\n",
    "# Your code here"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "# Question 5:\n",
    "\n",
    "(i) Write a loop to create five square, random matrices. Determine if each of them have an inverse.\n",
    "\n",
    "(ii) Write another loop to create five rectangular, random matrices. Should these have an inverse? What happens when you attempt to invert them?\n",
    "\n",
    "What can we say about the `randMatrix` function?"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Bonus Question :\n",
    "\n",
    "What is meant by a 'pivot'?"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": []
  }
 ],
 "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.3"
  }
 },
 "nbformat": 4,
 "nbformat_minor": 2
}