comp_math/task01/task2.ipynb

{
 "cells": [
  {
   "cell_type": "code",
   "execution_count": 35,
   "id": "cb0d4a44-e1b1-4b6c-a76a-20c30abce72c",
   "metadata": {},
   "outputs": [],
   "source": [
    "import numpy as np\n",
    "import matplotlib as mpl\n",
    "from numpy import float32, float64\n",
    "import matplotlib.pyplot as plt\n",
    "from functools import partial\n",
    "import itertools\n",
    "from collections import namedtuple"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 36,
   "id": "f6800ffb-61d5-4fc7-99c8-414be78ffd56",
   "metadata": {},
   "outputs": [],
   "source": [
    "label_font = 12\n",
    "markersize = 8"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 37,
   "id": "b6ae5a80-7a8d-48c0-aa49-70d6d612c54f",
   "metadata": {},
   "outputs": [],
   "source": [
    "def get_a_ij(i: int, j: int, n: int):\n",
    "    if i == j:\n",
    "        return 2.0 + (float64(i) / float64(n)) ** 2.0\n",
    "    elif j == i - 1 or j == i + 1:\n",
    "        return -1.0\n",
    "    elif (i == 0 and j == n - 1) or (i == n - 1 and j == 0):\n",
    "        return -1.0\n",
    "    else:\n",
    "        return 0.0\n",
    "\n",
    "\n",
    "def get_matrix_a(n: int) -> np.array:\n",
    "    a = np.zeros((n, n))\n",
    "    from_0_to_n = [i for i in range(n)]\n",
    "    for i, j in itertools.product(from_0_to_n, from_0_to_n):\n",
    "        a[i, j] = get_a_ij(i, j, n)\n",
    "    return a\n",
    "\n",
    "\n",
    "def get_f(n: int) -> np.array:\n",
    "    def get_f_i(i):\n",
    "        return (1.0 + n**2.0 * np.sin(np.pi / n) ** 2.0) * np.sin(\n",
    "            (2.0 * np.pi * i) / float64(n)\n",
    "        )\n",
    "\n",
    "    return np.array([get_f_i(i) for i in range(n)])"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 38,
   "id": "ea07e9f0-f0cf-4d01-857f-96e8b50ee21c",
   "metadata": {},
   "outputs": [],
   "source": [
    "# Векторные и подчиненные им матричные нормы\n",
    "def vec_norm_max(vector: np.array):\n",
    "    # |v|_1 = max(abs(v_i))\n",
    "    return np.abs(vector).max()\n",
    "\n",
    "\n",
    "def vec_norm_sum(vector: np.array):\n",
    "    # |v|_2 = sum(abs(v_i))\n",
    "    return np.abs(vector).sum()\n",
    "\n",
    "def vec_norm_euclid(vector: np.array):\n",
    "    return np.sqrt((vector ** 2.0).sum())\n",
    "\n",
    "\n",
    "def row_sum_norm(matrix: np.array):\n",
    "    # |A|_1 = max( sum(a_ij) for j ) over 1 <= i <= n\n",
    "    return np.sum(np.abs(matrix), axis=1).max()\n",
    "\n",
    "\n",
    "def column_sum_norm(matrix: np.array):\n",
    "    # |A|_2 = max( sum(a_ij) for i ) over 1 <= j <= n\n",
    "    return np.sum(np.abs(matrix), axis=0).max()\n",
    "\n",
    "\n",
    "def spectral_norm(matrix: np.array):\n",
    "    matrix_h = matrix.conj().T\n",
    "    eigenvalues = np.linalg.eigvals(np.matmul(matrix_h, matrix))\n",
    "    return np.sqrt(eigenvalues.max())\n",
    "\n",
    "\n",
    "def mu(matrix_a: int, norm):\n",
    "    inv_matrix_a = np.linalg.inv(matrix_a)\n",
    "    norm_a = norm(matrix_a)\n",
    "    norm_inv_a = norm(inv_matrix_a)\n",
    "    return norm_a * norm_inv_a\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 39,
   "id": "c9ae2bd0-1b87-46fc-96d7-c21a924bf72c",
   "metadata": {},
   "outputs": [],
   "source": [
    "EPS = 10e-8\n",
    "\n",
    "def lup(matrix):\n",
    "    if matrix.shape[0] != matrix.shape[1]:\n",
    "        raise AttributeError(\"Только квадратные матрицы подходят для LUP\")\n",
    "\n",
    "    n = matrix.shape[0]\n",
    "    p = np.identity(n)\n",
    "    \n",
    "    for i in range(0, n - 1):\n",
    "\n",
    "        max_idx = i\n",
    "        for k in range(i + 1, n):\n",
    "            # Найдем максимальный опорный элемент в столбце\n",
    "            if abs(matrix[k][i]) > abs(matrix[max_idx][i]):\n",
    "                max_idx = k\n",
    "        \n",
    "        if abs(matrix[max_idx][i]) <= EPS:\n",
    "            raise ArithmeticError(\"Опорный элемент равен нулю\")\n",
    "\n",
    "        if max_idx != i:\n",
    "            matrix[[i, max_idx]] = matrix[[max_idx, i]]\n",
    "            p[[i, max_idx]] = p[[max_idx, i]]\n",
    "\n",
    "        for j in range(i + 1, n):\n",
    "            matrix[j][i] /= matrix[i][i]\n",
    "            for k in range(i + 1, n):\n",
    "                matrix[j][k] -= matrix[j][i] * matrix[i][k]\n",
    "\n",
    "        l = np.zeros(matrix.shape)\n",
    "        for i in range(n):\n",
    "            for j in range(n):\n",
    "                if j < i:\n",
    "                    l[i][j] = matrix[i][j]\n",
    "                if j == i:\n",
    "                    l[i][j] = 1\n",
    "\n",
    "        u = np.zeros(matrix.shape)\n",
    "        for i in range(n):\n",
    "            for j in range(n):\n",
    "                if j >= i:\n",
    "                    u[i][j] = matrix[i][j]\n",
    "    return l, u , p"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 40,
   "id": "ffd52a5e-3bd9-4170-bcec-db917d5e7618",
   "metadata": {},
   "outputs": [],
   "source": [
    "def lower_solve(l: np.array, f: np.array):\n",
    "    assert l.ndim == 2 and l.shape[0] == l.shape[1]\n",
    "    dim = l.shape[0]\n",
    "\n",
    "    x = np.zeros(dim)\n",
    "    for i in range(dim):\n",
    "        tmp = f[i]\n",
    "        for j in range(i):\n",
    "            tmp -= l[i, j] * x[j]\n",
    "        x[i] = tmp / l[i, i]\n",
    "\n",
    "    return x\n",
    "\n",
    "\n",
    "def upper_solve(u: np.array, f: np.array):\n",
    "    # Solve Ux = f, where U is upper triangular\n",
    "    assert u.ndim == 2 and u.shape[0] == u.shape[1]\n",
    "    dim = u.shape[0]\n",
    "\n",
    "    x = np.zeros(dim)\n",
    "    for i in range(dim - 1, -1, -1):\n",
    "        tmp = f[i]\n",
    "        for j in range(i + 1, dim):\n",
    "            tmp -= u[i, j] * x[j]\n",
    "        x[i] = tmp / u[i, i]\n",
    "\n",
    "    return x\n",
    "\n",
    "\n",
    "def lu_solve(l, u, f):\n",
    "    # Ax = f, where A = LU\n",
    "    # L(Ux) = f, Ux = y <=> y = Ux\n",
    "    y = lower_solve(l, f)\n",
    "    x = upper_solve(u, y)\n",
    "    return x"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 41,
   "id": "b10516d2-d020-4695-a6b3-65efb37333c3",
   "metadata": {},
   "outputs": [],
   "source": [
    "def lup_solve(a: np.array, f: np.array):\n",
    "    l, u, p = lup(a)\n",
    "    z = np.matmul(p, f)\n",
    "    x = lu_solve(l, u, z)\n",
    "    return x"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 42,
   "id": "0d75a610-889b-4c85-8ed4-a03d2aa7a820",
   "metadata": {},
   "outputs": [],
   "source": [
    "def simple_iter(\n",
    "    a: np.array,\n",
    "    f: np.array,\n",
    "    tau: float64,\n",
    "    eps: float64,\n",
    "    norm = vec_norm_euclid,\n",
    "    max_iter: int = 1000000,\n",
    ") -> np.array:\n",
    "    assert a.ndim == 2\n",
    "    assert f.ndim == 1\n",
    "    assert a.shape[0] == a.shape[1]\n",
    "    assert a.shape[0] == f.shape[0]\n",
    "\n",
    "    dim = a.shape[0]\n",
    "    tau_f = f * tau\n",
    "    cur = np.zeros(dim)\n",
    "    b = np.eye(dim) - tau * a\n",
    "    err_list = []\n",
    "\n",
    "    for i in range(max_iter):\n",
    "        cur = np.matmul(b, cur) + tau_f\n",
    "        err = f - np.matmul(a, cur)\n",
    "        norm_err = norm(err)\n",
    "        err_list.append(norm_err)\n",
    "\n",
    "        if norm_err < eps:\n",
    "            return (cur, err_list)\n",
    "\n",
    "    raise RuntimeWarning(\"Простая итерация расходится\")"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 43,
   "id": "8dab9094-becf-4acb-b1fa-b370bac2cb18",
   "metadata": {},
   "outputs": [],
   "source": [
    "Gershgorin = namedtuple(\"Gershgorin\", \"a r\")\n",
    "\n",
    "\n",
    "def get_gershgorin(a: np.array):\n",
    "    assert a.ndim == 2\n",
    "    assert a.shape[0] == a.shape[1]\n",
    "\n",
    "    circles = []\n",
    "    for i, row in enumerate(a):\n",
    "        a_ii = a[i, i]\n",
    "        r_i = np.abs(row).sum() - a_ii\n",
    "        circles.append(Gershgorin(a_ii, r_i))\n",
    "\n",
    "    return circles"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 44,
   "id": "631382d5-81ad-4963-b168-9916848eb4ca",
   "metadata": {},
   "outputs": [],
   "source": [
    " # Коэффициенты полинома\n",
    "def compute_ch_poly(a: np.array, y0: np.array):\n",
    "    assert a.ndim == 2\n",
    "    assert y0.ndim == 1\n",
    "    assert a.shape[0] == a.shape[1]\n",
    "    assert a.shape[0] == y0.shape[0]\n",
    "\n",
    "    dim = a.shape[0]\n",
    "    y_matrix = np.zeros((dim, dim))\n",
    "    y = y0\n",
    "\n",
    "    for i in range(dim - 1, -1, -1):\n",
    "        y_matrix[:, i] = y\n",
    "        y = np.matmul(a, y)\n",
    "\n",
    "    ps = lup_solve(y_matrix, y)\n",
    "\n",
    "    return np.concatenate([np.ones(1), -1.0 * ps])"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 45,
   "id": "d20a06fa-4757-4752-b7f3-ec831d788c15",
   "metadata": {},
   "outputs": [],
   "source": [
    "def plot_gershgorin(ax: plt.Axes, eigvals: np.array, circles: list, **kwargs):\n",
    "    # https://github.com/WenqiJiang/matplotlib-templates/blob/master/plot/plot.py\n",
    "\n",
    "    max_x = 0.0\n",
    "    min_x = 0.0\n",
    "\n",
    "    for a, r in circles:\n",
    "        circle = plt.Circle((a.real, 0.0), r, **kwargs)\n",
    "        ax.add_patch(circle)\n",
    "\n",
    "        max_x = max(max_x, a.real + r)\n",
    "        min_x = min(min_x, a.real - r)\n",
    "\n",
    "    max_dim = max(abs(max_x), abs(min_x))\n",
    "    ax.set_xlim((min_x, max_x))\n",
    "    ax.set_ylim((-max_dim, max_dim))\n",
    "\n",
    "    ax.get_xaxis().set_visible(True)\n",
    "    ax.get_yaxis().set_visible(True)\n",
    "\n",
    "    ax.grid(True, which=\"both\")\n",
    "    ax.set_xlabel(\"$Re(\\lambda)$\", fontsize=label_font)\n",
    "    ax.set_ylabel(\"$Im(\\lambda)$\", fontsize=label_font)\n",
    "\n",
    "    plt.rcParams.update({\"figure.autolayout\": True})\n",
    "\n",
    "    ys = np.zeros(eigvals.shape[0])\n",
    "    ax.scatter(eigvals, ys, color=\"red\")"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 46,
   "id": "dad0efea-b922-47d8-8d1d-f4a1b710e960",
   "metadata": {},
   "outputs": [],
   "source": [
    "def plot_function(ax: plt.Axes, xs: np.array, ys: list, **kwargs):\n",
    "    # https://github.com/WenqiJiang/matplotlib-templates/blob/master/plot/plot.py\n",
    "\n",
    "    plot = ax.plot(xs, ys, **kwargs)\n",
    "\n",
    "    ax.get_xaxis().set_visible(True)\n",
    "    ax.get_yaxis().set_visible(True)\n",
    "\n",
    "    ax.grid(True, which=\"both\")\n",
    "    ax.set_xlabel(\"$x$\", fontsize=label_font)\n",
    "    ax.set_ylabel(\"$y$\", fontsize=label_font)\n",
    "\n",
    "    plt.rcParams.update({\"figure.autolayout\": True})\n",
    "    return plot"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 47,
   "id": "17559b3b-9771-4f00-a157-c11dde9c9a69",
   "metadata": {},
   "outputs": [],
   "source": [
    "def newton_solve(x0, f, der, eps: float64, max_iter=1000000) -> np.array:\n",
    "    cur = x0\n",
    "\n",
    "    for i in range(max_iter):\n",
    "        delta = f(cur) / der(cur)\n",
    "        cur -= delta\n",
    "\n",
    "        if abs(delta) < eps:\n",
    "            return cur\n",
    "\n",
    "    raise RuntimeWarning(\n",
    "        \"Метод Ньютона не сходится\")\n",
    "    "
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 48,
   "id": "9bc9ae73-4459-407b-b006-69d884826e4b",
   "metadata": {},
   "outputs": [],
   "source": [
    "def get_roots(coeffs: np.array, stpts: np.array, eps):\n",
    "    def f(x):\n",
    "        return np.polyval(coeffs, x)\n",
    "\n",
    "    def der(x):\n",
    "        return np.polyval(np.polyder(coeffs), x)\n",
    "\n",
    "    return np.array([newton_solve(st, f, der, eps=eps) for st in stpts])"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 49,
   "id": "a8c79ed1-fc90-4cf3-bbf0-fbb3216ea6e5",
   "metadata": {},
   "outputs": [],
   "source": [
    " def print_sep():\n",
    "    print(\"\\n----\\n\")"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 50,
   "id": "eb927b34-fe85-41f8-af0f-c3b7cab5e7f2",
   "metadata": {},
   "outputs": [],
   "source": [
    "def do_solve_with_tau(\n",
    "    a, f, eps, tau, comment=\"any\", norm = vec_norm_euclid\n",
    "):\n",
    "    (solution, errs) = simple_iter(a, f, tau, eps)\n",
    "    exact_sol = np.linalg.solve(a, f)\n",
    "    delta = solution - exact_sol\n",
    "\n",
    "    print_sep()\n",
    "    print(f\"Solution with tau = {tau} ({comment}):\")\n",
    "    print(solution)\n",
    "    print(f\"Norm of |exact - sol| = {norm(delta)}\")\n",
    "\n",
    "    return errs"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 51,
   "id": "acd33567-6f0c-4544-b46a-a99199122925",
   "metadata": {},
   "outputs": [],
   "source": [
    "n = 6  # size on system\n",
    "a = get_matrix_a(n)\n",
    "f = get_f(n)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 52,
   "id": "8dc8a48c-38bd-4d12-a74a-70280068234f",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "a = \n",
      "[[ 2.         -1.          0.          0.          0.         -1.        ]\n",
      " [-1.          2.02777778 -1.          0.          0.          0.        ]\n",
      " [ 0.         -1.          2.11111111 -1.          0.          0.        ]\n",
      " [ 0.          0.         -1.          2.25       -1.          0.        ]\n",
      " [ 0.          0.          0.         -1.          2.44444444 -1.        ]\n",
      " [-1.          0.          0.          0.         -1.          2.69444444]]\n",
      "f = \n",
      "[ 0.00000000e+00  8.66025404e+00  8.66025404e+00  1.22464680e-15\n",
      " -8.66025404e+00 -8.66025404e+00]\n"
     ]
    }
   ],
   "source": [
    "print(f'a = \\n{a}')\n",
    "print(f'f = \\n{f}')"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 53,
   "id": "d84ffb6f-e4e6-4c0d-a581-29e0664bfc3c",
   "metadata": {},
   "outputs": [],
   "source": [
    "coeffs = compute_ch_poly(a, np.ones(n))"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 56,
   "id": "50a89d66-c07a-4626-8976-b75a0d527a57",
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "(0.0, 4.694444444444445)"
      ]
     },
     "execution_count": 56,
     "metadata": {},
     "output_type": "execute_result"
    },
    {
     "data": {
      "image/png": "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",
      "text/plain": [
       "<Figure size 1170x830 with 2 Axes>"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    }
   ],
   "source": [
    "# Plot polynomial to find starting points for newton's method\n",
    "fig, (ax_gersh, ax_poly) = plt.subplots(2, 1, figsize=(11.7, 8.3))\n",
    "plot_gershgorin(ax_gersh, np.array([]), get_gershgorin(a), alpha=0.5)\n",
    "left, right = ax_gersh.get_xlim()\n",
    "xs = np.linspace(left, right, 1000)\n",
    "plot_function(ax_poly, xs, np.polyval(coeffs, xs))\n",
    "ax_poly.set_xlim(ax_gersh.get_xlim())"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 57,
   "id": "18ff4e10-6a90-4a18-8988-41b72ae31d9d",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "|lambda_0' - 2.0| <= 2.0\n",
      "|lambda_1' - 2.0277777777777777| <= 2.0\n",
      "|lambda_2' - 2.111111111111111| <= 1.9999999999999996\n",
      "|lambda_3' - 2.25| <= 2.0\n",
      "|lambda_4' - 2.4444444444444446| <= 2.0\n",
      "|lambda_5' - 2.6944444444444446| <= 2.0\n",
      "\n",
      "-- Собственные значения (Крылов) --\n",
      "\n",
      "lambda_0 = 0.21074228926813401\n",
      "lambda_1 = 1.1723536556934515\n",
      "lambda_2 = 1.3444997499925933\n",
      "lambda_3 = 3.172098845043765\n",
      "lambda_4 = 3.322122246700257\n",
      "lambda_5 = 4.305960991079286\n",
      "\n",
      "-- Собственные значения (Numpy) --\n",
      "\n",
      "lambda_0 = 0.21074228926852\n",
      "lambda_1 = 1.172353655693412\n",
      "lambda_2 = 1.344499749992459\n",
      "lambda_3 = 3.1720988450437133\n",
      "lambda_4 = 3.3221222467005886\n",
      "lambda_5 = 4.3059609910790835\n",
      "\n",
      "----\n",
      "\n",
      "tau_opt_numpy\t= 0.44280083854569274\n",
      "tau_opt_krylov\t= 0.4428008385457108\n",
      "\n",
      "----\n",
      "\n",
      "Solution with tau = 0.2 (some value):\n",
      "[ 5.3478266  12.93976584 12.23088945  4.22074719 -2.73420791 -2.24411219]\n",
      "Norm of |exact - sol| = 4.551685315972811e-06\n",
      "\n",
      "----\n",
      "\n",
      "Solution with tau = 0.4428008385457108 (opt with krylov):\n",
      "[ 5.34782662 12.93976583 12.23088947  4.22074718 -2.73420789 -2.24411221]\n",
      "Norm of |exact - sol| = 4.540529116882713e-06\n",
      "\n",
      "----\n",
      "\n",
      "Solution with tau = 0.44280083854569274 (opt with numpy):\n",
      "[ 5.34782662 12.93976583 12.23088947  4.22074718 -2.73420789 -2.24411221]\n",
      "Norm of |exact - sol| = 4.540529119850784e-06\n"
     ]
    }
   ],
   "source": [
    " eps = 1e-6\n",
    "\n",
    "# Шаг 2. Подсчет собственных значений\n",
    "for i, (c, r) in enumerate(get_gershgorin(a)):\n",
    "    print(f\"|lambda_{i}' - {c}| <= {r}\")\n",
    "\n",
    "# Метод Крылова\n",
    "krylov_eigvals = get_roots(coeffs, [0.0, 1.0, 1.5, 3.0, 3.5, 4.25], eps=eps)\n",
    "exact_eigvals = np.linalg.eigvals(a)\n",
    "krylov_eigvals.sort()\n",
    "exact_eigvals.sort()\n",
    "\n",
    "print(\"\\n-- Собственные значения (Крылов) --\\n\")\n",
    "for i, v in enumerate(krylov_eigvals):\n",
    "    print(f\"lambda_{i} = {v}\")\n",
    "\n",
    "print(\"\\n-- Собственные значения (Numpy) --\\n\")\n",
    "for i, v in enumerate(exact_eigvals):\n",
    "    print(f\"lambda_{i} = {v}\")\n",
    "\n",
    "tau_any = 0.20\n",
    "tau_opt_krylov = 2.0 / (krylov_eigvals.min() + krylov_eigvals.max())\n",
    "tau_opt_numpy = 2.0 / (exact_eigvals.min() + exact_eigvals.max())\n",
    "\n",
    "print_sep()\n",
    "print(f\"tau_opt_numpy\\t= {tau_opt_numpy}\")\n",
    "print(f\"tau_opt_krylov\\t= {tau_opt_krylov}\")\n",
    "\n",
    "bound_solve = partial(do_solve_with_tau, a=a, f=f, eps=eps)\n",
    "\n",
    "errs_some = bound_solve(tau=tau_any, comment=\"some value\")\n",
    "errs_krylov = bound_solve(tau=tau_opt_krylov, comment=\"opt with krylov\")\n",
    "errs_numpy = bound_solve(tau=tau_opt_numpy, comment=\"opt with numpy\")"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 55,
   "id": "f029039d-cc38-451d-b03b-512d9eab7829",
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "<matplotlib.legend.Legend at 0x7f66e303ab50>"
      ]
     },
     "execution_count": 55,
     "metadata": {},
     "output_type": "execute_result"
    },
    {
     "data": {
      "image/png": "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",
      "text/plain": [
       "<Figure size 1170x830 with 1 Axes>"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    }
   ],
   "source": [
    "fig, ax = plt.subplots(1, 1, figsize=(11.7, 8.3))\n",
    "\n",
    "ax.set_yscale('log')\n",
    "plot_some = plot_function(ax, np.arange(0, len(errs_some)), errs_some)\n",
    "plot_krylov = plot_function(ax, np.arange(0, len(errs_krylov)), errs_krylov)\n",
    "plot_numpy = plot_function(ax, np.arange(0, len(errs_numpy)), errs_numpy)\n",
    "\n",
    "ax.legend([plot_some[0], plot_krylov[0], plot_numpy[0]],\n",
    "          [f'$\\\\tau = {tau_any:1.2e}$',\n",
    "           f'$\\\\tau = {tau_opt_krylov:1.2e}$',\n",
    "           f'$\\\\tau = {tau_opt_numpy:1.2e}$'],\n",
    "          loc='upper right', fontsize=label_font)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "6f2c3236-f444-4fcb-a8d4-0c97bc28b6d1",
   "metadata": {},
   "outputs": [],
   "source": []
  }
 ],
 "metadata": {
  "kernelspec": {
   "display_name": "Python 3 (ipykernel)",
   "language": "python",
   "name": "python3"
  },
  "language_info": {
   "codemirror_mode": {
    "name": "ipython",
    "version": 3
   },
   "file_extension": ".py",
   "mimetype": "text/x-python",
   "name": "python",
   "nbconvert_exporter": "python",
   "pygments_lexer": "ipython3",
   "version": "3.11.5"
  }
 },
 "nbformat": 4,
 "nbformat_minor": 5
}