excercise1A.ipynb

{
 "cells": [
  {
   "cell_type": "markdown",
   "source": [
    "# Excercise 1A\n",
    "All our code for exercise 1A."
   ],
   "metadata": {}
  },
  {
   "cell_type": "markdown",
   "source": [
    "### Import dependencies"
   ],
   "metadata": {}
  },
  {
   "cell_type": "code",
   "execution_count": 21,
   "source": [
    "from typing import Callable\n",
    "\n",
    "import numpy as np\n",
    "import matplotlib.pyplot as plt"
   ],
   "outputs": [],
   "metadata": {}
  },
  {
   "cell_type": "markdown",
   "source": [
    "### Create the function\n",
    "$f(x) = \\frac{1}{x} - \\log(x) + \\log(2)$"
   ],
   "metadata": {}
  },
  {
   "cell_type": "code",
   "execution_count": 22,
   "source": [
    "def f(x):\n",
    "    result = 1 / x - np.log(x) + np.log(2)\n",
    "    return result"
   ],
   "outputs": [],
   "metadata": {}
  },
  {
   "cell_type": "markdown",
   "source": [
    "## 1.A.1 Plotting the function\n",
    "A plot of the function $f(x)$, at the interval $[0.1, 20]$."
   ],
   "metadata": {}
  },
  {
   "cell_type": "code",
   "execution_count": 23,
   "source": [
    "def plot():\n",
    "    x = 0.1\n",
    "    i = 0\n",
    "    qq = np.empty(199)\n",
    "    qr = np.empty(199)\n",
    "    while x <= 20:\n",
    "        qq[i] = f(x)\n",
    "        qr[i] = x\n",
    "        x += 0.1\n",
    "        i += 1\n",
    "    plt.plot(qr, qq)\n",
    "    plt.grid(linestyle=\":\", linewidth=1.5)\n",
    "    plt.show()\n",
    "\n",
    "\n",
    "plot()"
   ],
   "outputs": [
    {
     "output_type": "display_data",
     "data": {
      "image/png": "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",
      "text/plain": [
       "<Figure size 432x288 with 1 Axes>"
      ]
     },
     "metadata": {
      "needs_background": "light"
     }
    }
   ],
   "metadata": {}
  },
  {
   "cell_type": "markdown",
   "source": [
    "## 1.A.1 False Position Method\n",
    "Below this paragraph is our implementation of the False Position Method. We choose the left boundry $a = 1$, and right boundry $b = 5$. We determine the new endpoint using: $c = \\frac{a * f(b) - b * f(a)}{f(b) - f(a)}$. Then we check if $f(c)$ is the root of the function. This is done by taking the absolute value of $f(c)$ and checking if it is smaller than the acceptable error. If $c$ is not the root, we check if $c$ has the same sign as $a$, if this is the case, we make $c$ the new left boundry, if the sign of $c$ is the same as $b$, we make $c$ the new right boundry. We then repeat this process until either we reach the specified maximum of iterations, the width of the two boundaries gets smaller than the specified maximal width or if $f(c)$ is within the acceptable error. We then print the last $c$ which was calculated as the root of the function."
   ],
   "metadata": {}
  },
  {
   "cell_type": "code",
   "execution_count": 24,
   "source": [
    "def false_position(\n",
    "    left_boundry: float, \n",
    "    right_boundry: float, \n",
    "    max_iterations: int, \n",
    "    minimum_width: float, \n",
    "    acceptable_error: float,\n",
    "    function: Callable[[float], float],\n",
    "):\n",
    "    iterations = 0\n",
    "    left_boundry_array = np.empty(max_iterations + 1) \n",
    "    right_boundry_array = np.empty(max_iterations + 1)\n",
    "    left_boundry_array[0] = left_boundry\n",
    "    right_boundry_array[0] = right_boundry\n",
    "    stop_reason: str = \"\"\n",
    "    center: float = 0.0\n",
    "\n",
    "    for i in range(max_iterations):\n",
    "        iterations = i + 1\n",
    "        center = (\n",
    "            left_boundry * f(right_boundry) - right_boundry * function(left_boundry)\n",
    "        ) / (function(right_boundry) - function(left_boundry))\n",
    "\n",
    "        if abs(function(center)) < acceptable_error:\n",
    "            stop_reason = \"within acceptable error\"\n",
    "            break\n",
    "        \n",
    "        if np.sign(function(center)) == np.sign(function(left_boundry)):\n",
    "            left_boundry = center\n",
    "        else:\n",
    "            right_boundry = center\n",
    "\n",
    "        if right_boundry - left_boundry < minimum_width:\n",
    "            stop_reason = \"minimum width reached\"\n",
    "            break\n",
    "\n",
    "        left_boundry_array[iterations] = left_boundry\n",
    "        right_boundry_array[iterations] = right_boundry\n",
    "        \n",
    "        \n",
    "    root = center\n",
    "\n",
    "    if iterations == max_iterations:\n",
    "            stop_reason = \"maximum iterations reached\"\n",
    "\n",
    "    print(\n",
    "        f\"{root=}\\n{stop_reason=}\\n{left_boundry=}\\n{right_boundry=}\\n{iterations=}\"\n",
    "    )\n",
    "\n",
    "    return root\n",
    "\n",
    "def false_position_main():\n",
    "    left_boundry = 1\n",
    "    right_boundry = 5\n",
    "    max_iterations = 50\n",
    "    minimum_width = 0.00000001\n",
    "    acceptable_error = 0.00000001\n",
    "    function = f\n",
    "\n",
    "    false_position(left_boundry, right_boundry, max_iterations, minimum_width, acceptable_error, function)\n",
    "\n",
    "false_position_main()"
   ],
   "outputs": [
    {
     "output_type": "stream",
     "name": "stdout",
     "text": [
      "root=2.8430598827496514\n",
      "stop_reason='within acceptable error'\n",
      "left_boundry=1\n",
      "right_boundry=2.8430598945320167\n",
      "iterations=26\n"
     ]
    }
   ],
   "metadata": {}
  },
  {
   "cell_type": "markdown",
   "source": [
    "## 1.A.2 Bisection Method\n",
    "Below this paragraph is our implementation of the Bisection Method. We choose the left boundry $a = 1$, and right boundry $b = 5$. We determine the new endpoint using: $c = \\frac{a + (b-a)}{2}$. Then we check if $f(c)$ is the root of the function. This is done by taking the absolute value of $f(c)$ and checking if it is smaller than the acceptable error. If $c$ is not the root, we check if $c$ has the same sign as $a$, if this is the case, we make $c$ the new left boundry, if the sign of $c$ is the same as $b$, we make $c$ the new right boundry. We then repeat this process until either we reach the specified maximum of iterations, the width of the two boundaries gets smaller than the specified maximal width or if $f(c)$ is within the acceptable error. We then print the last $c$ which was calculated as the root of the function."
   ],
   "metadata": {}
  },
  {
   "cell_type": "code",
   "execution_count": 25,
   "source": [
    "def bisection_method(\n",
    "    left_boundry: float, \n",
    "    right_boundry: float, \n",
    "    max_iterations: int, \n",
    "    minimum_width: float, \n",
    "    acceptable_error: float,\n",
    "    function: Callable[[float], float],\n",
    "):\n",
    "    iterations = 0\n",
    "    left_boundry_array = np.empty(max_iterations + 1)\n",
    "    right_boundry_array = np.empty(max_iterations + 1)\n",
    "    left_boundry_array[0] = left_boundry\n",
    "    right_boundry_array[0] = right_boundry\n",
    "    stop_reason: str = \"\"\n",
    "    center: float = 0.0\n",
    "\n",
    "    for i in range(max_iterations):\n",
    "        iterations = i + 1\n",
    "        center = left_boundry + (right_boundry - left_boundry) / 2\n",
    "\n",
    "        if abs(function(center)) < acceptable_error:\n",
    "            stop_reason = \"within acceptable error\"\n",
    "            break\n",
    "        \n",
    "        if np.sign(function(center)) == np.sign(function(left_boundry)):\n",
    "            left_boundry = center\n",
    "        else:\n",
    "            right_boundry = center\n",
    "\n",
    "        left_boundry_array[iterations] = left_boundry\n",
    "        right_boundry_array[iterations] = right_boundry\n",
    "\n",
    "        if right_boundry - left_boundry < minimum_width:\n",
    "            stop_reason = \"width interval reached\"\n",
    "            break\n",
    "\n",
    "    root = center\n",
    "\n",
    "    if iterations == max_iterations:\n",
    "            stop_reason = \"max iterations reached\"\n",
    "    print(\n",
    "        f\"{root=}\\n{stop_reason=}\\n{left_boundry=}\\n{right_boundry=}\\n{iterations=}\"\n",
    "    )\n",
    "    return root\n",
    "\n",
    "def bisection_method_main():\n",
    "    left_boundry = 1\n",
    "    right_boundry = 5\n",
    "    max_iterations = 50\n",
    "    minimum_width = 0.00000001\n",
    "    acceptable_error = 0.00000001\n",
    "    function = f\n",
    "    \n",
    "    bisection_method(left_boundry, right_boundry, max_iterations, minimum_width, acceptable_error, function)\n",
    "\n",
    "bisection_method_main()"
   ],
   "outputs": [
    {
     "output_type": "stream",
     "name": "stdout",
     "text": [
      "root=2.843059867620468\n",
      "stop_reason='within acceptable error'\n",
      "left_boundry=2.8430598378181458\n",
      "right_boundry=2.8430598974227905\n",
      "iterations=27\n"
     ]
    }
   ],
   "metadata": {}
  },
  {
   "cell_type": "markdown",
   "source": [
    "## 1.A.3 Modified False Position\n",
    "Below our implementation of the Modified False Position, we use left boundry $a = 1$, $b = 5$."
   ],
   "metadata": {}
  },
  {
   "cell_type": "code",
   "execution_count": 26,
   "source": [
    "def bisection_part(\n",
    "    left_boundry: float,\n",
    "    right_boundry: float,\n",
    "    function: Callable[[float], float],\n",
    "):\n",
    "    if np.sign(function(left_boundry)) == np.sign(function(right_boundry)):\n",
    "        center = (\n",
    "            left_boundry * function(right_boundry)\n",
    "            - 2 * right_boundry * function(left_boundry)\n",
    "        ) / (function(right_boundry) - 2 * function(left_boundry))\n",
    "    else:\n",
    "        center = (\n",
    "            2 * left_boundry * function(right_boundry)\n",
    "            - right_boundry * function(left_boundry)\n",
    "        ) / (2 * function(right_boundry) - function(left_boundry))\n",
    "\n",
    "    return center"
   ],
   "outputs": [],
   "metadata": {}
  },
  {
   "cell_type": "code",
   "execution_count": 27,
   "source": [
    "def false_position_part(\n",
    "    left_boundry: float,\n",
    "    right_boundry: float,\n",
    "    function: Callable[[float], float],\n",
    "):\n",
    "    center = (left_boundry * function(right_boundry) - right_boundry * function(left_boundry)) / (function(right_boundry) - function(left_boundry))\n",
    "\n",
    "    return center"
   ],
   "outputs": [],
   "metadata": {}
  },
  {
   "cell_type": "code",
   "execution_count": 28,
   "source": [
    "def modified_false_position(\n",
    "    left_boundry: float, \n",
    "    right_boundry: float, \n",
    "    max_iterations: int, \n",
    "    minimum_width: float, \n",
    "    acceptable_error: float,\n",
    "    function: Callable[[float], float],\n",
    "):\n",
    "    iteration = 0\n",
    "\n",
    "    counter_left_boundry_used = 0\n",
    "    counter_right_boundry_used = 0\n",
    "\n",
    "    left_boundry_array = np.empty(max_iterations + 1)\n",
    "    right_boundry_array = np.empty(max_iterations + 1)\n",
    "    left_boundry_array[0] = left_boundry\n",
    "    right_boundry_array[0] = right_boundry\n",
    "    stop_reason: str = \"\"\n",
    "    max_iterations = 50\n",
    "    minimum_width = 0.000001\n",
    "    acceptable_error = 0.00000001\n",
    "    center = 0.0\n",
    "\n",
    "    for i in range(max_iterations):\n",
    "        iteration = i + 1\n",
    "\n",
    "        if counter_left_boundry_used == 2 or counter_right_boundry_used == 2:\n",
    "            center = bisection_part(left_boundry, right_boundry, function)\n",
    "        else:\n",
    "            center = false_position_part(left_boundry, right_boundry, function)\n",
    "\n",
    "        if abs(function(center)) < acceptable_error:\n",
    "            stop_reason = \"within acceptable error\"\n",
    "            break\n",
    "        \n",
    "        if np.sign(function(center)) == np.sign(function(left_boundry)):\n",
    "            left_boundry = center\n",
    "            counter_right_boundry_used += 1\n",
    "            counter_left_boundry_used = 0\n",
    "        else:\n",
    "            right_boundry = center\n",
    "            counter_left_boundry_used += 1\n",
    "            counter_right_boundry_used = 0\n",
    "\n",
    "        left_boundry_array[iteration] = left_boundry\n",
    "        right_boundry_array[iteration] = right_boundry\n",
    "\n",
    "        if right_boundry - left_boundry < minimum_width:\n",
    "            stop_reason = \"minimum width reached\"\n",
    "\n",
    "    if iteration == max_iterations:\n",
    "        stop_reason = \"max iterations reached\"\n",
    "\n",
    "    root = center\n",
    "    print(\n",
    "        f\"{root=}\\n{stop_reason=}\\n{left_boundry=}\\n{right_boundry=}\\n{iteration=}\"\n",
    "    )\n",
    "    return root\n",
    "\n",
    "def modified_false_position_main():\n",
    "    left_boundry = 1\n",
    "    right_boundry = 5\n",
    "    max_iterations = 50\n",
    "    minimum_width = 0.00000001\n",
    "    acceptable_error = 0.00000001\n",
    "    function = f\n",
    "    \n",
    "    modified_false_position(left_boundry, right_boundry, max_iterations, minimum_width, acceptable_error, function)\n",
    "\n",
    "modified_false_position_main()"
   ],
   "outputs": [
    {
     "output_type": "stream",
     "name": "stdout",
     "text": [
      "root=2.8430598917613343\n",
      "stop_reason='within acceptable error'\n",
      "left_boundry=1\n",
      "right_boundry=2.843059913210903\n",
      "iteration=22\n"
     ]
    }
   ],
   "metadata": {}
  },
  {
   "cell_type": "markdown",
   "source": [
    "## 1.A.4 Findings\n",
    "Our results make it clear that Bisection and False Position method are both in this simulation similarly efficient (27 vs. 26). However when combining these, we created the Modified False Position (which completes in 22 iterations). This seems to be much more efficient."
   ],
   "metadata": {}
  }
 ],
 "metadata": {
  "orig_nbformat": 4,
  "language_info": {
   "name": "python",
   "version": "3.8.3",
   "mimetype": "text/x-python",
   "codemirror_mode": {
    "name": "ipython",
    "version": 3
   },
   "pygments_lexer": "ipython3",
   "nbconvert_exporter": "python",
   "file_extension": ".py"
  },
  "kernelspec": {
   "name": "python3",
   "display_name": "Python 3.8.3 64-bit ('base': conda)"
  },
  "interpreter": {
   "hash": "250e59cf0b7b5cec3664e2265f2ec6cf89f1074736b01d93c1f9583811222aad"
  }
 },
 "nbformat": 4,
 "nbformat_minor": 2
}