---

import math
import numpy as np
from prettytable import PrettyTable

# Ввод значений x
x_list = input("Введите значения x через пробел: ").split()

# Создание таблиц
tableP1 = PrettyTable()
tableP1.field_names = ["x", "y(x)", "P1(x)", "|y(x)-P1(x)|", "q"]

tableP2 = PrettyTable()
tableP2.field_names = ["x", "y(x)", "P2(x)", "|y(x)-P2(x)|", "t"]

tableL = PrettyTable()
tableL.field_names = ["x", "y(x)", "L(x)", "|y(x)-L(x)|"]

tableDifP1 = PrettyTable()
tableDifP1.field_names = ["x", "y'(x)", "P1'(x)", "x0~", "|y'(x)-P1'(x)|", "q"]

tableDifP2 = PrettyTable()
tableDifP2.field_names = ["x", "y'(x)", "P2'(x)", "xn~", "|y'(x)-P2'(x)|", "t"]

# Узлы интерполяции
x_table = np.array([1.35, 1.37, 1.39, 1.41, 1.43, 1.45])

# Параметры сетки
h = 0.02
x0 = 1.35
xn = 1.45


# ------------------------------------------------------------
# Вспомогательные функции
# ------------------------------------------------------------
def toFixed(numObj, digits=6):
    return f"{numObj:.{digits}f}"


def f(x):
    """Исходная функция"""
    return 10.3 * math.sin(x) - math.exp((6 * x + 5) / 11)


def df(x):
    """Точная производная"""
    return (103 * math.cos(x) / 10) - (6 * math.exp((6 * x + 5) / 11) / 11)


def closest_value_left(x):
    """
    Возвращает ближайший узел.
    Если x находится ровно между двумя узлами,
    выбирается левый узел.
    """
    diff = [round(abs(x - i), 12) for i in x_table]
    min_diff = min(diff)

    # Все индексы с минимальным расстоянием
    indices = [i for i, d in enumerate(diff) if abs(d - min_diff) < 1e-12]

    # Берём первый индекс (левый узел)
    return x_table[indices[0]]


def closest_value_right(x):
    """
    Возвращает ближайший узел.
    Если x находится ровно между двумя узлами,
    выбирается правый узел.
    """
    diff = [round(abs(x - i), 12) for i in x_table]
    min_diff = min(diff)

    # Все индексы с минимальным расстоянием
    indices = [i for i, d in enumerate(diff) if abs(d - min_diff) < 1e-12]

    # Берём последний индекс (правый узел)
    return x_table[indices[-1]]


# ============================================================
# Первая интерполяционная формула Ньютона
# ============================================================
print("----------------------------Первая интерполяционная формула Ньютона-------------------")

for x in x_list:
    x = float(x)
    q = (x - x0) / h
    y = f(x)

    P1 = (
        6.75987976
        + q * 0.00701428
        + q * (q - 1) / 2 * (-0.00443293)
        + q * (q - 1) * (q - 2) / 6 * (-0.00001997)
        + q * (q - 1) * (q - 2) * (q - 3) / 24 * 0.00000157
        + q * (q - 1) * (q - 2) * (q - 3) * (q - 4) / 120 * 0.00000001
    )

    tableP1.add_row([
        toFixed(x),
        toFixed(y, 8),
        toFixed(P1, 8),
        toFixed(abs(y - P1), 8),
        toFixed(q, 4)
    ])

print(tableP1)


# ============================================================
# Вторая интерполяционная формула Ньютона
# ============================================================
print("----------------------------Вторая интерполяционная формула Ньютона------------------")

