Module C-Section 19.1, 19,2, 19.3, 19.4 19.5.ipynb

{
 "cells": [
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "# Module C-Section 19.1 - 19.5"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 1,
   "metadata": {
    "pycharm": {
     "name": "#%%\n"
    }
   },
   "outputs": [],
   "source": [
    "# Imports\n",
    "from math import log10\n",
    "from time import time\n",
    "\n",
    "import numpy as np\n",
    "from matplotlib import pyplot as plt"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Bisection Method"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 2,
   "metadata": {
    "pycharm": {
     "name": "#%%\n"
    }
   },
   "outputs": [],
   "source": [
    "# Bisection Method (bm)\n",
    "def bm_root(x: float, n: int, tol: float = 0.1, max_iter: int = 10**8) -> float:\n",
    "    \"\"\"\n",
    "    Bisection method to find the nth root of x\n",
    "    :param x: Value to find the nth root of\n",
    "    :param n: nth root to find\n",
    "    :param tol: tolerance\n",
    "    :param max_iter: maximum number of iterations\n",
    "    :return: nth root of x\n",
    "    \"\"\"\n",
    "\n",
    "    # Ensure that x and tol are strictly positive scalars\n",
    "    if x <= 0:\n",
    "        print(f\"Converting x to a positive number: {x} -> {abs(x)}\")\n",
    "        x = abs(x)\n",
    "\n",
    "    if tol <= 0:\n",
    "        print(f\"Converting tol to a positive number: {tol} -> {abs(tol)}\")\n",
    "        tol = abs(tol)\n",
    "\n",
    "    # Ensure that n is an integer strictly greater than 1\n",
    "    if not isinstance(n, int) or n <= 1:\n",
    "        raise ValueError(\"n must be an integer greater than 1\")\n",
    "\n",
    "    # f(y) = y^N - x\n",
    "    f = lambda y: y ** n - x\n",
    "\n",
    "    # Starting values\n",
    "    a = 0\n",
    "    b = x\n",
    "    r = x/2\n",
    "\n",
    "    while max_iter > 0:\n",
    "        r = (a + b) / 2\n",
    "\n",
    "        if abs(f(r)) < tol:\n",
    "            break\n",
    "\n",
    "        elif np.sign(f(a)) != np.sign(f(r)):\n",
    "            b = r\n",
    "\n",
    "        elif np.sign(f(r)) != np.sign(f(b)):\n",
    "            a = r\n",
    "\n",
    "        max_iter -= 1\n",
    "\n",
    "    if max_iter == 0:\n",
    "        print(\"Maximum number of iterations reached\")\n",
    "\n",
    "    return r\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 3,
   "metadata": {
    "pycharm": {
     "name": "#%%\n"
    }
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "x = 1, n = 2, tol = 0.001\n",
      "Bisection Method:   1.0\n",
      "Actual:             1.0\n",
      "Error:              0.0\n",
      "\n",
      "\n",
      "x = 4, n = 2, tol = 0.001\n",
      "Bisection Method:   2.0\n",
      "Actual:             2.0\n",
      "Error:              0.0\n",
      "\n",
      "\n",
      "x = 81, n = 4, tol = 0.001\n",
      "Bisection Method:   3.0\n",
      "Actual:             3.0\n",
      "Error:              0.0\n",
      "\n",
      "\n",
      "x = 286718338524635465625, n = 5, tol = 0.001\n",
      "Bisection Method:   12345.0\n",
      "Actual:             12345.0\n",
      "Error:              0.0\n",
      "\n",
      "\n",
      "x = 877347265250300669935309761849, n = 10, tol = 0.001\n",
      "Bisection Method:   987.0\n",
      "Actual:             987.0\n",
      "Error:              0.0\n",
      "\n",
      "\n",
      "Average Time: 0.46068903987379717 ms\n",
      "Standard Deviation: 0.4996069907882947 ms\n"
     ]
    },
    {
     "data": {
      "text/plain": "<Figure size 432x288 with 1 Axes>",
      "image/png": "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\n"
     },
     "metadata": {
      "needs_background": "light"
     },
     "output_type": "display_data"
    }
   ],
   "source": [
    "# Function to test bm_root\n",
    "def test_bm(x: float, n: int, tol: float) -> None:\n",
    "    \"\"\"\n",
    "    Test the Bisection Method\n",
    "    :param x: Value to find the nth root of\n",
    "    :param n: nth root to find\n",
    "    :param tol: tolerance\n",
    "    :return: True if the nth root of x is within tol of x, False otherwise\n",
    "    \"\"\"\n",
    "    print(f\"x = {x}, n = {n}, tol = {tol}\")\n",
    "\n",
    "    # Find the nth root of x using the Bisection method\n",
    "    n_root = bm_root(x=x, n=n, tol=tol, max_iter=10**8)\n",
    "\n",
    "    # Round to precision based on tolerance\n",
    "    round_to = int(abs(log10(tol)))\n",
    "    n_root = round(n_root, round_to)\n",
    "\n",
    "    # Print the results\n",
    "    print(f\"Bisection Method:   {n_root}\")\n",
    "    print(f\"Actual:             {round(x**(1/n), round_to)}\")\n",
    "    print(f\"Error:              {abs(n_root**n - x)}\")\n",
    "    print(f\"\\n\")\n",
    "\n",
    "bm_tol = 0.001\n",
    "\n",
    "# Test 1\n",
    "test_bm(x=1, n=2, tol=bm_tol)\n",
    "\n",
    "# Test 2\n",
    "test_bm(x=4, n=2, tol=bm_tol)\n",
    "\n",
    "# Test 3\n",
    "test_bm(x=81, n=4, tol=bm_tol)\n",
    "\n",
    "# Test 4\n",
    "_n = 5\n",
    "_x = 12345 ** _n\n",
    "test_bm(x=_x, n=5, tol=bm_tol)\n",
    "\n",
    "# Test 5\n",
    "_n = 10\n",
    "_x = 987 ** _n\n",
    "test_bm(x=_x, n=_n, tol=bm_tol)\n",
    "\n",
    "# Test Time\n",
    "test_len = 10**5\n",
    "_time = []\n",
    "for _x in range(1, test_len):\n",
    "    start = time()\n",
    "\n",
    "    for _n in range(2, 5):\n",
    "        bm_root(x=_x, n=_n, tol=0.01, max_iter=10**8)\n",
    "\n",
    "    end = time()\n",
    "    _time.append((end - start)*1000)\n",
    "\n",
    "# Add plot to fig\n",
    "fig = plt.scatter(range(1, test_len), _time)\n",
    "\n",
    "\n",
    "# Add labels\n",
    "plt.suptitle(\"Bisection Method\")\n",
    "plt.title(\"Time to find the 2nd - 6th roots of x\")\n",
    "plt.xlabel(\"number (x: 1 - 10^5)\")\n",
    "plt.ylabel(\"time (ms)\")\n",
    "\n",
    "# Print Stats\n",
    "print(f\"Average Time: {np.mean(_time)} ms\")\n",
    "print(f\"Standard Deviation: {np.std(_time)} ms\")\n"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Newton Raphson Method"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 4,
   "metadata": {
    "pycharm": {
     "name": "#%%\n"
    }
   },
   "outputs": [],
   "source": [
    "# Newton Raphson Method (nrm_root)\n",
    "def nrm_root(x: float, n: int, tol: float = 0.00001) -> float:\n",
    "    \"\"\"\n",
    "    Newton Raphson method to find the nth root of x\n",
    "    :param x: Value to find the nth root of\n",
    "    :param n: nth root to find\n",
    "    :param tol: tolerance\n",
    "    :return: nth root of x\n",
    "    \"\"\"\n",
    "\n",
    "    # Ensure that x and tol are strictly positive scalars\n",
    "    if x <= 0:\n",
    "        print(f\"Converting x to a positive number: {x} -> {abs(x)}\")\n",
    "        x = abs(x)\n",
    "\n",
    "    if tol <= 0:\n",
    "        print(f\"Converting tol to a positive number: {tol} -> {abs(tol)}\")\n",
    "        tol = abs(tol)\n",
    "\n",
    "    # Ensure that n is an integer strictly greater than 1\n",
    "    if not isinstance(n, int) or n <= 1:\n",
    "        raise ValueError(\"n must be an integer greater than 1\")\n",
    "\n",
    "    # f(y) = y^N - x\n",
    "    f = lambda y: y ** n - x\n",
    "\n",
    "    # f'(y) = Ny^(N-1)\n",
    "    f_prime = lambda y: n * y ** (n - 1)\n",
    "\n",
    "    # Initialize r\n",
    "    r = x\n",
    "\n",
    "    # Newton Raphson method to find the nth root of x\n",
    "    while abs(f(r)) > tol:\n",
    "        r = r - f(r)/f_prime(r)\n",
    "\n",
    "    # Return\n",
    "    return r"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 5,
   "metadata": {
    "pycharm": {
     "name": "#%%\n"
    }
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "x = 1, n = 2, tol = 1e-05\n",
      "Newton Raphson: 1\n",
      "Actual:         1.0\n",
      "Error:          0\n",
      "\n",
      "\n",
      "x = 4, n = 2, tol = 1e-05\n",
      "Newton Raphson: 2.0\n",
      "Actual:         2.0\n",
      "Error:          0.0\n",
      "\n",
      "\n",
      "x = 81, n = 4, tol = 1e-05\n",
      "Newton Raphson: 3.0\n",
      "Actual:         3.0\n",
      "Error:          0.0\n",
      "\n",
      "\n",
      "x = 286718338524635465625, n = 5, tol = 1e-05\n",
      "Newton Raphson: 12345.0\n",
      "Actual:         12345.0\n",
      "Error:          0.0\n",
      "\n",
      "\n",
      "x = 877347265250300669935309761849, n = 10, tol = 1e-05\n",
      "Newton Raphson: 987.0\n",
      "Actual:         987.0\n",
      "Error:          0.0\n",
      "\n",
      "\n",
      "Average Time: 0.06934139690136526 ms\n",
      "Standard Deviation: 0.2540284501516291 ms\n"
     ]
    },
    {
     "data": {
      "text/plain": "<Figure size 432x288 with 1 Axes>",
      "image/png": "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\n"
     },
     "metadata": {
      "needs_background": "light"
     },
     "output_type": "display_data"
    }
   ],
   "source": [
    "# Newton Raphson Method (nrm_root) Tests\n",
    "nrm_tol = 0.00001\n",
    "\n",
    "# Function to test nrm_root\n",
    "def test_nrm(x: float, n: int, tol: float) -> None:\n",
    "    \"\"\"\n",
    "    Test the Newton Raphson method\n",
    "    :param x: Value to find the nth root of\n",
    "    :param n: nth root to find\n",
    "    :param tol: tolerance\n",
    "    :return: True if the nth root of x is within tol of x, False otherwise\n",
    "    \"\"\"\n",
    "    print(f\"x = {x}, n = {n}, tol = {tol}\")\n",
    "\n",
    "    # Find the nth root of x using the Newton Raphson method\n",
    "    n_root = nrm_root(x=x, n=n, tol=tol)\n",
    "\n",
    "    # Round to precision based on tolerance\n",
    "    round_to = int(abs(log10(tol)))\n",
    "    n_root = round(n_root, round_to)\n",
    "\n",
    "    # Print the results\n",
    "    print(f\"Newton Raphson: {n_root}\")\n",
    "    print(f\"Actual:         {round(x**(1/n), round_to)}\")\n",
    "    print(f\"Error:          {abs(n_root**n - x)}\")\n",
    "    print(f\"\\n\")\n",
    "\n",
    "# Test 1\n",
    "test_nrm(x=1, n=2, tol=nrm_tol)\n",
    "\n",
    "# Test 2\n",
    "test_nrm(x=4, n=2, tol=nrm_tol)\n",
    "\n",
    "# Test 3\n",
    "test_nrm(x=81, n=4, tol=nrm_tol)\n",
    "\n",
    "# Test 4\n",
    "_n = 5\n",
    "_x = 12345 ** _n\n",
    "test_nrm(x=_x, n=5, tol=nrm_tol)\n",
    "\n",
    "# Test 5\n",
    "_n = 10\n",
    "_x = 987 ** _n\n",
    "test_nrm(x=_x, n=_n, tol=nrm_tol)\n",
    "\n",
    "# Test Time\n",
    "test_len = 10**5\n",
    "_time = []\n",
    "for _x in range(1, test_len):\n",
    "    start = time()\n",
    "\n",
    "    for _n in range(2, 5):\n",
    "        nrm_root(x=_x, n=_n, tol=0.01)\n",
    "\n",
    "    end = time()\n",
    "    _time.append((end - start)*1000)\n",
    "\n",
    "# Add plot to fig\n",
    "fig = plt.scatter(range(1, test_len), _time)\n",
    "\n",
    "# Add labels\n",
    "plt.suptitle(\"Newton Raphson Method\")\n",
    "plt.title(\"Time to find the 2nd - 6th roots of x\")\n",
    "plt.xlabel(\"number (x: 1 - 10^5)\")\n",
    "plt.ylabel(\"time (ms)\")\n",
    "\n",
    "# Print Stats\n",
    "print(f\"Average Time: {np.mean(_time)} ms\")\n",
    "print(f\"Standard Deviation: {np.std(_time)} ms\")"
   ]
  },
  {
   "cell_type": "markdown",
   "source": [
    "After building an algorithm to find the n-th root of x with both the *Bisection* and *Newton-Raphson* methods, we can notice that the **Newton Raphson** method is significantly faster, accurate, and in general better than the **Bisection** method.\n",
    "In terms of time, the **Newton Raphson** method is faster than the **Bisection** method by a factor of **6.5**. The average time for the **Newton Raphson** method is **0.071** milliseconds, while the average time for the **Bisection** method is **0.462** milliseconds. Furthermore, the standard deviation for the **Newton Raphson** method is **0.257** milliseconds, while the standard deviation for the **Bisection** method is **0.500** milliseconds showing that the newton raphson method takes consistently the same amount of time. This is a significant improvement over the bisection method.\n",
    "Overall, the **Newton Raphson** method offers a combination of speed and accuracy that is better than the **Bisection** method."
   ],
   "metadata": {
    "collapsed": false,
    "pycharm": {
     "name": "#%% md\n"
    }
   }
  },
  {
   "cell_type": "code",
   "execution_count": 6,
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Average Time: 0.007830257040210783 ms\n",
      "Standard Deviation: 0.0881181677749343 ms\n"
     ]
    },
    {
     "data": {
      "text/plain": "<Figure size 432x288 with 1 Axes>",
      "image/png": "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\n"
     },
     "metadata": {
      "needs_background": "light"
     },
     "output_type": "display_data"
    }
   ],
   "source": [
    "# Numpy's built-in nth root function test\n",
    "test_len = 10**5\n",
    "_time = []\n",
    "for _x in range(1, test_len):\n",
    "    start = time()\n",
    "\n",
    "    for _n in range(2, 5):\n",
    "        np.power(_x, 1/_n)\n",
    "\n",
    "    end = time()\n",
    "    _time.append((end - start)*1000)\n",
    "\n",
    "# Add plot to fig\n",
    "fig = plt.scatter(range(1, test_len), _time)\n",
    "\n",
    "# Add labels\n",
    "plt.suptitle(\"np.power Method\")\n",
    "plt.title(\"Time to find the 2nd - 6th roots of x\")\n",
    "plt.xlabel(\"number (x: 1 - 10^5)\")\n",
    "plt.ylabel(\"time (ms)\")\n",
    "\n",
    "# Print Stats\n",
    "print(f\"Average Time: {np.mean(_time)} ms\")\n",
    "print(f\"Standard Deviation: {np.std(_time)} ms\")"
   ],
   "metadata": {
    "collapsed": false,
    "pycharm": {
     "name": "#%%\n"
    }
   }
  },
  {
   "cell_type": "markdown",
   "source": [
    "However, comparing the **Newton Raphson** method to numpy's built-in nth root function, we can see that the  numpy's built-in nth root function is significantly faster, and the standard deviation is significantly lower. The average time for the  numpy's built-in nth root function is **0.0086** milliseconds, while the average time for the **Newton Raphson** method is **0.071** milliseconds. Furthermore, the standard deviation for the built-in Python nth root function is **0.0927** milliseconds, while the standard deviation for the **Newton Raphson** method is **0.257** milliseconds showing that the  numpy's built-in nth root function takes consistently lesser amount of time than the newton raphson method. In conclusion, the numpy's built-in nth root function is faster by a factor of **8.25**."
   ],
   "metadata": {
    "collapsed": false,
    "pycharm": {
     "name": "#%% md\n"
    }
   }
  },
  {
   "cell_type": "code",
   "execution_count": 7,
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Average Time: 0.001168524983284501 ms\n",
      "Standard Deviation: 0.034144989332976765 ms\n"
     ]
    },
    {
     "data": {
      "text/plain": "<Figure size 432x288 with 1 Axes>",
      "image/png": "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\n"
     },
     "metadata": {
      "needs_background": "light"
     },
     "output_type": "display_data"
    }
   ],
   "source": [
    "test_len = 10**5\n",
    "_time = []\n",
    "for _x in range(1, test_len):\n",
    "    start = time()\n",
    "\n",
    "    for _n in range(2, 5):\n",
    "        _x**(1/_n)\n",
    "\n",
    "    end = time()\n",
    "    _time.append((end - start)*1000)\n",
    "\n",
    "# Add plot to fig\n",
    "fig = plt.scatter(range(1, test_len), _time)\n",
    "\n",
    "# Add labels\n",
    "plt.suptitle(\"Python's built-in power Method\")\n",
    "plt.title(\"Time to find the 2nd - 6th roots of x\")\n",
    "plt.xlabel(\"number (x: 1 - 10^5)\")\n",
    "plt.ylabel(\"time (ms)\")\n",
    "\n",
    "# Print Stats\n",
    "print(f\"Average Time: {np.mean(_time)} ms\")\n",
    "print(f\"Standard Deviation: {np.std(_time)} ms\")"
   ],
   "metadata": {
    "collapsed": false,
    "pycharm": {
     "name": "#%%\n"
    }
   }
  },
  {
   "cell_type": "markdown",
   "source": [
    "Lastly, finding the n-th root with python's built-in function is way faster than the numpy's function. In fact, the built-in function is faster by a factor of **7.2**. Furthermore, the accuracy of th built-in and numpy's functions are more precise than our algorithms. Regardless, the algorithms provide a basic foundational introduction to root finding algorithms.\n",
    "\n",
    "**Summary of test results:**\n",
    "* Bisection Method:\n",
    "    * Average Time: 0.462 ms\n",
    "    * Standard Deviation: 0.500 ms\n",
    "\n",
    "* Newton Raphson Method:\n",
    "    * Average Time: 0.071 ms\n",
    "    * Standard Deviation: 0.257 ms\n",
    "\n",
    "* Numpy:\n",
    "    * Average Time: 0.0086 ms\n",
    "    * Standard Deviation: 0.0927 ms\n",
    "\n",
    "* Python's Built-in Function:\n",
    "    * Average Time: 0.0012 ms\n",
    "    * Standard Deviation: 0.035 ms"
   ],
   "metadata": {
    "collapsed": false,
    "pycharm": {
     "name": "#%% md\n"
    }
   }
  }
 ],
 "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.10.0"
  }
 },
 "nbformat": 4,
 "nbformat_minor": 1
}