system_of_linearEquations.ipynb

{
 "cells": [
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Solve system of Linear Equations\n",
    "\n",
    "either use linalg.inv() and linalg.dot() methods in chain to solve a system of linear equations, or simply use the solve() method. The solve() method is preferred.\n",
    "\n",
    "To find the value of x and y variables in Equation 1, we need to find the values in the matrix X. To do so, we can take the dot product of the inverse of matrix A, and the matrix B as shown below:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 4,
   "metadata": {},
   "outputs": [],
   "source": [
    "from sympy import Matrix\n",
    "import numpy as np"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 5,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Matrix A:\n",
      " [[ 7  4  1]\n",
      " [ 3  0  1]\n",
      " [-4  4  0]]\n",
      "Augmented Matrix [A B]\n",
      " [[ 7  4  1  8]\n",
      " [ 3  0  1  2]\n",
      " [-4  4  0  4]]\n",
      "The Row echelon form of matrix M and the pivot columns : (Matrix([\n",
      "[1, 0, 0, 1/4],\n",
      "[0, 1, 0, 5/4],\n",
      "[0, 0, 1, 5/4]]), (0, 1, 2))\n",
      "\n",
      "the free variables are:\n",
      "Write X1 in terms of the free variables\n",
      "Write X2 in terms of the free variables\n",
      "Write X3 in terms of the free variables\n",
      "\n",
      "Then write solution X in vector form [X1, X2, X3...Xn] = ... in terms of free variables\n",
      "Method1 answer: [0.25 1.25 1.25] \n",
      "\n",
      " Method2 answer: [0.25 1.25 1.25]\n"
     ]
    }
   ],
   "source": [
    "#4x  + 3y = 20\n",
    "#-5x + 9y = 26\n",
    "\n",
    "#A = [[ 4   3]\n",
    "     #[-5   9]]\n",
    "#A = np.array([[4, 3], [-5, 9]])\n",
    "A = np.array([[7, 4, 1], [3, 0, 1], [-4, 4, 0]])\n",
    "#A = np.array([[1, 2, 0, -3], [3, 6, 0, -9]])\n",
    "#A = np.array([[1, -2, -1, 3], [-2, 4, 5, -5], [3, -6, -6, 8]])\n",
    "#A = np.array([[1, 0, 5, -5, 2, -7], [0, 0, 1, 0, 0,-2], [0, 0, 0, 0, 1, 3], [0, 0, 0, 0, 0, 0]])\n",
    "print(\"Matrix A:\"+\"\\n\",A)\n",
    "\n",
    "#X = [[x]\n",
    "     #[y]]\n",
    "\n",
    "#B = [[20]\n",
    "     #[26]]\n",
    "#B = np.array([20, 26])\n",
    "#B = np.array([25, -10, -4])\n",
    "#B = np.array([0, 0])\n",
    "B = np.array([8, 2, 4])\n",
    "#B = np.array([0, 0, 0, 0])\n",
    "\n",
    "try:\n",
    "    inv_A = np.linalg.inv(A)\n",
    "    # METHOD 1: \n",
    "    X = np.linalg.inv(A).dot(B)\n",
    "    # METHOD 2: \n",
    "    X2 = np.linalg.solve(A,B)\n",
    "    \n",
    "    free_vars = []\n",
    "    #A_new = np.hstack((A,B))\n",
    "    numcols = A.shape[1]\n",
    "    A_new=(np.column_stack((A,B)))\n",
    "    print(\"Augmented Matrix [A B]\"+\"\\n\",A_new)\n",
    "    M_rref = Matrix(A_new).rref()     \n",
    "    print(\"The Row echelon form of matrix M and the pivot columns : {}\".format(M_rref)) \n",
    "    for i in range(0,numcols):\n",
    "        if i not in list(M_rref[1]):\n",
    "            free_vars.append(i)\n",
    "    print(\"\\n\"+\"the free variables are:\")\n",
    "    for ii in free_vars:\n",
    "        print(\"X\"+str(ii+1))\n",
    "    for iii in range(0,numcols):\n",
    "        if iii in list(M_rref[1]):\n",
    "            print(\"Write X\"+str(iii+1)+\" in terms of the free variables\")\n",
    "    print(\"\\n\"+\"Then write solution X in vector form [X1, X2, X3...Xn] = ... in terms of free variables\")\n",
    "    col_range = (M_rref[0]).shape[1]-1 \n",
    "    for l in np.array(M_rref[0]):\n",
    "        l = list(l)\n",
    "        if l[:col_range].count(0) == len(l[:col_range]):\n",
    "            if l[-2] == 0 and l[-1] != 0:\n",
    "                print(\"NO SOLUTION DUE TO ROW:\"+\"\\n\"+l)\n",
    "                    \n",
    "    if str(X) != str(X2):# or X[1]!=X2[1]:\n",
    "        print(\"UH OH! A discrepancy has occured between answers\")\n",
    "   \n",
    "    else: \n",
    "\n",
    "        print(\"Method1 answer:\",X,\"\\n\\n\",\"Method2 answer:\",X2)\n",
    "except Exception as e:\n",
    "    print(e,\"\\n\", \"Unable to solve non-square matrix; must resolve w/ row-reduction\"+\"\\n\")\n",
    "    free_vars = []\n",
    "    #A_new = np.hstack((A,B))\n",
    "    numcols = A.shape[1]\n",
    "    A_new=(np.column_stack((A,B)))\n",
    "    print(\"Augmented Matrix [A B]\"+\"\\n\",A_new)\n",
    "    M_rref = Matrix(A_new).rref()     \n",
    "    print(\"The Row echelon form of matrix M and the pivot columns : {}\".format(M_rref)) \n",
    "    for i in range(0,numcols):\n",
    "        if i not in list(M_rref[1]):\n",
    "            free_vars.append(i)\n",
    "    print(\"\\n\"+\"the free variables are:\")\n",
    "    for ii in free_vars:\n",
    "        print(\"X\"+str(ii+1))\n",
    "    for iii in range(0,numcols):\n",
    "        if iii in list(M_rref[1]):\n",
    "            print(\"Write X\"+str(iii+1)+\" in terms of the free variables\")\n",
    "    print(\"\\n\"+\"Then write solution X in vector form [X1, X2, X3...Xn] = ... in terms of free variables\")\n",
    "    col_range = (M_rref[0]).shape[1]-1 \n",
    "    for l in np.array(M_rref[0]):\n",
    "        l = list(l)\n",
    "        if l[:col_range].count(0) == len(l[:col_range]):\n",
    "            if l[-2] == 0 and l[-1] != 0:\n",
    "                print(\"\\n\"+\"NO SOLUTION DUE TO ROW:\"+\"\\n\"+str(l))"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": []
  },
  {
   "cell_type": "code",
   "execution_count": 6,
   "metadata": {},
   "outputs": [],
   "source": [
    "#https://integratedmlai.com/system-of-equations-solution/\n",
    "def print_matrix(Title, M):\n",
    "    print(Title)\n",
    "    for row in M:\n",
    "        print([round(x,3)+0 for x in row])\n",
    "        \n",
    "def print_matrices(Action, Title1, M1, Title2, M2):\n",
    "    print(Action)\n",
    "    print(Title1, '\\t'*int(len(M1)/2)+\"\\t\"*len(M1), Title2)\n",
    "    for i in range(len(M1)):\n",
    "        row1 = ['{0:+7.3f}'.format(x) for x in M1[i]]\n",
    "        row2 = ['{0:+7.3f}'.format(x) for x in M2[i]]\n",
    "        print(row1,'\\t', row2)\n",
    "        \n",
    "def zeros_matrix(rows, cols):\n",
    "    A = []\n",
    "    for i in range(rows):\n",
    "        A.append([])\n",
    "        for j in range(cols):\n",
    "            A[-1].append(0.0)\n",
    "\n",
    "    return A\n",
    "\n",
    "def copy_matrix(M):\n",
    "    rows = len(M)\n",
    "    cols = len(M[0])\n",
    "\n",
    "    MC = zeros_matrix(rows, cols)\n",
    "\n",
    "    for i in range(rows):\n",
    "        for j in range(cols):\n",
    "            MC[i][j] = M[i][j]\n",
    "\n",
    "    return MC\n",
    "\n",
    "def matrix_multiply(A,B):\n",
    "    rowsA = len(A)\n",
    "    colsA = len(A[0])\n",
    "\n",
    "    rowsB = len(B)\n",
    "    colsB = len(B[0])\n",
    "\n",
    "    if colsA != rowsB:\n",
    "        print('Number of A columns must equal number of B rows.')\n",
    "        sys.exit()\n",
    "\n",
    "    C = zeros_matrix(rowsA, colsB)\n",
    "\n",
    "    for i in range(rowsA):\n",
    "        for j in range(colsB):\n",
    "            total = 0\n",
    "            for ii in range(colsA):\n",
    "                total += A[i][ii] * B[ii][j]\n",
    "            C[i][j] = total\n",
    "\n",
    "    return C"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 7,
   "metadata": {},
   "outputs": [],
   "source": [
    "A = [[5.,3.,1.],[3.,9.,4.],[1.,3.,5.]]\n",
    "B = [[9.0],[16.0],[9.0]]"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 8,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Starting Matrices are:\n",
      "AM Matrix \t\t\t\t IM Matrix\n",
      "[' +5.000', ' +3.000', ' +1.000'] \t [' +9.000']\n",
      "[' +3.000', ' +9.000', ' +4.000'] \t ['+16.000']\n",
      "[' +1.000', ' +3.000', ' +5.000'] \t [' +9.000']\n",
      "\n",
      "\n",
      "Using the matrices above, Scale row-1 of AM and BM by diagonal element 1 of AM, which is 1/+5.000.\n",
      "\n",
      "AM Matrix \t\t\t\t BM Matrix\n",
      "[' +1.000', ' +0.600', ' +0.200'] \t [' +1.800']\n",
      "[' +3.000', ' +9.000', ' +4.000'] \t ['+16.000']\n",
      "[' +1.000', ' +3.000', ' +5.000'] \t [' +9.000']\n",
      "\n",
      "Using matrices above, subtract +3.000 *row-1 of AM from row-2 of AM, and subtract +3.000 * row-1 of BM from row-2 of BM\n",
      "\n",
      "AM Matrix \t\t\t\t BM Matrix\n",
      "[' +1.000', ' +0.600', ' +0.200'] \t [' +1.800']\n",
      "[' +0.000', ' +7.200', ' +3.400'] \t ['+10.600']\n",
      "[' +1.000', ' +3.000', ' +5.000'] \t [' +9.000']\n",
      "\n",
      "Using matrices above, subtract +1.000 *row-1 of AM from row-3 of AM, and subtract +1.000 * row-1 of BM from row-3 of BM\n",
      "\n",
      "AM Matrix \t\t\t\t BM Matrix\n",
      "[' +1.000', ' +0.600', ' +0.200'] \t [' +1.800']\n",
      "[' +0.000', ' +7.200', ' +3.400'] \t ['+10.600']\n",
      "[' +0.000', ' +2.400', ' +4.800'] \t [' +7.200']\n",
      "\n",
      "\n",
      "Using the matrices above, Scale row-2 of AM and BM by diagonal element 2 of AM, which is 1/+7.200.\n",
      "\n",
      "AM Matrix \t\t\t\t BM Matrix\n",
      "[' +1.000', ' +0.600', ' +0.200'] \t [' +1.800']\n",
      "[' +0.000', ' +1.000', ' +0.472'] \t [' +1.472']\n",
      "[' +0.000', ' +2.400', ' +4.800'] \t [' +7.200']\n",
      "\n",
      "Using matrices above, subtract +0.600 *row-2 of AM from row-1 of AM, and subtract +0.600 * row-2 of BM from row-1 of BM\n",
      "\n",
      "AM Matrix \t\t\t\t BM Matrix\n",
      "[' +1.000', ' +0.000', ' -0.083'] \t [' +0.917']\n",
      "[' +0.000', ' +1.000', ' +0.472'] \t [' +1.472']\n",
      "[' +0.000', ' +2.400', ' +4.800'] \t [' +7.200']\n",
      "\n",
      "Using matrices above, subtract +2.400 *row-2 of AM from row-3 of AM, and subtract +2.400 * row-2 of BM from row-3 of BM\n",
      "\n",
      "AM Matrix \t\t\t\t BM Matrix\n",
      "[' +1.000', ' +0.000', ' -0.083'] \t [' +0.917']\n",
      "[' +0.000', ' +1.000', ' +0.472'] \t [' +1.472']\n",
      "[' +0.000', ' +0.000', ' +3.667'] \t [' +3.667']\n",
      "\n",
      "\n",
      "Using the matrices above, Scale row-3 of AM and BM by diagonal element 3 of AM, which is 1/+3.667.\n",
      "\n",
      "AM Matrix \t\t\t\t BM Matrix\n",
      "[' +1.000', ' +0.000', ' -0.083'] \t [' +0.917']\n",
      "[' +0.000', ' +1.000', ' +0.472'] \t [' +1.472']\n",
      "[' +0.000', ' +0.000', ' +1.000'] \t [' +1.000']\n",
      "\n",
      "Using matrices above, subtract -0.083 *row-3 of AM from row-1 of AM, and subtract -0.083 * row-3 of BM from row-1 of BM\n",
      "\n",
      "AM Matrix \t\t\t\t BM Matrix\n",
      "[' +1.000', ' +0.000', ' +0.000'] \t [' +1.000']\n",
      "[' +0.000', ' +1.000', ' +0.472'] \t [' +1.472']\n",
      "[' +0.000', ' +0.000', ' +1.000'] \t [' +1.000']\n",
      "\n",
      "Using matrices above, subtract +0.472 *row-3 of AM from row-2 of AM, and subtract +0.472 * row-3 of BM from row-2 of BM\n",
      "\n",
      "AM Matrix \t\t\t\t BM Matrix\n",
      "[' +1.000', ' +0.000', ' +0.000'] \t [' +1.000']\n",
      "[' +0.000', ' +1.000', ' +0.000'] \t [' +1.000']\n",
      "[' +0.000', ' +0.000', ' +1.000'] \t [' +1.000']\n",
      "\n"
     ]
    }
   ],
   "source": [
    "AM = copy_matrix(A)\n",
    "n = len(A)\n",
    "BM = copy_matrix(B)\n",
    "\n",
    "print_matrices('Starting Matrices are:', 'AM Matrix', AM, \n",
    "               'IM Matrix', BM)\n",
    "print()\n",
    "\n",
    "indices = list(range(n)) # allow flexible row referencing ***\n",
    "for fd in range(n): # fd stands for focus diagonal\n",
    "    fdScaler = 1.0 / AM[fd][fd]\n",
    "    # FIRST: scale fd row with fd inverse. \n",
    "    for j in range(n): # Use j to indicate column looping.\n",
    "        AM[fd][j] *= fdScaler\n",
    "    BM[fd][0] *= fdScaler\n",
    "    \n",
    "    # Section to print out current actions:\n",
    "    string1  = '\\nUsing the matrices above, '\n",
    "    string1 += 'Scale row-{} of AM and BM by '\n",
    "    string2  = 'diagonal element {} of AM, '\n",
    "    string2 += 'which is 1/{:+.3f}.\\n'\n",
    "    stringsum = string1 + string2\n",
    "    val1 = fd+1; val2 = fd+1\n",
    "    Action = stringsum.format(val1,val2,round(1./fdScaler,3))\n",
    "    print_matrices(Action, 'AM Matrix', AM, 'BM Matrix', BM)\n",
    "    print()\n",
    "    \n",
    "    # SECOND: operate on all rows except fd row.\n",
    "    for i in indices[0:fd] + indices[fd+1:]: # *** skip fd row.\n",
    "        crScaler = AM[i][fd] # cr stands for \"current row\".\n",
    "        for j in range(n): # cr - crScaler*fdRow.\n",
    "            AM[i][j] = AM[i][j] - crScaler * AM[fd][j]\n",
    "        BM[i][0] = BM[i][0] - crScaler * BM[fd][0]\n",
    "        \n",
    "        # Section to print out current actions:\n",
    "        string1  = 'Using matrices above, subtract {:+.3f} *'\n",
    "        string1 += 'row-{} of AM from row-{} of AM, and '\n",
    "        string2 = 'subtract {:+.3f} * row-{} of BM '\n",
    "        string2 += 'from row-{} of BM\\n'\n",
    "        val1 = i+1; val2 = fd+1\n",
    "        stringsum = string1 + string2\n",
    "        Action = stringsum.format(crScaler, val2, val1, \n",
    "                                  crScaler, val2, val1)\n",
    "        print_matrices(Action, 'AM Matrix', AM, \n",
    "                               'BM Matrix', BM)\n",
    "        print()"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 9,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Now we multiply the original A matrix times our solution for X, which is BM.\n",
      "If we get our starting X, our solution is proved.\n",
      "\n",
      "[9.0]\n",
      "[16.0]\n",
      "[9.0]\n"
     ]
    }
   ],
   "source": [
    "print(\"Now we multiply the original A matrix times our solution for X, which is BM.\")\n",
    "print_matrix('If we get our starting X, our solution is proved.\\n', matrix_multiply(A,BM))"
   ]
  },
  {
   "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.8.3"
  }
 },
 "nbformat": 4,
 "nbformat_minor": 4
}