for x in x_list:
    x = float(x)
    t = (x - xn) / h
    y = f(x)

    P2 = (
        6.75043004
        + t * (-0.01083095)
        + t * (t + 1) / 2 * (-0.00448811)
        + t * (t + 1) * (t + 2) / 6 * (-0.00001682)
        + t * (t + 1) * (t + 2) * (t + 3) / 24 * 0.00000158
        + t * (t + 1) * (t + 2) * (t + 3) * (t + 4) / 120 * 0.00000001
    )

    tableP2.add_row([
        toFixed(x),
        toFixed(y, 8),
        toFixed(P2, 8),
        toFixed(abs(y - P2), 8),
        toFixed(t, 4)
    ])

print(tableP2)


# ============================================================
# Интерполяционная формула Лагранжа
# ============================================================
print("---------------------------Интерполяционная формула Лагранжа-------------------------")

for x in x_list:
    x = float(x)
    y = f(x)

    L = (
        -17603853.55176730 * (x - 1.37) * (x - 1.39) * (x - 1.41) * (x - 1.43) * (x - 1.45)
        + 88110599.50940073 * (x - 1.35) * (x - 1.39) * (x - 1.41) * (x - 1.43) * (x - 1.45)
        - 176288421.60911840 * (x - 1.35) * (x - 1.37) * (x - 1.41) * (x - 1.43) * (x - 1.45)
        + 176239683.29994464 * (x - 1.35) * (x - 1.37) * (x - 1.39) * (x - 1.43) * (x - 1.45)
        - 88037252.53834365 * (x - 1.35) * (x - 1.37) * (x - 1.39) * (x - 1.41) * (x - 1.45)
        + 17579244.90311123 * (x - 1.35) * (x - 1.37) * (x - 1.39) * (x - 1.41) * (x - 1.43)
    )

    tableL.add_row([
        toFixed(x),
        toFixed(y, 8),
        toFixed(L, 8),
        toFixed(abs(y - L), 8)
    ])

print(tableL)


# ============================================================
# Численное дифференцирование, основанное на 1ИФН
# x0~ — ближайший узел, при равенстве выбирается левый
# ============================================================
print("-------------------------Численное дифференцирование, основанное на 1ИФН----------------")

for x in x_list:
    x = float(x)

    closest_value_1 = closest_value_left(x)
    q = (x - closest_value_1) / h
    Dify = df(x)

    DifP1 = (1 / h) * (
        0.00701428
        + (2 * q - 1) / 2 * (-0.00443293)
        + (3 * q**2 - 6 * q + 2) / 6 * (-0.00001997)
        + (4 * q**3 - 18 * q**2 + 22 * q - 6) / 24 * 0.00000157
        + (5 * q**4 - 40 * q**3 + 105 * q**2 - 100 * q + 24) / 120 * 0.00000001
    )

    tableDifP1.add_row([
        toFixed(x),
        toFixed(Dify, 8),
        toFixed(DifP1, 8),
        toFixed(closest_value_1),
        toFixed(abs(Dify - DifP1), 8),
        toFixed(q, 4)
    ])

print(tableDifP1)


# ============================================================
# Численное дифференцирование, основанное на 2ИФН
# xn~ — ближайший узел, при равенстве выбирается правый
# ============================================================
print("-------------------------Численное дифференцирование, основанное на 2ИФН---------------")

for x in x_list:
    x = float(x)

    closest_value_2 = closest_value_right(x)
    t = (x - closest_value_2) / h
    Dify = df(x)

    DifP2 = (1 / h) * (
        -0.01083095
        + (2 * t + 1) / 2 * (-0.00448811)
        + (3 * t**2 + 6 * t + 2) / 6 * (-0.00001682)
        + (4 * t**3 + 18 * t**2 + 22 * t + 6) / 24 * 0.00000158
        + (5 * t**4 + 40 * t**3 + 105 * t**2 + 100 * t + 24) / 120 * 0.00000001
    )

    tableDifP2.add_row([
        toFixed(x),
        toFixed(Dify, 8),
        toFixed(DifP2, 8),
        toFixed(closest_value_2),
        toFixed(abs(Dify - DifP2), 8),
        toFixed(t, 4)
    ])

print(tableDifP2)