নিউটনের ডিভাইডেড ডিফারেন্স

import math

xs = [0.0, 0.5, 1.0, 1.5, 2.0]
ys = [math.sin(x) for x in xs]

def divided_diff_table(xs, ys):
    n = len(xs)
    table = [ys[:]]
    for level in range(1, n):
        prev = table[-1]
        new_row = []
        for i in range(n - level):
            val = (prev[i+1] - prev[i]) / (xs[i+level] - xs[i])
            new_row.append(val)
        table.append(new_row)
    coeffs = [table[k][0] for k in range(n)]
    return coeffs, table

coeffs, table = divided_diff_table(xs, ys)

print("ডিভাইডেড-ডিফারেন্স টেবিল (প্রতিটি সারি একটি মাত্রা):")
for level, row in enumerate(table):
    print(f"  মাত্রা {level}: " + ", ".join(f"{v:.6f}" for v in row))

print()
print("নিউটন সহগ (f[x0], f[x0,x1], ...):")
for i, c in enumerate(coeffs):
    print(f"  c{i} = {c:.6f}")

def newton_eval(xs, coeffs, x):
    n = len(coeffs)
    result = coeffs[-1]
    for k in range(n - 2, -1, -1):
        result = result * (x - xs[k]) + coeffs[k]
    return result

def lagrange_interpolate(xs, ys, x):
    total = 0.0
    n = len(xs)
    for i in range(n):
        term = ys[i]
        for j in range(n):
            if j != i:
                term *= (x - xs[j]) / (xs[i] - xs[j])
        total += term
    return total

for x_new in [1.2, 1.9]:
    p_newton = newton_eval(xs, coeffs, x_new)
    p_lagrange = lagrange_interpolate(xs, ys, x_new)
    true_val = math.sin(x_new)
    print()
    print(f"x_new = {x_new}")
    print(f"  নিউটন   P({x_new})  = {p_newton:.8f}")
    print(f"  লাগ্রাঞ্জ P({x_new}) = {p_lagrange:.8f}")
    print(f"  দুই মেথডের পার্থক্য     = {abs(p_newton - p_lagrange):.2e}")
    print(f"  প্রকৃত math.sin({x_new}) = {true_val:.8f}")