non_linear_optimization.ipynb

{
  "cells": [
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "Dd7YkAzQ0Z6t"
      },
      "source": [
        "![alt text](https://zewailcity.edu.eg/main/images/logo3.png)\n",
        "# Math 404 report 3\n",
        "### Ezzat Esam Eisawy  201901195"
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "pR_3kKM00UG5"
      },
      "source": [
        "# Imports"
      ]
    },
    {
      "cell_type": "code",
      "execution_count": null,
      "metadata": {
        "id": "-MKw0VWl0UG7"
      },
      "outputs": [],
      "source": [
        "import numpy as np\n",
        "import pandas as pd\n",
        "import matplotlib.pyplot as plt\n",
        "from typing import Callable\n",
        "from IPython.utils.io import capture_output\n",
        "from scipy.optimize import minimize"
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "wWEC8H2P0UG9"
      },
      "source": [
        "# Fibonaci and Golden Ratio elemination methods"
      ]
    },
    {
      "cell_type": "code",
      "execution_count": null,
      "metadata": {
        "id": "vJ7Ds-rw0UG-"
      },
      "outputs": [],
      "source": [
        "def solve_elimination_1D(\n",
        "    func: Callable[[float], float],\n",
        "    lower: float,\n",
        "    upper: float,\n",
        "    minimize: bool = True,\n",
        "    method: str = \"golden\",\n",
        "    accuracy: float = 0.1,\n",
        "    visualize: bool = True,\n",
        "):\n",
        "    \"\"\"\n",
        "    Solves a 1-dimensional optimization problem using the elimination method.\n",
        "\n",
        "    Parameters:\n",
        "    - func (Callable[[float], float]): The objective function to be minimized or maximized.\n",
        "    - lower (float): The lower bound of the search space.\n",
        "    - upper (float): The upper bound of the search space.\n",
        "    - minimize (bool, optional): If True, the goal is to minimize the objective function; otherwise, to maximize. Default is True.\n",
        "    - method (str, optional): The method to use for optimization. Options include \"golden\" for the golden section method and \"fib\" for Fibonacci method. Default is \"golden\".\n",
        "    - accuracy (float, optional): The desired accuracy of the solution. Default is 0.1.\n",
        "    - visualize (bool, optional): If True, the optimization process is visualized and a table of iterations is displayed. Default is True.\n",
        "\n",
        "    Returns:\n",
        "    - float: The optimal value of x within the specified bounds.\n",
        "    \"\"\"\n",
        "    x_lower = lower\n",
        "    x_upper = upper\n",
        "\n",
        "    f_x_upper = func(x_upper)\n",
        "    f_x_lower = func(x_lower)\n",
        "\n",
        "    if visualize:\n",
        "        history = pd.DataFrame(\n",
        "            columns=[\n",
        "                \"x_lower\",\n",
        "                \"f(x_lower)\",\n",
        "                \"x2\",\n",
        "                \"f(x2)\",\n",
        "                \"x1\",\n",
        "                \"f(x1)\",\n",
        "                \"x_upper\",\n",
        "                \"f(x_upper)\",\n",
        "                \"d\",\n",
        "            ]\n",
        "        )\n",
        "\n",
        "    if method == \"fib\":\n",
        "        n = abs(x_upper - x_lower) / accuracy\n",
        "\n",
        "        fib_list = [1, 1]\n",
        "\n",
        "        while fib_list[-1] < n:\n",
        "            fib_list.append(fib_list[-1] + fib_list[-2])\n",
        "\n",
        "    i = 0\n",
        "    while 1:\n",
        "        if method == \"fib\":\n",
        "            ratio = fib_list[-2 - i] / fib_list[-1 - i]\n",
        "        else:\n",
        "            ratio = 0.618\n",
        "\n",
        "        d = ratio * (x_upper - x_lower)\n",
        "        x1 = x_lower + d\n",
        "        x2 = x_upper - d\n",
        "\n",
        "        f_x1 = func(x1)\n",
        "        f_x2 = func(x2)\n",
        "\n",
        "        if visualize:\n",
        "            history.loc[i] = [\n",
        "                x_lower,\n",
        "                f_x_lower,\n",
        "                x2,\n",
        "                f_x2,\n",
        "                x1,\n",
        "                f_x1,\n",
        "                x_upper,\n",
        "                f_x_upper,\n",
        "                d,\n",
        "            ]\n",
        "\n",
        "        choose_x1 = (f_x1 > f_x2) if minimize else (f_x1 < f_x2)\n",
        "\n",
        "        if choose_x1:\n",
        "            x_upper = x1\n",
        "            f_x_upper = f_x1\n",
        "        else:\n",
        "            x_lower = x2\n",
        "            f_x_lower = f_x2\n",
        "\n",
        "        i += 1\n",
        "        if abs(x_upper - x_lower) < accuracy:\n",
        "            break\n",
        "\n",
        "    if visualize:\n",
        "        # display(history)\n",
        "        print(history.to_markdown())\n",
        "\n",
        "    return (x_upper + x_lower) / 2"
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "i1FVMJ2K0UHA"
      },
      "source": [
        "## Testing"
      ]
    },
    {
      "cell_type": "code",
      "execution_count": null,
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "xhWLZfoA0UHB",
        "outputId": "6ec460ca-3129-4513-e9e3-222ddca7c6df"
      },
      "outputs": [
        {
          "name": "stdout",
          "output_type": "stream",
          "text": [
            "|    |   x_lower |   f(x_lower) |       x2 |   f(x2) |      x1 |    f(x1) |   x_upper |   f(x_upper) |         d |\n",
            "|---:|----------:|-------------:|---------:|--------:|--------:|---------:|----------:|-------------:|----------:|\n",
            "|  0 |  0        |      0       | 1.52727  | 1.76485 | 2.47273 | 0.628754 |   4       |    -3.1136   | 2.47273   |\n",
            "|  1 |  0        |      0       | 0.945455 | 1.53214 | 1.52727 | 1.76485  |   2.47273 |     0.628754 | 1.52727   |\n",
            "|  2 |  0.945455 |      1.53214 | 1.52727  | 1.76485 | 1.89091 | 1.54085  |   2.47273 |     0.628754 | 0.945455  |\n",
            "|  3 |  0.945455 |      1.53214 | 1.30909  | 1.76053 | 1.52727 | 1.76485  |   1.89091 |     1.54085  | 0.581818  |\n",
            "|  4 |  1.30909  |      1.76053 | 1.52727  | 1.76485 | 1.67273 | 1.70982  |   1.89091 |     1.54085  | 0.363636  |\n",
            "|  5 |  1.30909  |      1.76053 | 1.45455  | 1.77493 | 1.52727 | 1.76485  |   1.67273 |     1.70982  | 0.218182  |\n",
            "|  6 |  1.30909  |      1.76053 | 1.38182  | 1.77345 | 1.45455 | 1.77493  |   1.52727 |     1.76485  | 0.145455  |\n",
            "|  7 |  1.38182  |      1.77345 | 1.45455  | 1.77493 | 1.45455 | 1.77493  |   1.52727 |     1.76485  | 0.0727273 |\n",
            "soltuion1.490909090909091\n"
          ]
        }
      ],
      "source": [
        "objective_function = lambda x : 2*np.sin(x) - (x**2)/10\n",
        "\n",
        "x = solve_elimination_1D(objective_function , 0 , 4 , minimize=False  , method=\"fib\")\n",
        "print(f\"soltuion{x}\")"
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "Jo1MosiL0UHF"
      },
      "source": [
        "# Interpolation methods"
      ]
    },
    {
      "cell_type": "code",
      "execution_count": null,
      "metadata": {
        "id": "jpPoDAGy0UHG"
      },
      "outputs": [],
      "source": [
        "def solve_quadratic_interpolation(func : Callable[[float], float], t_0 : float, accuracy : float=0.1, visualize=True, max_itr=10):\n",
        "    \"\"\"\n",
        "    Solves an optimization problem using quadratic interpolation.\n",
        "\n",
        "    Parameters:\n",
        "    - func (Callable[[float], float]): The objective function to be minimized.\n",
        "    - t_0 (float): The initial interval.\n",
        "    - accuracy (float, optional): The desired accuracy of the solution. Default is 0.1.\n",
        "    - visualize (bool, optional): If True, the optimization process is visualized. Default is True.\n",
        "    - max_itr (int, optional): The maximum number of iterations. Default is 10.\n",
        "\n",
        "    Returns:\n",
        "    - float: The optimal value of the parameter within the specified bounds.\n",
        "    \"\"\"\n",
        "\n",
        "    f_a = func(0)\n",
        "\n",
        "    A = 0\n",
        "\n",
        "    t = t_0\n",
        "\n",
        "    f_1 = func(t)\n",
        "\n",
        "\n",
        "    if f_1 > f_a:\n",
        "\n",
        "        f_c = f_1\n",
        "\n",
        "        C = t\n",
        "\n",
        "        f_b = func(t / 2)\n",
        "\n",
        "        B = t / 2\n",
        "\n",
        "    else:\n",
        "\n",
        "        while 1:\n",
        "\n",
        "            f_2 = func(2 * t)\n",
        "\n",
        "            if f_1 < f_2:\n",
        "\n",
        "                f_c = f_2\n",
        "\n",
        "                C = 2 * t\n",
        "\n",
        "                f_b = f_1\n",
        "\n",
        "                B = t\n",
        "\n",
        "                break\n",
        "\n",
        "            else:\n",
        "\n",
        "                f_1 = f_2\n",
        "\n",
        "                t = 2 * t\n",
        "\n",
        "\n",
        "    for i in range(max_itr):\n",
        "\n",
        "        # solving\n",
        "\n",
        "        # a + bA  + c A^2 = f_A\n",
        "\n",
        "        # a + bB + c B^2 = f_B\n",
        "\n",
        "        # a + bC + c C^2 = f_C\n",
        "\n",
        "        #print(f\"A = {A}, B = {B}, C = {C}\")\n",
        "        ans = np.linalg.solve(\n",
        "\n",
        "            np.array([[1, A, A**2], [1, B, B**2], [1, C, C**2]]),\n",
        "\n",
        "            np.array([f_a, f_b, f_c]),\n",
        "        )\n",
        "\n",
        "        a, b, c = ans\n",
        "\n",
        "\n",
        "        lambda_s = -b / (2 * c)\n",
        "        #print(f\"lambda s = {lambda_s :.2f}\")\n",
        "\n",
        "        h = lambda x: a + b * x + c * x**2\n",
        "        f = func(lambda_s)\n",
        "\n",
        "        convergance = np.abs((h(lambda_s) - f) / f)\n",
        "\n",
        "        # plot\n",
        "\n",
        "        if visualize:\n",
        "\n",
        "            print(f\"A = {A}, B = {B}, C = {C}\")\n",
        "\n",
        "            print(f\"lambda s = {lambda_s :.2f}\")\n",
        "\n",
        "            print(f\"Convergance = {convergance :.4f} , required = {accuracy :.4f}\")\n",
        "\n",
        "            x_values = np.linspace(0, 2 * t, 1000)\n",
        "\n",
        "            y_values_1 = [func(x) for x in x_values]\n",
        "\n",
        "            y_values_2 = h(x_values)\n",
        "\n",
        "\n",
        "            plt.figure()\n",
        "\n",
        "            plt.plot(x_values, y_values_1, label=\"Function\")\n",
        "\n",
        "            plt.plot(x_values, y_values_2, label=\"Quadratic Interpolation\")\n",
        "            plt.scatter(\n",
        "                lambda_s,\n",
        "                f,\n",
        "\n",
        "                color=\"red\",\n",
        "\n",
        "                label=f\"Function Minima: ({lambda_s:.2f}, {f:.2f})\",\n",
        "            )\n",
        "            plt.scatter(\n",
        "                lambda_s,\n",
        "\n",
        "                h(lambda_s),\n",
        "\n",
        "                color=\"green\",\n",
        "\n",
        "                label=f\"Interpolation Minima: ({lambda_s:.2f}, {h(lambda_s):.2f})\",\n",
        "            )\n",
        "            plt.scatter(\n",
        "\n",
        "                A,\n",
        "                f_a,\n",
        "\n",
        "                label=f\"A\",\n",
        "            )\n",
        "\n",
        "            plt.scatter(B, f_b, label=f\"B\")\n",
        "\n",
        "            plt.scatter(C, f_c, label=f\"C\")\n",
        "\n",
        "            plt.title(\"Quadratic Interpolation\")\n",
        "\n",
        "            plt.grid()\n",
        "\n",
        "            plt.xlabel(\"x\")\n",
        "\n",
        "            plt.ylabel(\"y\")\n",
        "\n",
        "            plt.legend()\n",
        "\n",
        "            plt.show()\n",
        "\n",
        "\n",
        "        if convergance > accuracy:\n",
        "\n",
        "            # case 1\n",
        "\n",
        "            if lambda_s > B and f < f_b:\n",
        "\n",
        "                A = B\n",
        "                f_a = f_b\n",
        "\n",
        "                B = lambda_s\n",
        "                f_b = f\n",
        "\n",
        "\n",
        "            # case 2\n",
        "\n",
        "            elif lambda_s > B and f > f_b:\n",
        "\n",
        "                C = lambda_s\n",
        "                f_c = f\n",
        "\n",
        "\n",
        "            # case 3\n",
        "\n",
        "            elif lambda_s < B and f < f_b:\n",
        "\n",
        "                C = B\n",
        "                f_c = f_b\n",
        "\n",
        "                B = lambda_s\n",
        "                f_b = f\n",
        "\n",
        "\n",
        "\n",
        "            # case 4\n",
        "\n",
        "            elif lambda_s < B and f > f_b:\n",
        "\n",
        "                A = lambda_s\n",
        "                f_a = f\n",
        "\n",
        "\n",
        "        else:\n",
        "\n",
        "            break\n",
        "    return lambda_s\n",
        "\n"
      ]
    },
    {
      "cell_type": "code",
      "execution_count": null,
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/",
          "height": 1000
        },
        "id": "3xEaHIdk0UHH",
        "outputId": "45a65495-4bdf-4ffc-c151-9702ec4dd3dd"
      },
      "outputs": [
        {
          "name": "stdout",
          "output_type": "stream",
          "text": [
            "A = 0, B = 2, C = 4\n",
            "lambda s = 1.13\n",
            "Convergance = 3.7930 , required = 0.0100\n"
          ]
        },
        {
          "data": {
            "image/png": "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",
            "text/plain": [
              "<Figure size 640x480 with 1 Axes>"
            ]
          },
          "metadata": {},
          "output_type": "display_data"
        },
        {
          "name": "stdout",
          "output_type": "stream",
          "text": [
            "A = 1.1333333333333333, B = 2, C = 4\n",
            "lambda s = 1.66\n",
            "Convergance = 0.4990 , required = 0.0100\n"
          ]
        },
        {
          "data": {
            "image/png": "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",
            "text/plain": [
              "<Figure size 640x480 with 1 Axes>"
            ]
          },
          "metadata": {},
          "output_type": "display_data"
        },
        {
          "name": "stdout",
          "output_type": "stream",
          "text": [
            "A = 1.658458102250572, B = 2, C = 4\n",
            "lambda s = 1.87\n",
            "Convergance = 0.0731 , required = 0.0100\n"
          ]
        },
        {
          "data": {
            "image/png": "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",
            "text/plain": [
              "<Figure size 640x480 with 1 Axes>"
            ]
          },
          "metadata": {},
          "output_type": "display_data"
        },
        {
          "name": "stdout",
          "output_type": "stream",
          "text": [
            "A = 1.8740625360908771, B = 2, C = 4\n",
            "lambda s = 1.95\n",
            "Convergance = 0.0099 , required = 0.0100\n"
          ]
        },
        {
          "data": {
            "image/png": "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",
            "text/plain": [
              "<Figure size 640x480 with 1 Axes>"
            ]
          },
          "metadata": {},
          "output_type": "display_data"
        },
        {
          "name": "stdout",
          "output_type": "stream",
          "text": [
            "Solution = 1.9549510186208594\n"
          ]
        }
      ],
      "source": [
        "f = lambda x: x**5 - 5 * x**3 - 20 * x + 5\n",
        "\n",
        "lambda_s = solve_quadratic_interpolation(f, 2, accuracy=1e-2)\n",
        "print(f\"Solution = {lambda_s}\")"
      ]
    },
    {
      "cell_type": "code",
      "execution_count": null,
      "metadata": {
        "id": "lgm0hRER0UHI"
      },
      "outputs": [],
      "source": [
        "def solve_cubic_interpolation(\n",
        "    objective_function: Callable[[float], float],\n",
        "    derivative_function: Callable[[float], float],\n",
        "    t_0: float,\n",
        "    accuracy: float = 0.1,\n",
        "    derivative_accuracy: float = 0.1,\n",
        "    max_itr=10,\n",
        "    visualize=True,\n",
        "):\n",
        "    \"\"\"\n",
        "    Solves an optimization problem using cubic interpolation.\n",
        "\n",
        "    Parameters:\n",
        "    - objective_function (Callable[[float], float]): The objective function to be minimized.\n",
        "    - derivative_function (Callable[[float], float]): The derivative of the objective function.\n",
        "    - t_0 (float): The initial interval.\n",
        "    - accuracy (float, optional): The desired accuracy of the solution. Default is 0.1.\n",
        "    - derivative_accuracy (float, optional): The desired accuracy of the derivative. Default is 0.1.\n",
        "    - max_itr (int, optional): The maximum number of iterations. Default is 20.\n",
        "    - visualize (bool, optional): If True, the optimization process is visualized. Default is True.\n",
        "\n",
        "    Returns:\n",
        "    - float: The optimal value of the parameter within the specified bounds.\n",
        "    \"\"\"\n",
        "    A = 0\n",
        "    fA = objective_function(A)\n",
        "    fA_derivative = derivative_function(A)\n",
        "    t = t_0\n",
        "    while 1:\n",
        "        B = t\n",
        "        fB_derivative = derivative_function(B)\n",
        "        if fB_derivative >= 0:\n",
        "            fB = objective_function(B)\n",
        "\n",
        "            break\n",
        "        t *= 2\n",
        "\n",
        "    for i in range(max_itr):\n",
        "        # solving a , b , c ,d\n",
        "        # a + b A + c A^2 + d A^3 = f_A\n",
        "        # a + b B + c B^2 + d B^3 = f_B\n",
        "        # 0 + b + 2cA + 3dA^2 = f_A_derivative\n",
        "        # 0 + b + 2cB + 3dB^2 = f_B_derivative\n",
        "\n",
        "        ans = np.linalg.solve(\n",
        "            np.array(\n",
        "                [\n",
        "                    [1, A, A**2, A**3],\n",
        "                    [1, B, B**2, B**3],\n",
        "                    [0, 1, 2 * A, 3 * A**2],\n",
        "                    [0, 1, 2 * B, 3 * B**2],\n",
        "                ]\n",
        "            ),\n",
        "            np.array([fA, fB, fA_derivative, fB_derivative]),\n",
        "        )\n",
        "        a, b, c, d = ans\n",
        "        lambda_1 = (-c + (c**2 - 3 * b * d) ** 0.5) / (3 * d)\n",
        "        lambda_2 = (-c - (c**2 - 3 * b * d) ** 0.5) / (3 * d)\n",
        "        if lambda_1 >= A and lambda_1 <= B:\n",
        "            lambda_s = lambda_1\n",
        "        else:\n",
        "            lambda_s = lambda_2\n",
        "\n",
        "        # print(lambda_1, lambda_2)\n",
        "        # print(A, B  , lambda_s)\n",
        "        h = lambda x: a + b * x + c * x**2 + d * x**3\n",
        "\n",
        "        f = objective_function(lambda_s)\n",
        "\n",
        "        # plot\n",
        "        if visualize:\n",
        "            x_values = np.linspace(0, 2 * t, 1000)\n",
        "            y_values_1 = [objective_function(x) for x in x_values]\n",
        "            y_values_2 = h(x_values)\n",
        "\n",
        "            plt.figure()\n",
        "            plt.plot(x_values, y_values_1, label=\"Function\")\n",
        "            plt.plot(x_values, y_values_2, label=\"cubic Interpolation\")\n",
        "            plt.scatter(\n",
        "                lambda_s,\n",
        "                f,\n",
        "                color=\"red\",\n",
        "                label=f\"Function Minima: ({lambda_s:.2f}, {f:.2f})\",\n",
        "            )\n",
        "            plt.scatter(\n",
        "                lambda_s,\n",
        "                h(lambda_s),\n",
        "                color=\"green\",\n",
        "                label=f\"Interpolation Minima: ({lambda_s:.2f}, {h(lambda_s):.2f})\",\n",
        "            )\n",
        "            plt.scatter(\n",
        "                A,\n",
        "                fA,\n",
        "                label=f\"A\",\n",
        "            )\n",
        "            plt.scatter(B, fB, label=f\"B\")\n",
        "            plt.title(\"cubic Interpolation\")\n",
        "            plt.xlabel(\"x\")\n",
        "            plt.ylabel(\"y\")\n",
        "            plt.grid()\n",
        "            plt.legend()\n",
        "            plt.show()\n",
        "\n",
        "        # check convergence\n",
        "        # print(np.abs((h(lambda_s) - f) / f), derivative_function(lambda_s))\n",
        "        # print(f , h(lambda_s))\n",
        "        if not (\n",
        "            np.abs((h(lambda_s) - f) / f) < accuracy\n",
        "            or abs(derivative_function(lambda_s)) < derivative_accuracy\n",
        "        ):\n",
        "            f_lambda_derivative = derivative_function(lambda_s)\n",
        "            if f_lambda_derivative >= 0:\n",
        "                B = lambda_s\n",
        "            else:\n",
        "                A = lambda_s\n",
        "        else:\n",
        "            break\n",
        "\n",
        "    return lambda_s"
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "ESmSMbAO0UHJ"
      },
      "source": [
        "## Testing"
      ]
    },
    {
      "cell_type": "code",
      "execution_count": null,
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/",
          "height": 489
        },
        "id": "eDQfnXuh0UHJ",
        "outputId": "7e5a2fbb-fd45-44a2-f8e9-a1da0258d4fc"
      },
      "outputs": [
        {
          "data": {
            "image/png": "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",
            "text/plain": [
              "<Figure size 640x480 with 1 Axes>"
            ]
          },
          "metadata": {},
          "output_type": "display_data"
        },
        {
          "name": "stdout",
          "output_type": "stream",
          "text": [
            "2.0\n"
          ]
        }
      ],
      "source": [
        "f = lambda x: x**5 - 5 * x**3 - 20 * x + 5\n",
        "f_derivative = lambda x: 5 * x**4 - 15 * x**2 - 20\n",
        "lambda_s = solve_cubic_interpolation(\n",
        "    f, f_derivative, 1, accuracy=1e-3, derivative_accuracy=0.1, visualize=True\n",
        ")\n",
        "print(lambda_s)"
      ]
    },
    {
      "cell_type": "code",
      "execution_count": null,
      "metadata": {
        "id": "KZCY3ekC0UHK"
      },
      "outputs": [],
      "source": [
        "def optimize_1d_general(\n",
        "    obj_function: Callable[[np.ndarray], float],\n",
        "    grad_function: Callable[[np.ndarray], np.ndarray],\n",
        "    x: np.ndarray,\n",
        "    s: np.ndarray,\n",
        "    interval: float,\n",
        "    method_1d: str = \"golden\",\n",
        "):\n",
        "    \"\"\"\n",
        "    Optimizes a one-dimensional objective function along a given search direction.\n",
        "\n",
        "    Parameters:\n",
        "    - obj_function (Callable[[np.ndarray], float]): The objective function to be minimized.\n",
        "    - grad_function (Callable[[np.ndarray], np.ndarray]): The gradient function.\n",
        "    - x (np.ndarray): The current point.\n",
        "    - s (np.ndarray): The search direction.\n",
        "    - interval (float): The interval for the one-dimensional optimization.\n",
        "    - method_1d (str, optional): The method for one-dimensional optimization. Options include \"constant\", \"fib\" (Fibonacci), \"golden\" (Golden Section), \"quad\" (Quadratic), and \"cubic\" (Cubic). Default is \"golden\".\n",
        "\n",
        "    Returns:\n",
        "    - float: The optimal value of the parameter within the specified interval.\n",
        "    \"\"\"\n",
        "\n",
        "    def function_to_optimize_lambda(lambda_s):\n",
        "        x_new = x + lambda_s * s\n",
        "        return obj_function(x_new)\n",
        "\n",
        "    if method_1d == \"constant\":\n",
        "        lambda_s = 1\n",
        "\n",
        "    elif method_1d == \"fib\":\n",
        "        lambda_s = solve_elimination_1D(\n",
        "            function_to_optimize_lambda,\n",
        "            0,\n",
        "            interval,\n",
        "            minimize=True,\n",
        "            method=\"fib\",\n",
        "            accuracy=0.001,\n",
        "            visualize=False,\n",
        "        )\n",
        "\n",
        "    elif method_1d == \"golden\":\n",
        "        lambda_s = solve_elimination_1D(\n",
        "            function_to_optimize_lambda,\n",
        "            0,\n",
        "            interval,\n",
        "            minimize=True,\n",
        "            method=\"golden\",\n",
        "            accuracy=0.001,\n",
        "            visualize=False,\n",
        "        )\n",
        "\n",
        "    elif method_1d == \"quad\":\n",
        "        lambda_s = solve_quadratic_interpolation(\n",
        "            function_to_optimize_lambda,\n",
        "            interval,\n",
        "            accuracy=0.001,\n",
        "            visualize=False,\n",
        "        )\n",
        "\n",
        "    elif method_1d == \"cubic\":\n",
        "\n",
        "        def function_derivative(lambda_s):\n",
        "            s_normalized = s / np.linalg.norm(s)\n",
        "            return s_normalized @ grad_function(x + lambda_s * s)\n",
        "\n",
        "        lambda_s = solve_cubic_interpolation(\n",
        "            function_to_optimize_lambda,\n",
        "            function_derivative,\n",
        "            interval,\n",
        "            accuracy=0.01,\n",
        "            derivative_accuracy=0.01,\n",
        "            visualize=False,\n",
        "        )\n",
        "\n",
        "    return lambda_s"
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "BGNbbQOw0UHL"
      },
      "source": [
        "# Descent functions"
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "lrouEoaH0UHL"
      },
      "source": [
        "## Fletcher reeves"
      ]
    },
    {
      "cell_type": "code",
      "execution_count": null,
      "metadata": {
        "id": "NBmE2CLb0UHL"
      },
      "outputs": [],
      "source": [
        "def solve_fletcher_reeves(\n",
        "    gradient_function: Callable[[np.ndarray], np.ndarray],\n",
        "    hessian_function: Callable[[np.ndarray], np.ndarray],\n",
        "    x_0: np.ndarray,\n",
        "    eps: float = 1e-3,\n",
        "):\n",
        "    \"\"\"\n",
        "    Solves an optimization problem using the Fletcher-Reeves conjugate gradient method.\n",
        "\n",
        "    Parameters:\n",
        "    - gradient_function (Callable[[np.ndarray], np.ndarray]): The gradient function.\n",
        "    - hessian_function (Callable[[np.ndarray], np.ndarray]): The Hessian function.\n",
        "    - x_0 (np.ndarray): The initial guess for the minimum.\n",
        "    - eps (float, optional): The desired accuracy of the solution. Default is 1e-3.\n",
        "\n",
        "    Returns:\n",
        "    - np.ndarray: The optimal values of the parameters.\n",
        "    \"\"\"\n",
        "\n",
        "    x1 = x_0\n",
        "\n",
        "    s1 = -gradient_function(x1)\n",
        "\n",
        "    A = hessian_function(x1)\n",
        "\n",
        "\n",
        "    lambda_s = np.linalg.norm(gradient_function(x1)) ** 2 / (s1 @ A @ s1)\n",
        "\n",
        "    x2 = x1 + lambda_s * s1\n",
        "\n",
        "\n",
        "    xi = x2\n",
        "\n",
        "    grad_f_i_1 = -s1\n",
        "    si_1 = s1\n",
        "\n",
        "\n",
        "    i = 0\n",
        "\n",
        "    while 1:\n",
        "        grad_f_i = gradient_function(xi)\n",
        "\n",
        "\n",
        "        if np.linalg.norm(grad_f_i) <= eps:\n",
        "            break\n",
        "\n",
        "\n",
        "        si = (\n",
        "            -grad_f_i\n",
        "            + np.linalg.norm(grad_f_i) ** 2 / np.linalg.norm(grad_f_i_1) ** 2 * si_1\n",
        "        )\n",
        "\n",
        "        lambda_si = np.linalg.norm(grad_f_i) ** 2 / (si @ A @ si)\n",
        "\n",
        "        xi = xi + lambda_si * si\n",
        "\n",
        "        A = hessian_function(xi)\n",
        "        i += 1\n",
        "\n",
        "\n",
        "    print(f\"Finished in {i} iterations\")\n",
        "\n",
        "\n",
        "    return xi"
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "dMrNWe8F0UHM"
      },
      "source": [
        "## Marquardt algorithm"
      ]
    },
    {
      "cell_type": "code",
      "execution_count": null,
      "metadata": {
        "id": "nwFWrxWW0UHM"
      },
      "outputs": [],
      "source": [
        "def solve_marquardt(\n",
        "    obj_function: Callable[[np.ndarray], float],\n",
        "    gradient_func: Callable[[np.ndarray], np.ndarray],\n",
        "    hessian_func: Callable[[np.ndarray], np.ndarray],\n",
        "    x_0: np.ndarray,\n",
        "    eps: float = 0.1,\n",
        "    alpha: float = 1e4,\n",
        "    c1: float = 0.5,\n",
        "    c2: float = 2,\n",
        "    method_1d: str = \"constant\",\n",
        "):\n",
        "    \"\"\"\n",
        "    Solves an optimization problem using the Marquardt method.\n",
        "\n",
        "    Parameters:\n",
        "    - obj_function (Callable[[np.ndarray], float]): The objective function to be minimized.\n",
        "    - gradient_func (Callable[[np.ndarray], np.ndarray]): The gradient function.\n",
        "    - hessian_func (Callable[[np.ndarray], np.ndarray]): The Hessian function.\n",
        "    - x_0 (np.ndarray): The initial guess for the minimum.\n",
        "    - eps (float, optional): The desired accuracy of the solution. Default is 0.1.\n",
        "    - alpha (float, optional): The initial value for the Marquardt parameter. Default is 1e4.\n",
        "    - c1 (float, optional): A constant for adjusting alpha when the function decreases. Default is 0.5.\n",
        "    - c2 (float, optional): A constant for adjusting alpha when the function increases. Default is 2.\n",
        "    - method_1d (str, optional): The method for one-dimensional optimization. Options include \"constant\", \"fib\" (Fibonacci), \"golden\" (Golden Section), \"quad\" (Quadratic), and \"cubic\" (Cubic). Default is \"constant\".\n",
        "\n",
        "    Returns:\n",
        "    - np.ndarray: The optimal values of the parameters.\n",
        "    \"\"\"\n",
        "    x = x_0\n",
        "    f = obj_function(x)\n",
        "    i = 0\n",
        "    while 1:\n",
        "        grad = gradient_func(x)\n",
        "        if np.linalg.norm(grad) <= eps:\n",
        "            break\n",
        "        hess = hessian_func(x)\n",
        "        # print(grad)\n",
        "        while 1:\n",
        "            s = -np.linalg.inv(hess + alpha * np.identity(x.shape[0])) @ grad\n",
        "\n",
        "\n",
        "\n",
        "            lambda_s = optimize_1d_general(\n",
        "                obj_function,\n",
        "                gradient_func,\n",
        "                x,\n",
        "                s,\n",
        "                2, method_1d=method_1d\n",
        "            )\n",
        "            #print(lambda_s)\n",
        "            x_new = x + lambda_s * s\n",
        "            f_new = obj_function(x_new)\n",
        "            if f_new < f:\n",
        "                alpha = alpha * c1\n",
        "                f = f_new\n",
        "                x = x_new\n",
        "                break\n",
        "            else:\n",
        "                alpha = alpha * c2\n",
        "\n",
        "        i += 1\n",
        "\n",
        "    print(f\"Finished in {i} iterations\")\n",
        "    return x"
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "RAvaPM7s0UHN"
      },
      "source": [
        "## Quasi-Newton algorithm"
      ]
    },
    {
      "cell_type": "code",
      "execution_count": null,
      "metadata": {
        "id": "upgBX72a0UHN"
      },
      "outputs": [],
      "source": [
        "def solve_quasi_newton(\n",
        "    obj_function: Callable[[np.ndarray], float],\n",
        "    gradient_func: Callable[[np.ndarray], np.ndarray],\n",
        "    x0: np.array,\n",
        "    method_1d: str = \"golden\",\n",
        "    eps: float = 1e-3,\n",
        "):\n",
        "    \"\"\"\n",
        "    Solves an optimization problem using the Quasi-Newton method.\n",
        "\n",
        "    Parameters:\n",
        "    - obj_function (Callable[[np.ndarray], float]): The objective function to be minimized.\n",
        "    - gradient_func (Callable[[np.ndarray], np.ndarray]): The gradient function.\n",
        "    - x0 (np.ndarray): The initial guess for the minimum.\n",
        "    - method_1d (str, optional): The method for one-dimensional optimization. Options include \"constant\", \"fib\" (Fibonacci), \"golden\" (Golden Section), \"quad\" (Quadratic), and \"cubic\" (Cubic). Default is \"golden\".\n",
        "    - eps (float, optional): The desired accuracy of the solution. Default is 1e-3.\n",
        "\n",
        "    Returns:\n",
        "    - np.ndarray: The optimal values of the parameters.\n",
        "    \"\"\"\n",
        "\n",
        "    B = np.identity(x0.shape[0])\n",
        "\n",
        "    x = x0\n",
        "\n",
        "    grad = gradient_func(x)\n",
        "\n",
        "\n",
        "    i = 0\n",
        "\n",
        "    while 1:\n",
        "\n",
        "        # if np.linalg.norm(grad) <= eps:\n",
        "\n",
        "        #     break\n",
        "\n",
        "        s = -B @ grad\n",
        "\n",
        "\n",
        "\n",
        "        lambda_s = optimize_1d_general(obj_function,gradient_func ,x, s, 4, method_1d=method_1d)  # TODO : find a dynamic way to get the interval\n",
        "\n",
        "        #print(lambda_s)\n",
        "\n",
        "        x_new = x + lambda_s * s\n",
        "\n",
        "\n",
        "        grad_new = gradient_func(x_new)\n",
        "\n",
        "        if np.linalg.norm(grad_new) <= eps:\n",
        "\n",
        "            break\n",
        "\n",
        "\n",
        "        # must reshape cuz numpy is stupid when dealing with 1D arrays\n",
        "\n",
        "        g = (grad_new - grad).reshape(-1, 1)\n",
        "\n",
        "        d = (lambda_s * s).reshape(-1, 1)\n",
        "\n",
        "\n",
        "        # EQ 6.136\n",
        "\n",
        "        B_new = (\n",
        "\n",
        "            B\n",
        "\n",
        "            + (1 + (g.T @ B @ g) / (d.T @ g)) * (d @ d.T) / (d.T @ g)\n",
        "\n",
        "            - (d @ g.T @ B) / (d.T @ g)\n",
        "\n",
        "            - (B @ g @ d.T) / (d.T @ g)\n",
        "        )\n",
        "\n",
        "\n",
        "        B = B_new\n",
        "\n",
        "        x = x_new\n",
        "        grad = grad_new\n",
        "\n",
        "        i += 1\n",
        "\n",
        "\n",
        "    print(f\"Finished in {i} iterations\")\n",
        "\n",
        "    return x"
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "dneFMDra0UHN"
      },
      "source": [
        "# Testing"
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "3atpvy4O0UHN"
      },
      "source": [
        "## Rosenbrock’s parabolic valley function\n",
        "\n",
        "Rosenbrock function:\n",
        "\\begin{align*}\n",
        "    \\text{rosenbrock_function}(x) &= 100 \\cdot (x_2 - x_1^2)^2 + (1 - x_1)^2\n",
        "\\end{align*}\n",
        "\n",
        "Gradient of Rosenbrock function:\n",
        "\\begin{align*}\n",
        "    \\nabla \\text{rosenbrock_function}(x) &= \\begin{bmatrix}\n",
        "        -400x_1(x_2 - x_1^2) - 2(1 - x_1) \\\\\n",
        "        200(x_2 - x_1^2)\n",
        "    \\end{bmatrix}\n",
        "\\end{align*}\n",
        "\n",
        "\n",
        "Hessian of Rosenbrock function:\n",
        "\\begin{align*}\n",
        "    \\nabla^2 \\text{rosenbrock_function}(x) &= \\begin{bmatrix}\n",
        "        -400(x_2 - 3x_1^2) + 2 & -400x_1 \\\\\n",
        "        -400x_1 & 200\n",
        "    \\end{bmatrix}\n",
        "\\end{align*}\n",
        "\n",
        "Initial guess:\n",
        "\\begin{align*}\n",
        "    x_0 &= \\begin{bmatrix}\n",
        "        -1.2 \\\\\n",
        "        1\n",
        "    \\end{bmatrix}\n",
        "\\end{align*}"
      ]
    },
    {
      "cell_type": "code",
      "execution_count": null,
      "metadata": {
        "id": "75dcmlYx0UHO"
      },
      "outputs": [],
      "source": [
        "rosenbrock_function = lambda x: 100 * (x[1] - x[0] ** 2) ** 2 + (1 - x[0]) ** 2\n",
        "rosenbrock_function_gradient = lambda x: np.array(\n",
        "    [\n",
        "        -400 * x[0] * (x[1] - x[0] ** 2) - 2 * (1 - x[0]),\n",
        "        200 * (x[1] - x[0] ** 2)\n",
        "    ]\n",
        ")\n",
        "rosenbrock_function_hessian = lambda x: np.array([\n",
        "    [-400 * (x[1] - 3 * x[0] ** 2) + 2, -400 * x[0]],\n",
        "    [-400 * x[0]                      , 200]\n",
        "]\n",
        ")\n",
        "x0 = np.array([-1.2, 1])"
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "CbhPVcUx0UHO"
      },
      "source": [
        "### Finding the the optimum using scipy"
      ]
    },
    {
      "cell_type": "code",
      "execution_count": null,
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "tgtp7T1v0UHO",
        "outputId": "829194e9-6657-42c0-840e-12938c63e24c"
      },
      "outputs": [
        {
          "name": "stdout",
          "output_type": "stream",
          "text": [
            "Minimum value: 2.0243313190213974e-11\n",
            "Optimal parameters: [0.9999955  0.99999099]\n",
            "Number of iterations: 32\n"
          ]
        }
      ],
      "source": [
        "\n",
        "# Define the Rosenbrock function\n",
        "rosenbrock_function = lambda x: 100 * (x[1] - x[0] ** 2) ** 2 + (1 - x[0]) ** 2\n",
        "\n",
        "# Initial guess\n",
        "initial_guess = np.array([-1.2, 1])\n",
        "\n",
        "# Use the minimize function to find the minimum\n",
        "result = minimize(rosenbrock_function, initial_guess, method=\"BFGS\")\n",
        "\n",
        "# Print the result\n",
        "print(\"Minimum value:\", result.fun)\n",
        "print(\"Optimal parameters:\", result.x)\n",
        "print(\"Number of iterations:\", result.nit)"
      ]
    },
    {
      "cell_type": "code",
      "execution_count": null,
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "ZM982bK70UHO",
        "outputId": "58523600-a1c6-4cd8-874d-4d574ad1f905"
      },
      "outputs": [
        {
          "name": "stdout",
          "output_type": "stream",
          "text": [
            "16.1 ms ± 1.21 ms per loop (mean ± std. dev. of 5 runs, 5 loops each)\n"
          ]
        }
      ],
      "source": [
        "%%timeit -n 5 -r 5\n",
        "with capture_output():  # suppress print statements\n",
        "    minimize(rosenbrock_function, initial_guess, method=\"BFGS\")"
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "oC3LO_zB0UHP"
      },
      "source": [
        "### Finding the optimum using imlemented methods"
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "h2vaLHSh1NRg"
      },
      "source": [
        "#### Flethcer reeves"
      ]
    },
    {
      "cell_type": "code",
      "execution_count": null,
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "vj2OPsHd0UHP",
        "outputId": "9bd1b206-a82c-4791-8243-0f6d88bb49ea"
      },
      "outputs": [
        {
          "name": "stdout",
          "output_type": "stream",
          "text": [
            "Finished in 7544 iterations\n",
            "Minimum of the function is at [0.99991057 0.99982093] with value 8.002046112392715e-09\n"
          ]
        }
      ],
      "source": [
        "x =solve_fletcher_reeves(\n",
        "    rosenbrock_function_gradient,\n",
        "    rosenbrock_function_hessian,\n",
        "    x0,\n",
        "    eps=1e-4,\n",
        ")\n",
        "\n",
        "value = rosenbrock_function(x)\n",
        "print(f\"Minimum of the function is at {x } with value {value  }\")"
      ]
    },
    {
      "cell_type": "code",
      "execution_count": null,
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "w5HuNnK-0UHP",
        "outputId": "f3fbac7c-97ea-4663-d108-9a914908ff2d"
      },
      "outputs": [
        {
          "name": "stdout",
          "output_type": "stream",
          "text": [
            "742 ms ± 227 ms per loop (mean ± std. dev. of 5 runs, 5 loops each)\n"
          ]
        }
      ],
      "source": [
        "%%timeit -n 5 -r 5\n",
        "with capture_output():  # suppress print statements\n",
        "    solve_fletcher_reeves(\n",
        "        rosenbrock_function_gradient,\n",
        "        rosenbrock_function_hessian,\n",
        "        x0,\n",
        "        eps=1e-4,\n",
        "    )\n"
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "rhNVGVr61Qhg"
      },
      "source": [
        "#### marquardt"
      ]
    },
    {
      "cell_type": "code",
      "execution_count": null,
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "dng7onFL0UHQ",
        "outputId": "eaac1ae8-49ca-4406-b29a-ab238069c075"
      },
      "outputs": [
        {
          "name": "stdout",
          "output_type": "stream",
          "text": [
            "Finished in 19 iterations\n",
            "Minimum of the function is at [1.00000236 1.00000472] with value 5.581148314101601e-12\n"
          ]
        }
      ],
      "source": [
        "x = solve_marquardt(\n",
        "    rosenbrock_function,\n",
        "    rosenbrock_function_gradient,\n",
        "    rosenbrock_function_hessian,\n",
        "    x0,\n",
        "    eps=1e-4,\n",
        "    method_1d=\"cubic\",\n",
        ")\n",
        "\n",
        "value = rosenbrock_function(x)\n",
        "print(f\"Minimum of the function is at {x } with value {value  }\")"
      ]
    },
    {
      "cell_type": "code",
      "execution_count": null,
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "Oshyj1gg0UHQ",
        "outputId": "48be69d3-4b01-4cba-cab2-d7ae6fb48948"
      },
      "outputs": [
        {
          "name": "stdout",
          "output_type": "stream",
          "text": [
            "58.3 ms ± 21.1 ms per loop (mean ± std. dev. of 5 runs, 5 loops each)\n"
          ]
        }
      ],
      "source": [
        "%%timeit -n 5 -r 5\n",
        "with capture_output():\n",
        "    solve_marquardt(\n",
        "    rosenbrock_function,\n",
        "    rosenbrock_function_gradient,\n",
        "    rosenbrock_function_hessian,\n",
        "    x0,\n",
        "    eps=1e-4,\n",
        "    method_1d=\"cubic\",\n",
        ")"
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "P8yAkSEL1Uh9"
      },
      "source": [
        "#### quasi newton"
      ]
    },
    {
      "cell_type": "code",
      "execution_count": null,
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "OR-4z9PX0UHR",
        "outputId": "d7556dd2-cbba-4727-fa21-f70675c9c81e"
      },
      "outputs": [
        {
          "name": "stdout",
          "output_type": "stream",
          "text": [
            "Finished in 22 iterations\n",
            "Minimum of the function is at [0.99958922 0.99918236] with value 1.7014934872000645e-07\n"
          ]
        }
      ],
      "source": [
        "x = solve_quasi_newton(\n",
        "    rosenbrock_function,\n",
        "    rosenbrock_function_gradient,\n",
        "    x0,\n",
        "    method_1d=\"quad\",\n",
        "    eps=1e-3,\n",
        ")\n",
        "\n",
        "value = rosenbrock_function(x)\n",
        "print(f\"Minimum of the function is at {x} with value {value  }\")"
      ]
    },
    {
      "cell_type": "code",
      "execution_count": null,
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "H8gUA6Us0UHR",
        "outputId": "caf5a345-83d2-43df-a3e5-121f0de7406c"
      },
      "outputs": [
        {
          "name": "stdout",
          "output_type": "stream",
          "text": [
            "13.4 ms ± 3.59 ms per loop (mean ± std. dev. of 5 runs, 5 loops each)\n"
          ]
        }
      ],
      "source": [
        "%%timeit -n 5 -r 5\n",
        "with capture_output():\n",
        "    solve_quasi_newton(\n",
        "    rosenbrock_function,\n",
        "    rosenbrock_function_gradient,\n",
        "    x0,\n",
        "    method_1d=\"quad\",\n",
        "    eps=1e-3,\n",
        ")"
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "HlC1O5NX2v-F"
      },
      "source": [
        "### Results\n",
        "\n",
        "| Method                       | Iterations | Runtime                 | x                                      | f(x)           |\n",
        "|------------------------------|------------|-------------------------|----------------------------------------|----------------|\n",
        "| **BFGS (Scipy)**              | 32         | 27.2 ms ± 4.96 ms       | [0.9999955, 0.99999099]                | 2.0243e-11     |\n",
        "| **Fletcher Reeves**           | 17144      | 537 ms ± 9.28 ms        | [0.99988823, 0.99977603]               | 1.2512542e-08  |\n",
        "| **Marquardt (Golden)**        | 24         | 14 ms ± 1.09 ms         | [0.99999999, 0.99999998]               | 1.5996e-16     |\n",
        "| **Marquardt (Fibonacci)**     | 24         | 14.7 ms ± 4.09 ms       | [0.99999999, 0.99999999]               | 1.7353e-16     |\n",
        "| **Marquardt (quadratic)**     | 21         | 12.1 ms ± 2.6 ms        | [0.99999959, 0.99999907]               | 1.297e-12      |\n",
        "| **Marquardt (cubic)**         | 19         | 22.4 ms ± 5.36 ms       | [1.00000236, 1.00000472]               | 5.5811e-12     |\n",
        "| **Quasi-Newton (Golden)**     | 526        | 247 ms ± 20.4 ms        | [0.99927916, 0.99855773]               | 5.1973e-07     |\n",
        "| **Quasi-Newton (Quadratic)**  | 277        | 121 ms ± 33.8 ms        | [1.00015339, 1.00031638]               | 3.269e-08      |\n"
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "umVh5oEy0UHS"
      },
      "source": [
        "## Powell's function\n",
        "\n",
        "Powell function:\n",
        "\\begin{align*}\n",
        "    \\text{powell_function}(x) &= (x_1 + 10x_2)^2 + 5(x_3 - x_4)^2 + (x_2 - 2x_3)^4 + 10(x_1 - x_4)^4\n",
        "\\end{align*}\n",
        "Gradient of Powell function:\n",
        "\\begin{align*}\n",
        "    \\nabla \\text{powell_function}(x) &= \\begin{bmatrix}\n",
        "        2(x_1 + 10x_2) + 40(x_1 - x_4)^3 \\\\\n",
        "        20(x_1 + 10x_2) + 4(x_2 - 2x_3)^3 \\\\\n",
        "        10(x_3 - x_4) - 8(x_2 - 2x_3)^3 \\\\\n",
        "        -10(x_3 - x_4) - 40(x_1 - x_4)^3\n",
        "    \\end{bmatrix}\n",
        "\\end{align*}\n",
        "\n",
        "Hessian of Powell function:\n",
        "\\begin{align*}\n",
        "    \\nabla^2 \\text{powell_function}(x) &= \\begin{bmatrix}\n",
        "        2 + 120(x_1 - x_4)^2 & 20 & 0 & -120(x_1 - x_4)^2 \\\\\n",
        "        20 & 200 + 12(x_2 - 2x_3)^2 & -24(x_2 - 2x_3)^2 & 0 \\\\\n",
        "        0 & -24(x_2 - 2x_3)^2 & 10 + 48(x_2 - 2x_3)^2 & -10 \\\\\n",
        "        -120(x_1 - x_4)^2 & 0 & -10 & 10 + 120(x_1 - x_4)^2\n",
        "    \\end{bmatrix}\n",
        "\\end{align*}\n",
        "\n",
        "Initial guess:\n",
        "\\begin{align*}\n",
        "    x_0 &= \\begin{bmatrix}\n",
        "        3.0 \\\\\n",
        "        -1.0 \\\\\n",
        "        0.0 \\\\\n",
        "        1.0\n",
        "    \\end{bmatrix}\n",
        "\\end{align*}"
      ]
    },
    {
      "cell_type": "code",
      "execution_count": null,
      "metadata": {
        "id": "Fyn6D7jD0UHS"
      },
      "outputs": [],
      "source": [
        "powell_function = (\n",
        "    lambda x: (x[0] + 10 * x[1]) ** 2\n",
        "    + 5 * (x[2] - x[3]) ** 2\n",
        "    + (x[1] - 2 * x[2]) ** 4\n",
        "    + 10 * (x[0] - x[3]) ** 4\n",
        ")\n",
        "\n",
        "# Gradient of Powell function\n",
        "gradient_powell_function = lambda x: np.array(\n",
        "    [\n",
        "        2 * (x[0] + 10 * x[1]) + 40 * (x[0] - x[3]) ** 3,\n",
        "        20 * (x[0] + 10 * x[1]) + 4 * (x[1] - 2 * x[2]) ** 3,\n",
        "        10 * (x[2] - x[3]) - 8 * (x[1] - 2 * x[2]) ** 3,\n",
        "        -10 * (x[2] - x[3]) - 40 * (x[0] - x[3]) ** 3,\n",
        "    ]\n",
        ")\n",
        "\n",
        "# Hessian of Powell function\n",
        "hessian_powell_function = lambda x: np.array(\n",
        "    [\n",
        "        [2 + 120 * (x[0] - x[3]) ** 2, 20, 0, -120 * (x[0] - x[3]) ** 2],\n",
        "        [20, 200 + 12 * (x[1] - 2 * x[2]) ** 2, -24 * (x[1] - 2 * x[2]) ** 2, 0],\n",
        "        [0, -24 * (x[1] - 2 * x[2]) ** 2, 10 + 48 * (x[1] - 2 * x[2]) ** 2, -10],\n",
        "        [-120 * (x[0] - x[3]) ** 2, 0, -10, 10 + 120 * (x[0] - x[3]) ** 2],\n",
        "    ]\n",
        ")\n",
        "\n",
        "x0 =  np.array((3.0, - 1.0, 0.0, 1.0))"
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "wmqUchWs0UHS"
      },
      "source": [
        "### Finding the optimum using scipy"
      ]
    },
    {
      "cell_type": "code",
      "execution_count": null,
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "BEsVjuC_0UHS",
        "outputId": "cc108e0a-87e9-438a-9527-d053d1f8b2ff"
      },
      "outputs": [
        {
          "name": "stdout",
          "output_type": "stream",
          "text": [
            "Minimum value: 4.337526732036312e-09\n",
            "Optimal parameters: [ 0.0058623  -0.00058624  0.00132846  0.00132817]\n",
            "Number of iterations: 35\n"
          ]
        }
      ],
      "source": [
        "powell_function = (\n",
        "    lambda x: (x[0] + 10 * x[1]) ** 2\n",
        "    + 5 * (x[2] - x[3]) ** 2\n",
        "    + (x[1] - 2 * x[2]) ** 4\n",
        "    + 10 * (x[0] - x[3]) ** 4\n",
        ")\n",
        "\n",
        "initial_guess = np.array((3.0, -1.0, 0.0, 1.0))\n",
        "\n",
        "result = minimize(powell_function, initial_guess, method=\"BFGS\")\n",
        "\n",
        "# Print the result\n",
        "print(\"Minimum value:\", result.fun)\n",
        "print(\"Optimal parameters:\", result.x)\n",
        "print(\"Number of iterations:\", result.nit)"
      ]
    },
    {
      "cell_type": "code",
      "execution_count": null,
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "yKNI8p-10UHT",
        "outputId": "6a2b3c2c-4865-4f2a-d574-922a7075f6b3"
      },
      "outputs": [
        {
          "name": "stdout",
          "output_type": "stream",
          "text": [
            "32.6 ms ± 9.97 ms per loop (mean ± std. dev. of 5 runs, 5 loops each)\n"
          ]
        }
      ],
      "source": [
        "%%timeit -n 5 -r 5\n",
        "with capture_output():  # suppress print statements\n",
        "    minimize(powell_function, initial_guess, method=\"BFGS\")"
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "4ju22PVE0UHT"
      },
      "source": [
        "### Finding the optimum using implemented methods"
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "2wIBiU3x1mfM"
      },
      "source": [
        "#### Fletcher reeves"
      ]
    },
    {
      "cell_type": "code",
      "execution_count": null,
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "zigsQgeT0UHg",
        "outputId": "8d4c3d2b-731b-47a5-d765-06857e82c6fa"
      },
      "outputs": [
        {
          "name": "stdout",
          "output_type": "stream",
          "text": [
            "Finished in 75145 iterations\n",
            "Minimum of the function is at [ 0.00523049 -0.00052304  0.00260661  0.00260672] with value 1.5567035443612935e-09\n"
          ]
        }
      ],
      "source": [
        "x = solve_fletcher_reeves(\n",
        "    gradient_powell_function,\n",
        "    hessian_powell_function,\n",
        "    x0,\n",
        "    eps=1e-6,\n",
        ")\n",
        "\n",
        "value = powell_function(x)\n",
        "print(f\"Minimum of the function is at {x } with value {value  }\")"
      ]
    },
    {
      "cell_type": "code",
      "execution_count": null,
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "HFoo-ZVY0UHg",
        "outputId": "029cc86d-3ac4-4305-f23f-1064cb484b26"
      },
      "outputs": [
        {
          "name": "stdout",
          "output_type": "stream",
          "text": [
            "3.63 s ± 249 ms per loop (mean ± std. dev. of 5 runs, 5 loops each)\n"
          ]
        }
      ],
      "source": [
        "%%timeit -n 5 -r 5\n",
        "with capture_output():\n",
        "    solve_fletcher_reeves(\n",
        "    gradient_powell_function,\n",
        "    hessian_powell_function,\n",
        "    x0,\n",
        "    eps=1e-6,\n",
        ")"
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "rfKUZ-gr1p5s"
      },
      "source": [
        "#### marquardt"
      ]
    },
    {
      "cell_type": "code",
      "execution_count": null,
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "-GEwMZkq0UHh",
        "outputId": "f36bc1b9-88a3-447f-9c96-95a91ebe1bfc"
      },
      "outputs": [
        {
          "name": "stdout",
          "output_type": "stream",
          "text": [
            "Finished in 29 iterations\n",
            "Minimum of the function is at [ 0.00144231 -0.00014423  0.00071879  0.00071879] with value 9.002591421872527e-12\n"
          ]
        }
      ],
      "source": [
        "x = solve_marquardt(\n",
        "    powell_function,\n",
        "    gradient_powell_function,\n",
        "    hessian_powell_function,\n",
        "    x0,\n",
        "    eps=1e-6,\n",
        "    method_1d=\"cubic\",\n",
        ")\n",
        "\n",
        "value = powell_function(x)\n",
        "print(f\"Minimum of the function is at {x } with value {value  }\")"
      ]
    },
    {
      "cell_type": "code",
      "execution_count": null,
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "fZLYzShU0UHi",
        "outputId": "30a9fa6e-b6dc-4198-d894-5f6c4a996588"
      },
      "outputs": [
        {
          "name": "stdout",
          "output_type": "stream",
          "text": [
            "35.5 ms ± 3.13 ms per loop (mean ± std. dev. of 5 runs, 5 loops each)\n"
          ]
        }
      ],
      "source": [
        "%%timeit -n 5 -r 5\n",
        "with capture_output():\n",
        "    solve_marquardt(\n",
        "    powell_function,\n",
        "    gradient_powell_function,\n",
        "    hessian_powell_function,\n",
        "    x0,\n",
        "    eps=1e-6,\n",
        "    method_1d=\"golden\",\n",
        ")"
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "r_OKiWf61si7"
      },
      "source": [
        "#### quasi newton"
      ]
    },
    {
      "cell_type": "code",
      "execution_count": null,
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "IEuZQMFf0UHi",
        "outputId": "a9f952d3-940a-4d41-e8ad-a23b57e8a351"
      },
      "outputs": [
        {
          "name": "stdout",
          "output_type": "stream",
          "text": [
            "Finished in 14 iterations\n",
            "Minimum of the function is at [ 5.81225540e-04 -5.80889936e-05  1.58060774e-04  1.58024521e-04] with value 4.595756718768112e-13\n"
          ]
        }
      ],
      "source": [
        "x = solve_quasi_newton(\n",
        "    powell_function,\n",
        "    gradient_powell_function,\n",
        "    x0,\n",
        "    method_1d=\"quad\",\n",
        "    eps=1e-6,\n",
        ")\n",
        "\n",
        "value = powell_function(x)\n",
        "print(f\"Minimum of the function is at {x } with value {value  }\")"
      ]
    },
    {
      "cell_type": "code",
      "execution_count": null,
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "XmsXcewd0UHi",
        "outputId": "aa6d0259-a485-44f7-e928-ed56dba350fb"
      },
      "outputs": [
        {
          "name": "stdout",
          "output_type": "stream",
          "text": [
            "6.71 ms ± 1.65 ms per loop (mean ± std. dev. of 5 runs, 5 loops each)\n"
          ]
        }
      ],
      "source": [
        "%%timeit -n 5 -r 5\n",
        "with capture_output():\n",
        "    solve_quasi_newton(\n",
        "    powell_function,\n",
        "    gradient_powell_function,\n",
        "    x0,\n",
        "    method_1d=\"quad\",\n",
        "    eps=1e-6,\n",
        ")"
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "EKlO5HVI2AIt"
      },
      "source": [
        "### Results\n",
        "\n",
        "| Method                     | Iterations | Runtime               | x                               | f(x)           |\n",
        "|-----------------------------|------------|-----------------------|---------------------------------|----------------|\n",
        "| **BFGS (Scipy)**            | 35         | 31.2 ms ± 9.07 ms     | [0.0058, -0.0006, 0.0013, 0.0013] | 4.337e-09      |\n",
        "| **Fletcher Reeves**         | 335219     | 13.3 s ± 498 ms       | [0.0052, -0.0005, 0.0026, 0.0026] | 1.538e-09      |\n",
        "| **Marquardt (Golden)**      | 34         | 26 ms ± 2.77 ms       | [0.0002, -0.0000, 0.0001, 0.0001] | 6.5377e-15     |\n",
        "| **Marquardt (Quadratic)**   | 34         | 13.7 ms ± 1.53 ms     | [0.0002, -0.0000, 0.0001, 0.0001] | 6.5786e-15     |\n",
        "| **Quasi-Newton (Golden)**   | 1953       | 700 ms ± 61.4 ms      | [0.0016, -0.0002, 0.0013, 0.0013] | 5.084e-11      |\n",
        "| **Quasi-Newton (Fibonacci)** | 1580       | 569 ms ± 54.5 ms      | [0.0043, -0.0004, 0.0016, 0.0016] | 7.2483e-10     |\n",
        "| **Quasi-Newton (Quadratic)** | 948       | 277 ms ± 40.5 ms      | [-0.0005, 0.0001, 0.0017, 0.0017] | 3.6659e-10     |\n"
      ]
    }
  ],
  "metadata": {
    "colab": {
      "provenance": []
    },
    "kernelspec": {
      "display_name": "Python 3",
      "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.11.5"
    }
  },
  "nbformat": 4,
  "nbformat_minor": 0
}