Equalver_Project.ipynb

{
 "cells": [
  {
   "cell_type": "markdown",
   "id": "74d4d737",
   "metadata": {},
   "source": [
    "# Main Program Functions"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 1,
   "id": "f407ed86",
   "metadata": {},
   "outputs": [],
   "source": [
    "# def mainMenu():\n",
    "# global fancy_equation\n",
    "# global python_equation\n",
    "# global equation_diff\n",
    "    \n",
    "#     fancy_equation = input(\"Enter the equation: \")\n",
    "#     if fancy_equation[0:5] == 'sqrt(' and fancy_equation[-1] == ')':\n",
    "#         display(Math('Equation: \\\\%s'%fancy_equation))\n",
    "#     else:\n",
    "#         display(Math('Equation: %s'%fancy_equation))\n",
    "\n",
    "    \n",
    "#     global error\n",
    "#     error = float(input('Enter the Error: '))\n",
    "    \n",
    "  \n",
    "#     max_iterations = float(input('Enter Maximum Iterations: '))\n",
    "    \n",
    "#     choice = str(input(\"\"\"Choose the Method using the number label:\\n1. Bisection\\n2. False Postition\\n3. Simple Fixed Point\\n4. Newton\\n5. Secant\\n\"\"\"))\n",
    "    \n",
    "#     if choice == '1':\n",
    "#         xL = float(input('Enter xL: '))\n",
    "#         xU = float(input('Enter xU: '))\n",
    "#         if checkFunctionHasSolutionOrNot(xL, xU):\n",
    "#             bisection(xL, xU)\n",
    "#         else:\n",
    "#             print(\"Function has no solution!\")\n",
    "#     elif choice == '2':\n",
    "#         xL = float(input('Enter xL: '))\n",
    "#         xU = float(input('Enter xU: '))\n",
    "#         if checkFunctionHasSolutionOrNot(xL, xU):\n",
    "#             false_position(xL, xU)\n",
    "#         else:\n",
    "#             print(\"Function has no solution!\")\n",
    "#     elif choice == '3':\n",
    "#         x_value = float(input('Enter x: '))\n",
    "#         simplefpoint(x_value)\n",
    "#     elif choice == '4':\n",
    "#         xo = float(input('Enter xo: '))\n",
    "#         newton(xo)\n",
    "#     elif choice == '5':\n",
    "#         xi_minus1 = float(input('Enter Xi_-1: '))\n",
    "#         xi = float(input('Enter x_i: '))\n",
    "#         secant(xi_minus1, xi)\n",
    "#     else:\n",
    "#         print(\"Wrong Choice!\")\n",
    "\n",
    "# def equation_converter(eq):\n",
    "#     global x\n",
    "#     simplifiedEquation = eq.strip()\n",
    "#     simplifiedEquation = simplifiedEquation.replace('x', '*x')\n",
    "    \n",
    "#     if simplifiedEquation[0] == '*':\n",
    "#         simplifiedEquation = simplifiedEquation.replace('*', '')\n",
    "        \n",
    "#     equation_list = []\n",
    "#     equation_list[:0] = simplifiedEquation # Seprate each character into an item in a list\n",
    "    \n",
    "#     # Remove extra spaces in the equation if exists\n",
    "#     if ' ' in equation_list:\n",
    "#         equation_list.remove(' ')\n",
    "    \n",
    "#     for i in range(len(equation_list)):\n",
    "\n",
    "#         if (equation_list[i] == '+' or equation_list[i] == '-') and equation_list[i+1] == '*':\n",
    "#             equation_list[i+1] = ''\n",
    "            \n",
    "#     simplifiedEquation = ''.join(equation_list) # Concatenate all list items to equation\n",
    "#     simplifiedEquation = simplifiedEquation.replace('^', '**')\n",
    "#     return sym.sympify(simplifiedEquation)\n",
    "\n",
    "# def f(value):\n",
    "#     temp_eq = python_equation\n",
    "#     return round(float(temp_eq.subs(x, value)), 3)\n",
    "\n",
    "# def f_diff(value):\n",
    "#     temp_eq_diff = equation_diff\n",
    "#     return round(float(temp_eq_diff.subs(x, value)), 3)\n",
    "    \n",
    "\n",
    "# def checkFunctionHasSolutionOrNot(xL, xU):\n",
    "#     \"\"\"Check the function has a solution or not for Bisection and False Position methods.\"\"\"\n",
    "#     if (f(xL) * f(xU) < 0):\n",
    "#         return True\n",
    "#     else:\n",
    "#         return False"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "ed43208a",
   "metadata": {},
   "source": [
    "# Functions for Five Methods "
   ]
  },
  {
   "cell_type": "markdown",
   "id": "be995300",
   "metadata": {},
   "source": [
    "## Bisection"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 2,
   "id": "2aa1ff04",
   "metadata": {},
   "outputs": [],
   "source": [
    "def bisection(xL, xU):\n",
    "    \"\"\"Calculate Xr and Error values.\"\"\"\n",
    "    iteration_counter = 0\n",
    "    \n",
    "    if max_iterations == 0:\n",
    "        return False\n",
    "    \n",
    "    solution = []\n",
    "    index = 1\n",
    "    \n",
    "    xR = (xL + xU) / 2\n",
    "    \n",
    "    # 1# Iteration\n",
    "    iteration_counter += 1\n",
    "#     display(Math('Iteration: %g \\\\space|\\\\quad x_l = %g \\\\quad|\\\\quad f(x_l) = %g \\\\quad|\\\\quad x_u = %g \\\\quad|\\\\quad f(x_u) = %g \\\\quad|\\\\quad x_r = %g \\\\quad|\\\\quad f(x_r) = %g \\\\quad|\\\\quad \\epsilon_a = ---'\n",
    "#                 %(iteration_counter, xL, f(xL), xU, f(xU), xR, f(xR))))\n",
    "    \n",
    "    if (f(xL) * f(xR)) < 0:\n",
    "        xU = xR\n",
    "    else:\n",
    "        xL = xR\n",
    "    \n",
    "    solution.append((index, xL, f(xL), xU, f(xU), xR, f(xR), \"---\"))\n",
    "    index += 1\n",
    "    \n",
    "    if max_iterations <= iteration_counter:\n",
    "#         display(Math('\\nRoot = %s' %xR))\n",
    "        return solution\n",
    "            \n",
    "    while(True):\n",
    "        iteration_counter += 1\n",
    "        xR_Old = xR\n",
    "        xR = (xL + xU) / 2\n",
    "#         display(Math('Iteration: %g \\\\space|\\\\quad x_l = %g \\\\quad|\\\\quad f(x_l) = %g \\\\quad|\\\\quad x_u = %g \\\\quad|\\\\quad f(x_u) = %g \\\\quad|\\\\quad x_r = %g \\\\quad|\\\\quad f(x_r) = %g \\\\quad|\\\\quad \\epsilon_a = %g \\%%'\n",
    "#                 %(iteration_counter, xL, f(xL), xU, f(xU), xR, f(xR), round((abs((xR - xR_Old) / xR) * 100), 3))))\n",
    "        \n",
    "        solution.append((index, xL, f(xL), xU, f(xU), xR, f(xR), str(round((abs((xR - xR_Old) / xR) * 100), round_entry_value.get()))+\"%\" ))\n",
    "        index+=1\n",
    "        \n",
    "        if ((abs((xR - xR_Old) / xR) * 100) <= float(error)):\n",
    "#             display(Math('\\nRoot = %s' %xR))\n",
    "            return solution;\n",
    "\n",
    "        if (f(xL) * f(xR)) < 0:\n",
    "            xU = xR;\n",
    "        else:\n",
    "            xL = xR;\n",
    "        \n",
    "        if max_iterations <= iteration_counter:\n",
    "#             display(Math('\\nRoot = %s' %xR))\n",
    "            return solution"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "e4c16a40",
   "metadata": {},
   "source": [
    "## False Position Method"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 3,
   "id": "e3761c6e",
   "metadata": {},
   "outputs": [],
   "source": [
    "def false_position(xL, xU):\n",
    "    \"\"\"Calculate Xr and Error values.\"\"\"\n",
    "    iteration_counter = 0\n",
    "    \n",
    "    if max_iterations == 0:\n",
    "        return False\n",
    "    \n",
    "    solution = []\n",
    "    index = 1\n",
    "    \n",
    "    xR = xU - ( (f(xU) * (xL - xU)) / (f(xL) - f(xU)) )\n",
    "    \n",
    "    # 1# Iteration\n",
    "    iteration_counter += 1\n",
    "#     display(Math('Iteration: %g \\\\space|\\\\quad x_l = %g \\\\quad|\\\\quad f(x_l) = %g \\\\quad|\\\\quad x_u = %g \\\\quad \\\\quad|\\\\quad f(x_u) = %g \\\\quad|\\\\quad x_r = %g \\\\quad|\\\\quad f(x_r) = %g \\\\quad|\\\\quad \\epsilon_a = ---'\n",
    "#                 %(iteration_counter, round(xL, 3), f(xL), round(xU, 3), f(xU), round(xR, 3), f(xR))))\n",
    "    \n",
    "    if (f(xL) * f(xR)) < 0.0:\n",
    "        xU = xR\n",
    "    else:\n",
    "        xL = xR\n",
    "        \n",
    "    solution.append((index, xL, f(xL), xU, f(xU), xR, f(xR), \"---\"))\n",
    "    index += 1    \n",
    "    \n",
    "    if max_iterations <= iteration_counter:\n",
    "#         display(Math('\\nRoot = %s' %xR))\n",
    "        return solution\n",
    "            \n",
    "    while(True):\n",
    "        iteration_counter += 1\n",
    "        xR_Old = xR\n",
    "        xR = xU - ( (f(xU) * (xL - xU)) / (f(xL) - f(xU)) )\n",
    "        eps = abs((xR - xR_Old) / xR) * 100\n",
    "#         display(Math('Iteration: %g \\\\space|\\\\quad x_l = %g \\\\quad|\\\\quad f(x_l) = %g \\\\quad|\\\\quad x_u = %g \\\\quad|\\\\quad f(x_u) = %g \\\\quad|\\\\quad x_r = %g \\\\quad|\\\\quad f(x_r) = %g \\\\quad|\\\\quad \\epsilon_a = %g \\%%'\n",
    "#                 %(iteration_counter, round(xL, 3), f(xL), round(xU, 3), f(xU), round(xR, 3), f(xR), round(eps, 3))))\n",
    "        \n",
    "        solution.append((index, xL, f(xL), xU, f(xU), xR, f(xR), str(round(eps, round_entry_value.get()))+\"%\"))\n",
    "        index+=1\n",
    "        \n",
    "        if (eps <= float(error)):\n",
    "#             display(Math('\\nRoot = %s' %xR))\n",
    "            return solution;\n",
    "\n",
    "        if (f(xL) * f(xR)) < 0.0:\n",
    "            xU = xR;\n",
    "        else:\n",
    "            xL = xR;\n",
    "            \n",
    "        if max_iterations <= iteration_counter:\n",
    "#             display(Math('\\nRoot = %s' %xR))\n",
    "            return solution"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "45bec191",
   "metadata": {},
   "source": [
    "## Simple Fixed Point"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 4,
   "id": "e58c1cd2",
   "metadata": {},
   "outputs": [],
   "source": [
    "def simplefpoint(x_value):\n",
    "    iteration_counter = 0\n",
    "    \n",
    "    if max_iterations == 0:\n",
    "        return False\n",
    "    \n",
    "    solution = []\n",
    "    index = 1\n",
    "    \n",
    "    # Iteration 1#\n",
    "    iteration_counter+=1\n",
    "    xi = x_value\n",
    "    xiplus1 = f(xi)\n",
    "#     display(Math('\\\\text{Iteration: }%g \\\\space | \\\\space x_i=%g \\\\quad \\\\space | x_{i+1}=%g \\\\space|\\\\space \\epsilon_a=-----' \n",
    "#                  %(iteration_counter, xi, xiplus1)))\n",
    "    \n",
    "    solution.append((index, xi, xiplus1, \"---\"))\n",
    "    index += 1\n",
    "    \n",
    "    if max_iterations <= iteration_counter:\n",
    "#         display(Math('\\nRoot = %s' %xiplus1))\n",
    "        return solution\n",
    "\n",
    "    # Iteration 2# \n",
    "    iteration_counter+=1\n",
    "    eps = abs((xiplus1 - xi) / xiplus1) * 100\n",
    "    xi = xiplus1\n",
    "    xiplus1 = f(xi)\n",
    "#     display(Math('\\\\text{Iteration: }%g \\\\space|\\\\space x_i=%g \\\\space|\\\\space x_{i+1}=%g \\\\space|\\\\space \\epsilon_a=%g \\%%' \n",
    "#                  %(iteration_counter, xi, xiplus1, round(eps, 3))))\n",
    "    \n",
    "    solution.append((index, xi, xiplus1, str(round(eps, round_entry_value.get()))+\"%\"))\n",
    "    index += 1\n",
    "    \n",
    "    if (eps <= float(error)):\n",
    "#         display(Math('\\nRoot = %s' %xiplus1))\n",
    "        return solution;\n",
    "    \n",
    "    \n",
    "    if max_iterations <= iteration_counter:\n",
    "#         display(Math('\\nRoot = %s' %xiplus1))\n",
    "        return solution\n",
    "    \n",
    "    while(eps > float(error)):  \n",
    "        iteration_counter+=1\n",
    "        eps = abs((xiplus1 - xi) / xiplus1) * 100\n",
    "        xi = xiplus1\n",
    "        xiplus1 = f(xi)\n",
    "#         display(Math('\\\\text{Iteration: }%g \\\\space|\\\\space x_i=%g \\\\space|\\\\space x_{i+1}=%g \\\\space|\\\\space \\epsilon_a=%g \\%%' \n",
    "#                      %(iteration_counter, xi, xiplus1, round(eps, 3))))\n",
    "        \n",
    "        solution.append((index, xi, xiplus1, str(round(eps, round_entry_value.get()))+\"%\"))\n",
    "        index += 1\n",
    "        \n",
    "        if (eps <= float(error)):\n",
    "#             display(Math('\\nRoot = %s' %xiplus1))\n",
    "            return solution;\n",
    "        \n",
    "        if max_iterations <= iteration_counter:\n",
    "#             display(Math('\\nRoot = %s' %xiplus1))\n",
    "            return solution\n",
    "    "
   ]
  },
  {
   "cell_type": "markdown",
   "id": "1051a92a",
   "metadata": {},
   "source": [
    "## Newton"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 5,
   "id": "1a9d933e",
   "metadata": {},
   "outputs": [],
   "source": [
    "def newton(xo):\n",
    "    iteration_counter = 0\n",
    "    \n",
    "    if max_iterations == 0:\n",
    "        return False\n",
    "    \n",
    "    solution = []\n",
    "    index = 1\n",
    "    \n",
    "    # Iteration #1\n",
    "    iteration_counter+=1\n",
    "    xi = xo\n",
    "#     display(Math('\\\\text{Iteration: }%g \\\\space | \\\\space x_i=%g \\\\quad \\\\quad \\\\space | \\\\space f({x_i})=%g \\\\space|\\\\space f\\'({x_i})=%g | \\\\space \\epsilon_a= -----' \n",
    "#                  %(iteration_counter, xi, f(xi), f_diff(xi))))\n",
    "    \n",
    "    solution.append((index, xi, f(xi), f_diff(xi), \"---\"))\n",
    "    index += 1\n",
    "    \n",
    "    if max_iterations <= iteration_counter:\n",
    "#         display(Math('\\nRoot = %s' %round(xi, 3)))\n",
    "        return True\n",
    "    \n",
    "    # Iteration #2\n",
    "    iteration_counter+=1\n",
    "    xiplus1 = xi - ( f(xi) / f_diff(xi) )\n",
    "    eps = abs((xiplus1 - xi) / xiplus1) * 100\n",
    "#     display(Math('\\\\text{Iteration: }%g \\\\space | \\\\space x_i=%g \\\\quad \\\\quad \\\\space | \\\\space f({x_i})=%g \\\\space|\\\\space f\\'({x_i})=%g | \\\\space \\epsilon_a=%g \\%%' \n",
    "#                  %(iteration_counter, xiplus1, f(xiplus1), f_diff(xiplus1), round(eps, 3))))\n",
    "    \n",
    "    solution.append((index, xiplus1, f(xiplus1), f_diff(xiplus1), str(round(eps, round_entry_value.get()))+\"%\"))\n",
    "    index += 1\n",
    "    \n",
    "    if eps <= float(error):\n",
    "#         display(Math('\\nRoot = %s' %round(xi, 3)))\n",
    "        return solution\n",
    "    \n",
    "    if max_iterations <= iteration_counter:\n",
    "#         display(Math('\\nRoot = %s' %round(xi, 3)))\n",
    "        return solution\n",
    "\n",
    "    while(eps > float(error)):  \n",
    "        iteration_counter+=1\n",
    "        xi = xiplus1\n",
    "        xiplus1 = xi - ( f(xi) / f_diff(xi) )\n",
    "        eps = abs((xiplus1 - xi) / xiplus1) * 100\n",
    "        \n",
    "#         display(Math('\\\\text{Iteration: }%g \\\\space | \\\\space x_i=%g \\\\quad \\\\space | \\\\space f({x_i})=%g \\\\space|\\\\space f\\'({x_i})=%g | \\\\space \\epsilon_a=%g \\%%' \n",
    "#                      %(iteration_counter, xiplus1, f(xiplus1), f_diff(xiplus1), round(eps, 3))))\n",
    "        \n",
    "        solution.append((index, xiplus1, f(xiplus1), f_diff(xiplus1), str(round(eps, round_entry_value.get()))+\"%\"))\n",
    "        index += 1\n",
    "        \n",
    "        if eps <= float(error):\n",
    "#             display(Math('\\nRoot = %s' %round(xi, 3)))\n",
    "            return solution\n",
    "        \n",
    "        if max_iterations <= iteration_counter:\n",
    "#             display(Math('\\nRoot = %s' %round(xi, 3)))\n",
    "            return True"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "c13a72fb",
   "metadata": {},
   "source": [
    "## Secant"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 6,
   "id": "a6925a97",
   "metadata": {},
   "outputs": [],
   "source": [
    "def secant(xi_minus1, xi):\n",
    "    iteration_counter = 0\n",
    "    if max_iterations == 0:\n",
    "        return False\n",
    "\n",
    "    solution = []\n",
    "    index = 1\n",
    "    \n",
    "    while(True):  \n",
    "        iteration_counter+=1\n",
    "        eps = abs((xi - xi_minus1) / xi) * 100\n",
    "#         display(Math('\\\\text{Iteration: }%g \\\\space | \\\\space x_{i-1}=%g \\\\quad \\\\quad \\\\space | \\\\space f(x_{i-1})=%g \\\\space|\\\\space x_i=%g \\\\quad | \\\\space f(x_i)=%g \\\\space | \\\\quad \\epsilon_a=%g\\%%' \n",
    "#                      %(iteration_counter, round(xi_minus1, 3), f(xi_minus1), round(xi, 3), f(xi), round(eps, 3))))\n",
    "        \n",
    "        if iteration_counter == 0:\n",
    "                    solution.append((index, round(xi_minus1, 3), f(xi_minus1), round(xi, 3), f(xi), str(round(eps, 3))+\"%\"))\n",
    "                    index += 1\n",
    "        \n",
    "        xi_old = xi\n",
    "        xi = xi - ( (f(xi) * (xi_minus1 - xi)) / (f(xi_minus1) - f(xi)) ) \n",
    "        xi_minus1 = xi_old\n",
    "        \n",
    "        solution.append((index, xi_minus1, f(xi_minus1), xi, f(xi), str(round(eps, round_entry_value.get()))+\"%\"))\n",
    "        index += 1\n",
    "        \n",
    "        if (eps <= float(error)):\n",
    "#             display(Math('\\nRoot = %s' %round(xi, 3)))\n",
    "            return solution\n",
    "        \n",
    "        if max_iterations <= iteration_counter:\n",
    "#             display(Math('\\nRoot = %s' %round(xi, 3)))\n",
    "            return solution"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "64bc558e",
   "metadata": {},
   "source": [
    "## Main Program "
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 7,
   "id": "7cf5f673",
   "metadata": {},
   "outputs": [],
   "source": [
    "# mainMenu()\n",
    "\n",
    "# Testing Functions\n",
    "# 1. Bisection: -2+7x-5x^2+6x^3 | Xl = 0 | Xu = 1 | e = 10%\n",
    "# 2. False Position: -26+82.3x-88x^2+45.4x^3-9x^4+0.65x^5 | Xl = 0.5 | Xu = 1 | e = 0.2%\n",
    "#                    -26+85x-91x^2+44x^3-8x^4+x^5 | Xl = 0.5 | Xu = 1 | e = 10%\n",
    "#                    -13-20x+19x^2-3x^3 | Xl = -1 | Xu = 0 | e = 1%\n",
    "# 3. Simple Fixed Point: -0.9x^2+1.7x+2.5 --> sqrt(1.88x+2.77) | x = 5 | e = 0.7%\n",
    "# 4. Newton: -0.9x^2+1.7x+2.5 | x = 5 | e = 0.7%\n",
    "# 5. Secant: 2x^3-11.7x^2+17.7x-5 | Xi-1 = 3 | Xi = 4, e = 0.7%"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "399e0b49",
   "metadata": {},
   "source": [
    "# GUI Code Starts"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "30887fb8",
   "metadata": {},
   "source": [
    "## Main Window"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 9,
   "id": "a7c94a19",
   "metadata": {},
   "outputs": [],
   "source": [
    "from IPython.display import display, Math\n",
    "import sympy as sym\n",
    "# GUI Libraries\n",
    "from tkinter import messagebox\n",
    "from tkinter import *\n",
    "from tkinter import ttk\n",
    "import matplotlib\n",
    "import matplotlib.pyplot as plt\n",
    "from matplotlib.backends.backend_tkagg import FigureCanvasTkAgg\n",
    "from PIL import ImageTk, Image # For images within tkinter\n",
    "import csv # For Export data to Excel file\n",
    "from tkinter import filedialog\n",
    "\n",
    "global python_equation\n",
    "global equation_diff\n",
    "global max_iterations\n",
    "\n",
    "global x\n",
    "x = sym.symbols('x')\n",
    "\n",
    "global python_equation\n",
    "python_equation = ''\n",
    "\n",
    "def equation_converter(eq):\n",
    "    try:\n",
    "        simplifiedEquation = eq.strip()\n",
    "        simplifiedEquation = simplifiedEquation.replace('x', '*x')\n",
    "\n",
    "        if simplifiedEquation[0] == '*':\n",
    "            simplifiedEquation = simplifiedEquation.replace('*', '')\n",
    "\n",
    "        equation_list = []\n",
    "        equation_list[:0] = simplifiedEquation # Seprate each character into an item in a list\n",
    "\n",
    "        # Remove extra spaces in the equation if exists\n",
    "        if ' ' in equation_list:\n",
    "            equation_list.remove(' ')\n",
    "\n",
    "        for i in range(len(equation_list)):\n",
    "\n",
    "            if (equation_list[i] == '+' or equation_list[i] == '-') and equation_list[i+1] == '*':\n",
    "                equation_list[i+1] = ''\n",
    "\n",
    "        simplifiedEquation = ''.join(equation_list) # Concatenate all list items to equation\n",
    "        simplifiedEquation = simplifiedEquation.replace('^', '**')\n",
    "        return sym.sympify(simplifiedEquation)\n",
    "    except:\n",
    "        return False\n",
    "\n",
    "def f(value):\n",
    "    global x\n",
    "    x = sym.symbols('x')\n",
    "    temp_eq = python_equation\n",
    "    return round(float(temp_eq.subs(x, value)), 3)\n",
    "\n",
    "def f_diff(value):\n",
    "    global x\n",
    "    x = sym.symbols('x')\n",
    "    temp_eq_diff = equation_diff\n",
    "    return round(float(temp_eq_diff.subs(x, value)), 3)\n",
    "    \n",
    "\n",
    "def checkFunctionHasSolutionOrNot(xL, xU):\n",
    "    \"\"\"Check the function has a solution or not for Bisection and False Position methods.\"\"\"\n",
    "    if (f(xL) * f(xU) < 0):\n",
    "        return True\n",
    "    else:\n",
    "        return False\n",
    "# Use TkAgg in the backend of tkinter application\n",
    "matplotlib.use('TkAgg')\n",
    "\n",
    "root = Tk()\n",
    "root.title('Equaveler')\n",
    "root.iconbitmap('./exe/images/equaveler_logo.ico')\n",
    "width_ = 950\n",
    "height_ = 650\n",
    "screen_width = root.winfo_screenwidth()\n",
    "screen_height = root.winfo_screenheight()\n",
    "x = (screen_width / 2) - (width_ / 2)\n",
    "y = (screen_height / 2) - (height_ / 2)\n",
    "root.geometry(f'{width_}x{height_}+{int(x)}+{int(y)}') # Window size\n",
    "root.resizable(0, 0)\n",
    "\n",
    "\n",
    "\n",
    "# Define a function to get the figure output\n",
    "def graph(text):\n",
    "    if equation_checker(entry.get()):\n",
    "        global python_equation\n",
    "        global equation_diff\n",
    "        global x\n",
    "        x = sym.symbols('x')\n",
    "        # Get the Entry Input\n",
    "        tmptext = entry.get()\n",
    "        python_equation = tmptext\n",
    "        python_equation = equation_converter(python_equation)\n",
    "        equation_diff = python_equation.diff(x)\n",
    "        tmptext = \"$\"+tmptext+\"$\"\n",
    "        # Clear any previous Syntax from the figure\n",
    "        wx.clear()\n",
    "        wx.text(0.5, 0.4, tmptext, fontsize = 12, ha=\"center\")\n",
    "        canvas.draw()\n",
    "    else:\n",
    "        entry.delete(0, END)\n",
    "\n",
    "def change_to_main_frame():\n",
    "    main_frame.pack()\n",
    "    input_frame.pack_forget()\n",
    "    \n",
    "# def change_to_methods_frame():\n",
    "#     methods_frame.pack(fill='both', expand=1)\n",
    "#     main_frame.pack_forget()\n",
    "    \n",
    "def change_to_input_frame():\n",
    "    input_frame.pack(fill='both', expand=1)\n",
    "    main_frame.pack_forget()\n",
    "\n",
    "def show_equation_examples():\n",
    "    help_window2 = Toplevel()\n",
    "    help_window2.title('Equation Examples')\n",
    "    help_window2.iconbitmap('./exe/images/equaveler_logo.ico')\n",
    "    width_ = 270\n",
    "    height_ = 240\n",
    "    screen_width = help_window2.winfo_screenwidth()\n",
    "    screen_height = help_window2.winfo_screenheight()\n",
    "    x = (screen_width / 2) - (width_ / 2)\n",
    "    y = (screen_height / 2) - (height_ / 2)\n",
    "    help_window2.geometry(f'{width_}x{height_}+{int(x)}+{int(y)}') # Window size\n",
    "    help_window2.resizable(0, 0)\n",
    "    \n",
    "    input_equations_image = PhotoImage(file=\"./exe/images/help.png\")\n",
    "    message = Label(help_window2, text=\"Enter an equation like...\", font=(\"Helvetica\", 12)).pack(pady=10)\n",
    "    help_equation = Label(help_window2, image=input_equations_image, borderwidth=1, bg=\"black\").pack()\n",
    "    button_help1 = Button(help_window2, text='Got it!', command=help_window2.destroy).pack(pady=10)\n",
    "    \n",
    "    help_window2.mainloop()\n",
    "    \n",
    "def show_input_examples():\n",
    "    help_window1 = Toplevel()\n",
    "    help_window1.title('Input Examples')\n",
    "    help_window1.iconbitmap('images/equaveler_logo.ico')\n",
    "    width_ = 270\n",
    "    height_ = 580\n",
    "    screen_width = help_window1.winfo_screenwidth()\n",
    "    screen_height = help_window1.winfo_screenheight()\n",
    "    x = (screen_width / 2) - (width_ / 2)\n",
    "    y = (screen_height / 2) - (height_ / 2)\n",
    "    help_window1.geometry(f'{width_}x{height_}+{int(x)}+{int(y)}') # Window size\n",
    "    help_window1.resizable(0, 0)\n",
    "    \n",
    "    input_functions_image = PhotoImage(file=\"./exe/images/input_functions.png\")\n",
    "    help_table = Label(help_window1, image=input_functions_image, borderwidth=1, bg=\"black\").pack()\n",
    "    button_help2 = Button(help_window1, text='Got it!', command=help_window1.destroy).pack(pady=10)\n",
    "    \n",
    "    help_window1.mainloop()\n",
    "    \n",
    "def clear_radio_choice_frame():\n",
    "    try:\n",
    "        for widgets in radio_choice_frame.winfo_children():\n",
    "            widgets.destroy()\n",
    "    except:\n",
    "        return\n",
    "            \n",
    "def equation_checker(equation):\n",
    "    if equation_converter(equation):\n",
    "        return True\n",
    "    else:\n",
    "        responce = messagebox.showerror(\"Error\",\"Equation contains wrong characters!\")\n",
    "\n",
    "def number_checker(number):\n",
    "    if number.isnumeric():\n",
    "        return True\n",
    "    else:\n",
    "        responce = messagebox.showerror(\"Error\",\"You must enter a number\")\n",
    "        return False\n",
    "\n",
    "def radio_button_pressed(clicked):   \n",
    "    if clicked == \"bisection\":\n",
    "        show_bisection()\n",
    "    elif clicked == \"false_pos\":\n",
    "        show_false_position()\n",
    "    elif clicked == \"simple_fix\":\n",
    "        show_simple_fixed_point()\n",
    "    elif clicked == \"newton\":\n",
    "        show_newton()\n",
    "    elif clicked == \"secant\":\n",
    "        show_secant()\n",
    "\n",
    "def show_bisection():\n",
    "    global radio_choice_frame\n",
    "    global choice\n",
    "    choice = \"Bisection\"\n",
    "    clear_radio_choice_frame()\n",
    "    radio_choice_frame.pack(anchor=W)\n",
    "    \n",
    "    xl_Label = Label(radio_choice_frame, text=\"xl\", font=(\"Helvetica\", 12)).pack(padx=120, pady=10, anchor=W)\n",
    "    xl_Entry = Entry(radio_choice_frame, textvariable=xl_value,  width=10, font=(\"Helvetica\", 12)).pack(padx=120, anchor=W)\n",
    "    \n",
    "    xu_Label = Label(radio_choice_frame, text=\"xU\", font=(\"Helvetica\", 12)).pack(padx=120, pady=10, anchor=W)\n",
    "    xu_Entry = Entry(radio_choice_frame, textvariable=xu_value, width=10, font=(\"Helvetica\", 12)).pack(padx=120, anchor=W)\n",
    "    \n",
    "def show_false_position():\n",
    "    global choice\n",
    "    choice = \"False Position Methos\"\n",
    "    clear_radio_choice_frame()\n",
    "    radio_choice_frame.pack(anchor=W)\n",
    "    xl_Label = Label(radio_choice_frame, text=\"xl\", font=(\"Helvetica\", 12)).pack(padx=120, pady=10, anchor=W)\n",
    "    xl_Entry = Entry(radio_choice_frame, textvariable=xl_value, width=10, font=(\"Helvetica\", 12)).pack(padx=120, anchor=W)\n",
    "    \n",
    "    xu_Label = Label(radio_choice_frame, text=\"xU\", font=(\"Helvetica\", 12)).pack(padx=120, pady=10, anchor=W)\n",
    "    xu_Entry = Entry(radio_choice_frame, textvariable=xu_value, width=10, font=(\"Helvetica\", 12)).pack(padx=120, anchor=W)\n",
    "    \n",
    "    \n",
    "def show_simple_fixed_point():\n",
    "    global choice\n",
    "    choice = \"Simple Fixed Point\"\n",
    "    clear_radio_choice_frame()\n",
    "    radio_choice_frame.pack(anchor=W)\n",
    "    x_Label = Label(radio_choice_frame, text=\"x\", font=(\"Helvetica\", 12)).pack(padx=120, pady=10, anchor=W)\n",
    "    x_Entry = Entry(radio_choice_frame, textvariable=x_value, width=10, font=(\"Helvetica\", 12)).pack(padx=120, anchor=W)\n",
    "    \n",
    "    \n",
    "def show_newton():\n",
    "    global choice\n",
    "    choice = \"Newton\"\n",
    "    clear_radio_choice_frame()\n",
    "    radio_choice_frame.pack(anchor=W)\n",
    "    x_Label = Label(radio_choice_frame, text=\"x\", font=(\"Helvetica\", 12)).pack(padx=120, pady=10, anchor=W)\n",
    "    x_Entry = Entry(radio_choice_frame, textvariable=x_value, width=10, font=(\"Helvetica\", 12)).pack(padx=120, anchor=W)\n",
    "    \n",
    "    \n",
    "def show_secant():\n",
    "    global choice\n",
    "    choice = \"Secant\"\n",
    "    clear_radio_choice_frame()\n",
    "    radio_choice_frame.pack(anchor=W)\n",
    "    xi_minus1_Label = Label(radio_choice_frame, text=\"X(i-1)\", font=(\"Helvetica\", 12)).pack(padx=120, pady=10, anchor=W)\n",
    "    xi_minus1_Entry = Entry(radio_choice_frame, textvariable=xi_minus1_value, width=10, font=(\"Helvetica\", 12)).pack(padx=120, anchor=W)\n",
    "    \n",
    "    xi_Label = Label(radio_choice_frame, text=\"Xi\", font=(\"Helvetica\", 12)).pack(padx=120, pady=10, anchor=W)\n",
    "    xi_Entry = Entry(radio_choice_frame, width=10, textvariable=xi_value, font=(\"Helvetica\", 12)).pack(padx=120, anchor=W)\n",
    "    \n",
    "def round_data(values, number_to_round):\n",
    "    rounded_result = []\n",
    "    for item in values:\n",
    "        rounded_result.append(tuple(map(lambda x: isinstance(x, float) and round(x, int(number_to_round)) or x, item)))\n",
    "    return rounded_result\n",
    "\n",
    "def calculate_method():\n",
    "    global error\n",
    "    global result\n",
    "    global max_iterations\n",
    "    if number_checker(max_iterations_temp.get()):\n",
    "        max_iterations = int(max_iterations_temp.get())\n",
    "        if equation_checker(entry.get()):\n",
    "            error = error_value.get()\n",
    "            if choice == \"Bisection\":\n",
    "                result = bisection(float(xl_value.get()), float(xu_value.get()))\n",
    "                create_table(choice, result)\n",
    "            elif choice == \"False Position Methos\":\n",
    "                result = false_position(float(xl_value.get()), float(xu_value.get()))\n",
    "                create_table(choice, result)\n",
    "            elif choice == \"Simple Fixed Point\":\n",
    "                result = simplefpoint(float(x_value.get()))\n",
    "                create_table(choice, result)\n",
    "            elif choice == \"Newton\":\n",
    "                result = newton(float(x_value.get()))\n",
    "                create_table(choice, result)\n",
    "            elif choice == \"Secant\":\n",
    "                result = secant(float(xi_minus1_value.get()), float(xi_value.get()))\n",
    "                create_table(choice, result)\n",
    "        else:\n",
    "            responce = messagebox.showerror(\"Missing Equation\",\"You must enter an equation first!\")\n",
    "            return\n",
    "    else:\n",
    "        pass\n",
    "\n",
    "def create_table(table_type, data):\n",
    "    data = round_data(data, round_entry_value.get())\n",
    "    if table_type == \"Bisection\" or table_type == \"False Position Methos\":\n",
    "        bisec_false_table(data)\n",
    "    elif table_type == \"Simple Fixed Point\":\n",
    "        simple_table(data)\n",
    "    elif table_type == \"Newton\":\n",
    "        newton_table(data)\n",
    "    elif table_type == \"Secant\":\n",
    "        secant_table(data)\n",
    "\n",
    "def bisec_false_table(contents1):\n",
    "    ws  = Tk()\n",
    "    \n",
    "    ws.title(choice + ' Solution')\n",
    "    ws.geometry('660x280')\n",
    "    ws.resizable(0, 0)\n",
    "    ws['bg'] = '#ffab40'\n",
    "    \n",
    "    table_frame = Frame(ws)\n",
    "    \n",
    "\n",
    "    bisection_table = ttk.Treeview(table_frame, yscrollcommand=1)\n",
    "\n",
    "    bisection_table['columns'] = ('i', 'xL', 'f(xL)', 'xU', 'f(xU)', 'xR', 'f(xR)', 'eps')\n",
    "\n",
    "    bisection_table.column(\"#0\", width=0, stretch=NO)\n",
    "    bisection_table.column(\"i\", anchor=CENTER, width=80)\n",
    "    bisection_table.column(\"xL\", anchor=CENTER, width=80)\n",
    "    bisection_table.column(\"f(xL)\", anchor=CENTER, width=80)\n",
    "    bisection_table.column(\"xU\", anchor=CENTER, width=80)\n",
    "    bisection_table.column(\"f(xU)\", anchor=CENTER, width=80)\n",
    "    bisection_table.column(\"xR\", anchor=CENTER, width=80)\n",
    "    bisection_table.column(\"f(xR)\", anchor=CENTER, width=80)\n",
    "    bisection_table.column(\"eps\", anchor=CENTER, width=80)\n",
    "\n",
    "    bisection_table.heading(\"#0\", text=\"\", anchor=CENTER)\n",
    "    bisection_table.heading(\"i\", text=\"Id\", anchor=CENTER)\n",
    "    bisection_table.heading(\"xL\", text=\"xL\", anchor=CENTER)\n",
    "    bisection_table.heading(\"f(xL)\", text=\"f(xL)\", anchor=CENTER)\n",
    "    bisection_table.heading(\"xU\", text=\"xU\", anchor=CENTER)\n",
    "    bisection_table.heading(\"f(xU)\", text=\"f(xU)\", anchor=CENTER)\n",
    "    bisection_table.heading(\"xR\", text=\"xR\", anchor=CENTER)\n",
    "    bisection_table.heading(\"f(xR)\", text=\"f(xR)\", anchor=CENTER)\n",
    "    bisection_table.heading(\"eps\", text=\"eps\", anchor=CENTER)\n",
    "\n",
    "    for index, item in enumerate(contents1):\n",
    "        bisection_table.insert(parent='',index='end', iid=index,text='', values=item)\n",
    "    \n",
    "    scrollbar = Scrollbar(ws, orient=VERTICAL, command=bisection_table.yview)\n",
    "    bisection_table.config(yscrollcommand=scrollbar.set)\n",
    "    scrollbar.pack(side=RIGHT, fill=Y) \n",
    "    \n",
    "    bisection_table.pack()\n",
    "    table_frame.pack()\n",
    "    \n",
    "    root = contents1[-1][5]\n",
    "    root_label = Label(ws, foreground='#800020', background='#ffab40',\n",
    "                       text=\"Root = \"+str(round(root, round_entry_value.get())), \n",
    "                       font=(\"Helvetica\", 16, \"italic\", \"bold\"))\n",
    "    root_label.place(x=10, y=240)\n",
    "    export_image = PhotoImage(file=(\"./exe/images/export_to_excel_smaller.png\"), master=ws)\n",
    "    csv_button = Button(ws, image=export_image, borderwidth=0, background='#ffab40', activebackground='#ffab40',\n",
    "                        command=lambda: write_to_csv(contents1))\n",
    "    csv_button.pack(anchor=S+E, padx=10, pady=10)\n",
    "    \n",
    "    ws.mainloop()\n",
    "\n",
    "def simple_table(contents2):\n",
    "    ws  = Tk()\n",
    "    ws.title(choice + ' Solution')\n",
    "    ws.geometry('340x285')\n",
    "    ws.resizable(0, 0)\n",
    "    ws['bg'] = '#ffab40'\n",
    "    \n",
    "    table_frame = Frame(ws)\n",
    "\n",
    "    bisection_table = ttk.Treeview(table_frame, yscrollcommand=1)\n",
    "\n",
    "    bisection_table['columns'] = ('i', 'xL', 'f(xL)', 'eps')\n",
    "\n",
    "    bisection_table.column(\"#0\", width=0, stretch=NO)\n",
    "    bisection_table.column(\"i\", anchor=CENTER, width=80)\n",
    "    bisection_table.column(\"xL\", anchor=CENTER, width=80)\n",
    "    bisection_table.column(\"f(xL)\", anchor=CENTER, width=80)\n",
    "    bisection_table.column(\"eps\", anchor=CENTER, width=80)\n",
    "\n",
    "    bisection_table.heading(\"#0\", text=\"\", anchor=CENTER)\n",
    "    bisection_table.heading(\"i\", text=\"Id\", anchor=CENTER)\n",
    "    bisection_table.heading(\"xL\", text=\"xL\", anchor=CENTER)\n",
    "    bisection_table.heading(\"f(xL)\", text=\"f(xL)\", anchor=CENTER)\n",
    "    bisection_table.heading(\"eps\", text=\"eps\", anchor=CENTER)\n",
    "\n",
    "    for index, item in enumerate(contents2):\n",
    "        bisection_table.insert(parent='',index='end', iid=index,text='', values=item)\n",
    "\n",
    "    scrollbar = Scrollbar(ws, orient=VERTICAL, command=bisection_table.yview)\n",
    "    bisection_table.config(yscrollcommand=scrollbar.set)\n",
    "    scrollbar.pack(side=RIGHT, fill=Y) \n",
    "    \n",
    "    bisection_table.pack()\n",
    "    table_frame.pack()\n",
    "    \n",
    "    root = contents2[-1][1]\n",
    "    root_label = Label(ws, foreground='#800020', background='#ffab40',\n",
    "                       text=\"Root = \"+str(round(root, round_entry_value.get())), \n",
    "                       font=(\"Helvetica\", 16, \"italic\", \"bold\"))\n",
    "    \n",
    "    root_label.place(x=10, y=240)\n",
    "    export_image = PhotoImage(file=(\"./exe/images/export_to_excel_smaller.png\"), master=ws)\n",
    "    csv_button = Button(ws, image=export_image, borderwidth=0, background='#ffab40', activebackground='#ffab40',\n",
    "                        command=lambda: write_to_csv(contents2))\n",
    "    csv_button.pack(anchor=S+E, padx=5, pady=10)\n",
    "    \n",
    "    ws.mainloop()\n",
    "    \n",
    "def newton_table(contents3):\n",
    "    ws  = Tk()\n",
    "    ws.title(choice + ' Solution')\n",
    "    ws.geometry('420x285')\n",
    "    ws.resizable(0, 0)\n",
    "    ws['bg'] = '#ffab40'\n",
    "    \n",
    "    table_frame = Frame(ws)\n",
    "\n",
    "    bisection_table = ttk.Treeview(table_frame, yscrollcommand=1)\n",
    "\n",
    "    bisection_table['columns'] = ('i', 'Xi', 'f(Xi)', \"f'(Xi)\", 'eps')\n",
    "\n",
    "    bisection_table.column(\"#0\", width=0, stretch=NO)\n",
    "    bisection_table.column(\"i\", anchor=CENTER, width=80)\n",
    "    bisection_table.column(\"Xi\", anchor=CENTER, width=80)\n",
    "    bisection_table.column(\"f(Xi)\", anchor=CENTER, width=80)\n",
    "    bisection_table.column(\"f'(Xi)\", anchor=CENTER, width=80)\n",
    "    bisection_table.column(\"eps\", anchor=CENTER, width=80)\n",
    "\n",
    "    bisection_table.heading(\"#0\", text=\"\", anchor=CENTER)\n",
    "    bisection_table.heading(\"i\", text=\"Id\", anchor=CENTER)\n",
    "    bisection_table.heading(\"Xi\", text=\"Xi\", anchor=CENTER)\n",
    "    bisection_table.heading(\"f(Xi)\", text=\"f(Xi)\", anchor=CENTER)\n",
    "    bisection_table.heading(\"f'(Xi)\", text=\"f'(Xi)\", anchor=CENTER)\n",
    "    bisection_table.heading(\"eps\", text=\"eps\", anchor=CENTER)\n",
    "\n",
    "    for index, item in enumerate(contents3):\n",
    "        bisection_table.insert(parent='',index='end', iid=index,text='', values=item)\n",
    "    \n",
    "    scrollbar = Scrollbar(ws, orient=VERTICAL, command=bisection_table.yview)\n",
    "    bisection_table.config(yscrollcommand=scrollbar.set)\n",
    "    scrollbar.pack(side=RIGHT, fill=Y) \n",
    "    \n",
    "    bisection_table.pack()\n",
    "    table_frame.pack()\n",
    "    \n",
    "    root = contents3[-1][1]\n",
    "    root_label = Label(ws, foreground='#800020', background='#ffab40',\n",
    "                       text=\"Root = \"+str(round(root, round_entry_value.get())), \n",
    "                       font=(\"Helvetica\", 16, \"italic\", \"bold\"))\n",
    "    root_label.place(x=10, y=240)\n",
    "    \n",
    "    export_image = PhotoImage(file=(\"./exe/images/export_to_excel_smaller.png\"), master=ws)\n",
    "    csv_button = Button(ws, image=export_image, borderwidth=0, background='#ffab40', activebackground='#ffab40',\n",
    "                        command=lambda: write_to_csv(contents3))\n",
    "    csv_button.pack(anchor=S+E, padx=10, pady=10)\n",
    "    \n",
    "    ws.mainloop()\n",
    "    \n",
    "def secant_table(contents4):\n",
    "    ws  = Tk()\n",
    "    ws.title(choice + ' Solution')\n",
    "    ws.geometry('500x280')\n",
    "    ws.resizable(0, 0)\n",
    "    ws['bg'] = '#ffab40'\n",
    "\n",
    "    table_frame = Frame(ws)\n",
    "\n",
    "    bisection_table = ttk.Treeview(table_frame, yscrollcommand=1)\n",
    "\n",
    "    bisection_table['columns'] = ('i', 'X(i-1)', 'f(X(i-1))', 'Xi', \"f(Xi)\", 'eps')\n",
    "\n",
    "    bisection_table.column(\"#0\", width=0, stretch=NO)\n",
    "    bisection_table.column(\"i\", anchor=CENTER, width=80)\n",
    "    bisection_table.column(\"X(i-1)\", anchor=CENTER, width=80)\n",
    "    bisection_table.column('f(X(i-1))', anchor=CENTER, width=80)\n",
    "    bisection_table.column(\"Xi\", anchor=CENTER, width=80)\n",
    "    bisection_table.column(\"f(Xi)\", anchor=CENTER, width=80)\n",
    "    bisection_table.column(\"eps\", anchor=CENTER, width=80)\n",
    "\n",
    "    bisection_table.heading(\"#0\", text=\"\", anchor=CENTER)\n",
    "    bisection_table.heading(\"i\", text=\"Id\", anchor=CENTER)\n",
    "    bisection_table.heading(\"X(i-1)\", text=\"X(i-1)\", anchor=CENTER)\n",
    "    bisection_table.heading('f(X(i-1))', text='f(X(i-1))', anchor=CENTER)\n",
    "    bisection_table.heading(\"Xi\", text=\"Xi\", anchor=CENTER)\n",
    "    bisection_table.heading(\"f(Xi)\", text=\"f(Xi)\", anchor=CENTER)\n",
    "    bisection_table.heading(\"eps\", text=\"eps\", anchor=CENTER)\n",
    "\n",
    "    for index, item in enumerate(contents4):\n",
    "        bisection_table.insert(parent='',index='end', iid=index,text='', values=item)\n",
    "    \n",
    "    scrollbar = Scrollbar(ws, orient=VERTICAL, command=bisection_table.yview)\n",
    "    bisection_table.config(yscrollcommand=scrollbar.set)\n",
    "    scrollbar.pack(side=RIGHT, fill=Y)\n",
    "    \n",
    "    bisection_table.pack()\n",
    "    table_frame.pack()\n",
    "    \n",
    "    root = contents4[-1][3]\n",
    "    root_label = Label(ws, foreground='#800020', background='#ffab40',\n",
    "                       text=\"Root = \"+str(round(root, round_entry_value.get())), \n",
    "                       font=(\"Helvetica\", 16, \"italic\", \"bold\"))\n",
    "    root_label.pack(pady=10, padx=10, anchor=S+W)\n",
    "    \n",
    "    export_image = PhotoImage(file=(\"./exe/images/export_to_excel_smaller.png\"), master=ws)\n",
    "    csv_button = Button(ws, image=export_image, borderwidth=0, background='#ffab40', activebackground='#ffab40',\n",
    "                        command=lambda: write_to_csv(contents4))\n",
    "    csv_button.place(x=420, y=235)\n",
    "    \n",
    "    ws.mainloop()\n",
    "    \n",
    "def write_to_csv(csv_data):\n",
    "    if choice == \"Bisection\":\n",
    "        fields=['i', 'xL', 'f(xL)', 'xU', 'f(xU)', 'xR', 'f(xR)', 'eps']\n",
    "    elif choice == \"False Position Methos\":\n",
    "        fields=['i', 'xL', 'f(xL)', 'xU', 'f(xU)', 'xR', 'f(xR)', 'eps']\n",
    "    elif choice == \"Simple Fixed Point\":\n",
    "        fields=['i','Xi','f(Xi)', 'eps']\n",
    "    elif choice == \"Newton\":\n",
    "        fields=['i','Xi','f(Xi)', \"f'(Xi)\", 'eps']\n",
    "    elif choice == \"Secant\":\n",
    "        fields=['i','X(i-1)','Xi', 'f(Xi)', 'eps']\n",
    "    \n",
    "    myfile = filedialog.asksaveasfile(defaultextension='.csv', title= \"Select file\", filetypes = [(\"CSV File\",\".csv\"),])\n",
    "    w = csv.writer(myfile, dialect='excel')\n",
    "    w.writerow(fields)\n",
    "    for record in csv_data:\n",
    "        w.writerow(record)\n",
    "    myfile.close()\n",
    "    \n",
    "            \n",
    "# Frames for the Application\n",
    "main_frame = Frame(root, width=width_, height=height_) # Main Window\n",
    "input_frame = Frame(root, width=width_, height=height_) # Take Equation from user Frame\n",
    "# methods_frame = Frame(root, width=width_, height=height_) # Methods Frame\n",
    "global radio_choice_frame\n",
    "radio_choice_frame = Frame(input_frame)\n",
    "\n",
    "main_frame.pack() # Show Welcome Window on Screen\n",
    "\n",
    "round_label = Label(input_frame, text=\"Round to\", font=(\"Helvetica\", 12)).place(x=300, y=340)\n",
    "global round_entry_value\n",
    "round_entry_value = IntVar(value=1)\n",
    "round_entry = Entry(input_frame, textvariable=round_entry_value, font=(\"Helvetica\", 12), width=6).place(x=302, y=373)\n",
    "\n",
    "\n",
    "max_iterations_label = Label(input_frame, text=\"Max Iterations\", font=(\"Helvetica\", 12)).place(x=300, y=410)\n",
    "\n",
    "max_iterations_temp = StringVar(value=1)\n",
    "max_iterations_entry = Entry(input_frame, textvariable=max_iterations_temp,\n",
    "                             font=(\"Helvetica\", 12), width=6).place(x=302, y=440)\n",
    "\n",
    "\n",
    "\n",
    "# Menu Bar\n",
    "main_menu = Menu(root)\n",
    "root.config(menu=main_menu)\n",
    "\n",
    "## File\n",
    "file_menu = Menu(main_menu, tearoff=0)\n",
    "main_menu.add_cascade(label=\"File\", menu=file_menu)\n",
    "# Sub-menu in help menu\n",
    "file_menu.add_command(label=\"Exit\", command=root.destroy)\n",
    "\n",
    "\n",
    "## Help\n",
    "help_menu = Menu(main_menu, tearoff=0)\n",
    "main_menu.add_cascade(label=\"Help\", menu=help_menu)\n",
    "# Sub-menu in help menu\n",
    "help_menu.add_command(label=\"Equation Examples\", command=show_equation_examples)\n",
    "help_menu.add_command(label=\"Input Functions\", command=show_input_examples)\n",
    "\n",
    "# Create an Entry widget\n",
    "var = StringVar(value=\"e.g. -2+7x-5x^2+6x^3\")\n",
    "msg_label = Label(input_frame, text=\"Equation\", font=(\"Helvetica\", 16)).place(x=77, y=5)\n",
    "entry = Entry(input_frame, width=50, textvariable=var,font=(\"Helvetica\", 16))\n",
    "entry.pack(pady=5)\n",
    "\n",
    "# Add a label widget in the frame\n",
    "label = Label(input_frame)\n",
    "label.pack()\n",
    "\n",
    "# Define the figure size and plot the figure\n",
    "fig = matplotlib.figure.Figure(figsize=(15, 1), dpi=100)\n",
    "\n",
    "wx = fig.add_subplot(111)\n",
    "canvas = FigureCanvasTkAgg(fig, master=label)\n",
    "canvas.get_tk_widget().pack(side=TOP, fill=BOTH, expand=True)\n",
    "canvas._tkcanvas.pack(side=TOP, fill=BOTH, expand=True)\n",
    "\n",
    "# Set the visibility of the Canvas figure\n",
    "wx.get_xaxis().set_visible(False)\n",
    "wx.get_yaxis().set_visible(False)\n",
    "\n",
    "root.bind('<Return>', graph)\n",
    "\n",
    "# Radio Buttons to choose methods\n",
    "# List of tuples of the values and variables\n",
    "# Make a frame to put radio buttons in it\n",
    "radio_frame = LabelFrame(input_frame, text=\"Choose a Method...\", padx=10, pady=10, font=(\"Helvetica\", 12)) # Inside of the frame padding\n",
    "radio_frame.pack(padx=120, pady=10, anchor=W) # Outside of the frame padding\n",
    "\n",
    "methods = [\n",
    "    (\"Bisection\", \"bisection\"),\n",
    "    (\"False Position Method\", \"false_pos\"),\n",
    "    (\"Simple Fixed Point\", \"simple_fix\"),\n",
    "    (\"Newton\", \"newton\"),\n",
    "    (\"Secant\", \"secant\")\n",
    "]\n",
    "\n",
    "global item\n",
    "item = StringVar()\n",
    "item.set(\"Bisection\") # Default method value\n",
    "\n",
    "for text, method in methods:\n",
    "    Radiobutton(radio_frame, text=text, variable=item, value=method,\n",
    "                command=lambda: radio_button_pressed(item.get())).pack(anchor=W)\n",
    "\n",
    "error_label = Label(input_frame, text=\"Error %\", font=(\"Helvetica\", 12)).pack(padx=120, pady=10, anchor=W)\n",
    "error_value = StringVar()\n",
    "error_entry = Entry(input_frame, textvariable=error_value, width=10, font=(\"Helvetica\", 12)).pack(padx=120, anchor=W)\n",
    "\n",
    "# global error\n",
    "# error = error_value.get()\n",
    "\n",
    "xl_value = StringVar()\n",
    "xu_value = StringVar()\n",
    "x_value = StringVar()\n",
    "xi_minus1_value = StringVar()\n",
    "xi_value = StringVar()\n",
    "\n",
    "# Images\n",
    "bg_image = PhotoImage(file=\"./exe/images/bg2.png\")\n",
    "proceed_image = PhotoImage(file=\"./exe/images/proceed_button2_smaller.png\")\n",
    "back_image = PhotoImage(file=\"./exe/images/back_button2_smaller.png\")\n",
    "calculate_image = PhotoImage(file=\"./exe/images/calculate_button1_smaller1.png\")\n",
    "\n",
    "\n",
    "# Canvas\n",
    "# Main Canvas\n",
    "canvas_main = Canvas(main_frame, width=width_, height=height_)\n",
    "canvas_main.pack(fill=\"both\", expand=True)\n",
    "\n",
    "# Background Image in canvas\n",
    "canvas_main.create_image(0,0, image=bg_image, anchor=\"nw\") # anchor = North West\n",
    "\n",
    "# Label (475, 50) those are the positions of x and y\n",
    "# canvas_main.create_text(width_/2, 50, text=\"Welcome to Equaveler!\", font=(\"Helvetica\", 50), fill=\"orange\")\n",
    "# canvas_main.create_text(width_/2, 600, text=\"Save your time by a click!\", font=(\"Helvetica\", 35), fill=\"black\")\n",
    "\n",
    "# Buttons\n",
    "# Main Screen Button\n",
    "proceed_button_main = Button(main_frame, activebackground=\"white\", borderwidth=0, image=proceed_image, bg=\"white\", command=change_to_input_frame)\n",
    "proceed_button_window = canvas_main.create_window(880, 565, anchor=\"nw\", window=proceed_button_main, width=60, height=60)\n",
    "\n",
    "\n",
    "# Methods Screen Buttons\n",
    "# proceed_button = Button(input_frame, borderwidth=0, image=proceed_image, command=change_to_methods_frame)\n",
    "# proceed_button.place(x=880, y=570, width=60, height=60)\n",
    "\n",
    "back_button = Button(input_frame, borderwidth=0, image=back_image, command=change_to_main_frame)\n",
    "back_button.place(x=10, y=565, width=60, height=60)\n",
    "\n",
    "choice = None\n",
    "calculate_button = Button(input_frame, image=calculate_image, borderwidth=0, command=lambda: calculate_method())\n",
    "calculate_button.place(x=(width_/2)-80, y=550, width=190, height=60)\n",
    "\n",
    "# # White-Dark Theme\n",
    "# button_mode=True\n",
    "# def customize():\n",
    "#     global button_mode\n",
    "#     if button_mode:\n",
    "#         theme_button.config(image=off,bg=\"#26242f\",activebackground=\"#26242f\")\n",
    "#         input_frame.config(bg=\"#26242f\")\n",
    "#         button_mode=False\n",
    "#     else:\n",
    "#         theme_button.config(image=on,bg=\"white\",activebackground=\"white\")\n",
    "#         input_frame.config(bg=\"white\")\n",
    "#         button_mode=True\n",
    "        \n",
    "# on = PhotoImage(file=\"images/light.png\")\n",
    "# off = PhotoImage(file=\"images/dark.png\")\n",
    "# theme_button = Button(input_frame, image=on, bd=0, bg=\"white\", activebackground=\"white\", command=customize)\n",
    "# theme_button.pack(padx=50,pady=50)\n",
    "\n",
    "root.mainloop()"
   ]
  }
 ],
 "metadata": {
  "kernelspec": {
   "display_name": "Python 3 (ipykernel)",
   "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.12"
  }
 },
 "nbformat": 4,
 "nbformat_minor": 5
}