A2_Abhishek_1911007.ipynb

{
  "nbformat": 4,
  "nbformat_minor": 0,
  "metadata": {
    "colab": {
      "provenance": [],
      "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/1_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": [
        "ch-1,section 1.8,problem 2 solution\n",
        "\n",
        "\n",
        "Solve this problem without a computer. This program suffers from at least one error:\n",
        "\n",
        "from math import *\n",
        "\n",
        "one = (log10, sin, log, exp)\n",
        "\n",
        "other = {}\n",
        "\n",
        "for o in one[1:]:\n",
        "\n",
        "other[o.] = o(1.)\n",
        "\n",
        "print(other)\n",
        "\n",
        "Explain what this code is doing and what will get printed out after you fix it up.\n"
      ],
      "metadata": {
        "id": "WQ_ml2-9D-ZK"
      }
    },
    {
      "cell_type": "code",
      "source": [
        "from math import *\n",
        "\n",
        "one = (log10, sin, log, exp)\n",
        "other = {}\n",
        "\n",
        "for o in one[1:]:\n",
        "    other[o.__name__] = o(1.0)\n",
        "\n",
        "print(other)"
      ],
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "CuSusmoTEUIK",
        "outputId": "675ea9c7-4dce-437c-b44a-a594f73500f5"
      },
      "execution_count": null,
      "outputs": [
        {
          "output_type": "stream",
          "name": "stdout",
          "text": [
            "{'sin': 0.8414709848078965, 'log': 0.0, 'exp': 2.718281828459045}\n"
          ]
        }
      ]
    },
    {
      "cell_type": "markdown",
      "source": [
        "Explanation:\n",
        "\n",
        "The code creates a tuple one containing four math functions: log10, sin, log, and exp.\n",
        "\n",
        "\n",
        "The loop iterates through the one tuple, starting from the second element (index 1), which is sin.\n",
        "\n",
        "Inside the loop, it adds an entry to the other dictionary with the function name (obtained using o._name_) as the key and the result of applying the function to the argument 1.0 as the value.\n",
        "\n",
        "Finally, it prints the other dictionary.\n",
        "\n",
        "The output of the fixed code will be a dictionary containing the results of applying the functions sin, log, and exp to the argument 1.0"
      ],
      "metadata": {
        "id": "XCsuroMcE7oA"
      }
    },
    {
      "cell_type": "markdown",
      "source": [
        "ch-1,section 1.8,problem 3 solution\n",
        "\n",
        "Produce a function, descr(), which describes properties of the function and argument\n",
        "value that are passed in to it. Define it using def descr(f, x):.\n",
        "\n",
        "(a) Write the function body; this should separately print out f, x, and f(x). Now call\n",
        "it repeatedly, for a number of user-defined and Python standard library functions.\n",
        "Notice that when you print out f the output is not human friendly.\n",
        "\n",
        "(b) Pass in as the first argument not the function but a string containing the function\n",
        "name. You now need a mechanism that converts the string you passed in to a func\u0002tion (since you still need to print out f(x)). Knowing the list of possibilities, create\n",
        "a dictionary that uses strings as keys and functions as values.\n",
        "\n",
        "(c) Modify the previous program so that the first argument that is passed in to descr()\n",
        "is a function, not a string. In order to produce the same output, you must also modify\n",
        "the body of the function since your dictionary will now be different."
      ],
      "metadata": {
        "id": "JCCMG3fOF8iy"
      }
    },
    {
      "cell_type": "markdown",
      "source": [
        "Ans of part (a)"
      ],
      "metadata": {
        "id": "ndCY_vTkIDex"
      }
    },
    {
      "cell_type": "code",
      "source": [
        "def descr(f, x):\n",
        "    result = f(x)\n",
        "    print(f\"Function: {f}\")\n",
        "    print(f\"Argument Value: {x}\")\n",
        "    print(f\"Result of f(x): {result}\")\n"
      ],
      "metadata": {
        "id": "rSx6f5_mIKNn"
      },
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "markdown",
      "source": [
        "Ans of Part (b)"
      ],
      "metadata": {
        "id": "Vm1sqGDFIhdw"
      }
    },
    {
      "cell_type": "code",
      "source": [
        "def descr(f_name, x):\n",
        "\n",
        "    function_map = {'sqrt':  x ** 0.5,'log':  math.log(x),'sin':  math.sin(x)}\n",
        "\n",
        "    function = function_map.get(f_name, None)\n",
        "\n",
        "    if function is None:\n",
        "        print(f\"Function '{f_name}' is not available.\")\n",
        "    else:\n",
        "        result = function(x)\n",
        "        print(f\"Function: {f_name}\")\n",
        "        print(f\"Argument Value: {x}\")\n",
        "        print(f\"Result of {f_name}(x): {result}\")"
      ],
      "metadata": {
        "id": "l7bLeLHOFyBI"
      },
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "markdown",
      "source": [
        "Ans of Part (c)"
      ],
      "metadata": {
        "id": "5J6B1Es_LUCy"
      }
    },
    {
      "cell_type": "code",
      "source": [
        "def descr(f, x):\n",
        "    try:\n",
        "        result = f(x)\n",
        "        print(f\"Function: {f.__name__}\")\n",
        "        print(f\"Argument Value: {x}\")\n",
        "        print(f\"Result of {f.__name__}(x): {result}\")\n",
        "    except Exception as e:\n",
        "        print(f\"Error: {e}\")\n"
      ],
      "metadata": {
        "id": "y3e8jKLGLZuA"
      },
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "markdown",
      "source": [
        "descr() function repeatedly for different functions and argument values attched below:"
      ],
      "metadata": {
        "id": "obGXB-DQo2ua"
      }
    },
    {
      "cell_type": "code",
      "source": [
        "\n",
        "\n",
        "# Part (a) - Calling with function objects\n",
        "descr(math.sqrt, 25)  # Output: Function: <built-in function sqrt>, Argument Value: 25, Result of f(x): 5.0\n",
        "descr(math.log, 10)   # Output: Function: <built-in function log>, Argument Value: 10, Result of f(x): 2.302585092994046\n",
        "descr(math.sin, 0.5)  # Output: Function: <built-in function sin>, Argument Value: 0.5, Result of f(x): 0.479425538604203\n",
        "\n",
        "# Part (b) - Calling with function names as strings\n",
        "descr('sqrt', 25)     # Output: Function: sqrt, Argument Value: 25, Result of sqrt(x): 5.0\n",
        "descr('log', 10)      # Output: Function: log, Argument Value: 10, Result of log(x): 2.302585092994046\n",
        "descr('sin', 0.5)     # Output: Function: sin, Argument Value: 0.5, Result of sin(x): 0.479425538604203\n",
        "\n",
        "# Part (c) - Calling with function objects\n",
        "descr(math.sqrt, 25)  # Output: Function: sqrt, Argument Value: 25, Result of sqrt(x): 5.0\n",
        "descr(math.log, 10)   # Output: Function: log, Argument Value: 10, Result of log(x): 2.302585092994046\n",
        "descr(math.sin, 0.5)  # Output: Function: sin, Argument Value: 0.5, Result of sin(x): 0.479425538604203\n"
      ],
      "metadata": {
        "id": "jz-vzeVno8E2"
      },
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "markdown",
      "source": [
        "ch-1,section 1.8,problem 4 solution"
      ],
      "metadata": {
        "id": "3jenmYrwpv9t"
      }
    },
    {
      "cell_type": "markdown",
      "source": [
        "Iterate through a list xs in reverse, printing out both the index (which will be decreasing)and each element itself. Try to come up with both Pythonic and unPythonic solutions.\n"
      ],
      "metadata": {
        "id": "VFpwsJPUpytC"
      }
    },
    {
      "cell_type": "markdown",
      "source": [
        "UnPythonic Solution:"
      ],
      "metadata": {
        "id": "uk2kulQfqIpK"
      }
    },
    {
      "cell_type": "code",
      "source": [
        "xs = [1, 2, 3, 4, 5]\n",
        "\n",
        "def unpythonic_reverse_print(xs):\n",
        "    index = len(xs) - 1\n",
        "    while index >= 0:\n",
        "        print(index, xs[index])\n",
        "        index -= 1\n",
        "\n",
        "\n",
        "unpythonic_reverse_print(xs)\n",
        "\n",
        "\n"
      ],
      "metadata": {
        "id": "DHrQWdLkqLwC",
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "outputId": "6444fb2c-3da4-4668-cd92-84172e04681d"
      },
      "execution_count": null,
      "outputs": [
        {
          "output_type": "stream",
          "name": "stdout",
          "text": [
            "4 5\n",
            "3 4\n",
            "2 3\n",
            "1 2\n",
            "0 1\n"
          ]
        }
      ]
    },
    {
      "cell_type": "markdown",
      "source": [],
      "metadata": {
        "id": "YMSYjPSDBGap"
      }
    },
    {
      "cell_type": "markdown",
      "source": [
        "Pythonic Solution:"
      ],
      "metadata": {
        "id": "cbRn9YYM8xAo"
      }
    },
    {
      "cell_type": "code",
      "source": [
        "xs = [1, 2, 3, 4, 5]\n",
        "def pythonic_reverse_print(xs):\n",
        "    for index, element in enumerate(reversed(xs)):\n",
        "        print(len(xs) - 1 - index, element)\n",
        "\n",
        "\n",
        "pythonic_reverse_print(xs)\n"
      ],
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "hVd3jcJs89la",
        "outputId": "911a9461-e3d1-46a7-a528-fcc7a04a1500"
      },
      "execution_count": null,
      "outputs": [
        {
          "output_type": "stream",
          "name": "stdout",
          "text": [
            "4 5\n",
            "3 4\n",
            "2 3\n",
            "1 2\n",
            "0 1\n"
          ]
        }
      ]
    },
    {
      "cell_type": "markdown",
      "source": [
        "ch-1,section 1.8,problem 5 solution\n",
        "\n",
        "\n",
        "Investigate the relative efficiency of multiplying two one-dimensional NumPy arrays,as and bs; these should be large and with non-constant content. Do this in four distinct ways: (a) sum(as*bs), (b) np.sum(as*bs), (c) np.dot(as,bs), and (d) as@bs. You may wish to use the default timer() function from the timeit module. To produce meaningful timing results, repeat such calculations thousands of times (at least)."
      ],
      "metadata": {
        "id": "KXZD0ce8BJVQ"
      }
    },
    {
      "cell_type": "code",
      "source": [
        "import numpy as np\n",
        "import timeit\n",
        "\n",
        "\n",
        "np.random.seed(42)\n",
        "as_array = np.random.rand(10000)\n",
        "bs_array = np.random.rand(10000)\n",
        "\n",
        "# Method (a): sum(as * bs)\n",
        "def method_a():\n",
        "    return sum(as_array * bs_array)\n",
        "\n",
        "# Method (b): np.sum(as * bs)\n",
        "def method_b():\n",
        "    return np.sum(as_array * bs_array)\n",
        "\n",
        "# Method (c): np.dot(as, bs)\n",
        "def method_c():\n",
        "    return np.dot(as_array, bs_array)\n",
        "\n",
        "# Method (d): as @ bs\n",
        "def method_d():\n",
        "    return as_array @ bs_array\n",
        "\n",
        "\n",
        "num_iterations = 10000\n",
        "\n",
        "time_a = timeit.timeit(method_a, number=num_iterations)\n",
        "time_b = timeit.timeit(method_b, number=num_iterations)\n",
        "time_c = timeit.timeit(method_c, number=num_iterations)\n",
        "time_d = timeit.timeit(method_d, number=num_iterations)\n",
        "\n",
        "\n",
        "print(f\"Method (a) time: {time_a:.6f} seconds\")\n",
        "print(f\"Method (b) time: {time_b:.6f} seconds\")\n",
        "print(f\"Method (c) time: {time_c:.6f} seconds\")\n",
        "print(f\"Method (d) time: {time_d:.6f} seconds\")\n"
      ],
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "vqpBn_60Boo4",
        "outputId": "f0e5ce93-10f6-411a-a7d8-7fe1773c6cec"
      },
      "execution_count": null,
      "outputs": [
        {
          "output_type": "stream",
          "name": "stdout",
          "text": [
            "Method (a) time: 11.423595 seconds\n",
            "Method (b) time: 0.141026 seconds\n",
            "Method (c) time: 0.040145 seconds\n",
            "Method (d) time: 0.038980 seconds\n"
          ]
        }
      ]
    }
  ]
}