numcheat 0.1.0__py3-none-any.whl

numcheat/core.py

@@ -0,0 +1,1956 @@
+# -*- coding: utf-8 -*-
+"""
+CHEATSHEET по численным методам — быстрый доступ к коду и теории по понятному имени.
+Готова к превращению в библиотеку (всё хранится в словарях PRACTICE / THEORY).
+
+Как пользоваться (в Jupyter или python):
+    from cheatsheet import code, theory, find, ls, show
+
+    ls()                          # показать всё, что есть (практика и теория)
+    find("шур")                   # найти, где искать по ключевому слову из билета
+    code("предиктор-корректор")   # печатает готовый код И кладёт его в буфер обмена
+    theory("штрассен")            # печатает ответ на теорвопрос И кладёт в буфер
+    show("ньютон")                # просто посмотреть код на экране (без копирования)
+
+Русские синонимы (для совместимости): код=code, теория=theory, найти=find, список=ls, показать=show.
+
+Практика (code) и теория разделены: code(...) -> реализация, theory(...) -> текст ответа.
+Весь код использует только разрешённые на экзамене средства (без классов, без np.dot/linalg и т.п.).
+"""
+
+import subprocess
+
+
+# ---------------------------------------------------------------- буфер обмена
+def _copy(text):
+    """Кладёт текст в буфер обмена. Сначала pyperclip, затем macOS pbcopy."""
+    try:
+        import pyperclip
+        pyperclip.copy(text)
+        return True
+    except Exception:
+        try:
+            subprocess.run(["pbcopy"], input=text.encode("utf-8"), check=True)
+            return True
+        except Exception:
+            return False
+
+
+# ============================================================ ОБЩИЕ ПОМОЩНИКИ
+# Подставляются автоматически к тем методам, которым нужны (матрицы / ОДУ).
+_IMPORTS = "import numpy as np\nimport matplotlib.pyplot as plt\n"
+
+_PI = "pi = 4 * np.arctan(1.0)   # число пи (np.pi в список разрешённых не входит)\n"
+
+_BASE_MATRIX = '''# --- базовые матричные операции (без np.dot/@/linalg) ---
+def dot(u, v):                       # скалярное произведение векторов
+    return sum(u[i] * v[i] for i in range(len(u)))
+
+def vec_norm(v):                     # евклидова норма sqrt(сумма квадратов)
+    return np.sqrt(sum(c * c for c in v))
+
+def identity(n):                     # единичная матрица
+    I = [[0.0] * n for _ in range(n)]
+    for i in range(n):
+        I[i][i] = 1.0
+    return I
+
+def trace(A):                        # след матрицы
+    return sum(A[i][i] for i in range(len(A)))
+
+def transpose(A):
+    return [[A[j][i] for j in range(len(A))] for i in range(len(A[0]))]
+
+def mat_add(A, B):
+    return [[A[i][j] + B[i][j] for j in range(len(A[0]))] for i in range(len(A))]
+
+def mat_sub(A, B):
+    return [[A[i][j] - B[i][j] for j in range(len(A[0]))] for i in range(len(A))]
+
+def mat_mul(A, B):                   # наивное умножение матриц
+    n, m, p = len(A), len(B), len(B[0])
+    C = [[0.0] * p for _ in range(n)]
+    for i in range(n):
+        for j in range(p):
+            s = 0.0
+            for k in range(m):
+                s += A[i][k] * B[k][j]
+            C[i][j] = s
+    return C
+
+def mat_vec(A, x):                   # матрица на вектор -> np.array
+    n, m = len(A), len(x)
+    return np.array([sum(A[i][k] * x[k] for k in range(m)) for i in range(n)])
+'''
+
+_QR_FUNC = '''# --- QR-разложение методом Грама-Шмидта (нужно QR-алгоритму и Шуру) ---
+def qr_gram_schmidt(A):
+    A = np.array(A, dtype=float)
+    m = len(A); n = len(A[0])
+    Q = np.zeros((m, n)); R = np.zeros((n, n))
+    for j in range(n):
+        v = np.array([A[i][j] for i in range(m)], dtype=float)
+        for i in range(j):
+            qi = np.array([Q[k][i] for k in range(m)])
+            R[i][j] = dot(qi, [A[k][j] for k in range(m)])
+            v = v - R[i][j] * qi
+        R[j][j] = vec_norm(v)
+        for k in range(m):
+            Q[k][j] = v[k] / R[j][j]
+    return Q, R
+'''
+
+_BASE_ODE = '''# --- общее для методов ОДУ ---
+def n_steps(t0, t_end, h):
+    return int(round((t_end - t0) / h))
+
+def rk4_step(f, t, y, h):            # один шаг РК4 (нужен для разгона Адамса)
+    k1 = f(t, y)
+    k2 = f(t + h/2, y + h/2 * k1)
+    k3 = f(t + h/2, y + h/2 * k2)
+    k4 = f(t + h,   y + h * k3)
+    return y + h/6 * (k1 + 2*k2 + 2*k3 + k4)
+'''
+
+
+# ====================================================================== ПРАКТИКА
+# Единый формат каждого сниппета:
+#   --- ПАРАМЕТРЫ (меняй здесь) ---   всё, что правят под конкретную задачу из билета
+#   --- АЛГОРИТМ (не трогай) ---      сам метод, его менять не нужно
+#   --- ЗАПУСК ---                    вызов с твоими параметрами
+# "bases" — какие блоки помощников подставить ("matrix","qr","ode","pi"); они копируются автоматически.
+PRACTICE = {}
+
+def _p(keys, bases, code):
+    entry = {"bases": bases, "code": code}
+    for k in keys:
+        PRACTICE[k] = entry
+
+# ---- 1. Бисекция ----
+_p(["бисекция", "половинное деление"], [],
+'''# ===== БИСЕКЦИЯ: корень уравнения f(x)=0 делением отрезка пополам =====
+
+# --- ПАРАМЕТРЫ (меняй здесь) ---
+def f(x):                  # уравнение в виде f(x)=0
+    return x**3 - 2*x - 2
+a, b = 1, 2                # отрезок [a, b]; на концах f ОБЯЗАНА иметь разные знаки (f(a)*f(b)<0)
+eps  = 1e-5                # точность
+
+# --- АЛГОРИТМ (не трогай) ---
+def bisect_method(f, a, b, eps):
+    while abs(b - a) > eps:        # пока отрезок длиннее точности
+        c = (a + b) / 2            # середина
+        if f(a) * f(c) <= 0:       # знак меняется слева -> корень в [a, c]
+            b = c
+        else:                      # иначе корень в [c, b]
+            a = c
+    return (a + b) / 2
+
+# --- ЗАПУСК ---
+print("Корень:", bisect_method(f, a, b, eps))
+''')
+
+# ---- 2. Простая итерация (1D) ----
+_p(["простая итерация", "функциональная итерация"], [],
+'''# ===== ПРОСТАЯ ИТЕРАЦИЯ: f(x)=0 приводим к x=phi(x) и повторяем =====
+
+# --- ПАРАМЕТРЫ (меняй здесь) ---
+def f(x):                  # уравнение f(x)=0
+    return x**2 - 2
+x0  = 1.4                  # стартовое приближение
+psi = -0.5                 # параметр: phi(x)=x+psi*f(x); подбери так, чтобы |1+psi*f'(x)|<1
+eps = 1e-6                 # точность
+
+# --- АЛГОРИТМ (не трогай) ---
+def simple_iteration(f, x, psi, eps, max_iter=1000):
+    for _ in range(max_iter):
+        x_new = x + psi * f(x)        # phi(x) = x + psi*f(x)
+        if abs(x_new - x) <= eps:
+            return x_new
+        x = x_new
+    return x
+
+# --- ЗАПУСК ---
+print("Корень:", simple_iteration(f, x0, psi, eps))
+''')
+
+# ---- 3. Секущих / хорд ----
+_p(["секущих", "хорд"], [],
+'''# ===== МЕТОД СЕКУЩИХ: производную заменяем разностью по двум точкам =====
+
+# --- ПАРАМЕТРЫ (меняй здесь) ---
+def f(x):                  # уравнение f(x)=0 (производная НЕ нужна)
+    return x**2 - 2
+x0, x1 = 1, 2              # ДВА стартовых приближения (нужны оба)
+eps    = 1e-6             # точность
+
+# --- АЛГОРИТМ (не трогай) ---
+def secant_method(f, x0, x1, eps, max_iter=1000):
+    for _ in range(max_iter):
+        x2 = x1 - f(x1) * (x1 - x0) / (f(x1) - f(x0))
+        if abs(x2 - x1) < eps:
+            return x2
+        x0, x1 = x1, x2
+    return x1
+
+# --- ЗАПУСК ---
+print("Корень:", secant_method(f, x0, x1, eps))
+''')
+
+# ---- 4. Ньютон (1D) ----
+_p(["ньютон", "ньютона", "касательных"], [],
+'''# ===== МЕТОД НЬЮТОНА: x_new = x - f(x)/f'(x) =====
+
+# --- ПАРАМЕТРЫ (меняй здесь) ---
+def f(x):                  # уравнение f(x)=0
+    return np.exp(x) - x - 2
+def df(x):                 # производная f'(x) (обязательно правильная!)
+    return np.exp(x) - 1
+x0  = 1.0                  # стартовое приближение
+eps = 1e-6                 # точность
+
+# --- АЛГОРИТМ (не трогай) ---
+def newton_method(f, df, x, eps, max_iter=1000):
+    for _ in range(max_iter):
+        x_new = x - f(x) / df(x)
+        if abs(x_new - x) < eps:
+            return x_new
+        x = x_new
+    return x
+
+# --- ЗАПУСК ---
+print("Корень:", newton_method(f, df, x0, eps))
+''')
+
+# ---- 5. Модифицированный Ньютон (1D) ----
+_p(["модифицированный ньютон", "модиф ньютон", "ньютон с фиксированной производной"], [],
+'''# ===== МОДИФИЦИРОВАННЫЙ НЬЮТОН: производную берём один раз в x0 =====
+
+# --- ПАРАМЕТРЫ (меняй здесь) ---
+def f(x):                  # уравнение f(x)=0
+    return np.exp(x) - x - 2
+def df(x):                 # производная f'(x)
+    return np.exp(x) - 1
+x0  = 1.0                  # стартовая точка (в ней же фиксируется производная)
+eps = 1e-4                 # точность
+
+# --- АЛГОРИТМ (не трогай) ---
+def modified_newton(f, df, x0, eps, max_iter=1000):
+    x = x0
+    d = df(x0)                    # производную считаем ОДИН раз в x0
+    for _ in range(max_iter):
+        x_new = x - f(x) / d
+        if abs(x_new - x) < eps:
+            return x_new
+        x = x_new
+    return x
+
+def newton_method(f, df, x, eps, max_iter=1000):   # обычный Ньютон для сравнения
+    for _ in range(max_iter):
+        x_new = x - f(x) / df(x)
+        if abs(x_new - x) < eps:
+            return x_new
+        x = x_new
+    return x
+
+# --- ЗАПУСК ---
+print("Модифицированный:", modified_newton(f, df, x0, eps))
+print("Обычный Ньютон:  ", newton_method(f, df, x0, eps))
+''')
+
+# ---- 6. Дихотомия (минимум) ----
+_p(["дихотомия"], [],
+'''# ===== ДИХОТОМИЯ: ищем МИНИМУМ функции (не корень!) на отрезке =====
+
+# --- ПАРАМЕТРЫ (меняй здесь) ---
+def g(x):                  # функция, минимум которой ищем
+    return x**3 - x**2
+a, b = 0.5, 1              # отрезок, где ровно один минимум (функция унимодальна)
+eps  = 1e-5                # точность
+
+# --- АЛГОРИТМ (не трогай) ---
+def dichotomy_min(g, a, b, eps):
+    delta = eps / 2
+    while abs(b - a) > eps:
+        c = (a + b) / 2
+        if g(c - delta) < g(c + delta):   # слева меньше -> минимум левее
+            b = c
+        else:
+            a = c
+    return (a + b) / 2
+
+# --- ЗАПУСК ---
+print("Точка минимума:", dichotomy_min(g, a, b, eps))
+''')
+
+# ---- 7. Простая итерация для систем ----
+_p(["итерация системы", "функциональная итерация системы", "система простая итерация"], [],
+'''# ===== ПРОСТАЯ ИТЕРАЦИЯ ДЛЯ СИСТЕМ: x = phi(x), повторяем =====
+
+# --- ПАРАМЕТРЫ (меняй здесь) ---
+def phi(x):                # система в виде x = phi(x); x это вектор, возвращаем вектор
+    return np.array([0.5 * np.cos(x[1]) + 0.3,
+                     np.sin(x[0] - 0.5) - 1.5])
+x0  = [0.13, -1.8]         # стартовый вектор
+eps = 1e-6                 # точность (по всем компонентам)
+
+# --- АЛГОРИТМ (не трогай) ---
+def simple_iteration_system(phi, x, eps, max_iter=1000):
+    x = np.array(x, dtype=float)
+    for _ in range(max_iter):
+        x_new = phi(x)
+        if all(abs(d) < eps for d in (x_new - x)):   # все компоненты сошлись
+            return x_new
+        x = x_new
+    return x
+
+# --- ЗАПУСК ---
+print("Решение:", simple_iteration_system(phi, x0, eps))
+''')
+
+# ---- 8. Гаусса-Зейделя (нелинейная система) ----
+_p(["гаусса-зейделя", "зейделя", "гаусс зейдель"], [],
+'''# ===== ГАУССА-ЗЕЙДЕЛЯ: новое значение компоненты идёт В ДЕЛО СРАЗУ =====
+
+# --- ПАРАМЕТРЫ (меняй здесь) ---
+# Систему приводим к x=phi1(...), y=phi2(...). Зейдель: новый x0_new СРАЗУ в формулу для x1_new.
+# Пример системы: x^2 - y = 1, x - y^2 = 0  ->  x = sqrt(1+y),  y = sqrt(x)
+def шаг(x):
+    x0_new = np.sqrt(1 + x[1])     # x = sqrt(1+y)
+    x1_new = np.sqrt(x0_new)       # y = sqrt(x); используем УЖЕ новый x0_new
+    return np.array([x0_new, x1_new])
+x0  = [1.5, 0.5]           # стартовый вектор
+eps = 1e-6                 # точность
+
+# --- АЛГОРИТМ (не трогай) ---
+def gauss_seidel(шаг, x, eps, max_iter=1000):
+    x = np.array(x, dtype=float)
+    for _ in range(max_iter):
+        x_new = шаг(x)
+        if all(abs(d) < eps for d in (x_new - x)):
+            return x_new
+        x = x_new
+    return x
+
+# --- ЗАПУСК ---
+print("Решение:", gauss_seidel(шаг, x0, eps))
+''')
+
+# ---- 9. Ньютон 2D ----
+_p(["ньютон 2d", "ньютон для систем", "ньютон двумерный"], [],
+'''# ===== НЬЮТОН ДЛЯ СИСТЕМЫ 2x2: решаем J*dx=-F, сдвигаем x =====
+
+# --- ПАРАМЕТРЫ (меняй здесь) ---
+def F(x):                  # система F(x)=0; x это [x, y]; возвращаем 2 числа
+    return np.array([x[0]**2 + x[1]**2 - 4.0,
+                     x[0] - x[1]])
+def jacobian(x):           # матрица Якоби: строки — уравнения, столбцы — производные по x[0], x[1]
+    return np.array([[2*x[0], 2*x[1]],
+                     [1.0,    -1.0]])
+x0  = [1.5, 1.5]           # стартовый вектор (НЕ ставь его в точку, где det(J)=0)
+eps = 1e-8                 # точность
+
+# --- АЛГОРИТМ (не трогай) ---
+def solve_2x2(A, b):       # решаем A z = b (2x2) по правилу Крамера
+    det = A[0,0]*A[1,1] - A[0,1]*A[1,0]
+    z0 = (b[0]*A[1,1] - A[0,1]*b[1]) / det
+    z1 = (A[0,0]*b[1] - b[0]*A[1,0]) / det
+    return np.array([z0, z1])
+
+def newton_2d(F, jacobian, x, eps, max_iter=100):
+    x = np.array(x, dtype=float)
+    for _ in range(max_iter):
+        dx = solve_2x2(jacobian(x), -F(x))   # J*dx = -F
+        x_new = x + dx
+        if all(abs(d) < eps for d in (x_new - x)):
+            return x_new
+        x = x_new
+    return x
+
+# --- ЗАПУСК ---
+print("Решение:", newton_2d(F, jacobian, x0, eps))
+''')
+
+# ---- 10. Модифицированный Ньютон 2D ----
+_p(["модифицированный ньютон 2d", "модиф ньютон 2d", "ньютон 2d фиксированный якобиан"], [],
+'''# ===== МОДИФИЦИРОВАННЫЙ НЬЮТОН 2D: якобиан считаем один раз в старте =====
+
+# --- ПАРАМЕТРЫ (меняй здесь) ---
+def F(x):                  # система F(x)=0
+    return np.array([x[0]**2 + x[1]**2 - 4.0, x[0] - x[1]])
+def jacobian(x):           # матрица Якоби
+    return np.array([[2*x[0], 2*x[1]], [1.0, -1.0]])
+x0  = [1.5, 1.5]           # стартовый вектор (в нём же фиксируется якобиан)
+eps = 1e-8                 # точность
+
+# --- АЛГОРИТМ (не трогай) ---
+def solve_2x2(A, b):
+    det = A[0,0]*A[1,1] - A[0,1]*A[1,0]
+    return np.array([(b[0]*A[1,1]-A[0,1]*b[1])/det, (A[0,0]*b[1]-b[0]*A[1,0])/det])
+
+def modified_newton_2d(F, jacobian, x0, eps, max_iter=500):
+    x = np.array(x0, dtype=float)
+    J0 = jacobian(x)               # якобиан фиксируем один раз
+    for _ in range(max_iter):
+        dx = solve_2x2(J0, -F(x))
+        x_new = x + dx
+        if all(abs(d) < eps for d in (x_new - x)):
+            return x_new
+        x = x_new
+    return x
+
+# --- ЗАПУСК ---
+print("Решение:", modified_newton_2d(F, jacobian, x0, eps))
+''')
+
+# ---- 11. Линейная интерполяция ----
+_p(["линейная интерполяция"], [],
+'''# ===== ЛИНЕЙНАЯ ИНТЕРПОЛЯЦИЯ: соединяем узлы отрезками =====
+
+# --- ПАРАМЕТРЫ (меняй здесь) ---
+xs = [0.1, 0.5, 1.0, 2.5]      # узлы по x (строго ПО ВОЗРАСТАНИЮ)
+ys = [0.1, 2.0, 0.4, -1.0]     # значения y в узлах (та же длина)
+
+# --- АЛГОРИТМ (не трогай) ---
+def linear_interp(xs, ys, x):
+    for i in range(len(xs) - 1):
+        if xs[i] <= x <= xs[i+1]:           # нашли интервал, куда попал x
+            return ys[i] + (ys[i+1] - ys[i]) / (xs[i+1] - xs[i]) * (x - xs[i])
+    return None
+
+# --- ЗАПУСК ---
+grid = np.linspace(xs[0], xs[-1], 300)
+plt.plot(grid, [linear_interp(xs, ys, x) for x in grid])
+plt.scatter(xs, ys, color="red", zorder=5)
+plt.grid(True); plt.title("Линейная интерполяция"); plt.show()
+''')
+
+# ---- 12. Лагранж ----
+_p(["лагранж", "лагранжа", "интерполяционный многочлен"], [],
+'''# ===== ИНТЕРПОЛЯЦИЯ ЛАГРАНЖА: один многочлен через все узлы =====
+
+# --- ПАРАМЕТРЫ (меняй здесь) ---
+xs = [0, 2, 5, 8]              # узлы по x (порядок любой)
+ys = [15, 18, 22, 20]          # значения в узлах (та же длина)
+x_eval = 4                     # точка, в которой нужно значение
+
+# --- АЛГОРИТМ (не трогай) ---
+def lagrange_interp(xs, ys, x):
+    total = 0.0
+    for i in range(len(xs)):
+        term = ys[i]
+        for j in range(len(xs)):
+            if i != j:
+                term *= (x - xs[j]) / (xs[i] - xs[j])   # базис Лагранжа
+        total += term
+    return total
+
+# --- ЗАПУСК ---
+print("Значение в x =", x_eval, ":", lagrange_interp(xs, ys, x_eval))
+grid = np.linspace(xs[0], xs[-1], 300)
+plt.plot(grid, [lagrange_interp(xs, ys, x) for x in grid])
+plt.scatter(xs, ys, color="red", zorder=5)
+plt.grid(True); plt.title("Интерполяция Лагранжа"); plt.show()
+''')
+
+# ---- 13. Кубический сплайн ----
+_p(["кубический сплайн", "сплайн", "сплайн-интерполяция"], [],
+'''# ===== КУБИЧЕСКИЙ СПЛАЙН (естественный): гладкая кривая через узлы =====
+
+# --- ПАРАМЕТРЫ (меняй здесь) ---
+xs = [-2, -1, 0, 1]            # узлы по x (ПО ВОЗРАСТАНИЮ)
+ys = [4, 1, 0, 2]              # значения в узлах
+x_eval = -0.5                  # точка, в которой нужно значение
+
+# --- АЛГОРИТМ (не трогай) ---
+def spline_moments(xs, ys):
+    n = len(xs) - 1
+    h = [xs[i+1] - xs[i] for i in range(n)]
+    a = [0.0]*(n+1); b = [0.0]*(n+1); c = [0.0]*(n+1); d = [0.0]*(n+1)
+    b[0] = 1.0; b[n] = 1.0              # естественный сплайн: M0 = Mn = 0
+    for i in range(1, n):
+        a[i] = h[i-1]; b[i] = 2*(h[i-1]+h[i]); c[i] = h[i]
+        d[i] = 6*((ys[i+1]-ys[i])/h[i] - (ys[i]-ys[i-1])/h[i-1])
+    for i in range(1, n+1):            # прогонка (Томас), прямой ход
+        w = a[i] / b[i-1]; b[i] -= w*c[i-1]; d[i] -= w*d[i-1]
+    M = [0.0]*(n+1); M[n] = d[n]/b[n]   # обратный ход
+    for i in range(n-1, -1, -1):
+        M[i] = (d[i] - c[i]*M[i+1]) / b[i]
+    return M
+
+def spline_eval(xs, ys, M, x):
+    for i in range(len(xs)-1):
+        if xs[i] <= x <= xs[i+1]:
+            h = xs[i+1]-xs[i]; A = (xs[i+1]-x)/h; B = (x-xs[i])/h
+            return A*ys[i] + B*ys[i+1] + ((A**3-A)*M[i] + (B**3-B)*M[i+1])*h*h/6
+    return None
+
+# --- ЗАПУСК ---
+M = spline_moments(xs, ys)
+print("Значение в x =", x_eval, ":", spline_eval(xs, ys, M, x_eval))
+grid = np.linspace(xs[0], xs[-1], 300)
+plt.plot(grid, [spline_eval(xs, ys, M, x) for x in grid])
+plt.scatter(xs, ys, color="red", zorder=5)
+plt.grid(True); plt.title("Кубический сплайн"); plt.show()
+''')
+
+# ---- 14. Наивное умножение ----
+_p(["наивное умножение", "умножение матриц"], ["matrix"],
+'''# ===== НАИВНОЕ УМНОЖЕНИЕ МАТРИЦ (три цикла, O(n^3)) =====
+# умножение делает mat_mul (определён выше в блоке помощников)
+
+# --- ПАРАМЕТРЫ (меняй здесь) ---
+A = [[1, 2, 4], [3, 4, 4]]      # матрица A (число столбцов A = число строк B)
+B = [[1, 2], [3, 2], [1, 6]]    # матрица B
+
+# --- ЗАПУСК ---
+print("A*B =", mat_mul(A, B))
+print("Операций умножения:", len(A) * len(B) * len(B[0]))   # n*m*p
+''')
+
+# ---- 14б. Наивное умножение со счётчиком ----
+_p(["наивное умножение со счётчиком", "умножение со счётчиком", "подсчёт операций"], [],
+'''# ===== НАИВНОЕ УМНОЖЕНИЕ + ПОДСЧЁТ числа операций умножения =====
+
+# --- ПАРАМЕТРЫ (меняй здесь) ---
+n = 4                           # размер случайных квадратных матриц n x n
+A = np.random.rand(n, n)
+B = np.random.rand(n, n)
+
+# --- АЛГОРИТМ (не трогай) ---
+def naive_mul_count(A, B):
+    n, m, p = len(A), len(B), len(B[0])
+    C = [[0.0]*p for _ in range(n)]
+    mul = 0
+    for i in range(n):
+        for j in range(p):
+            for k in range(m):
+                C[i][j] += A[i][k] * B[k][j]
+                mul += 1            # считаем каждое умножение
+    return C, mul
+
+# --- ЗАПУСК ---
+C, mul = naive_mul_count(A, B)
+print("Число умножений:", mul, " (теория n^3 =", n**3, ")")
+''')
+
+# ---- 15. Штрассен ----
+_p(["штрассен", "штрассена"], ["matrix"],
+'''# ===== АЛГОРИТМ ШТРАССЕНА: 7 умножений блоков вместо 8, O(n^2.81) =====
+
+# --- ПАРАМЕТРЫ (меняй здесь) ---
+n = 4                           # размер КВАДРАТНЫХ матриц = СТЕПЕНЬ ДВОЙКИ (2,4,8,16)
+A = [[c for c in row] for row in np.random.rand(n, n)]
+B = [[c for c in row] for row in np.random.rand(n, n)]
+
+# --- АЛГОРИТМ (не трогай) ---
+def strassen(A, B):
+    n = len(A)
+    if n == 1:
+        return [[A[0][0] * B[0][0]]]
+    m = n // 2
+    A11=[r[:m] for r in A[:m]]; A12=[r[m:] for r in A[:m]]
+    A21=[r[:m] for r in A[m:]]; A22=[r[m:] for r in A[m:]]
+    B11=[r[:m] for r in B[:m]]; B12=[r[m:] for r in B[:m]]
+    B21=[r[:m] for r in B[m:]]; B22=[r[m:] for r in B[m:]]
+    P1=strassen(A11, mat_sub(B12,B22)); P2=strassen(mat_add(A11,A12), B22)
+    P3=strassen(mat_add(A21,A22), B11); P4=strassen(A22, mat_sub(B21,B11))
+    P5=strassen(mat_add(A11,A22), mat_add(B11,B22))
+    P6=strassen(mat_sub(A12,A22), mat_add(B21,B22))
+    P7=strassen(mat_sub(A11,A21), mat_add(B11,B12))
+    C11=mat_add(mat_sub(mat_add(P5,P4),P2),P6); C12=mat_add(P1,P2)
+    C21=mat_add(P3,P4); C22=mat_sub(mat_sub(mat_add(P5,P1),P3),P7)
+    C=[[0.0]*n for _ in range(n)]
+    for i in range(m):
+        for j in range(m):
+            C[i][j]=C11[i][j]; C[i][j+m]=C12[i][j]
+            C[i+m][j]=C21[i][j]; C[i+m][j+m]=C22[i][j]
+    return C
+
+# --- ЗАПУСК ---
+print("Штрассен совпал с наивным:",
+      all(abs(strassen(A,B)[i][j]-mat_mul(A,B)[i][j])<1e-9 for i in range(n) for j in range(n)))
+''')
+
+# ---- 15б. Штрассен + график времени ----
+_p(["штрассен с таймером", "штрассен график времени", "время от размера матрицы"], ["matrix"],
+'''# ===== ШТРАССЕН + ГРАФИК времени работы от размера матрицы =====
+import time
+
+# --- ПАРАМЕТРЫ (меняй здесь) ---
+sizes = [2, 4, 8, 16, 32]      # размеры для графика (степени двойки)
+
+# --- АЛГОРИТМ (не трогай) ---
+def strassen(A, B):
+    n = len(A)
+    if n == 1: return [[A[0][0]*B[0][0]]]
+    m = n // 2
+    A11=[r[:m] for r in A[:m]]; A12=[r[m:] for r in A[:m]]
+    A21=[r[:m] for r in A[m:]]; A22=[r[m:] for r in A[m:]]
+    B11=[r[:m] for r in B[:m]]; B12=[r[m:] for r in B[:m]]
+    B21=[r[:m] for r in B[m:]]; B22=[r[m:] for r in B[m:]]
+    P1=strassen(A11, mat_sub(B12,B22)); P2=strassen(mat_add(A11,A12), B22)
+    P3=strassen(mat_add(A21,A22), B11); P4=strassen(A22, mat_sub(B21,B11))
+    P5=strassen(mat_add(A11,A22), mat_add(B11,B22))
+    P6=strassen(mat_sub(A12,A22), mat_add(B21,B22))
+    P7=strassen(mat_sub(A11,A21), mat_add(B11,B12))
+    C11=mat_add(mat_sub(mat_add(P5,P4),P2),P6); C12=mat_add(P1,P2)
+    C21=mat_add(P3,P4); C22=mat_sub(mat_sub(mat_add(P5,P1),P3),P7)
+    C=[[0.0]*n for _ in range(n)]
+    for i in range(m):
+        for j in range(m):
+            C[i][j]=C11[i][j]; C[i][j+m]=C12[i][j]
+            C[i+m][j]=C21[i][j]; C[i+m][j+m]=C22[i][j]
+    return C
+
+# --- ЗАПУСК ---
+t_naive, t_str = [], []
+for nsz in sizes:
+    A = [[c for c in row] for row in np.random.rand(nsz, nsz)]
+    B = [[c for c in row] for row in np.random.rand(nsz, nsz)]
+    s=time.time(); mat_mul(A,B);  t_naive.append(time.time()-s)
+    s=time.time(); strassen(A,B); t_str.append(time.time()-s)
+plt.plot(sizes, t_naive, "o-", label="наивный O(n^3)")
+plt.plot(sizes, t_str, "s-", label="Штрассен O(n^2.81)")
+plt.xlabel("размер n"); plt.ylabel("время, с"); plt.legend(); plt.grid(True); plt.show()
+''')
+
+# ---- 16. Характеристический многочлен ----
+_p(["характеристический многочлен", "собственные значения многочлен", "char poly"], ["matrix"],
+'''# ===== СОБСТВЕННЫЕ ЗНАЧЕНИЯ через характеристический многочлен =====
+
+# --- ПАРАМЕТРЫ (меняй здесь) ---
+A = [[2, -1, 0], [-1, 2, -1], [0, -1, 2]]      # КВАДРАТНАЯ матрица
+
+# --- АЛГОРИТМ (не трогай) ---
+def char_poly_coeffs(A):              # коэффициенты det(A - lambda*I) (Фаддеев-Леверье)
+    n = len(A); M = identity(n); coeffs = [1.0]
+    for k in range(1, n+1):
+        AM = mat_mul(A, M); ck = -trace(AM) / k; coeffs.append(ck)
+        M = mat_add(AM, [[ck if i==j else 0.0 for j in range(n)] for i in range(n)])
+    return coeffs
+
+def char_poly_eigenvalues(A):
+    return np.roots(char_poly_coeffs(A))   # roots разрешён для хар. уравнения
+
+# --- ЗАПУСК ---
+ev = char_poly_eigenvalues(A)
+print("Собственные значения:", ev)
+plt.scatter([e.real for e in ev], [e.imag for e in ev])   # СЗ на комплексной плоскости
+plt.axhline(0, color="gray"); plt.axvline(0, color="gray")
+plt.xlabel("Re"); plt.ylabel("Im"); plt.grid(True); plt.show()
+''')
+
+# ---- 17. Степенной метод ----
+_p(["степенной метод", "степенной", "наибольшее собственное значение"], ["matrix"],
+'''# ===== СТЕПЕННОЙ МЕТОД: наибольшее по модулю собственное значение =====
+
+# --- ПАРАМЕТРЫ (меняй здесь) ---
+A  = [[2, -1, 0], [-1, 2, -1], [0, -1, 2]]     # КВАДРАТНАЯ матрица
+x0 = [1, 1, 1]                                  # стартовый вектор (любой ненулевой)
+eps = 1e-5                                      # точность
+
+# --- АЛГОРИТМ (не трогай) ---
+def power_method(A, x, eps, max_iter=1000):
+    x = np.array(x, dtype=float); x = x / vec_norm(x)
+    lam_old = 0.0
+    for _ in range(max_iter):
+        y = mat_vec(A, x); x = y / vec_norm(y)
+        lam = dot(x, mat_vec(A, x)) / dot(x, x)   # отношение Рэлея
+        if abs(lam - lam_old) < eps:
+            return lam, x
+        lam_old = lam
+    return lam, x
+
+# --- ЗАПУСК ---
+lam, vec = power_method(A, x0, eps)
+print("Наибольшее СЗ:", lam)
+print("Собственный вектор:", vec)
+''')
+
+# ---- 18. Степенной со сдвигом ----
+_p(["степенной со сдвигом", "степенной метод со сдвигом", "сдвиг"], ["matrix"],
+'''# ===== СТЕПЕННОЙ СО СДВИГОМ: степенной метод к матрице (A - mu*I) =====
+
+# --- ПАРАМЕТРЫ (меняй здесь) ---
+A  = [[5,1,2,3],[1,5,4,5],[2,4,5,-2],[3,5,6,5]]   # КВАДРАТНАЯ матрица
+x0 = [1, 1, 1, 1]                                  # стартовый вектор
+eps = 1e-4                                         # точность
+# mu (сдвиг) задаём ниже: для поиска наименьшего СЗ берём mu = наибольшее СЗ
+
+# --- АЛГОРИТМ (не трогай) ---
+def power_method(A, x, eps, max_iter=1000):
+    x = np.array(x, dtype=float); x = x / vec_norm(x); lam_old = 0.0
+    for _ in range(max_iter):
+        y = mat_vec(A, x); x = y / vec_norm(y)
+        lam = dot(x, mat_vec(A, x)) / dot(x, x)
+        if abs(lam - lam_old) < eps: return lam, x
+        lam_old = lam
+    return lam, x
+
+def shifted_power(A, mu, x, eps, max_iter=1000):
+    n = len(A)
+    B = [[A[i][j] - (mu if i==j else 0.0) for j in range(n)] for i in range(n)]  # A - mu*I
+    _, v = power_method(B, x, eps, max_iter)
+    lam = dot(v, mat_vec(A, v)) / dot(v, v)        # СЗ исходной A через Рэлея
+    return lam, v
+
+# --- ЗАПУСК ---
+lam_max, _ = power_method(A, x0, eps)              # наибольшее СЗ
+print("lambda_max =", lam_max)
+lam_min, _ = shifted_power(A, lam_max, x0, eps)    # сдвиг mu=lam_max -> ловим наименьшее
+print("lambda_min =", lam_min)
+''')
+
+# ---- 19. Вращения Якоби ----
+_p(["вращения якоби", "метод вращений", "якоби", "собственные векторы"], ["matrix"],
+'''# ===== МЕТОД ВРАЩЕНИЙ ЯКОБИ: все СЗ и собственные векторы (для СИММЕТРИЧНОЙ A) =====
+
+# --- ПАРАМЕТРЫ (меняй здесь) ---
+A   = [[2, -1, 0], [-1, 2, -1], [0, -1, 2]]    # СИММЕТРИЧНАЯ матрица
+eps = 1e-3                                      # точность (порог внедиагональных элементов)
+
+# --- АЛГОРИТМ (не трогай) ---
+def jacobi_eig(A, eps, max_iter=1000):
+    A = [row[:] for row in A]; n = len(A)
+    V = identity(n)                      # копим собственные векторы
+    for _ in range(max_iter):
+        p, q, mx = 0, 1, 0.0             # наибольший внедиагональный A[p][q]
+        for i in range(n):
+            for j in range(i+1, n):
+                if abs(A[i][j]) > mx:
+                    mx = abs(A[i][j]); p, q = i, j
+        if mx < eps:
+            break
+        theta = (A[q][q] - A[p][p]) / (2 * A[p][q])   # угол поворота (t-формула)
+        sign = 1.0 if theta >= 0 else -1.0
+        t = sign / (abs(theta) + np.sqrt(theta*theta + 1))
+        c = 1 / np.sqrt(t*t + 1); s = t * c
+        J = identity(n); J[p][p]=c; J[q][q]=c; J[p][q]=s; J[q][p]=-s
+        A = mat_mul(mat_mul(transpose(J), A), J)       # A = J^T A J
+        V = mat_mul(V, J)
+    return [A[i][i] for i in range(n)], V
+
+# --- ЗАПУСК ---
+vals, V = jacobi_eig(A, eps)
+print("Собственные значения:", sorted(vals))
+''')
+
+# ---- 20. QR-алгоритм ----
+_p(["qr алгоритм", "qr-алгоритм"], ["matrix", "qr"],
+'''# ===== QR-АЛГОРИТМ: повторяем A = R*Q, на диагонали проступают СЗ =====
+# (qr_gram_schmidt и mat_mul определены выше в блоке помощников)
+
+# --- ПАРАМЕТРЫ (меняй здесь) ---
+A   = [[2,-1,0],[-1,2,-1],[0,-1,2]]    # КВАДРАТНАЯ матрица
+eps = 1e-9                              # порог поддиагональных элементов
+
+# --- АЛГОРИТМ (не трогай) ---
+def qr_algorithm(A, eps, max_iter=1000):
+    A = [[float(x) for x in row] for row in A]; n = len(A)
+    for _ in range(max_iter):
+        Q, R = qr_gram_schmidt(A)
+        A = mat_mul(R.tolist(), Q.tolist())            # A_{k+1} = R * Q
+        off = max((abs(A[i][j]) for i in range(n) for j in range(i)), default=0.0)
+        if off < eps:
+            break
+    return sorted(A[i][i] for i in range(n))
+
+# --- ЗАПУСК ---
+print("СЗ:", qr_algorithm(A, eps))
+''')
+
+# ---- 21. Разложение Шура ----
+_p(["шур", "шура", "разложение шура"], ["matrix", "qr"],
+'''# ===== РАЗЛОЖЕНИЕ ШУРА: A = U*T*U^T (T верхнетреугольная, на диагонали — СЗ) =====
+
+# --- ПАРАМЕТРЫ (меняй здесь) ---
+A   = [[5,1,2,3],[1,6,4,9],[2,4,7,10],[3,9,10,8]]   # КВАДРАТНАЯ матрица
+eps = 1e-9                                           # порог поддиагональных элементов
+
+# --- АЛГОРИТМ (не трогай) ---
+def schur(A, eps, max_iter=1000):
+    n = len(A); T = [[float(x) for x in row] for row in A]; U = identity(n)
+    for _ in range(max_iter):
+        Q, R = qr_gram_schmidt(T)
+        T = mat_mul(R.tolist(), Q.tolist())            # T = R Q
+        U = mat_mul(U, Q.tolist())                     # копим ортогональную U
+        off = max((abs(T[i][j]) for i in range(n) for j in range(i)), default=0.0)
+        if off < eps:
+            break
+    return U, T
+
+# --- ЗАПУСК ---
+U, T = schur(A, eps)
+print("Диагональ T (собственные значения):", [round(T[i][i],4) for i in range(len(A))])
+recon = mat_mul(mat_mul(U, T), transpose(U))      # проверка: U T U^T = A
+print("Восстановление A, макс ошибка:",
+      max(abs(recon[i][j]-A[i][j]) for i in range(len(A)) for j in range(len(A))))
+''')
+
+# ---- 21б. Проверка нормальности ----
+_p(["проверка нормальности", "нормальная матрица", "нормальность"], ["matrix"],
+'''# ===== ПРОВЕРКА НОРМАЛЬНОСТИ: матрица нормальна, если A*A^T == A^T*A =====
+
+# --- ПАРАМЕТРЫ (меняй здесь) ---
+A = [[5,1,2,3],[1,6,4,9],[2,4,7,10],[3,9,10,8]]   # матрица (симметричная -> нормальна)
+
+# --- АЛГОРИТМ (не трогай) ---
+def is_normal(A, tol=1e-9):
+    At = transpose(A)
+    AAt = mat_mul(A, At); AtA = mat_mul(At, A)
+    return all(abs(AAt[i][j] - AtA[i][j]) < tol for i in range(len(A)) for j in range(len(A)))
+
+# --- ЗАПУСК ---
+print("Матрица нормальна?", is_normal(A))
+''')
+
+# ---- 22. QR-разложение ----
+_p(["qr разложение", "qr-разложение", "грама-шмидта", "грам шмидт"], ["matrix", "qr"],
+'''# ===== QR-РАЗЛОЖЕНИЕ (Грам-Шмидт): A = Q*R =====
+# (qr_gram_schmidt и mat_mul определены выше в блоке помощников)
+
+# --- ПАРАМЕТРЫ (меняй здесь) ---
+A = [[1, 2], [3, 4]]               # матрица для разложения
+
+# --- ЗАПУСК ---
+Q, R = qr_gram_schmidt(A)
+print("Q =\\n", Q)
+print("R =\\n", R)
+print("Q*R =", mat_mul(Q.tolist(), R.tolist()))                 # = A
+print("Q^T*Q =", mat_mul(transpose(Q.tolist()), Q.tolist()))    # = единичная
+''')
+
+# ---- 23. Эйлер ----
+_p(["эйлер", "эйлера", "метод эйлера"], ["ode"],
+'''# ===== МЕТОД ЭЙЛЕРА: y_new = y + h*f(t,y) =====
+
+# --- ПАРАМЕТРЫ (меняй здесь) ---
+pi = 4 * np.arctan(1.0)        # пи (если нужен в отрезке/шаге)
+def f(t, y):                   # правая часть y' = f(t, y). Для ОДНОГО уравнения y — число
+    return -y + np.sin(t)
+y0    = 0.0                     # начальное значение y(t0)
+t0    = 0.0                     # начало отрезка
+t_end = 2*pi                    # конец отрезка
+h     = pi/20                   # шаг
+
+# --- АЛГОРИТМ (не трогай) ---
+def euler(f, y0, t0, t_end, h):
+    ts = [t0]; ys = [y0]; t = t0; y = y0
+    for _ in range(n_steps(t0, t_end, h)):
+        y = y + h * f(t, y); t = t + h
+        ts.append(t); ys.append(y)
+    return ts, ys
+
+# --- ЗАПУСК ---
+ts, ys = euler(f, y0, t0, t_end, h)
+plt.plot(ts, ys, ".-"); plt.grid(True); plt.title("Метод Эйлера"); plt.show()
+''')
+
+# ---- 24. Предиктор-корректор (Хойн) ----
+_p(["предиктор-корректор", "предиктор корректор", "хойн", "хойна"], ["ode"],
+'''# ===== ПРЕДИКТОР-КОРРЕКТОР (Хойн): предиктор Эйлером, корректор трапецией =====
+
+# --- ПАРАМЕТРЫ (меняй здесь) ---
+# Для СИСТЕМЫ: y0 = np.array([...]), а f возвращает np.array (как ниже)
+def f(t, y):                   # правая часть y' = f(t, y)
+    return np.array([np.log(1 + y[1]**2), -np.cos(y[0])])
+y0    = np.array([1.0, 1.0])    # начальное значение (число или np.array для системы)
+t0    = 0.0
+t_end = 1.0
+h     = 0.05
+
+# --- АЛГОРИТМ (не трогай) ---
+def heun(f, y0, t0, t_end, h):
+    ts = [t0]; ys = [y0]; t = t0; y = y0
+    for _ in range(n_steps(t0, t_end, h)):
+        fn = f(t, y)
+        y_pred = y + h * fn                      # предиктор (Эйлер)
+        y = y + h/2 * (fn + f(t + h, y_pred))    # корректор (трапеция)
+        t = t + h; ts.append(t); ys.append(y)
+    return ts, ys
+
+# --- ЗАПУСК ---
+ts, ys = heun(f, y0, t0, t_end, h)
+print("y(t_end) =", ys[-1])
+plt.plot(ts, [y[0] for y in ys], label="y1"); plt.plot(ts, [y[1] for y in ys], label="y2")
+plt.legend(); plt.grid(True); plt.title("Предиктор-корректор"); plt.show()
+''')
+
+# ---- 25. РК4 ----
+_p(["рунге-кутта", "рунге кутта", "рк4", "runge-kutta"], ["ode"],
+'''import numpy as np
+import matplotlib.pyplot as plt
+
+def n_steps(t0, t_end, h):
+    return int(round((t_end - t0) / h))
+
+def rk4_step(f, t, y, h):            # один шаг РК4 (нужен для разгона Адамса)
+    k1 = f(t, y)
+    k2 = f(t + h/2, y + h/2 * k1)
+    k3 = f(t + h/2, y + h/2 * k2)
+    k4 = f(t + h,   y + h * k3)
+    return y + h/6 * (k1 + 2*k2 + 2*k3 + k4)
+
+# ===== РУНГЕ-КУТТА 4-го порядка: точный метод O(h^4) =====
+
+# --- ПАРАМЕТРЫ (меняй здесь) ---
+# Для СИСТЕМЫ: y0 = np.array([...]), f возвращает np.array
+def f(t, y):                   # правая часть y' = f(t, y)
+    return -y + t
+
+def y_exact(t):                # точное решение из условия
+    return t - 1 + np.exp(-t)
+    
+y0    = 0
+t0    = 0.0
+t_end = 1.0
+h     = 0.1
+
+# --- АЛГОРИТМ (не трогай) ---
+def runge_kutta_4(f, y0, t0, t_end, h):
+    ts = [t0]; ys = [y0]; t = t0; y = y0
+    for _ in range(n_steps(t0, t_end, h)):
+        y = rk4_step(f, t, y, h)       # rk4_step определён выше
+        t = t + h
+        ts.append(t); ys.append(y)
+    return ts, ys
+
+# --- ЗАПУСК ---
+ts, ys = runge_kutta_4(f, y0, t0, t_end, h)
+
+# --- СРАВНЕНИЕ С ТОЧНЫМ РЕШЕНИЕМ ---
+exact = [y_exact(t) for t in ts]                  # точное в тех же узлах
+errors = [abs(ys[i] - exact[i]) for i in range(len(ts))]
+
+print(" t      РК4          точное       ошибка")
+for i in range(len(ts)):
+    print(f"{ts[i]:.1f}  {ys[i]:.8f}  {exact[i]:.8f}  {errors[i]:.2e}")
+
+print("\nМаксимальная (глобальная) ошибка:", max(errors))
+
+# --- ГРАФИК: два решения наложены ---
+plt.plot(ts, ys, "o-", label="РК4 (численное)")
+plt.plot(ts, exact, "-", label="точное t-1+e^(-t)")
+plt.grid(True); plt.legend(); plt.title("РК4 vs точное решение")
+plt.xlabel("t"); plt.ylabel("y"); plt.show()
+''')
+
+# ---- 26. Адамса-Башфорта ----
+_p(["адамса-башфорта", "адамс башфорт", "башфорт"], ["ode"],
+'''# ===== АДАМС-БАШФОРТ 4 (явный многошаговый); старт через РК4 =====
+
+# --- ПАРАМЕТРЫ (меняй здесь) ---
+def f(t, y):                   # правая часть y' = f(t, y) (работает и для систем)
+    return -y
+y0    = 1.0
+t0    = 0.0
+t_end = 1.0
+h     = 0.1
+
+# --- АЛГОРИТМ (не трогай) ---
+def adams_bashforth(f, y0, t0, t_end, h):
+    N = n_steps(t0, t_end, h)
+    ts = [t0]; ys = [y0]; t = t0; y = y0
+    for _ in range(min(3, N)):                   # 3 стартовые точки через РК4
+        y = rk4_step(f, t, y, h); t = t + h; ts.append(t); ys.append(y)
+    fs = [f(ts[i], ys[i]) for i in range(len(ys))]
+    while len(ys) <= N:
+        n = len(ys) - 1
+        y_new = ys[n] + h/24 * (55*fs[n] - 59*fs[n-1] + 37*fs[n-2] - 9*fs[n-3])
+        t_new = ts[n] + h
+        ts.append(t_new); ys.append(y_new); fs.append(f(t_new, y_new))
+    return ts, ys
+
+# --- ЗАПУСК ---
+ts, ys = adams_bashforth(f, y0, t0, t_end, h)
+print("y(t_end) =", ys[-1])
+''')
+
+# ---- 27. Адамса-Мултона ----
+_p(["адамса-мултона", "адамс мултон", "мултон", "мултона"], ["ode"],
+'''# ===== АДАМС-МУЛТОН (предиктор-корректор ABM, 4-й порядок) =====
+# ЧЕМ УНИКАЛЕН: многошаговый метод. ПРЕДСКАЗЫВАЕТ значение явным Адамсом-Башфортом и
+# УТОЧНЯЕТ его неявным Адамсом-Мултоном. Точнее Эйлера на порядки, на шаг дешевле РК4
+# (одно новое вычисление f). Первые 3 точки получает методом РК4 (сам разогнаться не может).
+#
+# СЦЕНАРИИ (выбери под билет):
+#   A) ОДНО уравнение y'=f(t,y), y — ЧИСЛО. Обычно просят сравнить с Эйлером и нарисовать y(t).
+#   B) СИСТЕМА: y0 = np.array([...]), f возвращает np.array. Обычно строят фазовый портрет.
+# Ниже настроен СЦЕНАРИЙ A. Как переключить на B — пометки в самом низу.
+
+# --- ПАРАМЕТРЫ (меняй здесь) --- [сценарий A: одно уравнение]
+def f(t, y):                   # правая часть y' = f(t, y); y — ЧИСЛО
+    return -0.2*y + np.cos(t)
+y0    = 1.0                     # начальное значение y(t0)
+t0    = 0.0                     # начало отрезка
+t_end = 10.0                    # конец отрезка
+h     = 0.1                     # шаг
+
+# --- АЛГОРИТМ (не трогай) ---
+def euler(f, y0, t0, t_end, h):              # Эйлер — для сравнения
+    ts = [t0]; ys = [y0]; t = t0; y = y0
+    for _ in range(n_steps(t0, t_end, h)):
+        y = y + h * f(t, y); t = t + h; ts.append(t); ys.append(y)
+    return ts, ys
+
+def adams_moulton(f, y0, t0, t_end, h):
+    N = n_steps(t0, t_end, h); ts = [t0]; ys = [y0]; t = t0; y = y0
+    for _ in range(min(3, N)):                   # разгон методом РК4
+        y = rk4_step(f, t, y, h); t = t + h; ts.append(t); ys.append(y)
+    fs = [f(ts[i], ys[i]) for i in range(len(ys))]
+    while len(ys) <= N:
+        n = len(ys) - 1
+        y_pred = ys[n] + h/24 * (55*fs[n] - 59*fs[n-1] + 37*fs[n-2] - 9*fs[n-3])  # предиктор AB4
+        t_new = ts[n] + h; f_pred = f(t_new, y_pred)
+        y_new = ys[n] + h/24 * (9*f_pred + 19*fs[n] - 5*fs[n-1] + fs[n-2])        # корректор AM4
+        ts.append(t_new); ys.append(y_new); fs.append(f(t_new, y_new))
+    return ts, ys
+
+# --- ЗАПУСК (сценарий A: одно уравнение + сравнение с Эйлером) ---
+ts, ys_am = adams_moulton(f, y0, t0, t_end, h)
+_,  ys_eu = euler(f, y0, t0, t_end, h)
+print("Адамс-Мултон y(t_end) =", ys_am[-1])
+print("Эйлер        y(t_end) =", ys_eu[-1])
+plt.plot(ts, ys_am, label="Адамс-Мултон")
+plt.plot(ts, ys_eu, "--", label="Эйлер")
+plt.xlabel("t"); plt.ylabel("y"); plt.legend(); plt.grid(True); plt.title("Решение ОДУ"); plt.show()
+
+# --- СЦЕНАРИЙ B (СИСТЕМА + фазовый портрет): поменяй ПАРАМЕТРЫ на векторные ---
+#   def f(t, y): return np.array([t**2 - y[1], y[0] + t])   # f возвращает вектор
+#   y0 = np.array([1.0, 0.0])
+# и вместо графика y(t) поставь фазовый портрет:
+#   plt.plot([y[0] for y in ys_am], [y[1] for y in ys_am])
+#   plt.xlabel("y1"); plt.ylabel("y2"); plt.grid(True); plt.show()
+''')
+
+# ---- 27б. Фазовый портрет ----
+_p(["фазовый портрет"], ["ode"],
+'''# ===== ФАЗОВЫЙ ПОРТРЕТ системы: траектория в координатах (y1, y2) =====
+
+# --- ПАРАМЕТРЫ (меняй здесь) ---
+# Систему из 2 уравнений пакуем в вектор y=[y1,y2]; f возвращает [dy1/dt, dy2/dt].
+# Пример (осциллятор dx/dt=y, dy/dt=-x):  y[0]=x, y[1]=y  ->  f=[y[1], -y[0]]
+def f(t, y):
+    return np.array([y[1], -y[0]])
+y0    = np.array([1.0, 0.0])    # начальный вектор [y1(0), y2(0)]
+t0    = 0.0
+t_end = 10.0
+h     = 0.1
+
+# --- АЛГОРИТМ (не трогай) ---
+def rk4_solve(f, y0, t0, t_end, h):
+    ts = [t0]; ys = [y0]; t = t0; y = y0
+    for _ in range(n_steps(t0, t_end, h)):
+        y = rk4_step(f, t, y, h); t = t + h
+        ts.append(t); ys.append(y)
+    return ts, ys
+
+# --- ЗАПУСК ---
+ts, ys = rk4_solve(f, y0, t0, t_end, h)
+plt.plot([y[0] for y in ys], [y[1] for y in ys])
+plt.xlabel("y1"); plt.ylabel("y2"); plt.axis("equal")
+plt.grid(True); plt.title("Фазовый портрет"); plt.show()
+''')
+
+# ---- 28. ДПФ / ОДПФ ----
+_p(["дпф", "дискретное преобразование фурье"], ["pi"],
+'''# ===== ДПФ (по определению, O(N^2)) и обратное ОДПФ =====
+
+# --- ПАРАМЕТРЫ (меняй здесь) ---
+x = [0.0, 1.0, 2.0, 3.0, 4.0, 3.0, 2.0, 1.0]   # сигнал (список чисел)
+
+# --- АЛГОРИТМ (не трогай) ---
+def dft(x):
+    N = len(x); X = []
+    for k in range(N):
+        s = 0 + 0j
+        for n in range(N):
+            theta = 2 * pi * k * n / N
+            s += x[n] * (np.cos(theta) - 1j * np.sin(theta))   # e^{-i*theta}
+        X.append(s)
+    return X
+
+def idft(X):
+    N = len(X); x = []
+    for n in range(N):
+        s = 0 + 0j
+        for k in range(N):
+            theta = 2 * pi * k * n / N
+            s += X[k] * (np.cos(theta) + 1j * np.sin(theta))
+        x.append(s / N)
+    return x
+
+# --- ЗАПУСК ---
+X = dft(x)
+print("Спектр (модули):", [round(abs(v), 3) for v in X])
+print("Восстановление (ОДПФ):", [round(v.real, 3) for v in idft(X)])
+''')
+
+# ---- 28б. Обратное ДПФ ----
+_p(["обратное дпф", "одпф"], ["pi"],
+'''# ===== ОБРАТНОЕ ДПФ: восстановить сигнал из спектра X =====
+
+# --- ПАРАМЕТРЫ (меняй здесь) ---
+# X — спектр (список комплексных), полученный из dft(x) или fft(x)
+
+# --- АЛГОРИТМ (не трогай) ---
+def idft(X):
+    N = len(X); x = []
+    for n in range(N):
+        s = 0 + 0j
+        for k in range(N):
+            theta = 2 * pi * k * n / N
+            s += X[k] * (np.cos(theta) + 1j * np.sin(theta))   # e^{+i*theta}
+        x.append(s / N)
+    return x
+
+# --- ЗАПУСК ---
+# signal_restored = [v.real for v in idft(X)]
+''')
+
+# ---- 29. БПФ / ОБПФ ----
+_p(["бпф", "быстрое преобразование фурье", "fft"], ["pi"],
+'''# ===== БПФ (Кули-Тьюки, O(N log N)) и обратное ОБПФ =====
+
+# --- ПАРАМЕТРЫ (меняй здесь) ---
+x = [0.0, 1.0, 2.0, 3.0, 4.0, 3.0, 2.0, 1.0]   # сигнал; длина = СТЕПЕНЬ ДВОЙКИ (2,4,8,16,32)
+
+# --- АЛГОРИТМ (не трогай) ---
+def fft(x):
+    N = len(x)
+    if N == 1:
+        return [x[0] + 0j]
+    even = fft(x[0::2]); odd = fft(x[1::2])
+    X = [0j] * N
+    for k in range(N // 2):
+        theta = 2 * pi * k / N
+        w = np.cos(theta) - 1j * np.sin(theta)     # поворотный множитель
+        X[k]          = even[k] + w * odd[k]
+        X[k + N // 2] = even[k] - w * odd[k]
+    return X
+
+def ifft(X):
+    N = len(X)
+    conj = [v.real - 1j * v.imag for v in X]
+    y = fft(conj)
+    return [(v.real - 1j * v.imag) / N for v in y]
+
+# --- ЗАПУСК ---
+X = fft(x)
+print("БПФ (модули):", [round(abs(v), 3) for v in X])
+print("Восстановление (ОБПФ):", [round(v.real, 3) for v in ifft(X)])
+''')
+
+# ---- 29б. Амплитудный спектр ----
+_p(["амплитудный спектр", "сигнал спектр", "пики в спектре", "генерация сигнала"], ["pi"],
+'''# ===== АМПЛИТУДНЫЙ СПЕКТР: сигнал -> БПФ -> амплитуды на частотах -> график =====
+# ВАЖНО про частоты: в билете частота "m/N" — это бин (индекс) k = m. Амплитуда = amp[m].
+
+# --- ПАРАМЕТРЫ (меняй здесь) ---
+N = 16                             # длина сигнала (СТЕПЕНЬ ДВОЙКИ)
+nn = np.linspace(0, N, N, endpoint=False)   # номера отсчётов 0..N-1
+# сигнал из билета (ВЕЗДЕ nn — номер отсчёта; число перед nn/N = частота, т.е. сколько волн):
+signal = np.sin(2*pi*(2*nn/N)) + 0.3*np.cos(2*pi*(4*nn/N)) + 0.05*np.random.rand(N)
+targets = [2, 4]                   # какие частоты ищем как m (частота = m/N, индекс k = m)
+
+# --- АЛГОРИТМ (не трогай) ---
+def fft(x):
+    N = len(x)
+    if N == 1: return [x[0] + 0j]
+    even = fft(x[0::2]); odd = fft(x[1::2])
+    X = [0j] * N
+    for k in range(N // 2):
+        theta = 2 * pi * k / N
+        w = np.cos(theta) - 1j * np.sin(theta)
+        X[k] = even[k] + w*odd[k]; X[k + N//2] = even[k] - w*odd[k]
+    return X
+def ifft(X):
+    N = len(X); conj = [v.real - 1j*v.imag for v in X]; y = fft(conj)
+    return [(v.real - 1j*v.imag)/N for v in y]
+
+# --- ЗАПУСК ---
+X = fft(list(signal))
+amp = [2*abs(X[k])/N for k in range(N//2)]     # amp[k] = амплитуда на частоте k/N
+for m in targets:
+    print(f"частота {m}/{N}: амплитуда = {round(amp[m], 3)}")
+
+restored = [v.real for v in ifft(X)]           # восстановление сигнала (если в билете просят)
+fig, ax = plt.subplots(1, 2, figsize=(11,4))
+ax[0].stem(range(N//2), amp); ax[0].set_title("Амплитудный спектр"); ax[0].grid(True)
+ax[0].set_xlabel("k (частота = k/N)")
+ax[1].plot(nn, signal, "o-", label="исходный"); ax[1].plot(nn, restored, "x--", label="восстановленный")
+ax[1].legend(); ax[1].set_title("Сигнал"); ax[1].grid(True); plt.show()
+''')
+
+# ---- Центральная разность ----
+_p(["центральная разность", "численное дифференцирование", "производная", "разность"], [],
+'''# ===== ЧИСЛЕННОЕ ДИФФЕРЕНЦИРОВАНИЕ (конечные разности) =====
+
+# --- ПАРАМЕТРЫ (меняй здесь) ---
+def f(x):                          # функция, производную которой приближаем
+    return x**3 * np.exp(-x)
+def df_exact(x):                   # точная производная (если в билете дана — для сравнения)
+    return (3*x**2 - x**3) * np.exp(-x)
+x_eval = 1                         # точка, где считаем производную
+hs = [0.1, 0.01]                   # шаги h (меньше h — точнее, но при очень малом растёт округление)
+
+# --- АЛГОРИТМ (не трогай) ---
+def deriv1_central(f, x, h):   # 1-я производная, центральная разность, ошибка O(h^2)
+    return (f(x + h) - f(x - h)) / (2 * h)
+def deriv1_forward(f, x, h):   # 1-я производная, прямая разность, ошибка O(h)
+    return (f(x + h) - f(x)) / h
+def deriv2_central(f, x, h):   # 2-я производная, центральная разность, ошибка O(h^2)
+    return (f(x + h) - 2 * f(x) + f(x - h)) / (h * h)
+
+# --- ЗАПУСК ---
+for h in hs:
+    print(f"h={h}: центральная={deriv1_central(f,x_eval,h):.6f}  точно={df_exact(x_eval):.6f}")
+# для 2-й производной возьми deriv2_central(f, x_eval, h)
+''')
+
+# ---- Суммирование Кахана ----
+_p(["кахан", "кахана", "суммирование кахана", "kahan"], [],
+'''# ===== СУММИРОВАНИЕ КАХАНА: точное сложение многих чисел =====
+
+# --- ПАРАМЕТРЫ (меняй здесь) ---
+data = [0.1] * 10              # список чисел для суммирования
+
+# --- АЛГОРИТМ (не трогай) ---
+def kahan_sum(nums):
+    s = 0.0          # сумма
+    c = 0.0          # компенсация потерянных младших разрядов
+    for x in nums:
+        y = x - c
+        t = s + y
+        c = (t - s) - y     # что потерялось при сложении
+        s = t
+    return s
+
+# --- ЗАПУСК ---
+print("Кахан: ", kahan_sum(data))   # точнее обычной суммы
+print("Обычная:", sum(data))
+''')
+
+
+# ====================================================================== ТЕОРИЯ
+THEORY = {}
+def _t(keys, text):
+    for k in keys:
+        THEORY[k] = text
+
+_t(["бисекция", "почему бисекция сходится"],
+"""БИСЕКЦИЯ — почему она работает и как отвечать на вопросы про неё.
+
+Бисекция это самый надёжный способ найти корень уравнения, и идея у неё почти бытовая. Если
+функция непрерывна и на одном конце отрезка она отрицательна, а на другом положительна, то
+где-то между ними она обязана пройти через ноль. Это и есть теорема о промежуточном значении
+(теорема Больцано), и именно она гарантирует, что корень на отрезке существует. Мы берём
+середину отрезка, смотрим, в какой из двух половин по-прежнему сохраняется смена знака, и
+выбрасываем вторую половину. За счёт этого отрезок с корнем на каждом шаге становится ровно
+вдвое короче и неизбежно стягивается к точке, где функция равна нулю.
+
+Платим за надёжность скоростью. Сходимость здесь линейная, и чтобы добраться до точности eps,
+нужно примерно log2 от (b минус a), делённого на eps, шагов. На практике это значит, что один
+новый верный десятичный знак появляется примерно за три-четыре итерации. Метод не использует
+производную и в принципе не умеет расходиться, поэтому его часто берут как страховку или чтобы
+грубо нащупать корень перед запуском более быстрого метода.
+
+Если спрашивают, как сократить число итераций, ответ один и простой. Число шагов зависит только
+от длины стартового отрезка, поэтому надо заранее изолировать корень и взять отрезок покороче.
+Если сравнивают с методом секущих, то бисекция медленнее (секущих сходится почти со скоростью
+золотого сечения), зато секущих может улететь при неудачном старте и сильнее страдает от ошибок
+округления, когда соседние значения функции почти совпадают и в знаменателе получается почти ноль.""")
+
+_t(["ньютон", "ньютона", "ньютон vs бисекция", "метод ньютона теория"],
+"""МЕТОД НЬЮТОНА — идея, скорость и подводные камни.
+
+Ньютон это самый быстрый из классических методов поиска корня. В каждой точке мы заменяем
+функцию её касательной и берём за следующее приближение ту точку, где касательная пересекает
+ось. Геометрически мы как бы скользим по касательным и очень быстро сваливаемся в корень.
+Алгебраически это означает, что новая ошибка примерно пропорциональна квадрату старой, поэтому
+число верных цифр на каждом шаге примерно удваивается. Это и называют квадратичной сходимостью,
+и из-за неё Ньютон обычно сходится за считанные итерации.
+
+За скорость приходится платить требованиями. Во-первых, нужна производная, причём правильная,
+иначе метод поедет не туда. Во-вторых, нужно достаточно хорошее начальное приближение. Если
+стартовая точка далеко от корня или производная там близка к нулю, касательная почти
+горизонтальна, и следующее приближение может улететь очень далеко или метод начнёт прыгать
+туда-сюда без сходимости. Поэтому на практике Ньютона часто подстраховывают, начиная с грубой
+локализации корня бисекцией.
+
+Когда сравнивают Ньютона и бисекцию, главная мысль такая. Бисекция медленная, но железобетонно
+надёжная и не требует производной. Ньютон очень быстрый, но капризный к старту и к производной.
+Разумная тактика часто состоит в том, чтобы сперва изолировать корень надёжным методом, а потом
+дошлифовать его Ньютоном.""")
+
+_t(["модифицированный ньютон", "модиф ньютон", "когда модифицированный ньютон"],
+"""МОДИФИЦИРОВАННЫЙ НЬЮТОН — когда он удобнее и при чём тут ошибки производной.
+
+Главная идея в том, что производную (а в многомерном случае целую матрицу Якоби) мы считаем
+только один раз, в стартовой точке, и дальше используем это же значение на всех шагах. Обычный
+Ньютон пересчитывает наклон касательной в каждой точке, а здесь мы фиксируем наклон по первой
+касательной и просто двигаемся с ним. Это заметно дешевле по вычислениям, особенно когда сама
+производная или матрица Якоби считается тяжело.
+
+Расплата за дешевизну это скорость. Обычный Ньютон сходится квадратично, а модифицированный
+только линейно, поэтому итераций понадобится больше. По сути это частный случай простой итерации,
+и сходится он, пока множитель ошибки по модулю меньше единицы.
+
+Самое интересное в этом методе как раз связано с ошибками производной, и про это любят спрашивать.
+Поскольку мы используем фиксированное приближённое значение производной, метод всё равно сходится
+к настоящему корню, даже если это значение посчитано неточно. Неточность в производной меняет лишь
+скорость сходимости, но не саму точку, в которую мы приходим. В этом сила модифицированного метода,
+он устойчив к погрешности в производной. Но если приближение производной сильно завышено или
+занижено, множитель сходимости может стать по модулю больше единицы, и тогда метод разойдётся.
+Поэтому модифицированный Ньютон хорош, когда производная дорогая, меняется слабо, а старт неплохой.""")
+
+_t(["гаусса-зейделя", "зейделя", "ньютон vs зейдель", "липшиц", "константа липшица"],
+"""ГАУССА-ЗЕЙДЕЛЯ ПРОТИВ НЬЮТОНА и роль константы Липшица.
+
+Метод Гаусса-Зейделя для нелинейной системы это та же идея простой итерации, где систему
+приводят к виду икс равно фи от икс и крутят по кругу. Отличие одно, но важное. Как только мы
+пересчитали одну компоненту вектора, мы сразу подставляем её новое значение в вычисление
+следующих компонент, не дожидаясь конца итерации. За счёт того что в работе всегда самая свежая
+информация, хорошие поправки расходятся по системе быстрее, и обычно Зейдель сходится заметно
+шустрее обычной простой итерации.
+
+Сходимость тут линейная и держится на том, что отображение фи является сжимающим. Здесь и
+появляется константа Липшица. Она показывает, во сколько раз отображение в худшем случае
+растягивает расстояние между точками. Если эта константа меньше единицы, отображение сжимающее,
+расстояние между приближением и решением каждый шаг уменьшается, и итерации гарантированно
+сходятся к единственной неподвижной точке. Чем меньше константа, тем быстрее сходимость. Если же
+она больше единицы, ошибки наоборот раздуваются, и метод расходится.
+
+Когда сравнивают Зейделя с методом Ньютона для систем, мысль такая. Ньютон сходится квадратично,
+очень быстро, но требует матрицы Якоби, её обращения и хорошего старта, а ещё чувствителен к тому,
+насколько матрица хорошо обусловлена. Зейдель сходится медленнее и только при условии сжатия, зато
+не нуждается в производных, проще и сам подправляет накапливающиеся ошибки округления, пока
+выполняется условие Липшица.""")
+
+_t(["интерполяция", "глобальная локальная", "сплайн", "интерполяция теория"],
+"""ИНТЕРПОЛЯЦИЯ В ЦЕЛОМ — глобальная и локальная, и где сплайны.
+
+Интерполяция это восстановление функции по нескольким известным точкам так, чтобы кривая прошла
+ровно через них. Рядом стоят два соседних понятия. Экстраполяция это попытка предсказать значение
+за пределами интервала с узлами, и она гораздо менее надёжна. Аппроксимация это когда мы не
+обязаны попадать точно в точки, а лишь хотим пройти рядом, что особенно разумно для зашумлённых
+данных.
+
+Важно различать глобальную и локальную интерполяцию. При глобальной один многочлен строится сразу
+по всем узлам, и сдвиг любого узла меняет всю кривую. Таков многочлен Лагранжа. При локальной
+каждый кусок кривой зависит только от ближайших узлов, поэтому далёкие точки на него не влияют.
+Таковы ступенчатая и линейная интерполяция и сплайны. Локальные методы устойчивее и не страдают
+от диких колебаний.
+
+Сплайны это золотая середина. На каждом интервале строится свой невысокий многочлен, а в узлах их
+сшивают так, чтобы совпадали значение и производные, и кривая получается гладкой без изломов. У
+кубического сплайна сшивают значение, первую и вторую производные, поэтому глаз вообще не замечает
+стыков. По сравнению с одним многочленом высокой степени сплайн не даёт жутких осцилляций у краёв
+(того самого феномена Рунге), а по сравнению с ломаной он гладкий. Поэтому сплайны и стали
+стандартом для плавных кривых.""")
+
+_t(["лагранж", "степень полинома", "интерполяция точность", "лагранжа теория"],
+"""ИНТЕРПОЛЯЦИЯ ЛАГРАНЖА — почему она точная в узлах и чем опасна высокая степень.
+
+Многочлен Лагранжа это один-единственный многочлен, который проходит точно через все заданные
+узлы. Собирается он из специальных базисных многочленов, каждый из которых хитро устроен. Базис с
+номером i равен единице в своём узле и равен нулю во всех остальных узлах. Поэтому когда мы
+подставляем какой-то узел, вся длинная сумма схлопывается ровно до значения функции в этом узле,
+и попадание в узлы получается точным по построению. По n точкам строится многочлен степени не
+выше n минус один, и такой многочлен через данные точки единственный.
+
+Самое важное и любимое на экзамене это связь степени и точности. Кажется, что чем больше узлов и
+выше степень, тем точнее, но это обманчиво. Для равномерно расставленных узлов высокой степени
+возникает феномен Рунге, когда многочлен начинает дико колебаться у краёв отрезка, и точность не
+растёт, а падает.
+
+Отдельно про зашумлённые данные. Интерполяция обязана пройти точно через каждую точку, поэтому
+она честно протаскивает кривую через весь шум, и результат скачет. Если данные с погрешностью,
+обычно лучше не интерполировать, а аппроксимировать методом наименьших квадратов или брать
+локальные методы вроде сплайнов, которые не так чувствительны к отдельным выбросам.""")
+
+_t(["штрассен", "сложность штрассена", "штрассена теория"],
+"""АЛГОРИТМ ШТРАССЕНА — как он экономит умножения и при чём тут память.
+
+Если перемножать матрицы по определению, то для матрицы размера n на n нужно порядка n в кубе
+операций умножения, и это довольно дорого. Штрассен заметил, что произведение блочных матриц
+два на два можно посчитать не за восемь умножений подматриц, а за семь, если хитро скомбинировать
+суммы и разности блоков. Одно умножение мы выкупаем ценой нескольких лишних сложений. Дальше тот
+же трюк применяется рекурсивно, пока блоки не станут совсем маленькими.
+
+Откуда берётся ускорение, видно из рекуррентного соотношения. Задача размера n сводится к семи
+задачам половинного размера плюс работа на сложения порядка n в квадрате. Решение такого
+соотношения даёт сложность примерно n в степени 2.81 вместо n в кубе. Главное тут именно семь, а
+не восемь подзадач на каждом уровне, а лишние сложения дают лишь квадратичный вклад и порядок не
+портят.
+
+Про память и архитектуру тоже любят спрашивать, и вот суть. Реальная скорость зависит не только от
+числа операций, но и от того, как данные ложатся в кэш процессора. Наивное умножение обходит вторую
+матрицу по столбцам, прыгая по памяти, и часто промахивается мимо кэша, поэтому порядок вложенных
+циклов влияет на время в разы. У Штрассена много промежуточных матриц, а значит больше обращений к
+памяти и накладных расходов, поэтому выигрыш заметен только на больших матрицах, а на маленьких
+наивный способ даже быстрее. Применяют Штрассена и его потомков там, где надо умножать действительно
+большие плотные матрицы.""")
+
+_t(["сложность", "big-o", "нотация", "профилирование"],
+"""СЛОЖНОСТЬ АЛГОРИТМОВ И НОТАЦИЯ BIG-O.
+
+Нотация big-O это способ грубо описать, как растёт время работы или расход памяти с увеличением
+размера входных данных. Нас интересует не точное число операций, а характер роста, причём с
+точностью до постоянного множителя и без учёта мелких слагаемых. Запись O от n в кубе означает,
+что при удвоении размера время вырастет примерно в восемь раз, а O от n логарифм n растёт почти
+линейно и потому считается очень хорошим.
+
+Полезно держать в голове несколько ориентиров из курса. Наивное умножение матриц это n в кубе,
+Штрассен примерно n в степени 2.81, обычное дискретное преобразование Фурье n в квадрате, а
+быстрое преобразование Фурье всего лишь n логарифм n. Для методов поиска корня считают не
+арифметику, а число итераций. Бисекция тратит порядка логарифма от длины отрезка, делённой на
+точность, а Ньютон сходится квадратично, то есть удваивает число верных знаков за шаг.
+
+Если спрашивают про профилирование в Python, достаточно назвать инструменты. Модули time и timeit
+меряют время выполнения, cProfile показывает, в каких функциях программа проводит больше всего
+времени, а в ноутбуке Jupyter удобны волшебные команды процент timeit для быстрых замеров,
+процент prun для разбивки по функциям и процент lprun для построчного профиля.""")
+
+_t(["степенной метод", "сдвиг", "зазор собственных значений", "скорость сходимости степенного"],
+"""СТЕПЕННОЙ МЕТОД — что он находит, как быстро и зачем сдвиги.
+
+Степенной метод находит наибольшее по модулю собственное значение матрицы и соответствующий ему
+собственный вектор, причём без всякого характеристического многочлена. Берём произвольный вектор и
+многократно умножаем его на матрицу, каждый раз нормируя. Чтобы понять, почему направление
+сходится к главному собственному вектору, разложим стартовый вектор по собственным векторам. После
+многих умножений каждое слагаемое умножается на свою степень собственного значения, и слагаемое с
+самым большим по модулю значением растёт быстрее всех остальных. Через несколько шагов оно
+перевешивает, и нормированный вектор выстраивается вдоль главного направления. Само значение
+удобно вытаскивать через отношение Рэлея.
+
+Скорость сходимости здесь линейная, и определяется она зазором между собственными значениями.
+Точнее, скоростью отношения второго по величине значения к первому. Если первое заметно больше
+второго, метод сходится быстро, а если они почти равны по модулю, сходимость становится мучительно
+медленной. Поэтому зазор так важен, и про него часто спрашивают.
+
+Сдвиги это способ управлять этим зазором и нацеливанием. Применяя метод не к самой матрице, а к
+матрице минус мю на единичную, мы сдвигаем все собственные значения на мю, оставляя собственные
+векторы прежними. Подбирая мю, можно сделать доминирующим нужное значение или увеличить разрыв и
+тем ускорить сходимость. Например, сдвинув на уже найденное наибольшее значение, можно поймать
+наименьшее. И не забывай нормировку на каждом шаге, она удерживает числа от переполнения и не даёт
+ошибкам округления раздуваться при медленной сходимости.""")
+
+_t(["шур", "шура", "нормальная матрица", "почему шур диагональный", "нормальность теория"],
+"""РАЗЛОЖЕНИЕ ШУРА И НОРМАЛЬНЫЕ МАТРИЦЫ.
+
+Теорема Шура говорит замечательную вещь. Любую квадратную матрицу можно записать как U умножить на
+T умножить на U сопряжённое транспонированное, где U унитарная (а для вещественных матриц просто
+ортогональная), а T верхнетреугольная. При этом на диагонали треугольной T стоят собственные
+значения исходной матрицы. На практике это разложение получают тем же QR-алгоритмом, только
+попутно накапливают произведение всех ортогональных множителей, и оно складывается в матрицу U.
+
+Почему для нормальных матриц T получается не просто треугольной, а диагональной, это и есть
+ключевой вопрос. Матрица называется нормальной, если она перестановочна со своим сопряжённым
+транспонированным, то есть A на A транспонированное равно A транспонированное на A. Оказывается,
+свойство нормальности сохраняется при унитарном подобии, а нормальная треугольная матрица обязана
+быть диагональной. Значит для нормальной матрицы T выходит диагональной, и это в точности означает,
+что у такой матрицы есть полный ортонормированный набор собственных векторов, то есть она унитарно
+диагонализуема. На экзамене проверить нормальность проще всего, сравнив A на A транспонированное с
+A транспонированное на A поэлементно.
+
+Если просят сравнить Шура с QR-разложением, держи в голове разницу. QR-разложение это однократная
+факторизация матрицы на ортогональную и треугольную части, стоит порядка n в кубе и само по себе
+собственных значений не даёт. Разложение Шура это уже результат многих QR-итераций, оно сходится к
+треугольной форме и выдаёт спектр, но обходится дороже из-за итераций. Зато оно очень устойчиво
+численно, потому что использует только ортогональные преобразования, которые не раздувают ошибки.
+Применяют Шура для вычисления собственных значений, матричных функций, решения матричных уравнений
+и в анализе устойчивости.""")
+
+_t(["qr", "qr разложение теория", "собственные значения теория", "qr алгоритм теория"],
+"""QR-РАЗЛОЖЕНИЕ И QR-АЛГОРИТМ — зачем они и как связаны.
+
+QR-разложение раскладывает матрицу на произведение ортогональной матрицы Q и верхнетреугольной R.
+Получают его ортогонализацией столбцов методом Грама-Шмидта. Мы идём по столбцам слева направо и из
+каждого вычитаем его проекции на уже найденные ортонормированные направления, а остаток нормируем.
+В итоге Q хранит ортонормированный базис, натянутый на столбцы исходной матрицы, а R показывает, как
+исходные столбцы выражаются через этот базис. Поскольку столбцы Q взаимно перпендикулярны и единичны,
+Q транспонированное на Q даёт единичную матрицу, а проверка QR равно A подтверждает корректность.
+
+QR-алгоритм это уже способ найти собственные значения, и он построен поверх QR-разложения. Идея
+неожиданно простая. Мы раскладываем матрицу на Q и R, а потом перемножаем их в обратном порядке,
+получая R на Q, и повторяем. Каждая такая операция это ортогональное подобие, поэтому собственные
+значения не меняются, а сама матрица постепенно становится почти треугольной, и на её диагонали
+проступают собственные значения. Скорость сходимости зависит от отношений соседних собственных
+значений, а чтобы её резко ускорить, на практике добавляют сдвиги. Именно QR-алгоритм стоит внутри
+библиотечных функций поиска спектра, а для эффективности матрицу сначала приводят к почти
+треугольной верхне-гессенберговой форме.""")
+
+_t(["центральная разность", "численное дифференцирование", "точность разности", "разность теория"],
+"""ЧИСЛЕННОЕ ДИФФЕРЕНЦИРОВАНИЕ — конечные разности и их точность.
+
+Когда производную нельзя или не хочется брать аналитически, её приближают по соседним значениям
+функции. Простейший вариант это прямая разность, когда мы берём значение в точке и чуть правее и
+делим разность на шаг. Она грубовата, её ошибка падает лишь линейно с уменьшением шага. Куда точнее
+центральная разность, где мы используем точки слева и справа от нашей и делим их разность на двойной
+шаг. У неё ошибка падает уже как квадрат шага, потому что несимметричные погрешности слева и справа
+взаимно гасятся. Вторую производную тоже приближают симметрично, через значение слева, в точке и
+справа, и её ошибка тоже ведёт себя как квадрат шага.
+
+Самое тонкое место это выбор шага, и про него любят спрашивать. Здесь спорят две ошибки. С одной
+стороны ошибка усечения, она тем больше, чем крупнее шаг, ведь мы заменяем гладкую функцию грубой
+разностью. С другой стороны ошибка округления, она наоборот растёт, когда шаг слишком мал, потому
+что мы вычитаем почти одинаковые числа и теряем значащие цифры, а потом ещё делим на крошечный шаг.
+Поэтому существует оптимальный шаг где-то посередине, и делать его сколь угодно малым бессмысленно.
+
+Если сравнивают центральную разность с прямой, вывод такой. Центральная точнее при том же порядке
+затрат, ведь её ошибка квадратичная против линейной у прямой, поэтому её и предпочитают, когда можно
+взять точки по обе стороны от интересующей нас точки.""")
+
+_t(["эйлер", "методы оду", "порядок точности", "устойчивость оду методы"],
+"""МЕТОДЫ РЕШЕНИЯ ОДУ — порядок точности и устойчивость по-человечески.
+
+Все эти методы решают одну задачу. Дано уравнение на производную и начальное значение, и надо
+по шагам построить решение вперёд по времени. Самый простой это метод Эйлера, который делает шаг по
+касательной, зная наклон в текущей точке. Он наглядный, но грубый, его глобальная ошибка падает лишь
+линейно с уменьшением шага, поэтому говорят, что он первого порядка. Чтобы стало точнее, наклон
+оценивают аккуратнее. Метод Хойна усредняет наклоны в начале и в предсказанной точке и даёт второй
+порядок, а Рунге-Кутта четвёртого порядка пробует целых четыре наклона внутри шага и оказывается
+очень точным. Многошаговые методы Адамса экономят вычисления, переиспользуя уже посчитанные значения
+из предыдущих точек.
+
+Полезно различать локальную и глобальную ошибку. Локальная это ошибка за один шаг, а глобальная это
+то, что накапливается на всём отрезке. Обычно глобальная ошибка на один порядок шага хуже локальной,
+потому что шагов примерно обратно пропорционально шагу. Отсюда и удобное правило, что у метода
+порядка p уменьшение шага вдвое уменьшает итоговую ошибку примерно в два в степени p раз.
+
+Про устойчивость мысль такая. Метод устойчив, если небольшие ошибки со временем затухают, а не
+раздуваются. У явных методов вроде Эйлера есть ограничение на размер шага, и при слишком крупном шаге
+на жёстких задачах решение разваливается, накопленные ошибки начинают расти лавинообразно. Неявные
+методы устойчивее и терпят большие шаги. Поэтому фазовый портрет так полезен, он наглядно показывает,
+сохраняет ли численное решение правильное качественное поведение или метод его искажает.""")
+
+_t(["фазовый портрет", "адаптивный шаг", "устойчивость оду"],
+"""ФАЗОВЫЕ ПОРТРЕТЫ, АДАПТИВНЫЙ ШАГ И УСТОЙЧИВОСТЬ.
+
+Фазовый портрет это картинка траекторий системы в координатах самих переменных, без явного времени
+на осях. Для системы из двух уравнений мы просто рисуем одну переменную против другой. Такая картинка
+очень помогает понять качественное поведение, не решая систему в формулах. На ней видно положения
+равновесия, замкнутые циклы, притягивает система к равновесию или разбегается. Поэтому фазовые
+портреты любят в анализе динамических систем.
+
+Здесь же всплывает важная тема искажений. Численный метод вносит свои ошибки, и они могут испортить
+портрет. Классический пример это гармонический осциллятор, у которого настоящая траектория это
+замкнутая окружность. Явный метод Эйлера потихоньку добавляет энергию, и вместо окружности рисуется
+раскручивающаяся спираль. Это наглядный признак того, что схема неустойчива на такой задаче.
+
+Адаптивный шаг это идея менять размер шага по ходу решения. Там, где решение меняется бурно, шаг
+делают мельче, а на спокойных участках крупнее. Это позволяет держать заданную точность меньшими
+усилиями и помогает проскочить трудные жёсткие места. Но это не панацея. Слишком мелкий шаг не только
+замедляет счёт, но и увеличивает число операций, а значит и накопление ошибок округления. Так что всё
+упирается в баланс между ошибкой метода, устойчивостью и ошибками округления.""")
+
+_t(["дпф", "бпф", "фурье", "почему бпф быстрее", "шум в спектре"],
+"""ДИСКРЕТНОЕ И БЫСТРОЕ ПРЕОБРАЗОВАНИЕ ФУРЬЕ.
+
+Дискретное преобразование Фурье раскладывает сигнал на гармоники, то есть переводит его из
+временного представления в частотное. Чтобы понять, как оно выделяет частоты, представь, что мы
+домножаем сигнал на эталонное колебание определённой частоты и складываем. Если в сигнале такая
+частота есть, произведение в среднем не нулевое и сумма большая, а вклады всех остальных частот при
+суммировании взаимно гасятся, потому что эталонные колебания взаимно ортогональны. В итоге модуль
+каждого коэффициента показывает, насколько сильно представлена соответствующая частота, а его фаза
+её сдвиг.
+
+Про шум обязательно спросят. Шум добавляет фон по всему спектру и приподнимает общий уровень, из-за
+чего слабые настоящие компоненты могут утонуть в этом фоне. Чтобы уменьшить его влияние, берут
+сигнал подлиннее, ведь чем больше отсчётов, тем лучше разрешение по частоте и тем чище проступают
+пики, а ещё усредняют спектры нескольких записей или применяют оконные функции и фильтрацию. И
+помни, что разрешение по частоте определяется частотой дискретизации, делённой на число отсчётов,
+поэтому чтобы различить две близкие частоты, нужно больше отсчётов.
+
+Быстрое преобразование Фурье считает ровно то же самое, но несравнимо быстрее. Прямое вычисление по
+определению это двойная сумма и стоит порядка n в квадрате. Алгоритм Кули-Тьюки делит сигнал на
+отсчёты с чётными и нечётными номерами и сводит задачу размера n к двум задачам половинного размера.
+За счёт периодичности промежуточных сумм одна пара даёт сразу два выходных значения, это так
+называемая бабочка. В результате сложность падает до n логарифм n, как у сортировки слиянием, и
+именно поэтому спектральный анализ стал практичным.""")
+
+_t(["ieee754", "округление", "ошибки округления", "плавающая точка", "кахан теория"],
+"""ЧИСЛА С ПЛАВАЮЩЕЙ ТОЧКОЙ И ОШИБКИ ОКРУГЛЕНИЯ.
+
+Компьютер хранит вещественные числа в стандарте IEEE 754 с конечной точностью, у типа double это
+примерно пятнадцать-шестнадцать значащих десятичных цифр. Беда в том, что большинство чисел в
+двоичной системе не представимы точно, даже безобидная одна десятая записывается бесконечной
+двоичной дробью, и компьютер хранит лишь её ближайшее приближение. Эта неустранимая погрешность
+называется ошибкой представления, а её масштаб задаёт машинный эпсилон порядка двух на десять в
+минус шестнадцатой.
+
+Дальше эти крошечные погрешности живут своей жизнью. В длинных суммах и в итерационных методах они
+накапливаются. Особенно коварна потеря значимости при вычитании двух близких чисел, когда старшие
+одинаковые цифры сокращаются и в результате остаются почти одни шумовые младшие разряды. Из-за
+конечной точности арифметика ещё и перестаёт быть ассоциативной, то есть результат сложения может
+немного зависеть от порядка слагаемых.
+
+Когда спрашивают, как с этим бороться, называй практические приёмы. Складывать лучше числа близкого
+порядка, избегать вычитания почти равных величин, пользоваться устойчивыми формулами. Для длинных
+сумм существует суммирование по Кахану, которое заводит дополнительную компенсирующую переменную и
+аккуратно возвращает в сумму то, что иначе потерялось бы при округлении, и за счёт этого сумма
+получается заметно точнее обычной.""")
+
+_t(["верные цифры", "значащие цифры", "погрешность", "абсолютная относительная погрешность"],
+"""ПОГРЕШНОСТИ И ВЕРНЫЕ ЦИФРЫ.
+
+Когда мы заменяем точное число приближённым, возникает погрешность, и её меряют двумя способами.
+Абсолютная погрешность это просто модуль разности между точным и приближённым значением, она в тех
+же единицах, что и само число. Относительная погрешность это абсолютная, делённая на само значение,
+и она безразмерная, её удобно выражать в процентах. Относительная честнее отражает качество, ведь
+ошибка в один метр это много при измерении комнаты и пустяк при измерении расстояния между городами.
+
+Значащие цифры это все цифры числа начиная с первой ненулевой. Когда мы округляем приближённое
+число, мы как раз оставляем столько цифр, сколько оправдано его точностью, лишние цифры создавали бы
+ложное впечатление, будто мы знаем больше, чем на самом деле.
+
+Отдельно различают верные цифры в строгом и в широком смысле, и это любят спрашивать. Цифра считается
+верной в строгом, то есть узком, смысле, если абсолютная погрешность числа не превосходит половины
+единицы того разряда, где стоит эта цифра. Цифра верна в широком смысле, если погрешность не
+превосходит целой единицы этого разряда. То есть узкий критерий строже широкого ровно вдвое, и одна
+и та же цифра может быть верной в широком смысле, но уже не дотягивать до верной в строгом.""")
+
+
+
+# ----- ОШИБКИ (отдельная шпаргалка под теорвопросы про погрешности и устойчивость) -----
+
+_t(["ошибки округления", "потеря значимости", "накопление ошибок", "ошибки представления"],
+"""ОШИБКИ ОКРУГЛЕНИЯ — общая картина для любого билета.
+
+Компьютер хранит вещественные числа с конечной точностью, у типа double это около пятнадцати-
+шестнадцати значащих цифр. Отсюда сразу три источника бед, которые всплывают почти в каждом методе.
+Первый это ошибка представления, ведь большинство чисел в двоичной системе не записываются точно,
+даже одна десятая хранится лишь приближённо, и каждое число уже приходит с крошечной погрешностью.
+Второй это потеря значимости, она возникает при вычитании двух близких чисел, когда старшие
+одинаковые цифры сокращаются и остаются в основном шумовые младшие разряды. Третий это накопление,
+когда в длинных суммах и в итерационных методах мелкие погрешности складываются и постепенно
+вырастают.
+
+Из-за конечной точности арифметика ещё и перестаёт быть строго ассоциативной, то есть результат
+может слегка зависеть от порядка операций. Поэтому два математически одинаковых выражения на
+компьютере могут дать чуть разные ответы.
+
+Бороться с этим помогает несколько привычек. Складывать лучше числа близкого порядка, избегать
+вычитания почти равных величин, пользоваться устойчивыми формулами, а для длинных сумм применять
+суммирование по Кахану, которое заводит компенсирующую переменную и аккуратно возвращает в сумму
+то, что иначе потерялось бы при округлении.""")
+
+_t(["ошибка ньютона", "ньютон округление", "округление ньютон", "ошибка округления ньютон"],
+"""ОШИБКА ОКРУГЛЕНИЯ И МЕТОД НЬЮТОНА.
+
+Шаг Ньютона это икс минус эф делить на эф штрих, а в двумерном случае это деление на определитель
+матрицы Якоби. У этой формулы два слабых места. Первое возникает, когда производная близка к нулю,
+тогда мы делим на крошечное число и любая мелкая ошибка округления в значении функции или
+производной многократно усиливается, шаг становится грубым, и метод может прыгнуть далеко в сторону
+или застрять. Второе слабое место это сам корень, ведь возле него функция стремится к нулю и
+вычисляется как разность почти равных величин, отсюда потеря значимости, и именно там, где нужнее
+всего точность, значение функции считается хуже всего.
+
+В итоге Ньютон очень быстро подходит к корню, но у самого корня упирается в уровень ошибок
+округления и точнее этого пола уже не становится. А если рядом ещё и производная мала, этот пол
+оказывается выше обычного, и квадратичная сходимость деградирует в медленную линейную.
+
+Самый яркий пример это кратный корень, например функция икс минус один в квадрате. В корне единица
+производная равна нулю, поэтому Ньютон и теряет скорость, и делит у корня на почти ноль. Такой же
+эффект даёт система, где кривые касаются в решении, как окружность икс квадрат плюс игрек квадрат
+равно два и гипербола икс игрек равно один, которые касаются в точке один-один и дают вырожденный
+Якоби, отчего решение получается с дрожащими последними знаками.""")
+
+_t(["ошибка степенного метода", "степенной округление", "степенной ошибки", "ошибки степенного"],
+"""ОШИБКА ОКРУГЛЕНИЯ И СТЕПЕННОЙ МЕТОД.
+
+Степенной метод многократно умножает вектор на матрицу, и тут есть две вещи про ошибки. Во-первых,
+без нормировки длина вектора каждый шаг растёт или падает в разы и быстро упирается в переполнение
+или в исчезновение в ноль, поэтому нормировка на каждом шаге это не только математика, но и защита
+от ошибок представления чисел с плавающей точкой. Во-вторых, скорость сходимости определяется
+отношением второго собственного значения к первому, и когда они близки по модулю, сходимость очень
+медленная, итераций нужно много, а значит мелкие ошибки округления успевают заметно накопиться, и
+последние знаки собственного значения становятся ненадёжными.
+
+Стандарт хранения чисел тоже вносит свою лепту. Каждый элемент матрицы и вектора уже представлен
+приближённо, и эти крошечные погрешности на каждом умножении и сложении немного подрастают.
+
+Минимизировать влияние помогает несколько приёмов. Обязательно нормировать вектор на каждом шаге,
+считать само собственное значение через устойчивое отношение Рэлея, а не через деление компонент,
+не задавать чрезмерно жёсткую точность остановки, которой всё равно не достичь из-за округления, и
+по возможности работать с симметричными или хорошо обусловленными матрицами, где зазор между
+собственными значениями побольше.""")
+
+_t(["ошибка оду", "ошибка эйлера", "локальная глобальная ошибка", "ошибки усечения", "ошибки оду"],
+"""ОШИБКИ В ЧИСЛЕННОМ РЕШЕНИИ ОДУ.
+
+Здесь различают два совершенно разных вида ошибок. Ошибка усечения это ошибка самого метода, она
+появляется оттого, что мы заменяем точное решение приближённой формулой, и зависит от порядка метода
+и от шага. Ошибка округления это уже про арифметику с плавающей точкой и появляется из-за конечной
+точности чисел. Важно ещё отличать локальную ошибку от глобальной. Локальная это промах за один шаг,
+а глобальная это то, что накопилось на всём отрезке. Обычно глобальная ошибка на один порядок шага
+хуже локальной, потому что число шагов примерно обратно пропорционально шагу. Отсюда удобное правило,
+что у метода порядка пэ уменьшение шага вдвое уменьшает итоговую ошибку примерно в два в степени пэ раз.
+
+Очень поучительно, что делать шаг сколь угодно мелким нельзя. Пока шаг крупный, главная беда это
+ошибка усечения, и уменьшение шага помогает. Но когда шаг становится совсем маленьким, начинает
+расти ошибка округления, ведь мы делаем очень много шагов и на каждом немного округляем, а ещё
+складываем большое значение с очень маленькой добавкой и теряем младшие разряды. Поэтому существует
+оптимальный шаг где-то посередине.
+
+Отдельно про устойчивость. У явных методов вроде Эйлера есть ограничение на размер шага, и на
+жёстких задачах при слишком крупном шаге накопленные ошибки начинают расти лавинообразно, решение
+разваливается. Неявные методы устойчивее и терпят большие шаги. Фазовый портрет хорошо показывает,
+сохраняет ли численное решение правильное качественное поведение или метод его искажает из-за
+накопления ошибок.""")
+
+_t(["ошибка зейделя", "зейдель округление", "устойчивость к округлению", "ошибки итерационных"],
+"""УСТОЙЧИВОСТЬ ИТЕРАЦИОННЫХ МЕТОДОВ К ОШИБКАМ ОКРУГЛЕНИЯ.
+
+У итерационных методов вроде простой итерации и Гаусса-Зейделя есть приятное свойство, они сами
+подправляют ошибки. Пока отображение является сжимающим, то есть константа Липшица меньше единицы,
+расстояние до решения каждый шаг уменьшается. А значит и любая случайная ошибка округления, которая
+чуть сдвинула текущее приближение, на следующих шагах тоже затухает, ведь метод просто продолжает
+притягиваться к неподвижной точке из новой точки. Поэтому такие методы очень устойчивы к округлению,
+лишняя погрешность не накапливается, а гасится.
+
+Если же константа Липшица больше или равна единице, картина обратная, ошибки не затухают, а
+раздуваются, и метод расходится. То есть устойчивость к округлению напрямую завязана на то же
+условие сжатия, что и сама сходимость.
+
+Полезно сравнить с прямыми методами. В них нет самокоррекции, и ошибки округления, сделанные по
+ходу вычислений, остаются в ответе и могут накапливаться, особенно на плохо обусловленных задачах.
+Поэтому для больших или плохо обусловленных систем итерационные методы часто оказываются надёжнее
+по части ошибок округления, хотя и сходятся медленнее.""")
+
+_t(["ошибка штрассена", "штрассен округление", "штрассен ieee754", "ошибки штрассена"],
+"""ОШИБКИ ПРЕДСТАВЛЕНИЯ И АЛГОРИТМ ШТРАССЕНА.
+
+Каждое число в матрице хранится в стандарте IEEE 754 лишь приближённо, и это исходная ошибка
+представления. Дальше всё зависит от того, сколько арифметики мы над этими числами совершаем.
+Наивное умножение для каждого элемента считает честную сумму произведений, и ошибки там накапливаются
+довольно предсказуемо. Штрассен ради экономии умножений делает много дополнительных сложений и, что
+важнее, вычитаний промежуточных блоков. А вычитание близких величин это потеря значимости, поэтому у
+Штрассена больше возможностей для усиления ошибок округления.
+
+Из этого следует практический вывод. Штрассен асимптотически быстрее, но численно менее устойчив,
+чем наивный способ. На хорошо обусловленных данных разница незаметна, но на плохо обусловленных
+матрицах, где элементы сильно различаются по величине, лишние сложения и вычитания промежуточных
+результатов могут заметно ухудшить точность итога.
+
+Поэтому Штрассена и его потомков применяют там, где важна скорость на действительно больших
+матрицах и где данные не слишком капризны, а когда нужна максимальная точность, часто остаются на
+обычном умножении или комбинируют подходы.""")
+
+_t(["ошибка интерполяции", "переполнение интерполяция", "overflow интерполяция", "ошибки интерполяции"],
+"""ОШИБКИ И ПЕРЕПОЛНЕНИЕ В ИНТЕРПОЛЯЦИИ.
+
+В интерполяции ошибки приходят с нескольких сторон. Если данные зашумлены, интерполяция честно
+протаскивает кривую через каждую шумную точку, и шум переносится в результат, поэтому для
+зашумлённых данных разумнее аппроксимация, а не точная интерполяция. Если же узлов много и мы строим
+один многочлен высокой степени, возникает феномен Рунге с дикими колебаниями у краёв, и формальная
+точность не растёт, а падает.
+
+Отдельная опасность это переполнение. У многочлена высокой степени в промежуточных вычислениях
+появляются очень большие произведения и разности, и при больших значениях аргумента или большом
+числе узлов эти величины могут вылезти за диапазон представимых чисел и превратиться в бесконечность,
+а заодно по дороге теряется точность из-за вычитания близких больших чисел. Грубо говоря, чем выше
+степень, тем сильнее раздуваются промежуточные числа и тем выше риск и переполнения, и потери
+значимости.
+
+Лекарство простое по сути. Брать локальные методы вроде линейной интерполяции и сплайнов, где
+каждый кусок зависит лишь от соседних узлов и промежуточные величины остаются скромными, либо
+снижать степень многочлена. Тогда и переполнение не грозит, и колебаний нет, и устойчивость к
+ошибкам округления заметно выше.""")
+
+_t(["ошибка дифференцирования", "ошибка разности", "оптимальный шаг", "ошибки дифференцирования"],
+"""ОШИБКИ ЧИСЛЕННОГО ДИФФЕРЕНЦИРОВАНИЯ.
+
+Когда производную приближают конечными разностями, спорят две ошибки. Ошибка усечения это ошибка
+самой формулы, она тем больше, чем крупнее шаг, потому что мы заменяем гладкую производную грубой
+разностью. У прямой разности эта ошибка падает линейно с уменьшением шага, у центральной разности
+быстрее, как квадрат шага, потому что несимметричные погрешности слева и справа взаимно гасятся.
+
+Но уменьшать шаг бесконечно нельзя, и это главная мысль про ошибки здесь. При очень маленьком шаге
+в числителе мы вычитаем почти одинаковые значения функции, происходит потеря значимости, а потом ещё
+делим на крошечный шаг, что усиливает уже накопившуюся ошибку округления. Поэтому ошибка округления
+наоборот растёт, когда шаг слишком мал.
+
+Из-за этого существует оптимальный шаг где-то посередине, при котором сумма ошибки усечения и ошибки
+округления минимальна. Делать шаг сколь угодно малым в надежде на точность бессмысленно, после
+некоторого предела точность не улучшается, а ухудшается. Центральную разность при этом предпочитают
+прямой, потому что при том же порядке затрат её ошибка усечения квадратичная, а не линейная.""")
+
+_t(["устойчивость", "распространение ошибки", "стабильность", "обусловленность"],
+"""УСТОЙЧИВОСТЬ И РАСПРОСТРАНЕНИЕ ОШИБКИ.
+
+Устойчивость это про то, что происходит с маленькими ошибками по ходу вычислений. Алгоритм называют
+устойчивым, если внесённые погрешности, будь то ошибки округления или неточность входных данных, со
+временем остаются ограниченными или затухают, а не раздуваются. Если же на каждом шаге ошибка
+умножается на число больше единицы, она нарастает лавинообразно, и метод неустойчив, его результат
+быстро теряет смысл. Удобно держать в голове множитель распространения ошибки. Когда он по модулю
+меньше единицы, ошибка гаснет, когда больше единицы, ошибка растёт.
+
+Важно отличать устойчивость алгоритма от обусловленности самой задачи. Обусловленность это свойство
+задачи, она показывает, насколько сильно ответ меняется при малом изменении входных данных. Если
+задача плохо обусловлена, то даже идеально устойчивый алгоритм не спасёт, ответ будет чувствителен к
+любым погрешностям. А неустойчивый алгоритм может испортить ответ даже у хорошо обусловленной задачи.
+
+В численных методах эта идея встречается повсюду. У итерационных методов устойчивость это условие
+сжатия с константой Липшица меньше единицы. У методов решения ОДУ устойчивость ограничивает размер
+шага. У матричных вычислений устойчивость обеспечивают ортогональными преобразованиями, которые не
+раздувают нормы и потому не усиливают ошибки.""")
+
+_t(["минимизация ошибок", "как уменьшить ошибки округления", "уменьшить ошибки", "кахан"],
+"""КАК УМЕНЬШИТЬ ВЛИЯНИЕ ОШИБОК ОКРУГЛЕНИЯ.
+
+Полный набор приёмов, который пригодится почти в любом билете, где спрашивают, как минимизировать
+ошибки. Старайся не вычитать почти равные числа, потому что именно там происходит потеря значимости,
+и по возможности переписывай формулу так, чтобы опасного вычитания не было. Складывай числа близкого
+порядка, а не подмешивай к огромной сумме крошечные слагаемые, которые просто теряются. Для длинных
+сумм используй суммирование по Кахану, оно заводит дополнительную компенсирующую переменную и на
+каждом шаге аккуратно возвращает в сумму ту часть, что иначе была бы потеряна при округлении, за счёт
+чего сумма получается заметно точнее обычной.
+
+Помогает и выбор устойчивых формул и алгоритмов. В линейной алгебре это ортогональные преобразования,
+которые не раздувают ошибки, в интерполяции это локальные методы и невысокие степени, в численном
+дифференцировании это разумный, не слишком маленький шаг. Полезно нормировать величины, чтобы они не
+уходили в переполнение или в исчезающе малые значения.
+
+И наконец, иногда самый простой выход это увеличить точность вычислений, перейдя к более широкому
+типу чисел, либо не требовать от метода точности тоньше, чем позволяет машинная арифметика, ведь
+ниже уровня ошибок округления улучшения всё равно не будет.""")
+
+
+
+# ====================================================================== ДОСТУП
+# Синонимы -> канонические ключи (чтобы искать как удобно по формулировке билета)
+ALIASES = {
+    "ньютон касательных": "ньютон", "касательная": "ньютон",
+    "метод ньютона": "ньютон", "метод бисекции": "бисекция",
+    "метод эйлера": "эйлер", "метод хорд": "секущих",
+    "predictor": "предиктор-корректор", "heun": "хойн",
+    "qr": "qr разложение", "spline": "кубический сплайн",
+    "lagrange": "лагранж", "strassen": "штрассен",
+    "power": "степенной метод", "jacobi": "вращения якоби",
+    "schur": "шур", "dft": "дпф", "euler": "эйлер",
+}
+
+
+def _resolve(name, table):
+    """Находит ключ: точное совпадение -> алиас -> подстрока."""
+    key = name.strip().lower()
+    if key in table:
+        return key
+    if key in ALIASES and ALIASES[key] in table:
+        return ALIASES[key]
+    hits = [k for k in table if key in k]
+    if len(hits) == 1:
+        return hits[0]
+    if len(hits) > 1:
+        print("Уточни, есть несколько вариантов:", ", ".join(sorted(hits)))
+        return None
+    return None
+
+
+def _assemble(key):
+    """Собирает полный код метода (импорты + нужные помощники + сама реализация)."""
+    e = PRACTICE[key]
+    parts = [_IMPORTS]
+    if "pi" in e["bases"]:
+        parts.append(_PI)
+    if "matrix" in e["bases"]:
+        parts.append(_BASE_MATRIX)
+    if "qr" in e["bases"]:
+        parts.append(_QR_FUNC)
+    if "ode" in e["bases"]:
+        parts.append(_BASE_ODE)
+    parts.append(e["code"])
+    return "\n".join(parts)
+
+
+def code(name):
+    """Молча кладёт готовый код метода в буфер обмена (вообще без вывода)."""
+    key = _resolve(name, PRACTICE)
+    if key is None:
+        print(f"Не нашёл '{name}'. ls() — имена.")
+        return
+    full = _assemble(key)
+    if not _copy(full):        # только если буфер недоступен — показать код для ручного копирования
+        print(full)
+
+
+def show(name):
+    """Если нужно ПОСМОТРЕТЬ код (а не копировать) — печатает его."""
+    key = _resolve(name, PRACTICE)
+    if key is None:
+        print(f"Не нашёл '{name}'. ls() — имена.")
+        return
+    print(_assemble(key))
+
+
+def theory(name):
+    """Молча кладёт ответ на теоретический вопрос в буфер обмена (вообще без вывода)."""
+    key = _resolve(name, THEORY)
+    if key is None:
+        print(f"Не нашёл теорию '{name}'. ls() — имена.")
+        return
+    text = THEORY[key]
+    if not _copy(text):        # только если буфер недоступен — показать текст
+        print(text)
+
+
+def find(word):
+    """Ищет ключевое слово среди практики и теории — где смотреть по билету."""
+    w = word.strip().lower()
+    pr = sorted({k for k in PRACTICE if w in k})
+    th = sorted({k for k in THEORY if w in k})
+    print(f"Поиск '{word}':")
+    print("  ПРАКТИКА (код):", ", ".join(pr) if pr else "—")
+    print("  ТЕОРИЯ:       ", ", ".join(th) if th else "—")
+
+
+_ГРУППЫ = [
+    ("Нелинейные ур-я",  ["бисекция", "простая итерация", "секущих", "ньютон",
+                          "модифицированный ньютон", "дихотомия"]),
+    ("Системы нелин.",   ["итерация системы", "гаусса-зейделя", "ньютон 2d",
+                          "модифицированный ньютон 2d"]),
+    ("Интерполяция",     ["линейная интерполяция", "лагранж", "кубический сплайн"]),
+    ("Умножение матриц", ["наивное умножение", "наивное умножение со счётчиком",
+                          "штрассен", "штрассен с таймером"]),
+    ("Собств. значения", ["характеристический многочлен", "степенной метод",
+                          "степенной со сдвигом", "вращения якоби", "qr алгоритм",
+                          "шур", "проверка нормальности", "qr разложение"]),
+    ("ОДУ",              ["эйлер", "предиктор-корректор", "рунге-кутта",
+                          "адамса-башфорта", "адамса-мултона", "фазовый портрет"]),
+    ("Фурье",            ["дпф", "обратное дпф", "бпф", "амплитудный спектр"]),
+    ("Прочее",           ["центральная разность", "кахан"]),
+]
+
+
+_ТЕМЫ_ОБЩИЕ = ["бисекция", "ньютон", "модифицированный ньютон", "гаусса-зейделя", "интерполяция",
+               "лагранж", "штрассен", "сложность", "степенной метод", "шур", "qr",
+               "центральная разность", "эйлер", "фазовый портрет", "дпф", "ieee754", "верные цифры"]
+
+_ТЕМЫ_ОШИБКИ = ["ошибки округления", "ошибка ньютона", "ошибка степенного метода", "ошибка оду",
+                "ошибка зейделя", "ошибка штрассена", "ошибка интерполяции",
+                "ошибка дифференцирования", "устойчивость", "минимизация ошибок"]
+
+
+def ls():
+    """Компактно показывает всё содержимое по темам."""
+    print("ПРАКТИКА  ->  code(\"имя\")  (копирует в буфер)")
+    for title, names in _ГРУППЫ:
+        print(f"  {title:18s}: " + ", ".join(names))
+    print("ТЕОРИЯ    ->  theory(\"имя\")  (копирует в буфер)")
+    print("  Общая : " + ", ".join(_ТЕМЫ_ОБЩИЕ))
+    print("  Ошибки: " + ", ".join(_ТЕМЫ_ОШИБКИ))
+
+
+# русские синонимы (для обратной совместимости со старым кодом)
+код = code
+теория = theory
+найти = find
+список = ls
+показать = show
+
+
+if __name__ == "__main__":
+    ls()