A4_Abhishek_1911007.ipynb

{
  "nbformat": 4,
  "nbformat_minor": 0,
  "metadata": {
    "colab": {
      "provenance": [],
      "authorship_tag": "ABX9TyOozF0IT6HNQfKlPNd/MZ64",
      "include_colab_link": true
    },
    "kernelspec": {
      "name": "python3",
      "display_name": "Python 3"
    },
    "language_info": {
      "name": "python"
    }
  },
  "cells": [
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "view-in-github",
        "colab_type": "text"
      },
      "source": [
        "<a href=\"https://colab.research.google.com/github/physicsme1729/Numerical-methods-in-physics/blob/main/3_swarup_kumar_Giri_P745.ipynb\" target=\"_parent\"><img src=\"https://colab.research.google.com/assets/colab-badge.svg\" alt=\"Open In Colab\"/></a>"
      ]
    },
    {
      "cell_type": "markdown",
      "source": [
        "Problem 1:\n",
        "\n",
        "\n",
        "\n",
        "Take the standard quadratic equation:\n",
        "\\begin{equation}\n",
        "    ax^2+bx+c=0\n",
        "\\end{equation}\n",
        "The formula for the solutions of this equation is very well known:\n",
        "\\begin{equation}\n",
        "    x_{\\pm}=\\frac{-b\\pm\\sqrt{b^2-4ac}}{2a}\n",
        "\\end{equation}\n",
        "# Take b > 0 for concreteness. It is easy to see that when $b^2>>ac$ we don’t get a catastrophic cancellation when evaluating $b^2-4ac$ (we may still get a “benign” cancellation).\n",
        "Furthermore,$\\sqrt{b^2-4ac}=b$. However, this means that $x_+$ will involve catastrophic cancellation in the numerator.\n",
        "\n",
        "\n",
        "We will employ an analytical trick in order to help us preserve significant figures. Observe that the product of the two roots obeys the relation:\n",
        "\\begin{equation}\n",
        "    x_+x_-=\\frac{c}{a}\n",
        "\\end{equation}\n",
        "The answer now presents itself: use the $x_{\\pm}$ formula to calculate $x_-$, for which no catastrophic cancellation takes place. Then, use the $ x_+x_-$ equation to calculate $x_+$.Notice that you ended up calculating $x_+$ via division only (i.e., without a catastrophic cancellation).\n",
        "\n",
        "\n",
        "Write a Python code that evaluates and prints out: \\\\\n",
        "(a):$x_-$\\\n",
        "(b): $x_+$ using the “bad” formula, and\\\n",
        "(c): $x_+$ using the “good” formula. \\\n",
        "# Take a = 1, c = 1, b = $10^8$."
      ],
      "metadata": {
        "id": "kCEwrO33LMhK"
      }
    },
    {
      "cell_type": "markdown",
      "source": [
        " The solutions of a quadratic equation while avoiding catastrophic cancellation. Here's the code and a discussion of the results:"
      ],
      "metadata": {
        "id": "auqsGi7jM-Qt"
      }
    },
    {
      "cell_type": "code",
      "source": [
        "import math\n",
        "\n",
        "def quadratic_roots(a, b, c):\n",
        "    discriminant = b**2 - 4*a*c\n",
        "    x_minus = (-b - math.sqrt(discriminant)) / (2*a)\n",
        "    return x_minus\n",
        "\n",
        "def calculate_x_plus_good(a, c, x_minus):\n",
        "    x_plus = c / (a * x_minus)\n",
        "    return x_plus\n",
        "\n",
        "def calculate_x_plus_bad(a, b, c):\n",
        "    discriminant = b**2 - 4*a*c\n",
        "    x_plus = (-b + math.sqrt(discriminant)) / (2*a)\n",
        "    return x_plus\n",
        "\n",
        "# Given values\n",
        "a = 1\n",
        "b = 10**8\n",
        "c = 1\n",
        "\n",
        "# Calculate x_-\n",
        "x_minus = quadratic_roots(a, b, c)\n",
        "\n",
        "# Calculate x_+ using the \"good\" formula\n",
        "x_plus_good = calculate_x_plus_good(a, c, x_minus)\n",
        "\n",
        "# Calculate x_+ using the \"bad\" formula\n",
        "x_plus_bad = calculate_x_plus_bad(a, b, c)\n",
        "\n",
        "print(\"x_-:\", x_minus)\n",
        "print(\"x_+ using bad formula:\", x_plus_bad)\n",
        "print(\"x_+ using good formula:\", x_plus_good)\n"
      ],
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "GT1v15nZNELa",
        "outputId": "8d9be3b3-1f17-4441-f967-9c22a4b8083d"
      },
      "execution_count": null,
      "outputs": [
        {
          "output_type": "stream",
          "name": "stdout",
          "text": [
            "x_-: -100000000.0\n",
            "x_+ using bad formula: -7.450580596923828e-09\n",
            "x_+ using good formula: -1e-08\n"
          ]
        }
      ]
    },
    {
      "cell_type": "markdown",
      "source": [
        "***Discussions of the answers:-***"
      ],
      "metadata": {
        "id": "MFEJkfWyQQws"
      }
    },
    {
      "cell_type": "markdown",
      "source": [
        "(a) $x_-$: This is calculated directly using the quadratic formula's root that doesn't involve catastrophic cancellation. Since $b^2 \\gg ac$, there isn't a significant risk of catastrophic cancellation when evaluating $b^2 - 4ac$, and the result for $x_-$ should be accurate."
      ],
      "metadata": {
        "id": "wCfKGhxPQWdW"
      }
    },
    {
      "cell_type": "markdown",
      "source": [
        "(b) $x_+$ using the \"bad\" formula: This uses the regular quadratic formula, and given the large value of b, there is a potential for catastrophic cancellation in the numerator when calculating $-b + \\sqrt{b^2 - 4ac}$. This could lead to loss of precision in the result."
      ],
      "metadata": {
        "id": "BRV9ASSCQ0vZ"
      }
    },
    {
      "cell_type": "markdown",
      "source": [
        " $x_+$ using the \"good\" formula: This uses the approach you've described, which first calculates x_- (avoiding catastrophic cancellation) and then uses the relation $x_+x_- = \\frac{c}{a}$ to find $x_+$. This method should preserve significant figures and avoid the issues of catastrophic cancellation."
      ],
      "metadata": {
        "id": "9Z0htDKwRHe-"
      }
    },
    {
      "cell_type": "markdown",
      "source": [
        "Problem-2\n",
        "\n",
        "\n",
        "***We will study the following function:***\n",
        "\n",
        "\\begin{equation*}\n",
        "    f(x)=\\frac{1-cosx}{x^2}\n",
        "\\end{equation*}\n",
        "\n",
        "**(a) Start by plotting the function, using a grid of the form $x = 0.1\\times i$ for i = 1, 2,..., 100. This should give you some idea of the values you should expect for f(x) at small x.\\\n",
        "(b)  Verify your previous hunch by taking the limit $x \\to 0$ and using L’Hopital’s rule.\\\n",
        "(c)  Now, see what value you find for f(x) when x = 1.2 $\\times$ $10^{-8}$. Does this make sense,\n",
        "even qualitatively?\\\n",
        "(d) Use a trigonometric identity that enables you to avoid cancellation. Evaluate the new function at x = 1.2 $\\times$ $10^{-8}$ and compare it with your analytical answer for $x \\to 0$.**"
      ],
      "metadata": {
        "id": "UKl3tPj7RfG_"
      }
    },
    {
      "cell_type": "markdown",
      "source": [
        "(a) Plotting the Function:"
      ],
      "metadata": {
        "id": "pAcd1EefWaqh"
      }
    },
    {
      "cell_type": "code",
      "source": [
        "import numpy as np\n",
        "import matplotlib.pyplot as plt\n",
        "\n",
        "def f(x):\n",
        "    return (1 - np.cos(x)) / x**2\n",
        "\n",
        "x_vals = np.arange(0.1, 10.1, 0.1)\n",
        "y_vals = f(x_vals)\n",
        "\n",
        "plt.plot(x_vals, y_vals)\n",
        "plt.xlabel('x')\n",
        "plt.ylabel('f(x)')\n",
        "plt.title('Plot of f(x)')\n",
        "plt.grid(True)\n",
        "plt.show()\n"
      ],
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/",
          "height": 472
        },
        "id": "YPiVX-xYYGU3",
        "outputId": "8565af3e-f55c-4f87-d5d5-f16e7034d820"
      },
      "execution_count": null,
      "outputs": [
        {
          "output_type": "display_data",
          "data": {
            "text/plain": [
              "<Figure size 640x480 with 1 Axes>"
            ],
            "image/png": "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\n"
          },
          "metadata": {}
        }
      ]
    },
    {
      "cell_type": "markdown",
      "source": [
        "This code will generate a plot of the function f(x)  for the specified range of x values."
      ],
      "metadata": {
        "id": "zzyJOtbUYhm6"
      }
    },
    {
      "cell_type": "markdown",
      "source": [
        "(b) Taking the Limit and Using L'Hopital's Rule:\n",
        "For the given function \\begin{equation*}\n",
        "    f(x)=\\frac{1-cosx}{x^2}\n",
        "\\end{equation*}\n",
        "\n",
        ", as x approaches 0:\n",
        "\n",
        "\\begin{equation*}\n",
        "    \\lim_{x \\to 0 } f(x) = \\lim_{x \\to 0 } \\frac{1-cosx}{x^2}\n",
        "\\end{equation*}\n",
        "\n",
        "Applying L'Hopital's rule:\n",
        "\\begin{equation*}\n",
        "    \\lim_{x \\to 0 } f(x) = \\lim_{x \\to 0 } \\frac{sinx}{2x} =\\frac{1}{2}\n",
        "\\end{equation*}\n",
        "So, the limit of f(x) as x approaches 0 is $\\frac{1}{2}$\n"
      ],
      "metadata": {
        "id": "lsG8fbzLYvlk"
      }
    },
    {
      "cell_type": "markdown",
      "source": [
        "(c) Evaluating f(x) at x =1.2 $\\times$ $10^{-8}$\n",
        "\n"
      ],
      "metadata": {
        "id": "SEeMVqkqaPbz"
      }
    },
    {
      "cell_type": "code",
      "source": [
        "x_small = 1.2e-8\n",
        "result_small_x = f(x_small)\n",
        "print(\"f(x) at x =\", x_small, \":\", result_small_x)\n"
      ],
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "lQFUmPakaiL_",
        "outputId": "4094bef6-ee42-42aa-f018-4ac1c78433dc"
      },
      "execution_count": null,
      "outputs": [
        {
          "output_type": "stream",
          "name": "stdout",
          "text": [
            "f(x) at x = 1.2e-08 : 0.7709882115452477\n"
          ]
        }
      ]
    },
    {
      "cell_type": "markdown",
      "source": [
        "(d) Using a Trigonometric Identity to Avoid Cancellation:"
      ],
      "metadata": {
        "id": "peGXj9CxaxPs"
      }
    },
    {
      "cell_type": "markdown",
      "source": [
        "To avoid cancellation in the numerator, you can use the trigonometric identity $1-cosx=2sin^2(x/2)$ . By substituting this identity into the original function, you can avoid direct subtraction and therefore avoid potential cancellation issues."
      ],
      "metadata": {
        "id": "hm03URRJay1w"
      }
    },
    {
      "cell_type": "markdown",
      "source": [
        "Here's how you can calculate f(x) using this identity:"
      ],
      "metadata": {
        "id": "qMbiJt-CbQ2j"
      }
    },
    {
      "cell_type": "code",
      "source": [
        "def f_with_identity(x):\n",
        "    numerator = 2 * np.sin(x/2)**2\n",
        "    denominator = x**2\n",
        "    return numerator / denominator\n",
        "\n",
        "result_with_identity = f_with_identity(x_small)\n",
        "print(\"f(x) using trig identity at x =\", x_small, \":\", result_with_identity)\n"
      ],
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "2jmZ3tr-bYuu",
        "outputId": "24ecaaf6-b98f-4f7f-a14e-e15a332b6c62"
      },
      "execution_count": null,
      "outputs": [
        {
          "output_type": "stream",
          "name": "stdout",
          "text": [
            "f(x) using trig identity at x = 1.2e-08 : 0.5\n"
          ]
        }
      ]
    },
    {
      "cell_type": "markdown",
      "source": [
        "This should give you a more accurate result for f(X) at small x."
      ],
      "metadata": {
        "id": "cAtKgTxfbcMS"
      }
    },
    {
      "cell_type": "markdown",
      "source": [
        "Problem 3 :\n",
        "\n",
        "\n",
        "let’s focus on numerical-error aspects. Assume you have n values $x_i$.\\\n",
        "(a) First, evaluate the mean:\n",
        "\\begin{equation*}\n",
        "    \\mu =\\frac{1}{n}\\sum_{i=0}^{n-1}x_i\n",
        "\\end{equation*}\n",
        "(b)  You can evaluate the variance using a two-pass algorithm:\n",
        "\\begin{equation*}\n",
        "    \\sigma^2 =\\frac{1}{n}\\sum_{i=0}^{n-1}(x_i-\\mu)^2\n",
        "\\end{equation*}\n",
        "This is called a two-pass algorithm because you need to evaluate the mean first, so you have to loop through the $x_i$ once to get the mean and a second time to get the variance. Many people prefer the following one-pass algorithm:\n",
        "\\begin{equation*}\n",
        "    \\sigma^2 =(\\frac{1}{n}\\sum_{i=0}^{n-1}x_i^2)-\\mu^2\n",
        "\\end{equation*}\n",
        "You should be able to see that this formula allows you to keep running sums of the $x_i$ and the $x_i^2$ values in parallel and then perform only one subtraction at the end.\n",
        "Naively, you might think that the two-pass algorithm will suffer from more roundoff error problems, since it involves n subtractions. On the other hand, if you solved the earlier problem on $\\tilde{x}^2$- $\\tilde{y}^2$, you might be more wary of subtracting the squares of two nearly equal numbers (which is what the one-pass algorithm does). Write two Python\n",
        "functions, one for each algorithm, and test them on the two cases below:\\\n",
        "Case 1: $x_i$=0,0.01,0.02,.....,0.09\\\n",
        "Case 2: $x_i$=123456789.0, 123456789.01, 123456789.02,..., 123456789.09"
      ],
      "metadata": {
        "id": "8D1wpK1LbmjQ"
      }
    },
    {
      "cell_type": "markdown",
      "source": [
        "***Ans:-***\n",
        "Here are two Python functions, each implementing the two-pass and one-pass algorithms for calculating the variance. We'll then test these functions on the provided test cases:"
      ],
      "metadata": {
        "id": "BPy_MFUBuGRX"
      }
    },
    {
      "cell_type": "markdown",
      "source": [
        "Case 1:"
      ],
      "metadata": {
        "id": "qScnbSsTz-q7"
      }
    },
    {
      "cell_type": "code",
      "source": [
        "import numpy as np\n",
        "\n",
        "def calculate_mean(x):\n",
        "    n = len(x)\n",
        "    mean = sum(x) / n\n",
        "    return mean\n",
        "\n",
        "def two_pass_variance(x, mean):\n",
        "    n = len(x)\n",
        "    variance = sum((xi - mean) ** 2 for xi in x) / n\n",
        "    return variance\n",
        "\n",
        "def one_pass_variance(x, mean):\n",
        "    n = len(x)\n",
        "    sum_x = sum(xi for xi in x)\n",
        "    sum_x_squared = sum(xi ** 2 for xi in x)\n",
        "    variance = (sum_x_squared / n) - (mean )** 2\n",
        "    return variance\n",
        "\n",
        "# Test case\n",
        "case1 = np.arange(0, 0.1, 0.01)\n",
        "\n",
        "\n",
        "mean_case1 = calculate_mean(case1)\n",
        "variance_two_pass_case1 = two_pass_variance(case1, mean_case1)\n",
        "variance_one_pass_case1 = one_pass_variance(case1, mean_case1)\n",
        "\n",
        "print(\"Mean of Case 1:\", mean_case1)\n",
        "print(\"Two-pass algorithm variance for Case 1:\", variance_two_pass_case1)\n",
        "print(\"One-pass algorithm variance for Case 1:\", variance_one_pass_case1)\n",
        "\n",
        "\n",
        "\n",
        "\n",
        "\n",
        "\n"
      ],
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "Aww15fgBuWTx",
        "outputId": "bbd2e0be-ba72-4a0c-c09e-4c9cef0f0e02"
      },
      "execution_count": null,
      "outputs": [
        {
          "output_type": "stream",
          "name": "stdout",
          "text": [
            "Mean of Case 1: 0.045000000000000005\n",
            "Two-pass algorithm variance for Case 1: 0.0008249999999999997\n",
            "One-pass algorithm variance for Case 1: 0.0008249999999999998\n"
          ]
        }
      ]
    },
    {
      "cell_type": "markdown",
      "source": [
        "Case2:"
      ],
      "metadata": {
        "id": "vrDzJEQD0OPu"
      }
    },
    {
      "cell_type": "code",
      "source": [
        "import numpy as np\n",
        "\n",
        "def calculate_mean(x):\n",
        "    n = len(x)\n",
        "    mean = sum(x) / n\n",
        "    return mean\n",
        "\n",
        "def two_pass_variance(x, mean):\n",
        "    n = len(x)\n",
        "    variance = sum((xi - mean) ** 2 for xi in x) / n\n",
        "    return variance\n",
        "\n",
        "def one_pass_variance(x, mean):\n",
        "    n = len(x)\n",
        "    sum_x = sum(xi for xi in x)\n",
        "    sum_x_squared = sum(xi ** 2 for xi in x)\n",
        "    variance = (sum_x_squared / n) - mean ** 2\n",
        "    return variance\n",
        "\n",
        "# Test case\n",
        "case2 = case2 = [123456789.0 + i * 0.01 for i in range(10)]\n",
        "\n",
        "mean_case2 = calculate_mean(case2)\n",
        "variance_two_pass_case2 = two_pass_variance(case2, mean_case2)\n",
        "variance_one_pass_case1 = one_pass_variance(case2, mean_case2)\n",
        "\n",
        "print(\"Mean of Case 2:\", mean_case2)\n",
        "print(\"Two-pass algorithm variance for Case 2:\", variance_two_pass_case2)\n",
        "print(\"One-pass algorithm variance for Case 2:\", variance_one_pass_case2)"
      ],
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "YOsTqfpKx-xa",
        "outputId": "89bf5f61-c100-4d55-c757-9e4fd01dafad"
      },
      "execution_count": null,
      "outputs": [
        {
          "output_type": "stream",
          "name": "stdout",
          "text": [
            "Mean of Case 2: 123456789.04499996\n",
            "Two-pass algorithm variance for Case 2: 0.0008249999612588655\n",
            "One-pass algorithm variance for Case 2: 10.0\n"
          ]
        }
      ]
    },
    {
      "cell_type": "markdown",
      "source": [
        "Problem 3\n",
        "\n",
        "\n",
        " Create a function that takes in three lists and produces the output in Fig. 3.2. Feel free to use the xscale() and yscale() functions.\n",
        " Fig 3.2 atach below"
      ],
      "metadata": {
        "id": "Q68iiJy6utEi"
      }
    },
    {
      "cell_type": "markdown",
      "source": [
        "![Screenshot 2023-08-20 223015.png](data:image/png;base64,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)"
      ],
      "metadata": {
        "id": "d5A-LBFQ5C1j"
      }
    },
    {
      "cell_type": "markdown",
      "source": [
        "you want to create a function that takes in three lists and produces an output similar to a graph you described. The output should be formatted as a table with columns \"h,\" \"abs. error in fd,\" and \"abs. error in cd,\" and then the data in the table is used to create a graph.\n",
        "\n",
        "Here's a Python function that takes three lists as input and produces the desired output along with a graph using the 'matplotlib' library for visualization:"
      ],
      "metadata": {
        "id": "LlCK17C_5KE6"
      }
    },
    {
      "cell_type": "code",
      "source": [
        "from math import exp, sin, cos\n",
        "import matplotlib.pyplot as plt\n",
        "\n",
        "def f(x):\n",
        "    return exp(sin(2*x))\n",
        "\n",
        "def fprime(x):\n",
        "    return 2*exp(sin(2*x))*cos(2*x)\n",
        "\n",
        "def calc_fd(f, x, h):\n",
        "    fd = (f(x+h) - f(x))/h\n",
        "    return fd\n",
        "\n",
        "def calc_cd(f, x, h):\n",
        "    cd = (f(x+h/2) - f(x-h/2))/h\n",
        "    return cd\n",
        "\n",
        "def generate_graph(hs, fds, cds):\n",
        "    plt.figure()\n",
        "\n",
        "    plt.xscale('log')  # Set x-axis to be logarithmic scale\n",
        "    plt.yscale('log')  # Set y-axis to be logarithmic scale\n",
        "\n",
        "    plt.plot(hs, fds, label='abs. error in fd')\n",
        "    plt.plot(hs, cds, label='abs. error in cd')\n",
        "\n",
        "    plt.xlabel('h')\n",
        "    plt.ylabel('Absolute Error')\n",
        "    plt.title('Absolute Error vs. h')\n",
        "    plt.legend()\n",
        "\n",
        "    plt.show()\n",
        "\n",
        "if __name__ == '__main__':\n",
        "    x = 0.5\n",
        "    an = fprime(x)\n",
        "    hs = [10**(-i) for i in range(1, 12)]\n",
        "    fds = [abs(calc_fd(f, x, h) - an) for h in hs]\n",
        "    cds = [abs(calc_cd(f, x, h) - an) for h in hs]\n",
        "\n",
        "    generate_graph(hs, fds, cds)\n"
      ],
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/",
          "height": 476
        },
        "id": "ybM7X-F3DUXn",
        "outputId": "8ef7c4f7-0a2a-4c82-dc41-b8d2dc69df5a"
      },
      "execution_count": null,
      "outputs": [
        {
          "output_type": "display_data",
          "data": {
            "text/plain": [
              "<Figure size 640x480 with 1 Axes>"
            ],
            "image/png": "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\n"
          },
          "metadata": {}
        }
      ]
    },
    {
      "cell_type": "markdown",
      "source": [
        "This function ***'create_output_and_graph'*** takes in the three lists ***'hs', 'fds', and 'cds', ***and then it generates the desired output table and plots a graph with the absolute error values. The ***'xscale('log')'*** and ***'yscale('log')***' functions set the scales of the graph to logarithmic, as i mentioned."
      ],
      "metadata": {
        "id": "QhqJSF0WD5Iq"
      }
    }
  ]
}