testBetter.ipynb

{
 "cells": [
  {
   "cell_type": "code",
   "execution_count": 55,
   "metadata": {},
   "outputs": [],
   "source": [
    "# from mpmath import mp, matrix\n",
    "# import numpy as np\n",
    "\n",
    "\n",
    "# class GaussEliminationSolver:\n",
    "#     def __init__(self, A, B, sf=5):\n",
    "#         self.sf = sf\n",
    "#         mp.dps = self.sf\n",
    "#         self.n= A.rows\n",
    "#         self.A = mp.matrix(A)\n",
    "#         self.B = mp.matrix(B)\n",
    "\n",
    "#     def scaling(self):\n",
    "#         scaling_factors = mp.matrix([0] * self.n)\n",
    "#         for i in range(self.n):\n",
    "#             scaling_factors[i, 0] = max([abs(self.A[i, j]) for j in range(i + 1)])\n",
    "#         return scaling_factors\n",
    "\n",
    "#     def gaussian_elimination(self):\n",
    "#         augmented_matrix = matrix(\n",
    "#             [[self.A[i, j] for j in range(self.A.cols)] + [self.B[i, 0]] for i in range(self.A.rows)])\n",
    "#         n = augmented_matrix.rows\n",
    "\n",
    "#         print(\"Initial Augmented Matrix:\")\n",
    "#         print(augmented_matrix)\n",
    "\n",
    "#         scaling_factors = self.scaling()\n",
    "\n",
    "#         for i in range(n):\n",
    "#             max_index = max(range(i, n), key=lambda x: abs(\n",
    "#                 augmented_matrix[x, i] / scaling_factors[x]))\n",
    "\n",
    "#             if i != max_index:\n",
    "#                 print(f\"\\nSwapping rows {i + 1} and {max_index + 1}:\")\n",
    "#                 augmented_matrix[i, :], augmented_matrix[max_index,\n",
    "#                                                          :] = augmented_matrix[max_index, :], augmented_matrix[i, :]\n",
    "#                 print(augmented_matrix)\n",
    "\n",
    "#             for j in range(i + 1, n):\n",
    "#                 factor = augmented_matrix[j, i] / augmented_matrix[i, i]\n",
    "#                 print(\n",
    "#                     f\"\\nRow {j + 1} = Row {j + 1} - ({factor}) * Row {i + 1}:\")\n",
    "#                 augmented_matrix[j, :] -= factor * augmented_matrix[i, :]\n",
    "#                 print(augmented_matrix)\n",
    "\n",
    "#         return augmented_matrix\n",
    "\n",
    "#     def back_substitution(self, augmented_matrix):\n",
    "#         n = len(augmented_matrix)\n",
    "#         solution = matrix([mp.mpf(0)] * n)\n",
    "\n",
    "#         for i in range(n - 1, -1, -1):\n",
    "#             # Fetch the constant from the augmented matrix\n",
    "#             solution[i] = mp.mpf(augmented_matrix[i, n])\n",
    "\n",
    "#             for j in range(i + 1, n):\n",
    "#                 solution[i] -= mp.mpf(augmented_matrix[i, j]) * solution[j]\n",
    "\n",
    "#             solution[i] /= mp.mpf(augmented_matrix[i, i])\n",
    "\n",
    "#         return solution\n",
    "\n",
    "\n",
    "# # Example usage:\n",
    "# A = matrix([[-8, 1, -2],\n",
    "#             [-3, -1, 7],\n",
    "#             [2, -6, 1]])\n",
    "\n",
    "# B = matrix([[106.8],\n",
    "#             [177.2],\n",
    "#             [279.2]])\n",
    "\n",
    "# solver = GaussEliminationSolver(A, B)\n",
    "# augmented_matrix = solver.gaussian_elimination()\n",
    "# solution = solver.back_substitution(augmented_matrix)\n",
    "\n",
    "# print(\"\\nSolution:\")\n",
    "# print(solution)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 54,
   "metadata": {},
   "outputs": [],
   "source": [
    "# from mpmath import mp, matrix\n",
    "# from Solver import Solver\n",
    "\n",
    "# class GaussEliminationSolver(Solver):\n",
    "\n",
    "#     def solve(self):\n",
    "#         augmented_matrix = self.gaussian_elimination()\n",
    "#         solution = self.back_substitution(augmented_matrix)\n",
    "#         return solution\n",
    "\n",
    "#     def gaussian_elimination(self):\n",
    "#         A,B = self.A,self.B\n",
    "#         augmented_matrix = matrix([[A[i, j] for j in range(A.cols)] + [B[i, 0]] for i in range(A.rows)])\n",
    "#         n = augmented_matrix.rows\n",
    "\n",
    "#         self.steps.append(\"Initial Augmented Matrix:\")\n",
    "#         self.steps.append(augmented_matrix)\n",
    "\n",
    "#         for i in range(n):\n",
    "#             max_index = max(range(i, n), key=lambda x: abs(augmented_matrix[x, i]))\n",
    "\n",
    "#             if i != max_index:\n",
    "#                 self.steps.append(f\"\\nSwapping rows {i + 1} and {max_index + 1}:\")\n",
    "#                 augmented_matrix[i, :], augmented_matrix[max_index, :] = augmented_matrix[max_index, :], augmented_matrix[i, :]\n",
    "#                 self.steps.append(augmented_matrix)\n",
    "\n",
    "\n",
    "#             for j in range(i + 1, n):\n",
    "#                 factor = augmented_matrix[j, i] / augmented_matrix[i, i]\n",
    "#                 self.steps.append(f\"\\nRow {j + 1} = Row {j + 1} - ({factor}) * Row {i + 1}:\")\n",
    "#                 augmented_matrix[j, :] -= factor * augmented_matrix[i, :]\n",
    "#                 self.steps.append(augmented_matrix)\n",
    "\n",
    "#         return augmented_matrix\n",
    "\n",
    "#     def back_substitution(self, augmented_matrix):\n",
    "#         n = len(augmented_matrix)\n",
    "#         solution = matrix([mp.mpf(0)] * n)  \n",
    "\n",
    "#         for i in range(n - 1, -1, -1):\n",
    "#             solution[i] = mp.mpf(augmented_matrix[i, n])  # Fetch the constant from the augmented matrix\n",
    "\n",
    "#             for j in range(i + 1, n):\n",
    "#                 solution[i] -= mp.mpf(augmented_matrix[i, j]) * solution[j]\n",
    "\n",
    "#             solution[i] /= mp.mpf(augmented_matrix[i, i])\n",
    "\n",
    "#         return solution\n",
    "\n",
    "\n",
    "    \n",
    "\n",
    "# # Example \n",
    "# A = matrix([[-8, 1, -2],\n",
    "#             [-3, -1, 7],\n",
    "#             [2, -6, 1]])\n",
    "\n",
    "# B = matrix([[106.8],\n",
    "#             [177.2],\n",
    "#             [279.2]])\n",
    "\n",
    "# a = GaussEliminationSolver(A,B)\n",
    "# solution = a.back_substitution(a.gaussian_elimination())\n",
    "# print(solution)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "JACOBI TEST\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 19,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "R = [0.0  1.0]\n",
      "[4.0  0.0]\n",
      "D = [-8.0  0.0]\n",
      "[ 0.0  2.0]\n",
      "Iteration 1:\n",
      "x_old = [1.0]\n",
      "[1.0]\n",
      "R = [0.0  1.0]\n",
      "[4.0  0.0]\n",
      "v2 = [1.0]\n",
      "[1.0]\n",
      "x0 = -1.8125 and Absolute relative error: 1.5517\n",
      "R = [0.0  1.0]\n",
      "[4.0  0.0]\n",
      "v2 = [1.0]\n",
      "[1.0]\n",
      "x1 = 0.5 and Absolute relative error: 1.0\n",
      "Iteration 2:\n",
      "x_old = [-1.8125]\n",
      "[    0.5]\n",
      "R = [0.0  1.0]\n",
      "[4.0  0.0]\n",
      "v2 = [-1.8125]\n",
      "[    0.5]\n",
      "x0 = -1.875 and Absolute relative error: 0.033333\n",
      "R = [0.0  1.0]\n",
      "[4.0  0.0]\n",
      "v2 = [-1.8125]\n",
      "[    0.5]\n",
      "x1 = 6.125 and Absolute relative error: 0.91837\n",
      "Iteration 3:\n",
      "x_old = [-1.875]\n",
      "[ 6.125]\n",
      "R = [0.0  1.0]\n",
      "[4.0  0.0]\n",
      "v2 = [-1.875]\n",
      "[ 6.125]\n",
      "x0 = -1.1719 and Absolute relative error: 0.6\n",
      "R = [0.0  1.0]\n",
      "[4.0  0.0]\n",
      "v2 = [-1.875]\n",
      "[ 6.125]\n",
      "x1 = 6.25 and Absolute relative error: 0.02\n",
      "Iteration 4:\n",
      "x_old = [-1.1719]\n",
      "[   6.25]\n",
      "R = [0.0  1.0]\n",
      "[4.0  0.0]\n",
      "v2 = [-1.1719]\n",
      "[   6.25]\n",
      "x0 = -1.1563 and Absolute relative error: 0.013514\n",
      "R = [0.0  1.0]\n",
      "[4.0  0.0]\n",
      "v2 = [-1.1719]\n",
      "[   6.25]\n",
      "x1 = 4.8438 and Absolute relative error: 0.29032\n",
      "Iteration 5:\n",
      "x_old = [-1.1563]\n",
      "[ 4.8438]\n",
      "R = [0.0  1.0]\n",
      "[4.0  0.0]\n",
      "v2 = [-1.1563]\n",
      "[ 4.8438]\n",
      "x0 = -1.332 and Absolute relative error: 0.13196\n",
      "R = [0.0  1.0]\n",
      "[4.0  0.0]\n",
      "v2 = [-1.1563]\n",
      "[ 4.8438]\n",
      "x1 = 4.8125 and Absolute relative error: 0.0064935\n",
      "Iteration 6:\n",
      "x_old = [-1.332]\n",
      "[4.8125]\n",
      "R = [0.0  1.0]\n",
      "[4.0  0.0]\n",
      "v2 = [-1.332]\n",
      "[4.8125]\n",
      "x0 = -1.3359 and Absolute relative error: 0.002924\n",
      "R = [0.0  1.0]\n",
      "[4.0  0.0]\n",
      "v2 = [-1.332]\n",
      "[4.8125]\n",
      "x1 = 5.1641 and Absolute relative error: 0.068079\n",
      "\n",
      "Converged after 6 iterations.\n",
      "[-1.3359]\n",
      "[ 5.1641]\n"
     ]
    }
   ],
   "source": [
    "\n",
    "import numpy as np\n",
    "from mpmath import mp, matrix\n",
    "\n",
    "def diagonally_dominant(array, parsed_bef):\n",
    "        abs_matrix = np.absolute(array.tolist())\n",
    "        diagonal = np.diag(abs_matrix)\n",
    "        greater = False\n",
    "        gr_eq = True\n",
    "        for i in range(abs_matrix.shape[0]):\n",
    "            if diagonal[i] > np.sum(abs_matrix,axis=1)[i] - diagonal[i]:\n",
    "                greater = True\n",
    "            elif diagonal[i] == np.sum(abs_matrix,axis=1)[i] - diagonal[i]:\n",
    "                continue\n",
    "            else:\n",
    "                gr_eq = False\n",
    "                break\n",
    "        \n",
    "        if greater and gr_eq:\n",
    "            return array, True\n",
    "        elif not parsed_bef:\n",
    "            return convert_matrix(array)\n",
    "        else:\n",
    "            return array, False\n",
    "\n",
    "def convert_matrix(array):\n",
    "        array = np.array(array.tolist())  # convert to numpy array\n",
    "        if len(array.shape) == 1:\n",
    "            array = np.expand_dims(array, axis=0)\n",
    "        abs_matrix = np.absolute(array)\n",
    "        max_indices = np.argmax(abs_matrix, axis=1)\n",
    "        #Check if the matrix can be converted into diagonal diagonally dominant one\n",
    "        if len(np.unique(max_indices)) != len(max_indices):\n",
    "            return array, False\n",
    "        \n",
    "        for i in range(array.shape[0]):\n",
    "            max_ind = np.argmax(abs_matrix[i])\n",
    "            if i != max_ind:\n",
    "                array[:,[i,max_ind]] = array[:, [max_ind,i]]\n",
    "                abs_matrix[:, [i,max_ind]] = abs_matrix[:, [max_ind,i]]\n",
    "\n",
    "        return diagonally_dominant(array,True)\n",
    "\n",
    "class JacobiSolver:\n",
    "\n",
    "    def __init__(self, A, b, itr=10, tolerance=0.00001, x=None, Sf=5):\n",
    "        self.A = A\n",
    "        self.AD = np.array(A)\n",
    "        self.b = b\n",
    "        self.itr = itr\n",
    "        self.tolerance = tolerance\n",
    "        self.x = mp.matrix(x)\n",
    "        self.sf = Sf\n",
    "        \n",
    "        pass\n",
    "\n",
    "        \n",
    "    def matrixwithoutDiagonal(self, A): # function to get the matrix without the diagonal and the diagonal\n",
    "        Dia=mp.matrix(len(A))\n",
    "        for i in range(len(A)):\n",
    "            Dia[i, i] = A[i, i]\n",
    "            A[i, i] = 0\n",
    "        return A, Dia  \n",
    "    def check_zero_diagonal(self, matrix): # function to check if the diagonal has zeros\n",
    "        for i in range(len(matrix)):\n",
    "            if matrix[i, i] == 0:\n",
    "                return True\n",
    "        return False\n",
    "    \n",
    "    def solve(self): # function to solve the system of equations\n",
    "        mp.dps = self.sf # set the precision\n",
    "        \n",
    "        \n",
    "        # if self.check_zero_diagonal(D):\n",
    "        #     self.A,check= diagonally_dominant(self.A, False)\n",
    "        #     self.A=mp.matrix(self.A)\n",
    "        #     R,D = self.matrixwithoutDiagonal(self.A) # R is the matrix without the diagonal\n",
    "        \n",
    "        \n",
    "        # iterate through the number of iterations\n",
    "        \n",
    "        R,D = self.matrixwithoutDiagonal(self.A) # R is the matrix without the diagonal \n",
    "        R=mp.matrix(R)\n",
    "        D=mp.matrix(D)\n",
    "        print(f\"R = {R}\")\n",
    "        print(f\"D = {D}\")\n",
    "        \n",
    "        for i in range(self.itr):\n",
    "            print(f\"Iteration {i+1}:\")\n",
    "            x_old = mp.matrix(self.x.copy())  # copy the old values of x\n",
    "            print(f\"x_old = {x_old}\")\n",
    "            for itr in range(len(self.x)):\n",
    "                # dot_product = round_to_sf(sum(round_to_sf(R[itr, j] * x_old[j],sf) for j in range(len(x_old))),sf)\n",
    "                dot_product = mp.mpf(self.matrixSumofProduct(R, x_old, itr)) # calculate the sum of the product of R and x_old\n",
    "                self.x[itr] = mp.mpf(mp.mpf(self.b[itr] - dot_product) / D[itr, itr]) # calculate the new x\n",
    "                abs_rel_error = (np.abs((self.x[itr] - x_old[itr]) / self.x[itr]))  # calculate the absolute relative error for each x\n",
    "                print(\n",
    "                    f\"x{itr} = {self.x[itr]} and Absolute relative error: {abs_rel_error}\") # print the new x and the absolute relative error\n",
    "            \n",
    "            err = np.absolute((np.array(self.x.tolist()) - np.array(x_old.tolist())) / np.array(self.x.tolist()))\n",
    "            if np.all(err < self.tolerance):\n",
    "                print(f\"\\nConverged after {i + 1} iterations.\")\n",
    "                break\n",
    "\n",
    "        return self.x\n",
    "        pass\n",
    "\n",
    "    # function to calculate the sum of the product of two vectors\n",
    "    def matrixSumofProduct(self, R, v2, itr):\n",
    "        sum = mp.mpf(0)\n",
    "        R = mp.matrix(R)\n",
    "        v2 = mp.matrix(v2)\n",
    "        print(f\"R = {R}\")\n",
    "        print(f\"v2 = {v2}\")\n",
    "        for i in range(len(v2)): # iterate through the length of the vector\n",
    "            sum += R[itr, i] * v2[i,0] \n",
    "        return sum\n",
    "    \n",
    "    \n",
    "    \n",
    "# # Example usage:\n",
    "\n",
    "A = mp.matrix([[-8, 1],\n",
    "            [4,2]])\n",
    "B = mp.matrix([15.5, 5])\n",
    "    \n",
    "x = mp.matrix([[1],\n",
    "            [1]])\n",
    "x= (JacobiSolver(A, B, 50 , 0.1 ,x=x ).solve())\n",
    "\n",
    "\n",
    "print(x)   \n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 3,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Iteration 1:\n",
      "x_old = [1.0]\n",
      "[0.0]\n",
      "[1.0]\n",
      "x0 = 1.375 and Absolute relative error: 0.27273\n",
      "x1 = 1.0 and Absolute relative error: 1.0\n",
      "x2 = 1.1667 and Absolute relative error: 0.14286\n",
      "Iteration 2:\n",
      "x_old = [ 1.375]\n",
      "[   1.0]\n",
      "[1.1667]\n",
      "x0 = 0.95833 and Absolute relative error: 0.43478\n",
      "x1 = 0.89167 and Absolute relative error: 0.12149\n",
      "x2 = 0.875 and Absolute relative error: 0.33333\n",
      "Iteration 3:\n",
      "x_old = [0.95833]\n",
      "[0.89167]\n",
      "[  0.875]\n",
      "x0 = 1.0719 and Absolute relative error: 0.10593\n",
      "x1 = 1.0333 and Absolute relative error: 0.1371\n",
      "x2 = 1.0319 and Absolute relative error: 0.15209\n",
      "Iteration 4:\n",
      "x_old = [1.0719]\n",
      "[1.0333]\n",
      "[1.0319]\n",
      "x0 = 0.97951 and Absolute relative error: 0.094292\n",
      "x1 = 0.97924 and Absolute relative error: 0.055244\n",
      "x2 = 0.97049 and Absolute relative error: 0.063327\n",
      "Iteration 5:\n",
      "x_old = [0.97951]\n",
      "[0.97924]\n",
      "[0.97049]\n",
      "x0 = 1.0152 and Absolute relative error: 0.035119\n",
      "x1 = 1.01 and Absolute relative error: 0.03046\n",
      "x2 = 1.0103 and Absolute relative error: 0.039398\n",
      "Iteration 6:\n",
      "x_old = [1.0152]\n",
      "[  1.01]\n",
      "[1.0103]\n",
      "x0 = 0.99368 and Absolute relative error: 0.021625\n",
      "x1 = 0.99491 and Absolute relative error: 0.015168\n",
      "x2 = 0.99328 and Absolute relative error: 0.017127\n",
      "Iteration 7:\n",
      "x_old = [0.99368]\n",
      "[0.99491]\n",
      "[0.99328]\n",
      "x0 = 1.0036 and Absolute relative error: 0.009877\n",
      "x1 = 1.0026 and Absolute relative error: 0.0076799\n",
      "x2 = 1.003 and Absolute relative error: 0.0096494\n",
      "Iteration 8:\n",
      "x_old = [1.0036]\n",
      "[1.0026]\n",
      "[ 1.003]\n",
      "x0 = 0.99828 and Absolute relative error: 0.0053163\n",
      "x1 = 0.99869 and Absolute relative error: 0.0039238\n",
      "x2 = 0.99837 and Absolute relative error: 0.0045956\n",
      "Iteration 9:\n",
      "x_old = [0.99828]\n",
      "[0.99869]\n",
      "[0.99837]\n",
      "x0 = 1.0009 and Absolute relative error: 0.0026155\n",
      "x1 = 1.0007 and Absolute relative error: 0.0019776\n",
      "x2 = 1.0008 and Absolute relative error: 0.0024214\n",
      "Iteration 10:\n",
      "x_old = [1.0009]\n",
      "[1.0007]\n",
      "[1.0008]\n",
      "x0 = 0.99955 and Absolute relative error: 0.0013501\n",
      "x1 = 0.99966 and Absolute relative error: 0.0010084\n",
      "x2 = 0.99959 and Absolute relative error: 0.001204\n",
      "Iteration 11:\n",
      "x_old = [0.99955]\n",
      "[0.99966]\n",
      "[0.99959]\n",
      "x0 = 1.0002 and Absolute relative error: 0.00067791\n",
      "x1 = 1.0002 and Absolute relative error: 0.00051013\n",
      "x2 = 1.0002 and Absolute relative error: 0.00061785\n",
      "Iteration 12:\n",
      "x_old = [1.0002]\n",
      "[1.0002]\n",
      "[1.0002]\n",
      "x0 = 0.99988 and Absolute relative error: 0.00034527\n",
      "x1 = 0.99991 and Absolute relative error: 0.00025847\n",
      "x2 = 0.9999 and Absolute relative error: 0.00030998\n",
      "Iteration 13:\n",
      "x_old = [0.99988]\n",
      "[0.99991]\n",
      "[ 0.9999]\n",
      "x0 = 1.0001 and Absolute relative error: 0.00017356\n",
      "x1 = 1.0 and Absolute relative error: 0.00013065\n",
      "x2 = 1.0001 and Absolute relative error: 0.00015735\n",
      "Iteration 14:\n",
      "x_old = [1.0001]\n",
      "[   1.0]\n",
      "[1.0001]\n",
      "x0 = 0.99997 and Absolute relative error: 8.6787e-5\n",
      "x1 = 0.99998 and Absolute relative error: 6.4851e-5\n",
      "x2 = 0.99997 and Absolute relative error: 8.0111e-5\n",
      "\n",
      "Converged after 14 iterations.\n",
      "[0.99997]\n",
      "[0.99998]\n",
      "[0.99997]\n"
     ]
    }
   ],
   "source": [
    "import numpy as np\n",
    "from mpmath import mp, matrix\n",
    "\n",
    "\n",
    "\n",
    "class JacobiSolver:\n",
    "    def __init__(self, A, b, itr=10, tolerance=0.00001, x=None, sf=5):\n",
    "        self.A = A\n",
    "        self.b = b\n",
    "        self.itr = itr\n",
    "        self.tolerance = tolerance\n",
    "        self.x = mp.matrix(x)\n",
    "        self.sf = sf\n",
    "\n",
    "    def matrix_without_diagonal(self, A):\n",
    "        Dia = mp.matrix(len(A))\n",
    "        for i in range(len(A)):\n",
    "            Dia[i, i] = A[i, i]\n",
    "            A[i, i] = 0\n",
    "        return A, Dia\n",
    "\n",
    "    def check_zero_diagonal(self, matrix):\n",
    "        return any(matrix[i, i] == 0 for i in range(len(matrix)))\n",
    "\n",
    "    def solve(self):\n",
    "        mp.dps = self.sf\n",
    "\n",
    "        R, D = self.matrix_without_diagonal(self.A)\n",
    "        R = mp.matrix(R)\n",
    "        D = mp.matrix(D)\n",
    "\n",
    "        for i in range(self.itr):\n",
    "            print(f\"Iteration {i+1}:\")\n",
    "            x_old = self.x.copy()\n",
    "            print(f\"x_old = {x_old}\")\n",
    "\n",
    "            for itr in range(len(self.x)):\n",
    "                dot_product = mp.fdot(R[itr, :], x_old)\n",
    "                self.x[itr] = (self.b[itr] - dot_product) / D[itr, itr]\n",
    "                abs_rel_error = abs((self.x[itr] - x_old[itr]) / self.x[itr])\n",
    "                print(f\"x{itr} = {self.x[itr]} and Absolute relative error: {abs_rel_error}\")\n",
    "\n",
    "            err = np.abs((np.array(self.x.tolist()) - np.array(x_old.tolist())) / np.array(self.x.tolist()))\n",
    "            if np.all(err < self.tolerance):\n",
    "                print(f\"\\nConverged after {i + 1} iterations.\")\n",
    "                break\n",
    "\n",
    "        return self.x\n",
    "\n",
    "# Example usage:\n",
    "\n",
    "A = mp.matrix([[8, 3, 2],\n",
    "               [1, 5, 1],\n",
    "               [2, 1, 6]])\n",
    "B = mp.matrix([13, 7, 9])\n",
    "\n",
    "x = mp.matrix([[1],\n",
    "               [0],\n",
    "               [1]])\n",
    "\n",
    "# 8*x+3*y+2*z=13\n",
    "# x+5*y+z=7\n",
    "# 2*x+y+6*z=9\n",
    "x = JacobiSolver(A, B, 50, 0.0001, x=x).solve()\n",
    "\n",
    "print(x)\n"
   ]
  }
 ],
 "metadata": {
  "kernelspec": {
   "display_name": "base",
   "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.11.4"
  }
 },
 "nbformat": 4,
 "nbformat_minor": 2
}