diff --git "a/\320\2403213/ziyatdinov_408659/lab1/main.py" "b/\320\2403213/ziyatdinov_408659/lab1/main.py"
new file mode 100644
index 0000000..a250fa4
--- /dev/null
+++ "b/\320\2403213/ziyatdinov_408659/lab1/main.py"
@@ -0,0 +1,157 @@
+import sys
+import numpy as np
+
+def random_matrix():
+    n = int(input("Введите размер (n): "))
+    matrix = np.random.randint(-1000, 1000, (n, n))
+    d = np.random.randint(-1000, 1000, n)
+    return n, matrix, d
+
+
+def create_matrix():
+    n = int(input("Введите размер (n): "))
+
+    print("Введите матрицу (n на n):")
+    matrix = []
+    for i in range(n):
+        while True:
+            row = input().split()
+            if len(row) == n:
+                try:
+                    matrix.append([float(x) for x in row])
+                    break
+                except ValueError:
+                    pass
+            print(f"Введите пж {n} чисел")
+    print("Введите вектор b:")
+    while True:
+        b = input().split()
+        if len(b) == n:
+            try:
+                b = [float(x) for x in b]
+                break
+            except ValueError:
+                pass
+        print(f"Введите пж {n} чисел")
+
+    return n, matrix, b
+
+
+def perebor_strok(lst):
+    if len(lst) <= 1:
+        yield lst
+    else:
+        for i in range(len(lst)):
+            first = lst[i]
+            rest = lst[:i] + lst[i + 1:]
+            for p in perebor_strok(rest):
+                yield [first] + p
+
+
+def change_stroke(A, b):
+    n = len(A)
+    indices = list(range(n))
+
+    for el_perebor in perebor_strok(indices):
+        val = True
+        for i in range(n):
+            diagonal = abs(A[el_perebor[i]][i])
+            nodiagonal = sum(abs(A[el_perebor[i]][j]) for j in range(n) if j != i)
+            if diagonal < nodiagonal:
+                val = False
+                break
+
+        if val:
+            new_A = [A[idx] for idx in el_perebor]
+            new_b = [b[idx] for idx in el_perebor]
+            print("Найдена перестановка строк для диагонального преобладания:")
+            print("Перестановка индексов:", el_perebor)
+            return new_A, new_b
+
+    print("Перестановкой строк добиться диагонального преобладания не удалось.")
+    return A, b
+
+
+def displaying(matrix):
+    for row in matrix:
+        print(*row)
+
+
+def create_C_d(A, b):
+    n = len(A)
+    C = [[0.0]*n for _ in range(n)]
+    d = [0.0]*n
+
+    for i in range(n):
+        d[i] = b[i] / A[i][i]
+        for j in range(n):
+            if i == j:
+                C[i][j] = 0.0
+            else:
+                C[i][j] = -A[i][j] / A[i][i]
+    return C, d
+
+
+def matrix_norm(C):
+    return max(sum(abs(x) for x in row) for row in C)
+
+
+def gaussSeidel(C, d, eps, max_iter):
+    n = len(C)
+    old = d
+
+    for k in range(max_iter):
+        new = old[:]  # копируем список
+
+        for i in range(n):
+            s1 = sum(C[i][j] * new[j] for j in range(i))
+            s2 = sum(C[i][j] * old[j] for j in range(i + 1, n))
+            new[i] = d[i] + s1 + s2
+
+        diff = max(abs(new[i] - old[i]) for i in range(n))
+        print(f"Погрешность для {k + 1}ой итерации:", diff)
+        if diff < eps:
+            return new, k + 1
+
+        old = new
+
+    return old, max_iter
+
+
+def main():
+    mode = input("Выберите источник ввода (1 - консоль, 2 - файл): ")
+    if mode.strip() == "2":
+        filename = input("Введите имя файла: ")
+        sys.stdin = open(filename, "r", encoding="utf-8")
+
+    n, A, b = random_matrix()
+    displaying(A)
+    # n, A, b = create_matrix()
+
+    A, b = change_stroke(A, b)
+    C, d = create_C_d(A, b)
+
+    print("матрица С")
+    displaying(C)
+
+    norma = matrix_norm(C)
+    print("Норма матрицы C (по строкам) =", norma)
+    if norma < 1:
+        print("Условие ||C|| < 1 выполняется")
+    else:
+        print("Условие ||C|| < 1 не выполняется")
+
+    eps_str = input("Введите точность: ")
+    eps = float(eps_str)
+    max_iter_str = input("Введите максимальное число итераций: ")
+    max_iter = int(max_iter_str)
+
+    x, k = gaussSeidel(C, d, eps, max_iter)
+
+    print("Результат решения системы:")
+    for i in range(n):
+        print(f"x[{i+1}] =", x[i])
+    print("Выполнено итераций:", k)
+
+
+main()
diff --git "a/\320\2403213/ziyatdinov_408659/lab1/reports/\320\233\320\220\320\221\320\2201_\320\222\320\253\320\247\320\234\320\220\320\242.pdf" "b/\320\2403213/ziyatdinov_408659/lab1/reports/\320\233\320\220\320\221\320\2201_\320\222\320\253\320\247\320\234\320\220\320\242.pdf"
new file mode 100644
index 0000000..e9d6d66
Binary files /dev/null and "b/\320\2403213/ziyatdinov_408659/lab1/reports/\320\233\320\220\320\221\320\2201_\320\222\320\253\320\247\320\234\320\220\320\242.pdf" differ
diff --git "a/\320\2403213/ziyatdinov_408659/lab2/lab2(1_method).py" "b/\320\2403213/ziyatdinov_408659/lab2/lab2(1_method).py"
new file mode 100644
index 0000000..c34dd0d
--- /dev/null
+++ "b/\320\2403213/ziyatdinov_408659/lab2/lab2(1_method).py"
@@ -0,0 +1,290 @@
+import math
+import random
+import numpy as np
+import matplotlib.pyplot as plt
+
+def r_uravnenie(degree, min_k, max_k):
+
+    koefs = [random.randint(min_k, max_k) for _ in range(degree + 1)]
+    def uravnenie(x):
+        return sum(koefs[i] * x**i for i in range(len(koefs)))
+    return uravnenie, koefs
+
+
+def plot_function_system(f_system, x_min, x_max, y_min, y_max, root, title="График системы с решением"):
+    def f1(x, y):
+        return f_system([x, y])[0]
+
+    def f2(x, y):
+        return f_system([x, y])[1]
+
+    X, Y = np.meshgrid(
+        np.linspace(x_min, x_max, 300),
+        np.linspace(y_min, y_max, 300)
+    )
+
+    Z1 = np.zeros_like(X)
+    Z2 = np.zeros_like(X)
+
+    for i in range(X.shape[0]):
+        for j in range(X.shape[1]):
+            Z1[i, j] = f1(X[i, j], Y[i, j])
+            Z2[i, j] = f2(X[i, j], Y[i, j])
+
+    plt.figure(figsize=(7, 6))
+
+    plt.contour(X, Y, Z1, levels=[0], colors='red')
+    plt.contour(X, Y, Z2, levels=[0], colors='blue')
+
+
+    x, y = root
+    plt.axhline(0, color='black', linewidth=0.8)
+    plt.axvline(0, color='black', linewidth=0.8)
+
+    plt.plot(x, y, 'go', label=f'Решение ({x:.4f}, {y:.4f})')
+    plt.text(x, y, f"({x:.4f}, {y:.4f})", fontsize=9, ha='left', va='bottom')
+
+    plt.grid(True)
+    plt.xlim(x_min, x_max)
+    plt.ylim(y_min, y_max)
+    plt.title(title)
+    plt.legend()
+    plt.show()
+
+
+def p_r_uravnenie(koefs):
+
+    p_koefs = []
+    for i in range(1, len(koefs)):
+        p_koefs.append(i * koefs[i])
+    def p_uravnenie(x):
+        return sum(p_koefs[i] * x**i for i in range(len(p_koefs)))
+    return p_uravnenie, p_koefs
+
+
+
+def f_example(x):
+    # return math.cos(2*x) - 7 * math.sin(x) - 4
+    return x**3 - x + 4
+
+def df_example(x):
+    # return -2 * math.sin(2 * x) - 7 * math.cos(x)
+    return 3*x**2 - 1
+
+
+
+def f_system(vars_xy):
+    x, y = vars_xy
+    # return np.array([
+    #     math.cos(x - 1) + y - 0.5,
+    #     x - math.cos(y) - 3
+    # ])
+    return np.array([
+        x**2 + y**2 - 4,
+        y - 3*x**2
+    ])
+
+def df_system(vars_xy):
+    x, y = vars_xy
+    # return np.array([
+    #      [-math.sin(x - 1), 1],
+    #     [1, math.sin(y)]
+    # ])
+    return np.array([
+        [2*x, 2*y],
+        [-6*x, 1]
+    ])
+
+def plot_function(f, a, b,root,  title="График функции"):
+
+    x_vals = np.linspace(a, b, 400)
+    y_vals = [f(x) for x in x_vals]
+    plt.figure(figsize=(7, 4))
+    plt.plot(x_vals, y_vals, label='f(x)')
+    plt.axhline(0, color='black', linewidth=0.8)
+
+    y_root = f(root)
+    plt.plot(root, y_root, 'ro', label=f'Решение: x={root:.4f}')
+    plt.text(root, y_root, f"({root:.4f}, {y_root:.4f})", fontsize=9, ha='left', va='bottom')
+
+    plt.grid(True)
+    plt.xlim(a, b)
+    ymin, ymax = min(y_vals), max(y_vals)
+    plt.ylim(ymin - abs(ymin)*0.1, ymax + abs(ymax)*0.1)
+    plt.title(title)
+    plt.legend()
+    plt.show()
+
+
+def chord_method(f, a, b, accuracy, m_c):
+
+    if f(a) * f(b) > 0:
+        raise ValueError("На отрезке [a, b] функция не меняет знак. Корень может отсутствовать или быть не единственным.")
+    count = 0
+    for _ in range(int(m_c)):
+        count += 1
+        x = (a * f(b) - b * f(a)) / (f(b) - f(a))
+        if abs(f(x)) <= accuracy:
+            return x, count, f(x)
+        if f(a) * f(x) < 0:
+            b = x
+        else:
+            a = x
+    x = (a * f(b) - b * f(a)) / (f(b) - f(a))
+    return x, count, f(x)
+
+
+def secant_method(f, x0, x1, accuracy, m_c):
+    count = 0
+    for _ in range(int(m_c)):
+        count += 1
+        value_in_x0 = f(x0)
+        value_in_x1 = f(x1)
+        if abs(value_in_x1 - value_in_x0) < 1e-14:
+            raise ZeroDivisionError("Разница f(x1) и f(x0) слишком мала, деление невозможно.")
+        x2 = x1 - value_in_x1 * (x1 - x0) / (value_in_x1 - value_in_x0)
+        if abs(x2 - x1) < accuracy:
+            return x2, count, f(x2)
+        x0, x1 = x1, x2
+    return x2, count, f(x2)
+
+
+def iteration_easy_method(fi, x0, accuracy, m_c):
+    count = 0
+    for _ in range(int(m_c)):
+        count += 1
+        x1 = fi(x0)
+        if abs(x1 - x0) < accuracy:
+            return x1, count
+        x0 = x1
+    return x0, count
+
+
+def compute_alpha(df, a, b, steps=100):
+    mas_val = np.linspace(a, b, steps)
+    max_val = max(abs(df(x)) for x in mas_val)
+    if (max_val == 0):
+        max_val = 1
+    return 1.0 / max_val
+
+
+
+def newton_method_system(fun, dfun, x0, accuracy, count):
+    x = np.array(x0, dtype=float)
+    for i in range(count):
+        F = fun(x)
+        dF = dfun(x)
+        try:
+            delta = np.linalg.solve(dF, F)
+        except np.linalg.LinAlgError:
+            return x, i
+        x_new = x - delta
+
+
+        if abs(x_new[0] - x[0]) <= accuracy and abs(x_new[1] - x[1]) <= accuracy:
+            return x_new, i + 1
+        x = x_new
+    return x, count
+
+
+
+
+def main():
+    print("Хотите решить ОДНОМЕРНОЕ уравнение или СИСТЕМУ?")
+    print("1) Одномерное уравнение")
+    print("2) Система (метод Ньютона)")
+    choice_global = input("Выберите (1 или 2): ")
+
+    if choice_global == '1':
+        print("1) Использовать случайное уравнение?")
+        print("2) Использовать функцию ?")
+        choice = input("Выберите (1 или 2): ")
+
+        if choice == '1':
+            deg = int(input("Введите степень случайного уравнения: "))
+            poly, coeffs = r_uravnenie(deg, -5, 5)
+            print(f"Случайно сгенерированное уравнение (коэффициенты): {coeffs[::-1]}")
+            f = poly
+            dpoly, dcoeffs = p_r_uravnenie(coeffs)
+            df = dpoly
+        else:
+            f = f_example
+            df = df_example
+
+        print("Введите границы интервала (a b): ")
+        inp = input().split()
+        a = float(inp[0])
+        b = float(inp[1])
+
+        # plot_function(f, a, b, title="График выбранной функции на интервале")
+
+        print("Введите требуемую точность: ")
+        accuracy = float(input())
+
+        print("Введите максимальное число итераций: ")
+        count = int(input())
+
+        print("Какой метод использовать?")
+        print("1) Метод хорд")
+        print("2) Метод секущих")
+        print("3) Метод простой итерации")
+        choice_method = input("Выберите (1, 2, 3): ")
+
+        if choice_method == '1':
+            try:
+                root, n_iter, f_val = chord_method(f, a, b, accuracy, count)
+                print(f"\nМетод хорд:\nНайденный корень: {root}\nКоличество итераций: {n_iter}\nf(root) = {f_val}")
+                plot_function(f, a, b, root, title="График выбранной функции на интервале")
+            except ValueError as e:
+                print(f"Ошибка: {e}")
+
+        elif choice_method == '2':
+            try:
+                root, n_iter, f_val = secant_method(f, a, b, accuracy, count)
+                print(f"\nМетод секущих:\nНайденный корень: {root}\nКоличество итераций: {n_iter}\nf(root) = {f_val}")
+                plot_function(f, a, b, root, title="График выбранной функции на интервале")
+            except ZeroDivisionError as e:
+                print(f"Ошибка: {e}")
+
+        elif choice_method == '3':
+            alpha = compute_alpha(df, a, b)
+            print(f"Вычислен alpha = {alpha}")
+            def fi(x):
+                return x - alpha * f(x)
+            x0 = (a + b) / 2
+
+            root, n_iter = iteration_easy_method(fi, x0, accuracy, count)
+            print(f"\nМетод простой итерации:\nНайденный корень: {root}\nКоличество итераций: {n_iter}\nf(root) = {f(root)}")
+            plot_function(f, a, b, root, title="График выбранной функции на интервале")
+        else:
+            print("Неправильный выбор метода!")
+
+    else:
+        print("Решаем систему методом Ньютона.")
+        print("Для демонстрации возьмём систему со слайдов:\n  1) x^2 + y^2 = 4\n  2) y - 3x^2 = 0\n")
+
+        print("Введите начальное приближение (x0, y0): ")
+        inp = input().split()
+        x0 = float(inp[0])
+        y0 = float(inp[1])
+
+        print("Введите требуемую точность: ")
+        accuracy = float(input())
+
+        print("Введите максимальное число итераций: ")
+        count = int(input())
+
+        root, iters = newton_method_system(f_system, df_system, [x0, y0], accuracy, count)
+        if (root[0] == x0 and root[1] == y0) and (f_system([x0, y0])[0] != 0 or f_system([x0, y0])[1] != 0):
+            root, iters = newton_method_system(f_system, df_system, [x0 + accuracy, y0 + accuracy], accuracy, count)
+        print(f_system([0, 0]))
+        print("\nМетод Ньютона")
+        print(f"Решения: x = {root[0]:.6f}, y = {root[1]:.6f}")
+        print(f"Число итераций: {iters}")
+        print(f"f1(x,y) = {f_system(root)[0]:.6e}")
+        print(f"f2(x,y) = {f_system(root)[1]:.6e}")
+        plot_function_system(f_system, root[0] - 3, root[0] + 3, root[1] - 3, root[1]  + 3, root, title="График системы с решением")
+
+
+if __name__ == "__main__":
+    main()
diff --git "a/\320\2403213/ziyatdinov_408659/lab2/reports/\320\222\320\253\320\247_\320\234\320\220\320\242_\320\233\320\220\320\221\320\220_2.pdf" "b/\320\2403213/ziyatdinov_408659/lab2/reports/\320\222\320\253\320\247_\320\234\320\220\320\242_\320\233\320\220\320\221\320\220_2.pdf"
new file mode 100644
index 0000000..4479a0c
Binary files /dev/null and "b/\320\2403213/ziyatdinov_408659/lab2/reports/\320\222\320\253\320\247_\320\234\320\220\320\242_\320\233\320\220\320\221\320\220_2.pdf" differ
diff --git "a/\320\2403213/ziyatdinov_408659/lab3/Vich_Mat_3.py" "b/\320\2403213/ziyatdinov_408659/lab3/Vich_Mat_3.py"
new file mode 100644
index 0000000..b0d8062
--- /dev/null
+++ "b/\320\2403213/ziyatdinov_408659/lab3/Vich_Mat_3.py"
@@ -0,0 +1,263 @@
+import math
+import random
+import numpy as np
+import matplotlib.pyplot as plt
+def r_uravnenie(degree, min_k, max_k):
+    koefs = [random.randint(min_k, max_k) for _ in range(degree + 1)]
+    def uravnenie(x):
+        return sum(koefs[i] * x**i for i in range(len(koefs)))
+    return uravnenie, koefs
+def p_r_uravnenie(koefs):
+    p_koefs = []
+    for i in range(1, len(koefs)):
+        p_koefs.append(i * koefs[i])
+    def p_uravnenie(x):
+        return sum(p_koefs[i] * x**i for i in range(len(p_koefs)))
+    return p_uravnenie, p_koefs
+def f_example(x):
+    # return math.cos(2*x) - 7 * math.sin(x) - 4
+    # return (x**4) / 4 + x**2 - 8 * x + 12
+    # return 2 * x**2 + 16 / x
+    # return -3*x**3 + 2 * x**2 + 4 * x - 3
+    # return (x**4)/10 + (x**2)/5 - 7
+    return -1 * (x**3) - (x**2) + x + 3
+def df_example(x):
+    # return -2 * math.sin(2 * x) - 7 * math.cos(x)
+    # return x**3 + 2*x - 8
+    return (x**3)*4/10 + x*2/5
+def ddf_example(x):
+    # return -2 * math.sin(2 * x) - 7 * math.cos(x)
+    # return 3*x**2 + 2
+    return 1.2 * (x**2) + 0.4
+def dddf_example(x):
+    # return -2 * math.sin(2 * x) - 7 * math.cos(x)
+    # return 3*x**2 + 2
+    return 2.4 * x
+def ddddf_example(x):
+    # return -2 * math.sin(2 * x) - 7 * math.cos(x)
+    # return 3*x**2 + 2
+    return 0
+
+def plot_function(f, a, b,root,  title="График функции"):
+    x_vals = np.linspace(a, b, 400)
+    y_vals = [f(x) for x in x_vals]
+    plt.figure(figsize=(7, 4))
+    plt.plot(x_vals, y_vals, label='f(x)')
+    plt.axhline(0, color='black', linewidth=0.8)
+    y_root = f(root)
+    plt.plot(root, y_root, 'ro', label=f'Решение: x={root:.4f}')
+    plt.text(root, y_root, f"({root:.4f}, {y_root:.4f})", fontsize=9, ha='left', va='bottom')
+    plt.grid(True)
+    plt.xlim(a, b)
+    ymin, ymax = min(y_vals), max(y_vals)
+    plt.ylim(ymin - abs(ymin)*0.1, ymax + abs(ymax)*0.1)
+    plt.title(title)
+    plt.legend()
+    plt.show()
+
+
+
+
+def pryamougolnik_method_full (f, ddf, a, b, e, choice, steps = 100):
+    mas_val = np.linspace(a, b, steps)
+    max_val = max(abs(ddf(x)) for x in mas_val)
+    n = int((max_val * ((b - a) ** 3) / 24 / e) ** 0.5) + 3
+    sum1 = pryamougolnik_method(f, a, b, n, choice)
+    count = 1
+    for i in range(1000):
+        n = n * 2
+        count += 1
+        sum2 = pryamougolnik_method(f, a, b, n, choice)
+        if abs(sum2 - sum1) <= e:
+            return sum2, count
+        sum1 = sum2
+    return sum1, count + 1
+
+def pryamougolnik_method(f, a, b, n, choice):
+    h = (b - a) / n
+    sum = 0
+    if choice == 1:
+        for i in range(n):
+            sum = sum + f(a + h * i)
+        sum = sum * h
+    elif choice == 2:
+        for i in range(1, n + 1):
+            sum = sum + f(a + h * i)
+        sum = sum * h
+    else:
+        for i in range(n):
+            sum = sum + f(a + h / 2 + h * i)
+        sum = sum * h
+    return sum
+
+
+
+
+def tropeciya_method_full (f, ddf, a, b, e,  steps = 100):
+    mas_val = np.linspace(a, b, steps)
+    max_val = max(abs(ddf(x)) for x in mas_val)
+    n = int((max_val * ((b - a) ** 3) / 12 / e) ** 0.5) + 2
+    sum1 = tropeciya_method(f, a, b, n)
+    count = 1
+    for i in range(1000):
+        n = n * 2
+        count += 1
+        sum2 = tropeciya_method(f, a, b, n)
+        if abs(sum2 - sum1) <= e:
+            return sum2, count
+        sum1 = sum2
+    return sum1, count + 1
+
+def tropeciya_method(f, a, b, n):
+    h = (b - a) / n
+    sum = 0
+    for i in range(1, n):
+        sum = sum + f(a + h * i)
+    sum = (sum + (f(a) + f(a + n * h)) / 2) * h
+    return sum
+
+
+
+
+def sympson_method_full (f, ddddf, a, b, e,  steps = 100):
+    mas_val = np.linspace(a, b, steps)
+    max_val = max(abs(ddddf(x)) for x in mas_val)
+    n = int((max_val * ((b - a) ** 5) / 180 / e) ** 0.25) + 5
+    sum1 = sympson_method(f, a, b, n)
+    count = 1
+    for i in range (1000):
+        n = n * 2
+        count += 1
+        sum2 = sympson_method(f, a, b, n)
+        if abs(sum2 - sum1) <= e:
+            return sum2, count
+        sum1 = sum2
+    return sum1, count + 1
+
+def sympson_method(f, a, b, n):
+    h = (b - a) / n
+    sum = f(a) + f(b)
+    for i in range (1, n):
+        if i % 2 == 1:
+            sum = sum + 4 * f(a + h * i)
+        else:
+            sum = sum + 2 * f(a + h * i)
+    sum = sum * h / 3
+    return sum
+
+
+
+def nesobstvenniy_integral_method(f, ddf, a, b, e, point, c = 0):
+    eps = 0.001 * (b - a)
+    sum0 = None
+    if point == 'a':
+        for _ in range(500):
+
+            sum1, _ = tropeciya_method_full(f, ddf, a + eps, b, e)
+
+            if sum0 is not None and abs(sum1 - sum0) < e:
+                return sum1
+            sum0 = sum1
+            eps /= 2
+        return None
+    if point == 'b':
+        for _ in range(500):
+            sum1, _ = tropeciya_method_full(f, ddf, a, b - eps, e)
+
+            if sum0 is not None and abs(sum1 - sum0) < e:
+                return sum1
+            sum0 = sum1
+            eps /= 2
+        return None
+    if point == 'c':
+        for _ in range(1000):
+            l, _ = tropeciya_method_full(f, ddf,  a, c - eps, e)
+            r, _ = tropeciya_method_full(f, ddf,  c + eps, b, e)
+            sum1 = l + r
+            if sum0 is not None and abs(sum1 - sum0) < e:
+                return sum1
+            sum0 = sum1
+            eps /= 2
+        return None
+    return -1
+
+
+print("1) Использовать случайное уравнение?")
+print("2) Использовать функцию? (Найти обычный интеграл)")
+print("3) Найти несобственный интеграл")
+
+choice = input("Выберите (1 или 2 или 3): ")
+
+if choice == '1' or choice == '2':
+    if choice == '1':
+        deg = int(input("Введите степень случайного уравнения: "))
+        poly, coeffs = r_uravnenie(deg, -5, 5)
+        print(f"Случайно сгенерированное уравнение (коэффициенты): {coeffs[::-1]}")
+        f = poly
+        df, dcoeffs = p_r_uravnenie(coeffs)
+        ddf, ddcoeffs = p_r_uravnenie(dcoeffs)
+        dddf, dddcoeffs = p_r_uravnenie(ddcoeffs)
+        ddddf, ddddcoeffs = p_r_uravnenie(dddcoeffs)
+    else:
+        f = f_example
+        df = df_example
+        ddf = ddf_example
+        dddf = dddf_example
+        ddddf = ddddf_example
+
+    print("Введите границы интервала (a b): ")
+    inp = input().split()
+    a = float(inp[0])
+    b = float(inp[1])
+
+    print("Введите требуемую точность: ")
+    e = float(input())
+
+    print("Какой метод использовать?")
+    print("1) Метод прямоугольника")
+    print("2) Метод трапеции")
+    print("3) Метод Симпсона")
+    choice_method = input("Выберите (1/2/3): ")
+
+    if choice_method == '1':
+        print("1) Формула левых прямоугольников")
+        print("2) Формула правых прямоугольников")
+        print("3) Формула средних прямоугольников")
+        choice = input("Выберите (1/2/3): ")
+        try:
+            ans, n = pryamougolnik_method_full(f, ddf, a, b, e, choice)
+            print(f"\nМетод прямоугольника:\nНайденный интеграл : {ans}\nКоличество итераций: {n}")
+        except ValueError as e:
+            print(f"Ошибка: {e}")
+    elif choice_method == '2':
+        try:
+            ans, n = tropeciya_method_full(f, ddf, a, b, e)
+            print(f"\nМетод тропеции:\nНайденный интеграл : {ans}\nКоличество итераций: {n}")
+        except ValueError as e:
+            print(f"Ошибка: {e}")
+    elif choice_method == '3':
+        try:
+            ans, n = sympson_method_full(f, ddddf, a, b, e)
+            print(f"\nМетод Симпсона\nНайденный интеграл : {ans}\nКоличество итераций: {n}")
+        except ValueError as e:
+            print(f"Ошибка: {e}")
+    else:
+        print("Неправильный выбор метода!")
+else:
+    f1 = lambda x: 1 / math.sqrt(x)
+    ddf1 = lambda x: 3 / (4 * (x**2) * (x ** 0.5))
+    val1 = nesobstvenniy_integral_method(f1, ddf1, 0.0, 10.0, 0.01, 'a')
+    print("Разрыв в левой точке отрезка (a)")
+    print(val1)
+
+    f1 = lambda x: 1 / math.sqrt(-1 * x)
+    ddf1 = lambda x: 3 / (4 * (x**2) * math.sqrt(-1 * x))
+    val1 = nesobstvenniy_integral_method(f1, ddf1, -10.0, 0.0, 0.01, 'b')
+    print("Разрыв в правой точке отрезка (b)")
+    print(val1)
+
+    f1 = lambda x: 1 / x
+    ddf1 = lambda x: 2 / x**3
+    val1 = nesobstvenniy_integral_method(f1, ddf1, -10.0, 9, 0.001, 'c')
+    print("Разрыв в внутри отрезка (c)")
+    print(val1)
diff --git "a/\320\2403213/ziyatdinov_408659/lab3/reports/\320\222\321\213\321\207_\320\274\320\260\321\202_3.pdf" "b/\320\2403213/ziyatdinov_408659/lab3/reports/\320\222\321\213\321\207_\320\274\320\260\321\202_3.pdf"
new file mode 100644
index 0000000..7600c27
Binary files /dev/null and "b/\320\2403213/ziyatdinov_408659/lab3/reports/\320\222\321\213\321\207_\320\274\320\260\321\202_3.pdf" differ
diff --git "a/\320\2403213/ziyatdinov_408659/lab4/Vich_mat_4.py" "b/\320\2403213/ziyatdinov_408659/lab4/Vich_mat_4.py"
new file mode 100644
index 0000000..f770b27
--- /dev/null
+++ "b/\320\2403213/ziyatdinov_408659/lab4/Vich_mat_4.py"
@@ -0,0 +1,264 @@
+import math
+import matplotlib.pyplot as plt
+import numpy as np
+
+def f(x):
+    # return 1.2 * x ** 2.5
+    # return 2 * math.log(x) + 1
+    return 3 * math.exp(0.7 * x)
+    # return 0.5 * x ** 3 - x ** 2 + 2 * x - 1
+    # return 1.5 * x**2 - 2 * x + 4
+
+
+
+
+ok = True
+while ok:
+    print("Введите интервал: ")
+    str = input().split()
+    l = float(str[0])
+    r = float(str[1])
+    if l > 0 and r > 0:
+        ok = False
+    else:
+        print("Интервал должен быть справа от нуля")
+ok = True
+while ok:
+    print("Введите шаг больше 0: ")
+    h = float(input())
+    if h > 0:
+        ok = False
+    else:
+        print("Шаг должен быть больше нуля")
+
+mas_x = []
+mas_y = []
+n = int((r - l) / h) + 1
+
+for i in range (n):
+    mas_x.append(l)
+    mas_y.append(f(l))
+    l += h
+
+# mas_x = [1.1, 2.3, 3.7, 4.5, 5.4, 6.8, 7.5]
+# mas_y = [2.73, 5.12, 7.74, 8.91, 10.59, 12.75, 13.43]
+
+
+
+
+def lin_app(mas_x, mas_y, n):
+    sum_x = 0
+    sum_xx = 0
+    sum_y = 0
+    sum_xy = 0
+    for i in range(n):
+        sum_x += mas_x[i]
+        sum_xx += mas_x[i] ** 2
+        sum_y += mas_y[i]
+        sum_xy += mas_x[i] * mas_y[i]
+    d = sum_xx * n - sum_x ** 2
+    d1 = sum_xy * n - sum_x * sum_y
+    d2 = sum_xx * sum_y - sum_x * sum_xy
+    b = d2 / d
+    a = d1 / d
+    # print(a, b)
+    def f_kv(x):
+        return a * x + b
+    S = 0
+    s1 = 0
+    s2 = 0
+    s3 = 0
+    s_phi = 0
+    for i in range (n):
+        S += (f_kv(mas_x[i]) - mas_y[i]) ** 2
+        s1 += (mas_x[i] - sum_x / n) * (mas_y[i] - sum_y / n)
+        s2 += (mas_x[i] - sum_x / n) ** 2
+        s3 += (mas_y[i] - sum_y / n) ** 2
+        s_phi += f_kv(mas_x[i])
+    𝜹 = (S / n) ** 0.5
+    r = s1 / (s2 * s3) ** 0.5
+    s1 = 0
+    s2 = 0
+    s_phi = s_phi / n
+    for i in range (n):
+        s1 += (mas_y[i] - f_kv(mas_x[i])) ** 2
+        s2 += (mas_y[i] - s_phi) ** 2
+    R_2 = 1 - s1 / s2
+    # print(𝜹)
+    return a, b, S, 𝜹, r, R_2
+
+def kvadrat_app(mas_x, mas_y, n):
+    sum_x = 0
+    sum_xx = 0
+    sum_xxx = 0
+    sum_xxxx = 0
+    sum_y = 0
+    sum_xy = 0
+    sum_xxy = 0
+    for i in range(n):
+        sum_x += mas_x[i]
+        sum_xx += mas_x[i] ** 2
+        sum_xxx += mas_x[i] ** 3
+        sum_xxxx += mas_x[i] ** 4
+        sum_y += mas_y[i]
+        sum_xy += mas_x[i] * mas_y[i]
+        sum_xxy += (mas_x[i] ** 2) * mas_y[i]
+
+    d = (n * (sum_xx * sum_xxxx - sum_xxx ** 2)- sum_x * (sum_x * sum_xxxx - sum_xxx * sum_xx)+ sum_xx * (sum_x * sum_xxx - sum_xx ** 2))
+    d0 = (sum_y * (sum_xx * sum_xxxx - sum_xxx ** 2) - sum_x * (sum_xy * sum_xxxx - sum_xxx * sum_xxy) + sum_xx * (sum_xy * sum_xxx - sum_xx * sum_xxy))
+    d1 = (n * (sum_xy * sum_xxxx - sum_xxx * sum_xxy)- sum_y * (sum_x * sum_xxxx - sum_xxx * sum_xx)+ sum_xx * (sum_x * sum_xxy - sum_xy * sum_xx))
+    d2 = (n * (sum_xx * sum_xxy - sum_xy * sum_xxx)- sum_x * (sum_x * sum_xxy - sum_xy * sum_xx)+ sum_y * (sum_x * sum_xxx - sum_xx ** 2))
+    c = d0 / d
+    b = d1 / d
+    a = d2 / d
+
+    def f_kv(x):
+        return c + b * x + a * x*x
+    S = 0
+    s_phi = 0
+    for i in range (n):
+        S += (f_kv(mas_x[i]) - mas_y[i]) ** 2
+        s_phi += f_kv(mas_x[i])
+    𝜹 = (S / n) ** 0.5
+    s_phi = s_phi / n
+    s1 = 0
+    s2 = 0
+    for i in range(n):
+        s1 += (mas_y[i] - f_kv(mas_x[i])) ** 2
+        s2 += (mas_y[i] - s_phi) ** 2
+    R_2 = 1 - s1 / s2
+    print(𝜹)
+    return a, b, c, S, 𝜹, R_2
+
+def step_app(mas_x, mas_y, n):
+    sum_x = 0
+    sum_xx = 0
+    sum_y = 0
+    sum_xy = 0
+    for i in range (n):
+        sum_x += math.log(mas_x[i])
+        sum_xx += math.log(mas_x[i]) ** 2
+        sum_y += math.log(mas_y[i])
+        sum_xy += math.log(mas_x[i]) * math.log(mas_y[i])
+    d = sum_xx * n - sum_x ** 2
+    d1 = sum_xy * n - sum_x * sum_y
+    d2 = sum_xx * sum_y - sum_x * sum_xy
+    a = math.exp(d2 / d)
+    b = d1 / d
+    def f_kv(x):
+        return  a * x**b
+    S = 0
+    s_phi = 0
+    for i in range (n):
+        S += (f_kv(mas_x[i]) - mas_y[i]) ** 2
+        s_phi += f_kv(mas_x[i])
+    𝜹 = (S / n) ** 0.5
+    s_phi = s_phi / n
+    s1 = 0
+    s2 = 0
+    for i in range(n):
+        s1 += (mas_y[i] - f_kv(mas_x[i])) ** 2
+        s2 += (mas_y[i] - s_phi) ** 2
+    R_2 = 1 - s1 / s2
+    return a, b, S, 𝜹, R_2
+
+
+def exp_app(mas_x, mas_y, n):
+    sum_x = 0
+    sum_xx = 0
+    sum_y = 0
+    sum_xy = 0
+    for i in range(n):
+        sum_x += mas_x[i]
+        sum_xx += mas_x[i] ** 2
+        sum_y += math.log(mas_y[i])
+        sum_xy += mas_x[i] * math.log(mas_y[i])
+    d = sum_xx * n - sum_x ** 2
+    d1 = sum_xy * n - sum_x * sum_y
+    d2 = sum_xx * sum_y - sum_x * sum_xy
+    a = math.exp(d2 / d)
+    b = d1 / d
+    def f_kv(x):
+        return a * math.exp(b * x)
+    S = 0
+    s_phi = 0
+    for i in range (n):
+        S += (f_kv(mas_x[i]) - mas_y[i]) ** 2
+        s_phi += f_kv(mas_x[i])
+    𝜹 = (S / n) ** 0.5
+    s_phi = s_phi / n
+    s1 = 0
+    s2 = 0
+    for i in range(n):
+        s1 += (mas_y[i] - f_kv(mas_x[i])) ** 2
+        s2 += (mas_y[i] - s_phi) ** 2
+    R_2 = 1 - s1 / s2
+    return a, b, S, 𝜹, R_2
+
+
+def log_app(mas_x, mas_y, n):
+    sum_x = 0
+    sum_xx = 0
+    sum_y = 0
+    sum_xy = 0
+    for i in range(n):
+        sum_x += math.log(mas_x[i])
+        sum_xx += math.log(mas_x[i]) ** 2
+        sum_y += mas_y[i]
+        sum_xy += math.log(mas_x[i]) * mas_y[i]
+    d = sum_xx * n - sum_x ** 2
+    d1 = sum_xy * n - sum_x * sum_y
+    d2 = sum_xx * sum_y - sum_x * sum_xy
+    b = d2 / d
+    a = d1 / d
+    def f_kv(x):
+        return a * math.log(x) + b
+    S = 0
+    s_phi = 0
+    for i in range (n):
+        S += (f_kv(mas_x[i]) - mas_y[i]) ** 2
+        s_phi += f_kv(mas_x[i])
+    𝜹 = (S / n) ** 0.5
+    s_phi = s_phi / n
+    s1 = 0
+    s2 = 0
+    for i in range(n):
+        s1 += (mas_y[i] - f_kv(mas_x[i])) ** 2
+        s2 += (mas_y[i] - s_phi) ** 2
+    R_2 = 1 - s1 / s2
+    return a, b, S, 𝜹, R_2
+
+variants = []
+a_lin, b_lin, S_lin, delta_lin, r_lin, R2_lin = lin_app(mas_x, mas_y, n)
+variants.append(("φ = ax + b", R2_lin, lambda x: a_lin * x + b_lin))
+a_step, b_step, S_step, delta_step, R2_step = step_app(mas_x, mas_y, n)
+variants.append(("φ = ax^b", R2_step, lambda x: a_step * x**b_step))
+a_exp, b_exp, S_exp, delta_exp, R2_exp = exp_app(mas_x, mas_y, n)
+variants.append(("φ = ae^(bx)", R2_exp, lambda x: a_exp * math.exp(b_exp * x)))
+a_log, b_log, S_log, delta_log, R2_log = log_app(mas_x, mas_y, n)
+variants.append(("φ = a*ln(x) + b", R2_log, lambda x: a_log * math.log(x) + b_log))
+a_kv, b_kv, c_kv, S_kv, delta_kv, R2_kv = kvadrat_app(mas_x, mas_y, n)
+variants.append(("φ = ax^2 + bx + c", R2_kv, lambda x: a_kv * x**2 + b_kv * x + c_kv))
+print(f"{'Вид функции':<25} {'a':>10} {'b':>10} {'c':>10} {'S':>12} {'δ':>12} {'R²':>10}")
+print("-" * 100)
+print(f"{'φ = ax + b':<25} {a_lin:10.4f} {b_lin:10.4f} {'-':>10} {S_lin:12.5f} {delta_lin:12.5f} {R2_lin:10.4f}")
+print(f"{'φ = ax^b':<25} {a_step:10.4f} {b_step:10.4f} {'-':>10} {S_step:12.5f} {delta_step:12.5f} {R2_step:10.4f}")
+print(f"{'φ = ae^(bx)':<25} {a_exp:10.4f} {b_exp:10.4f} {'-':>10} {S_exp:12.5f} {delta_exp:12.5f} {R2_exp:10.4f}")
+print(f"{'φ = a*ln(x) + b':<25} {a_log:10.4f} {b_log:10.4f} {'-':>10} {S_log:12.5f} {delta_log:12.5f} {R2_log:10.4f}")
+print(f"{'φ = ax^2 + bx + c':<25} {a_kv:10.4f} {b_kv:10.4f} {c_kv:10.4f} {S_kv:12.5f} {delta_kv:12.5f} {R2_kv:10.4f}")
+print("Коэфицент корреляции пирсона =", r_lin)
+
+best_variant = max(variants, key=lambda m: m[1])
+name, best_r2, func = best_variant
+x_vals = np.linspace(min(mas_x), max(mas_x), 300)
+y_vals = [func(x) for x in x_vals]
+plt.figure(figsize=(8, 5))
+plt.plot(x_vals, y_vals, label=f"Аппроксимация: {name}", color='blue')
+plt.scatter(mas_x, mas_y, color='red', label="Исходные точки")
+plt.title(f"Аппроксимация: {name}\nR² = {best_r2:.4f}")
+plt.xlabel("x")
+plt.ylabel("y")
+plt.grid(True)
+plt.legend()
+plt.tight_layout()
+plt.show()
\ No newline at end of file
diff --git "a/\320\2403213/ziyatdinov_408659/lab4/reports/\320\222\321\213\321\207_\320\274\320\260\321\202_4.pdf" "b/\320\2403213/ziyatdinov_408659/lab4/reports/\320\222\321\213\321\207_\320\274\320\260\321\202_4.pdf"
new file mode 100644
index 0000000..e2f5c41
Binary files /dev/null and "b/\320\2403213/ziyatdinov_408659/lab4/reports/\320\222\321\213\321\207_\320\274\320\260\321\202_4.pdf" differ
diff --git "a/\320\2403213/ziyatdinov_408659/lab5/Vich_mat_5.py" "b/\320\2403213/ziyatdinov_408659/lab5/Vich_mat_5.py"
new file mode 100644
index 0000000..17287d6
--- /dev/null
+++ "b/\320\2403213/ziyatdinov_408659/lab5/Vich_mat_5.py"
@@ -0,0 +1,223 @@
+import math
+import numpy as np
+import matplotlib.pyplot as plt
+
+def func_sin(x):
+    return math.sin(x)
+
+def func_cos(x):
+    return math.cos(x)
+
+def func_exp(x):
+    return math.exp(x)
+
+def func_log(x):
+    return math.log(x)
+
+def func_x2(x):
+    return x ** 2
+
+def func_x3(x):
+    return x ** 3
+
+
+def razdelennaya_table(x_mas, y_mas):
+    n = len(x_mas)
+    table = [y_mas.copy()]
+    for j in range(1, n):
+        col = []
+        for i in range(n - j):
+            diff = (table[j - 1][i + 1] - table[j - 1][i]) / (x_mas[i + j] - x_mas[i])
+            col.append(diff)
+        table.append(col)
+    return table
+
+def konechnie_table(y_mas):
+    table = [y_mas.copy()]
+    while len(table[-1]) > 1:
+        prev = table[-1]
+        cur = []
+        for i in range(len(prev) - 1):
+            raznost = prev[i + 1] - prev[i]
+            cur.append(raznost)
+        table.append(cur)
+    return table
+
+
+def lagrange(x_mas, y_mas, x):
+    total = 0
+    n = len(x_mas)
+    for i in range(n):
+        term = y_mas[i]
+        for j in range(n):
+            if i != j:
+                term *= (x - x_mas[j]) / (x_mas[i] - x_mas[j])
+        total += term
+    return total
+
+def newton_razdelennaya(x_mas, table, x):
+    result = table[0][0]
+    prod = 1.0
+    for j in range(1, len(x_mas)):
+        prod *= (x - x_mas[j - 1])
+        result += table[j][0] * prod
+    return result
+
+def newton_pryamoy(x_mas, table, x):
+    h = x_mas[1] - x_mas[0]
+    t = (x - x_mas[0]) / h
+    result = table[0][0]
+    fact = 1
+    prod = 1
+    for k in range(1, len(x_mas)):
+        prod *= (t - (k - 1))
+        fact *= k
+        result += table[k][0] * prod / fact
+    return result
+
+def newton_nazad(x_mas, table, x):
+    h = x_mas[1] - x_mas[0]
+    t = (x - x_mas[-1]) / h
+    result = table[0][-1]
+    fact = 1
+    prod = 1
+    for k in range(1, len(x_mas)):
+        prod *= (t + (k - 1))
+        fact *= k
+        result += table[k][-1] * prod / fact
+    return result
+
+
+def print_table(table):
+    for row in zip(*table):
+        print("\t".join(f"{val: .6g}" for val in row))
+
+def get_nodes_from_keyboard():
+    print("Введите пары x y :")
+    x_mas, ys = [], []
+    while True:
+        line = input()
+        if not line.strip():
+            break
+        x_str, y_str = line.split()
+        x_mas.append(float(x_str))
+        ys.append(float(y_str))
+    return x_mas, ys
+
+def get_nodes_from_file():
+    path = input("Имя файла: ")
+    x_mas, y_mas = [], []
+    with open(path, encoding="utf8") as f:
+        for line in f:
+            if not line.strip():
+                continue
+            x_str, y_str = line.split()
+            x_mas.append(float(x_str))
+            y_mas.append(float(y_str))
+    return x_mas, y_mas
+
+def get_nodes_from_function():
+    print("Выберите функцию:")
+    print("1 — sin(x)")
+    print("2 — cos(x)")
+    print("3 — exp(x)")
+    print("4 — log(x)")
+    print("5 — x^2")
+    print("6 — x^3")
+    nomer = input("Введите номер: ")
+
+    if nomer == "1":
+        f = func_sin
+    elif nomer == "2":
+        f = func_cos
+    elif nomer == "3":
+        f = func_exp
+    elif nomer == "4":
+        f = func_log
+    elif nomer == "5":
+        f = func_x2
+    elif nomer == "6":
+        f = func_x3
+    else:
+        raise ValueError("Нет такой функции")
+
+    a = float(input("Левая граница: "))
+    b = float(input("Правая граница: "))
+    n = int(input("Количество точек : "))
+    x_mas = [a + i * (b - a) / (n - 1) for i in range(n)]
+    y_mas = [f(x) for x in x_mas]
+    return x_mas, y_mas, f
+
+
+def main():
+    print("Способы задания точек:")
+    print("1 — с клавиатуры")
+    print("2 — из файла")
+    print("3 — аналитическая функция")
+    choice = input("Выбор: ")
+
+    f_real = None
+
+    if choice == "1":
+        x_mas, y_mas = get_nodes_from_keyboard()
+    elif choice == "2":
+        x_mas, y_mas = get_nodes_from_file()
+    elif choice == "3":
+        x_mas, y_mas, f_real = get_nodes_from_function()
+    else:
+        print("Неизвестный выбор")
+        return
+
+    def get_first(t):
+        return t[0]
+    x_mas, y_mas = zip(*sorted(zip(x_mas, y_mas), key=get_first))
+    x_mas, y_mas = list(x_mas), list(y_mas)
+
+    dd = razdelennaya_table(x_mas, y_mas)
+    print("\nТаблица разделённых разностей (Уже прям конечных):")
+    print_table(dd)
+
+    if len(x_mas) > 1 and all(abs((x_mas[i + 1] - x_mas[i]) - (x_mas[1] - x_mas[0])) < 1e-9 for i in range(len(x_mas) - 1)):
+        fd = konechnie_table(y_mas)
+        print("\nТаблица конечных разностей:")
+        print_table(fd)
+    else:
+        fd = None
+        print("\nТочки неравноотстоящие — конечные разности не строим.")
+
+    x_val = float(input("\nВведите x, где считаем f(x): "))
+
+    val_lagr = lagrange(x_mas, y_mas, x_val)
+    val_newt_div = newton_razdelennaya(x_mas, dd, x_val)
+    print(f"\nЛагранж: {val_lagr}")
+    print(f"Ньютон (разделённые): {val_newt_div}")
+
+    if fd is not None:
+        val_fwd = newton_pryamoy(x_mas, fd, x_val)
+        val_bwd = newton_nazad(x_mas, fd, x_val)
+        print(f"Ньютон (вперёд): {val_fwd}")
+        print(f"Ньютон (назад):  {val_bwd}")
+
+    if f_real is not None:
+        print(f"Точное значение: {f_real(x_val)}")
+
+    dense_x = np.linspace(x_mas[0], x_mas[-1], 400)
+    lag_vals = [lagrange(x_mas, y_mas, xi) for xi in dense_x]
+    newt_vals = [newton_razdelennaya(x_mas, dd, xi) for xi in dense_x]
+
+    plt.figure()
+    if f_real is not None:
+        plt.plot(dense_x, [f_real(xi) for xi in dense_x], label="Исходная функция")
+    plt.plot(dense_x, lag_vals, "--", label="Лагранж")
+    plt.plot(dense_x, newt_vals, ":", label="Ньютон (разд.)")
+    plt.scatter(x_mas, y_mas, color="red", label="Узлы")
+    plt.legend()
+    plt.grid(True)
+    plt.show()
+
+
+if __name__ == "__main__":
+    try:
+        main()
+    except Exception as e:
+        print("Ошибка:", e)
diff --git "a/\320\2403213/ziyatdinov_408659/lab5/reports/\320\222\321\213\321\207_\320\274\320\260\321\202_5.pdf" "b/\320\2403213/ziyatdinov_408659/lab5/reports/\320\222\321\213\321\207_\320\274\320\260\321\202_5.pdf"
new file mode 100644
index 0000000..846eb80
Binary files /dev/null and "b/\320\2403213/ziyatdinov_408659/lab5/reports/\320\222\321\213\321\207_\320\274\320\260\321\202_5.pdf" differ
diff --git "a/\320\2403213/ziyatdinov_408659/lab6/Vich_mat_6.py" "b/\320\2403213/ziyatdinov_408659/lab6/Vich_mat_6.py"
new file mode 100644
index 0000000..f4564a9
--- /dev/null
+++ "b/\320\2403213/ziyatdinov_408659/lab6/Vich_mat_6.py"
@@ -0,0 +1,155 @@
+import math
+
+import numpy as np
+import matplotlib.pyplot as plt
+
+
+def uravnenie_1(x, y):
+    return y - x
+
+def uravnenie_2(x, y):
+    return y + x
+
+def uravnenie_3(x, y):
+    return y
+
+def tochnoe_reshenie_1(x, x0, y0):
+    C = y0 - x0 - 1
+    return x + 1 + C * math.exp(x - x0)
+
+def tochnoe_reshenie_2(x, x0, y0):
+    C = y0 + x0 + 1
+    return -x - 1 + C * math.exp(x - x0)
+
+def tochnoe_reshenie_3(x, x0, y0):
+    return y0 * math.exp(x - x0)
+
+def vybrat_uravnenie(nomer):
+    if nomer == "2":
+        return uravnenie_2, tochnoe_reshenie_2
+    elif nomer == "3":
+        return uravnenie_3, tochnoe_reshenie_3
+    else:
+        return uravnenie_1, tochnoe_reshenie_1
+
+
+def yavnyj_eiler(f, x0, y0, xn, h):
+    x_mas = []
+    y_mas = []
+    x = x0
+    y = y0
+    while x <= xn + 0.000001:
+        x_mas.append(x)
+        y_mas.append(y)
+        y = y + h * f(x, y)
+        x = x + h
+    return x_mas, y_mas
+
+def runge_kutta_4_poryadka(f, x0, y0, xn, h):
+    x_mas = []
+    y_mas = []
+    x = x0
+    y = y0
+    while x <= xn + 1e-12:
+        x_mas.append(x)
+        y_mas.append(y)
+        k1 = f(x, y)
+        k2 = f(x + h / 2, y + h * k1 / 2)
+        k3 = f(x + h / 2, y + h * k2 / 2)
+        k4 = f(x + h, y + h * k3)
+        y = y + h * (k1 + 2 * k2 + 2 * k3 + k4) / 6
+        x = x + h
+    return x_mas, y_mas
+
+def miln(f, x0, y0, xn, h):
+    x_mas, y_mas = runge_kutta_4_poryadka(f, x0, y0, x0 + 3*h, h)
+    i = 4
+    while x_mas[-1] + h <= xn + 1e-12:
+        x_i = x0 + i * h
+        f_i_3 = f(x_mas[i-3], y_mas[i-3])
+        f_i_2 = f(x_mas[i-2], y_mas[i-2])
+        f_i_1 = f(x_mas[i-1], y_mas[i-1])
+        y_progn = y_mas[i-4] + 4*h/3 * (2*f_i_3 - f_i_2 + 2*f_i_1)
+        f_progn = f(x_i, y_progn)
+        y_korr = y_mas[i-2] + h/3 * (f_i_2 + 4*f_i_1 + f_progn)
+        y_korr = y_mas[i-2] + h/3 * (f_i_2 + 4*f_i_1 + f(x_i, y_korr))
+        x_mas.append(x_i)
+        y_mas.append(y_korr)
+        i += 1
+
+    return x_mas, y_mas
+
+
+
+def raspechatat_tablicu(xs, ys, zagolovok):
+    print(f"\n{zagolovok}")
+    print(" i    x           y")
+    for i in range(len(xs)):
+        print(f"{i:3d}  {xs[i]:10.6f}  {ys[i]:12.8f}")
+
+def postroit_grafiki(x_mas_e, y_mas_e, xs_rk, ys_rk, xs_m, ys_m, exact_fn, x0, xn, y0):
+    plt.figure(figsize=(8, 5))
+    plt.plot(x_mas_e, y_mas_e, label="Эйлер")
+    plt.plot(xs_rk, ys_rk, label="Рунге–Кутта-4")
+    plt.plot(xs_m, ys_m, label="Милн")
+    if exact_fn is not None:
+        xs_toch = np.linspace(x0, xn, 400)
+        ys_toch = []
+        for x in xs_toch:
+            ys_toch.append(exact_fn(x, x0, y0))
+        plt.plot(xs_toch, ys_toch, "k--", linewidth=2, label="Точное решение")
+    plt.xlabel("x")
+    plt.ylabel("y")
+    plt.title("Сравнение численных решений")
+    plt.grid(True)
+    plt.legend()
+    plt.show()
+
+def otsenka_rule_runge(mas_y_1, mas_y_2, p):
+    raznosti = []
+    for i in range(len(mas_y_1)):
+        raznosti.append(abs(mas_y_2[2 * i] - mas_y_1[i]))
+    return max(raznosti) / (2**p - 1)
+
+
+
+def main():
+
+    print("Выберите уравнение:")
+    print("  1) y' = y – x")
+    print("  2) y' = y + x")
+    print("  3) y' = y")
+    vibor = input("Ваш выбор: ")
+    f, f_tochnoe = vybrat_uravnenie(vibor)
+    x0 = float(input("Введите x0: "))
+    y0 = float(input("Введите y0: "))
+    xn = float(input("Введите xn: "))
+    h = float(input("Введите шаг h: "))
+
+    mas_x_e, mas_y_e = yavnyj_eiler(f, x0, y0, xn, h)
+    mas_x_rk, mas_y_rk = runge_kutta_4_poryadka(f, x0, y0, xn, h)
+    mas_x_m, mas_y_m = miln(f, x0, y0, xn, h)
+    raspechatat_tablicu(mas_x_e, mas_y_e, "Метод Эйлера")
+    raspechatat_tablicu(mas_x_rk, mas_y_rk, "Метод Рунге–Кутты 4")
+    raspechatat_tablicu(mas_x_m, mas_y_m, "Метод Милна")
+    _, ys_e_half = yavnyj_eiler(f, x0, y0, xn, h/2)
+    _, mas_y_rk_half = yavnyj_eiler(f, x0, y0, xn, h / 2)
+    err_eiler = otsenka_rule_runge(mas_y_e, ys_e_half, 1)
+    err_runge_kutta = otsenka_rule_runge(mas_y_rk, mas_y_rk_half, 4)
+    print(f"Погрешность Эйлера: {err_eiler:.3e}")
+    if f_tochnoe is not None:
+        max_err_m = 0
+        for i in range(len(mas_x_m)):
+            x = mas_x_m[i]
+            y = mas_y_m[i]
+            err = abs(f_tochnoe(x, x0, y0) - y)
+            if err > max_err_m:
+                max_err_m = err
+
+
+        print(f"Погрешность Рунге–Кутты 4: {err_runge_kutta:.3e}")
+        print(f"Погрешность Милна: {max_err_m:.3e}")
+    postroit_grafiki(mas_x_e, mas_y_e, mas_x_rk, mas_y_rk, mas_x_m, mas_y_m, f_tochnoe, x0, xn, y0)
+
+if __name__ == "__main__":
+    main()
\ No newline at end of file
diff --git "a/\320\2403213/ziyatdinov_408659/lab6/reports/\320\222\321\213\321\207_\320\274\320\260\321\202_6.pdf" "b/\320\2403213/ziyatdinov_408659/lab6/reports/\320\222\321\213\321\207_\320\274\320\260\321\202_6.pdf"
new file mode 100644
index 0000000..0b2924a
Binary files /dev/null and "b/\320\2403213/ziyatdinov_408659/lab6/reports/\320\222\321\213\321\207_\320\274\320\260\321\202_6.pdf" differ