from sympy import *
import pandas as pd
import numpy as np
import matplotlib as plt
import math as mt

def func(x):
    return x**3 - sin(x)

a = 0.6
b = 1.1
h = round((b - a) / 10, 2)
x = symbols('x')
expr = func(x)
print('Функция:', expr)

n = 4
m = 1
k = 1

test_data = []
for i in range(5):
    test_data.append({
        'x': symbols(f"x_{i}"),
        'y': symbols(f"f_{i}")
    })
arr_x = []
for i in range(0, 11):
    arr_x.append(a+i*h)

def X(i):
    return a+i*h

def L_n(x, h, data_1, n):
    L_n = 0
    for j in range(0, n+1):
        term = data_1[j]['y']
        for i in range(0, n+1):
            if i!=j:
                term*=(x-i*h)/((j-i) * test_h)
        L_n += term
    return L_n


x = symbols('x')
test_h = symbols('h')
beta_Lagrange_4 = L_n(x, test_h, test_data, n)
print("Многочлен Лагранжа при n=4 в общем виде при подстановке h(i-j) вместо x_i-x_j:")
beta_Lagrange_4

data1 = []
for i in range(5):
    data1.append({
        'x': X(i),
        'y': symbols(f"f_{i}")
    })
Lagrange_4 = beta_Lagrange_4.as_poly().args[0]

exp_deriv = 1
def deriv_by_x(function, value, k):
    global exp_deriv
    _x = symbols('x')
    exp_deriv = diff(function, _x, k)
    return exp_deriv.subs(_x, value)

Lagrange_derivative = deriv_by_x(Lagrange_4, m*test_h, k)
print("Производная многочлена Лагранжа при n = 4 (L_4_1(x)):")
exp_deriv

print("Производная многочлена Лагранжа при n = 4 при подстановке x = m*h (L_4_1(x_m)):")
Lagrange_derivative

y_values = []
for i in range(5):
    y_values.append(func(X(i)))

for i in range(5):
    Lagrange_derivative = Lagrange_derivative.subs(data1[i]['y'], y_values[i])
Lagrange_derivative = Lagrange_derivative.subs(test_h, h)
print("Значение производной многочлена Лагранжа в точке x_m:")
Lagrange_derivative

def w(arr, x, n):
    w = 1
    for i in range (0, n+1):
        w *= x-arr[i]
    return w

def multiplier(function, n, dot):
    x = symbols('x')
    exp_deriv = diff(expr, x, n+1)
    return exp_deriv.subs(x, dot)

def remainder(arr, x, dot, n):
    return multiplier(expr, n, dot) / mt.factorial(n+1) * w(arr, x, n)

beta_remainder_l = remainder(arr_x, x, a, n)
Remainder_l = beta_remainder_l.as_poly().args[0]
print("Остаток в точке ξ = a:")
Remainder_l

Remainder_l_1 = abs(deriv_by_x(Remainder_l, X(m), k))
print("Остаток в точке ξ = a, x = x_m:")
Remainder_l_1

beta_remainder_r = remainder(arr_x, x, X(n), n)
Remainder_r = beta_remainder_r.as_poly().args[0]
print("Остаток в точке ξ = x_n:")
Remainder_r

Remainder_r_1 = abs(deriv_by_x(Remainder_r, X(m), k))
print("Остаток в точке ξ = x_n, x = x_m:")
Remainder_r_1

def check(min_rem, max_rem, true_rem):
    if true_rem >= max_rem or true_rem <= min_rem:
        return false
    return true

min_remainder_1 = min(Remainder_l_1, Remainder_r_1)
max_remainder_1 = max(Remainder_l_1, Remainder_r_1)

Real_derivative = deriv_by_x(expr, X(m), k)
remainder_4_1 = abs(Lagrange_derivative - Real_derivative)
print('Значение остатка:', remainder_4_1)
print(min_remainder_1, '<', remainder_4_1, '<', max_remainder_1, 'is', check(min_remainder_1, max_remainder_1, remainder_4_1))